---
title: 思考ブロックのプレフィックスチェック
url: https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking/prefix-checks
description: プレフィックスチェックが何を比較するか、どのモデルがそれを実行するか、リクエストがそれに失敗したときに何が起こるか、そして400エラーとエラーが発生しない場合への対処方法について説明します。
featureMetadata:
  status: stable
  supportedModels:
    - claude-fable-5-2
    - claude-mythos-5-2
    - claude-fable-5-1
    - claude-mythos-5-1
    - claude-opus-5-5
    - claude-sonnet-5-5
    - claude-haiku-5-5
  supportedPlatforms:
    Claude API: stable
    Amazon Bedrock: stable
    Amazon Bedrock (bedrock-runtime): stable
    Claude Platform on AWS: stable
    Claude Models on Google Cloud (Anthropic managed): stable
    Claude Models on Google Cloud (Google managed): stable
    Microsoft Foundry: stable
---

[保持された思考を持つモデル](https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking/prefix-checks#outcomes)に思考ブロックを送り返す各リクエストには、「prefix check」（プレフィックスチェック）が行われます。Claudeがブロックを生成した後に`system`、`tools`、またはそれより前のメッセージが変更された場合、プレフィックスチェックは失敗します。また、他の思考ブロックの間にある思考ブロックが省かれたり移動されたりした場合にも失敗します。

プレフィックスチェックに失敗した場合、400エラーになることもあれば、ならないこともあり、[モデルによって異なります](https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking/prefix-checks#outcomes)。そのため、[両方のケースに対処する](https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking/prefix-checks#handle-either-outcome)ようにしてください。

## プレフィックスチェックの影響を受けるのは誰か

次のいずれかに当てはまる場合、変更する必要はありません。

* Claude Code、claude.ai、またはClaude Managed Agentsが会話履歴を管理している。
* Claude Agent SDKが履歴を管理しており、SDKに渡すシステムプロンプトが変わらない。
* コードが[「append-only」（追記のみ）な統合の3つの習慣](https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking/prefix-checks#prefix-check)に従っており、途中でリクエストを書き換えるものが何もない。
* [保持された思考を持つモデル](https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking/prefix-checks#outcomes)を呼び出していない。

リクエストがライブラリ、プロキシ、またはゲートウェイを経由する場合は、[それが送信する内容と、あなたが送信した内容を比較してください](https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#find-the-change-details)。それらを運用している場合は、何をそのまま通すべきかについて[ライブラリ、プロキシ、ゲートウェイ](https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking/change-tools-or-instructions#libraries-proxies-gateways)を参照してください。

## 何が変わってはならないのか、そしてその理由

統合を追記のみにしてください。次の3つの習慣でそれが実現できます。

1. 各アシスタントターンは、テキストが空の思考ブロックも含め、APIが返したとおりに正確に送り返します。
2. `system`と`tools`は会話ごとに一度だけ構築し、毎回そのコピーを送信します。
3. すべての更新は末尾の新しいメッセージに入れ、そのままにしておきます。

各思考ブロックの推論は、そのブロックより前にあったもの、つまり`system`、`tools`、およびそれより前のすべてのメッセージに正確に基づいています。その内容がブロックの*プレフィックス*であり、[プレフィックスチェック](https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking/prefix-checks#prefix-check-details)が比較するのはこれです。

プレフィックスチェックはプロンプトキャッシングに似ていますが、変更があった場合、単にキャッシュミスになるのではなく、その後の思考が無効になる点が異なります。

システムプロンプトに今日の日付を入れるアプリを例に考えます。午前0時に日付が変わると、会話内にすでにある思考のプレフィックスも変わります。その思考は無効になり、次のリクエストは失敗する可能性があります。追記のみのアプリは、システムプロンプトを元のまま保ち、新しい日付を[末尾のメッセージ](https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking/change-tools-or-instructions#changing-context)で伝えます。

<Frame>
  ![末尾での更新ではすべての思考が有効なまま保たれ、ターン2またはsystemへの変更ではその後の思考が無効になります](https://platform.claude.com/docs/ja/images/preserved-thinking-add-or-change.svg)
</Frame>

変更によって無効になるのは、すでにその後に続いている思考だけです。変更より前の思考と、その後にClaudeが生成する思考は有効なままです。

## コードがシステムプロンプト、ツール、または履歴を変更する場合

| コードが次のことを行う場合…                             | 対処方法                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| ------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 日付、モード、または指示ファイルを使ってシステムプロンプトを再構築する        | `system`の変更をやめてください。[独自の指示をシステムメッセージとして追加し](https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking/change-tools-or-instructions#new-instructions)（`messages`内の`role: "system"`エントリ）、[新しい値は最新のターンで伝えてください](https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking/change-tools-or-instructions#changing-context)。他の人が編集できるテキストについては、代わりに[他の人が編集できるテキスト](https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking/change-tools-or-instructions#untrusted-text)を参照してください。 |
| ツールを追加、削除、または言い換える、あるいはMCPサーバーの接続時にツールが増える | `tools`の変更をやめ、[システムメッセージでツールを追加または削除してください](https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking/change-tools-or-instructions#tool-changes)。                                                                                                                                                                                                                                                                                                                                                           |
| 古いターンを切り詰める、折りたたむ、または要約し、最新のターンは変更しない      | [APIに要約を書かせるか、残したターンの思考を削除してください](https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking/change-tools-or-instructions#server-side-trimming)。                                                                                                                                                                                                                                                                                                                                                             |

テキストが空の思考ブロックを省く、保存された会話を再構築するなど、その他の原因にはそれぞれ独自の修正方法があります。[プレフィックスチェックに失敗せずにツールや指示を変更する](https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking/change-tools-or-instructions)を参照してください。自分の原因を見つけるには、[エージェントにコードを確認させてください](https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking#hand-to-an-agent)。

## プレフィックスチェックが失敗したときに各モデルが行うこと

Claude APIおよび[一部のクラウドプラットフォーム](https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking#feature-availability)では、[`prefix_mismatch_behavior`](https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking/prefix-checks#preserved-thinking-controls)を未設定のままにしてプレフィックスチェックに失敗した場合の結果は、モデルによって異なります。

| 保持された思考を持つモデル     | 結果                                                                                                                        |
| ----------------- | ------------------------------------------------------------------------------------------------------------------------- |
| Claude Fable 5.2  | 400エラー                                                                                                                    |
| Claude Mythos 5.2 | 400エラー                                                                                                                    |
| Claude Mythos 5.1 | 400エラー                                                                                                                    |
| Claude Fable 5.1  | [400エラーの可能性あり](https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking/prefix-checks#possible-400-error) |
| Claude Opus 5.5   | [400エラーの可能性あり](https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking/prefix-checks#possible-400-error) |
| Claude Sonnet 5.5 | [400エラーの可能性あり](https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking/prefix-checks#possible-400-error) |
| Claude Haiku 5.5  | [400エラーの可能性あり](https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking/prefix-checks#possible-400-error) |

表に「400エラーの可能性あり」とある場合、2つのケースがあります。プレフィックスチェックに失敗したリクエストは、400エラーを受け取ることもあれば、エラーを受け取らないこともあります。エラーが返されない場合、プレフィックスチェックに失敗したブロックはモデルに届きます。Claudeはそれらを他の入力と同様に読み取り、それらに対して課金が発生し、Claudeはその後変更された内容についての推論をもとに作業します。

これらのモデルでは、[リクエストがどちらのケースになるかを確認する](https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking/prefix-checks#check-which-case)ことができますが、[両方のケースに対処する](https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking/prefix-checks#handle-either-outcome)ようにしてください。

<Tip>
  [追記のみの統合の3つの習慣](https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking/prefix-checks#prefix-check)に従うコードによって、リクエストがプレフィックスチェックに失敗することはありません。
</Tip>

`prefix_mismatch_behavior`を未設定のままにした[Message Batchesのアイテム](https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#batches)はエラーを受け取らず、APIはプレフィックスチェックに失敗したブロックを除外する場合があります。

## 両方のケースに対処する

すべてのリクエストで1つの結果を得るには、統合を追記のみにするか、`prefix_mismatch_behavior`を設定してください。そうでない場合、コードは両方の動作に対処する必要があります。

* **追記のみ：** [3つの習慣](https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking/prefix-checks#prefix-check)に従えば、コードによってリクエストがプレフィックスチェックに失敗することはありません。
* **設定：** すべてのリクエストで`"error"`を指定すると、プレフィックスチェックの各失敗は400エラーになり、[コードでそれを捕捉します](https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#handle-the-error-in-code)。
* **両方の動作：** 設定を未設定のままにする場合は、400エラーを捕捉し、[Claudeに届いた、プレフィックスチェックに失敗した思考を監視してください](https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking/prefix-checks#watch-production-traffic)。

400エラーの後は、回復するためにその会話の以降のリクエストで`"drop_block"`を送信してください。これにはコストが伴います。[思考の除外によるコスト](https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#drop-block-cost)を参照してください。エラーを隠すためにすべての会話でこれを送信しないでください。

## 技術的な詳細

### プレフィックスチェックの仕組み

保持された思考を持つモデルは、各思考ブロックのプレフィックスのフィンガープリントをその`signature`に記録します。APIリファレンスではプレフィックスチェックを会話チェックと呼んでおり、400エラーはプレフィックスチェックに失敗したブロックが`is bound to a different conversation`であると示します。

### どのモデルがプレフィックスチェックを実行するか

プレフィックスチェックは、Claude APIおよび[一部のクラウドプラットフォーム](https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking#feature-availability)で実行されます。これは、[保持された思考を持つモデル](https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking/prefix-checks#outcomes)が生成した思考ブロックを、それらのモデルのいずれかへのリクエストにおいてチェックします。Claude APIでは、Claude Opus 5などの他のモデルはこれを実行せず、それらのブロックも対象になりません。

### 何が変更とみなされるか

* **各ブロックはそれぞれ独自の記録と照合されます。** APIは、このリクエストでブロックより前にあるものと、Claudeがそのブロックを生成したときにその署名が記録したものを比較します。前回のリクエストは関係しません。プレフィックスチェックは内容だけを見て、セッション、ID、ユーザーは見ません。新しいリクエストやフォークでも同じ内容であれば、プレフィックスチェックに合格します。
* **プレフィックスチェックは、Claudeが読み取った内容ではなく、あなたが送信した内容を比較します。** [トークンしきい値でのコンパクション](https://platform.claude.com/docs/ja/build-with-claude/compaction-threshold)とコンテキスト編集は、Claudeが読み取る内容だけを変更するため、決して変更とはみなされません。しきい値コンパクションブロックの後は、APIはそのブロック以降のメッセージと、`system`および`tools`だけを比較します。オンデマンドコンパクションには独自の条件があります。[残した思考が有効なままとなる条件](https://platform.claude.com/docs/ja/build-with-claude/compaction-thinking-blocks#conditions-for-kept-thinking-to-stay-valid)を参照してください。URLで送信されたファイル、およびClaude APIでは[MCPツールリスト](https://platform.claude.com/docs/ja/agents-and-tools/mcp-connector#pin-mcp-tool-list)については、APIは代わりに取得した内容を比較します。
* **送信する思考は途切れのない連続でなければなりません。** 思考ブロックは内容としては比較されません。ただし、送信する各思考ブロックは、最初のものを除き、Claudeがそれを生成したときと同じ直前の思考ブロックを持っていなければなりません。そのため、[最も古いもの、最も新しいもの、またはすべてを省く](https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking/change-tools-or-instructions#leave-out-thinking)ことはできますが、間にあるものを1つ省くことはできません。

変更はツールの説明の1単語程度の小さなものでもあり得ます。それより前のメッセージの変更、挿入、移動、削除は、ロールにかかわらず変更とみなされます。同じメッセージ内で思考ブロックより前にあるテキストを変更した場合も同様です。

### 変更とみなされないもの

| 変更とみなされないもの                                                                            | 理由                                           |
| -------------------------------------------------------------------------------------- | -------------------------------------------- |
| `model`、`effort`、`max_tokens`、`tool_choice`、`metadata`、`thinking.display`、およびその他のパラメータ | 比較されるのは`system`、`tools`、およびメッセージだけです         |
| JSONのフォーマットやキーの順序                                                                      | APIはテキストではなく、パースされたJSONを比較します                |
| `cache_control`マーカー                                                                    | これらはどこでキャッシュするかを示すものであり、Claudeが読み取る内容ではありません |
| 何からも参照されていない`defer_loading: true`のツール                                                  | 何かが参照するまで、Claudeのコンテキストに含まれません               |

### `prefix_mismatch_behavior`を設定する

[ベータヘッダー](https://platform.claude.com/docs/ja/api/beta-headers#beta-features-on-other-platforms)`thinking-binding-controls-2026-08-01`は、設定`thinking.block_binding.prefix_mismatch_behavior`と、レスポンスの`input_transformations`配列を追加します。

| 値              | ブロックがプレフィックスチェックに失敗した場合                                                                                                                                                                                      |
| -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `"error"`      | APIは、最初の無効なブロックを示す400エラーでリクエストを拒否します                                                                                                                                                                         |
| `"drop_block"` | APIは無効なブロックを除外し、リクエストは成功します。それらのブロックに対して課金は発生しませんが、[それらを除外するとコストが増える場合があります](https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#drop-block-cost) |
| 未設定、または`null`  | [モデルによって異なります](https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking/prefix-checks#outcomes)                                                                                              |

プレフィックスチェックに失敗したブロックは、変更が残っている間、それらを送信する以降のすべてのリクエストで無効なままです。この設定は、それを含む1つのリクエストに対してのみ作用します。思考がオフ（`"disabled"`または`"between_tools"`）の場合、これを送信するとすべてのモデルで400エラーになります。

次のリクエストは`prefix_mismatch_behavior`を`"drop_block"`に設定しています。最初のターンでは送り返す思考がないため、`input_transformations`は空で返されます。

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "anthropic-beta: thinking-binding-controls-2026-08-01" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-opus-5-5",
      "max_tokens": 16000,
      "thinking": {
        "type": "adaptive",
        "block_binding": {
          "prefix_mismatch_behavior": "drop_block"
        }
      },
      "messages": [
        {
          "role": "user",
          "content": "What is the greatest common divisor of 1071 and 462?"
        }
      ]
    }'
  ```

  ```bash CLI
  ant beta:messages create --beta thinking-binding-controls-2026-08-01 <<'YAML'
  model: claude-opus-5-5
  max_tokens: 16000
  thinking:
    type: adaptive
    block_binding:
      prefix_mismatch_behavior: drop_block
  messages:
    - role: user
      content: What is the greatest common divisor of 1071 and 462?
  YAML
  ```

  ```python Python
  client = anthropic.Anthropic()

  response = client.beta.messages.create(
      model="claude-opus-5-5",
      max_tokens=16000,
      thinking={
          "type": "adaptive",
          "block_binding": {"prefix_mismatch_behavior": "drop_block"},
      },
      messages=[
          {
              "role": "user",
              "content": "What is the greatest common divisor of 1071 and 462?",
          }
      ],
      betas=["thinking-binding-controls-2026-08-01"],
  )

  for block in response.content:
      if block.type == "text":
          print(block.text)

  print(f"Input transformations: {len(response.input_transformations or [])}")
  ```

  ```typescript TypeScript
  const client = new Anthropic();

  const response = await client.beta.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 16000,
    thinking: {
      type: "adaptive",
      block_binding: { prefix_mismatch_behavior: "drop_block" }
    },
    messages: [
      { role: "user", content: "What is the greatest common divisor of 1071 and 462?" }
    ],
    betas: ["thinking-binding-controls-2026-08-01"]
  });

  for (const block of response.content) {
    if (block.type === "text") {
      console.log(block.text);
    }
  }
  console.log(`Input transformations: ${response.input_transformations?.length ?? 0}`);
  ```

  ```csharp C#
  using Anthropic.Models.Beta;
  using Anthropic.Models.Beta.Messages;
  using Model = Anthropic.Models.Messages.Model;

  AnthropicClient client = new();

  var response = await client.Beta.Messages.Create(
      new()
      {
          Model = Model.ClaudeOpus5_5,
          MaxTokens = 16000,
          Thinking = new BetaThinkingConfigAdaptive
          {
              BlockBinding = new()
              {
                  PrefixMismatchBehavior = BetaThinkingPrefixMismatchBehavior.DropBlock,
              },
          },
          Messages =
          [
              new BetaUserMessageParam
              {
                  Content = "What is the greatest common divisor of 1071 and 462?",
              },
          ],
          Betas = [AnthropicBeta.ThinkingBindingControls2026_08_01],
      }
  );

  foreach (var block in response.Content)
  {
      if (block.TryPickText(out var textBlock))
      {
          Console.WriteLine(textBlock.Text);
      }
  }

  Console.WriteLine($"Input transformations: {response.InputTransformations?.Count ?? 0}");
  ```

  ```go Go
  client := anthropic.NewClient()

  response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 16000,
  	Thinking: anthropic.BetaThinkingConfigParamUnion{
  		OfAdaptive: &anthropic.BetaThinkingConfigAdaptiveParam{
  			BlockBinding: anthropic.BetaThinkingBlockBindingParam{
  				PrefixMismatchBehavior: anthropic.BetaThinkingPrefixMismatchBehaviorDropBlock,
  			},
  		},
  	},
  	Messages: []anthropic.BetaMessageParam{
  		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("What is the greatest common divisor of 1071 and 462?")),
  	},
  	Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaThinkingBindingControls2026_08_01},
  })
  if err != nil {
  	log.Fatal(err)
  }

  for _, block := range response.Content {
  	if textBlock, ok := block.AsAny().(anthropic.BetaTextBlock); ok {
  		fmt.Println(textBlock.Text)
  	}
  }
  fmt.Printf("Input transformations: %d\n", len(response.InputTransformations))
  ```

  ```java Java
  import com.anthropic.models.beta.AnthropicBeta;
  import com.anthropic.models.beta.messages.BetaMessage;
  import com.anthropic.models.beta.messages.BetaThinkingBlockBinding;
  import com.anthropic.models.beta.messages.BetaThinkingConfigAdaptive;
  import com.anthropic.models.beta.messages.BetaThinkingPrefixMismatchBehavior;
  import com.anthropic.models.beta.messages.MessageCreateParams;
  import com.anthropic.models.messages.Model;

  void main() {
      AnthropicClient client = AnthropicOkHttpClient.fromEnv();

      MessageCreateParams params = MessageCreateParams.builder()
          .model(Model.CLAUDE_OPUS_5_5)
          .maxTokens(16000L)
          .addBeta(AnthropicBeta.THINKING_BINDING_CONTROLS_2026_08_01)
          .thinking(BetaThinkingConfigAdaptive.builder()
              .blockBinding(BetaThinkingBlockBinding.builder()
                  .prefixMismatchBehavior(BetaThinkingPrefixMismatchBehavior.DROP_BLOCK)
                  .build())
              .build())
          .addUserMessage("What is the greatest common divisor of 1071 and 462?")
          .build();

      BetaMessage response = client.beta().messages().create(params);

      response.content().stream()
          .flatMap(block -> block.text().stream())
          .forEach(textBlock -> IO.println(textBlock.text()));
      IO.println("Input transformations: "
          + response.inputTransformations().map(List::size).orElse(0));
  }
  ```

  ```php PHP
  use Anthropic\Beta\AnthropicBeta;
  use Anthropic\Beta\Messages\BetaTextBlock;
  use Anthropic\Beta\Messages\BetaThinkingBlockBinding;
  use Anthropic\Beta\Messages\BetaThinkingConfigAdaptive;
  use Anthropic\Beta\Messages\BetaThinkingPrefixMismatchBehavior;
  use Anthropic\Client;
  use Anthropic\Messages\Model;

  $client = new Client();

  $response = $client->beta->messages->create(
      model: Model::CLAUDE_OPUS_5_5,
      maxTokens: 16000,
      thinking: BetaThinkingConfigAdaptive::with(
          blockBinding: BetaThinkingBlockBinding::with(
              prefixMismatchBehavior: BetaThinkingPrefixMismatchBehavior::DROP_BLOCK,
          ),
      ),
      messages: [
          ['role' => 'user', 'content' => 'What is the greatest common divisor of 1071 and 462?'],
      ],
      betas: [AnthropicBeta::THINKING_BINDING_CONTROLS_2026_08_01],
  );

  foreach ($response->content as $block) {
      if ($block instanceof BetaTextBlock) {
          echo $block->text, PHP_EOL;
      }
  }

  echo 'Input transformations: ', count($response->inputTransformations ?? []), PHP_EOL;
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  response = client.beta.messages.create(
    model: Anthropic::Model::CLAUDE_OPUS_5_5,
    max_tokens: 16_000,
    thinking: {
      type: "adaptive",
      block_binding: { prefix_mismatch_behavior: "drop_block" }
    },
    messages: [
      { role: "user", content: "What is the greatest common divisor of 1071 and 462?" }
    ],
    betas: [Anthropic::AnthropicBeta::THINKING_BINDING_CONTROLS_2026_08_01]
  )

  response.content.each do |block|
    puts block.text if block.is_a?(Anthropic::Beta::BetaTextBlock)
  end

  puts "Input transformations: #{response.input_transformations&.length || 0}"
  ```
</CodeGroup>

### 本番トラフィックを監視する

`prefix_mismatch_behavior`が未設定の場合、[一部のモデル](https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking/prefix-checks#outcomes)では、プレフィックスチェックに失敗したリクエストがエラーを受け取らない可能性があります。その場合、プレフィックスチェックに失敗した思考ブロックはモデルに届きます。本番トラフィックでそれらのブロックを見つけるには、`thinking-binding-controls-2026-08-01`ベータヘッダーを送信し、設定を未設定のままにして、各レスポンスの`input_transformations`配列をログに記録してください。ヘッダーはその配列を追加するものであり、モデルが受け取る内容は変わりません。

それらの各ブロックは、その配列内に独自の`thinking_mismatch_allowed`エントリを持ちます。1つのエントリは次のようになります。

```json
{
  "input_transformations": [
    {
      "type": "thinking_mismatch_allowed",
      "path": "messages.1.content.0",
      "reason": "prefix_binding_mismatch"
    }
  ]
}
```

変更を見つけるには、[コードが変更したものを見つける](https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#find-the-change)を参照してください。

### どちらのケースになるかを確認する

[一部のモデル](https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking/prefix-checks#outcomes)では、プレフィックスチェックに失敗したリクエストは、400エラーを受け取る可能性も、エラーを受け取らない可能性もあります。次のテストで、リクエストがどちらになるかがわかります。

1. それらのモデルのいずれかによる思考ブロックを含む会話を用意します。システムプロンプト（`system`）を変更または追加します。Claudeがそのブロックを生成した後にシステムプロンプトが変更されたため、そのブロックはプレフィックスチェックに失敗します。
2. `thinking-binding-controls-2026-08-01`ベータヘッダーを付けて同じモデルに送信し、`prefix_mismatch_behavior`は未設定のままにします。

レスポンスは次のいずれかです。

* **`bound to a different conversation`と示す[400エラー](https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#prefix-mismatch-error)：** リクエストは400エラーを受け取りました。
* **`input_transformations`配列に`thinking_mismatch_allowed`エントリがある200レスポンス：** リクエストはエラーを受け取りませんでした。各エントリは、プレフィックスチェックに失敗してClaudeに届いた思考ブロックを示します。
* **`input_transformations`配列が空の200レスポンス：** プレフィックスチェックに失敗したブロックはないため、このテストでは何もわかりません。会話にそのモデルによる思考ブロックが含まれていることを確認してください。

この結果はその1つのリクエストについて示すものであり、以降のリクエストについては何も保証しません。そのため、[両方のケースに対処する](https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking/prefix-checks#handle-either-outcome)ようにコードを書いてください。

## 次のステップ

<CardGroup cols={2}>
  <Card title="プレフィックスチェックに失敗せずにツールや指示を変更する" icon="edit" href="https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking/change-tools-or-instructions">
    コードが会話に加える各変更の代わりに何を送信すべきかを説明します。
  </Card>

  <Card title="別の会話にバインドされた思考ブロックを修正する" icon="wrench" href="https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation">
    プレフィックスチェックに失敗している会話を回復し、コードが何を変更しているかを見つけ、それが解消されたことをテストします。
  </Card>

  <Card title="保持された思考" icon="book" href="https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking">
    保持された思考とは何か、思考ブロックが何に結び付けられているか、そしてモデルやアカウントの切り替えについて説明します。
  </Card>
</CardGroup>
