---
title: 思考
url: https://platform.claude.com/docs/ja/build-with-claude/thinking
description: Claudeの思考の仕組みを理解します。思考を有効にする方法、思考出力の読み取り方、effortによる思考の深さの調整、そしてツール、キャッシング、ストリーミングと組み合わせた思考の使い方を説明します。
---

<Note>
  「zero data retention」（ゼロデータ保持）、すなわちZDRがこの機能にどのように適用されるかについては、[APIとデータ保持](https://platform.claude.com/docs/ja/manage-claude/api-and-data-retention)を参照してください。
</Note>

1回のパスで回答するモデルは、最初の試行ですべてを正しく行う必要があります。下書きも、確認も、途中での方針転換もできません。証明、厄介なバグ、長時間のエージェントタスクでは、最初のアプローチが最善とは限りません。

「thinking」（思考）は、この制約を取り除きます。思考が有効な場合、Claudeは回答する前に自分の言葉で問題に取り組みます。何が求められているかを言い換え、さまざまなアプローチを試し、中間結果を確認し、うまくいかない道筋は放棄します。この事前の思考は、応答の前に `thinking` コンテンツブロックとして届き、Claudeはそれをもとに最終的な回答を生成します。そのため思考は、数学、コーディング、分析、長時間実行されるエージェント型の作業といった複雑なタスクのパフォーマンスを向上させます。こうしたタスクでは、回答の品質が中間作業に左右されます。思考がなければ、その中間作業は応答そのものに圧縮されるか、省略されてしまいます。

思考にはコストがかかります。Claudeが推論に費やすトークンは、思考テキストが返されない場合でも出力トークンとして課金され、レスポンステキストとともに`max_tokens`にカウントされます。このページでは、API全体での思考の動作について説明します。具体的には、思考の有効化、出力の読み取り、そしてツール、「streaming」（ストリーミング）、キャッシング、「context window」（コンテキストウィンドウ）との相互作用の管理を扱います。

## 思考の仕組み

<Frame>
  ![図：Claudeは事前に思考するかどうかを判断し、ツール呼び出しの間に思考することがあり、テキストの前に「thinking block」（思考ブロック）を返します](https://platform.claude.com/docs/ja/images/how-thinking-works.svg)
</Frame>

特定のリクエストでClaudeが思考するかどうか、またどの程度深く思考するかは、思考の設定とリクエストの複雑さによって決まります。

応答における事前思考は次のようになります。1つ以上の`thinking`コンテンツブロックが`text`ブロックの前に届きます。思考ブロックは、それに続く`text`ブロックと同様に生成されたコンテンツですが、正規の応答とは分離されています。各思考ブロックには`signature`フィールドも含まれています。これは完全な推論の暗号化されたコピーであり、マルチターンおよびツール使用の会話では変更せずにそのまま返します（[思考の暗号化](https://platform.claude.com/docs/ja/build-with-claude/thinking#thinking-encryption)を参照）：

```json
{
  "content": [
    {
      "type": "thinking",
      "thinking": "Let me break this down. The question has two parts, so I'll start with the simpler one and use its result to constrain the second...",
      "signature": "WaUjzkypQ2mUEVM36O2Txu...."
    },
    {
      "type": "text",
      "text": "Based on my analysis..."
    }
  ]
}
```

このテキストが常に表示されるとは限らず、表示されるものが生の思考の連鎖であることは決してありません。思考ブロック内のテキストは[Claudeの推論の要約](https://platform.claude.com/docs/ja/build-with-claude/thinking#summarized-thinking)です。思考設定の`display`フィールドは、その要約を返すかどうかを制御します。`"summarized"`は要約を返し、多くのモデルでデフォルトである`"omitted"`は、`thinking`フィールドが空の思考ブロックを返します。いずれの場合も、ブロックの課金は同じであり、マルチターンの会話で返す方法も同じです。モデルごとのデフォルトと詳細については、[思考表示の制御](https://platform.claude.com/docs/ja/build-with-claude/thinking#controlling-thinking-display)を参照してください。

Claudeがツールを使用する場合、ツール呼び出しの間にも思考が現れることがあります。[ツール使用と思考](https://platform.claude.com/docs/ja/build-with-claude/thinking#thinking-with-tool-use)を参照してください。完全な応答形式については、[Messages APIリファレンス](https://platform.claude.com/docs/ja/api/messages/create)を参照してください。

## 思考の設定

ほとんどのモデルでは、思考はデフォルトで有効になっているか、パラメータを1つ設定するだけで有効になります。次の表は、リクエストが送信できる各`thinking`値に対して各モデルがどのように動作するかを示しています。400エラーはAPIがリクエストを拒否することを意味し、[思考のトラブルシューティング](https://platform.claude.com/docs/ja/build-with-claude/thinking-troubleshooting)に各エラーとその修正方法が記載されています。

| モデル                   | `thinking`フィールドなし | `"adaptive"` | `budget_tokens`付きの`"enabled"` | `"between_tools"`      | `"disabled"`         |
| --------------------- | ----------------- | ------------ | ----------------------------- | ---------------------- | -------------------- |
| Claude Opus 5.5       | 適応型思考             | 適応型思考        | 400エラー                        | 400エラー                 | 400エラー               |
| Claude Sonnet 5.5     | 適応型思考             | 適応型思考        | 400エラー                        | `high` effort以下で事前思考オフ | 400エラー               |
| Claude Haiku 5.5      | 適応型思考             | 適応型思考        | 400エラー                        | 400エラー                 | `high` effort以下で思考オフ |
| Claude Fable 5.1      | 適応型思考             | 適応型思考        | 400エラー                        | 400エラー                 | 400エラー               |
| Claude Mythos 5.1     | 適応型思考             | 適応型思考        | 400エラー                        | 400エラー                 | 400エラー               |
| Claude Fable 5        | 適応型思考             | 適応型思考        | 400エラー                        | 400エラー                 | 400エラー               |
| Claude Mythos 5       | 適応型思考             | 適応型思考        | 400エラー                        | 400エラー                 | 400エラー               |
| Claude Opus 5         | 適応型思考             | 適応型思考        | 400エラー                        | 400エラー                 | `high` effort以下で思考オフ |
| Claude Sonnet 5       | 適応型思考             | 適応型思考        | 400エラー                        | 400エラー                 | 思考オフ                 |
| Claude Opus 4.8       | 思考オフ              | 適応型思考        | 400エラー                        | 400エラー                 | 思考オフ                 |
| Claude Opus 4.7       | 思考オフ              | 適応型思考        | 400エラー                        | 400エラー                 | 思考オフ                 |
| Claude Mythos Preview | 適応型思考             | 適応型思考        | 拡張思考                          | 400エラー                 | 400エラー               |
| Claude Opus 4.6       | 思考オフ              | 適応型思考        | 拡張思考（非推奨）                     | 400エラー                 | 思考オフ                 |
| Claude Sonnet 4.6     | 思考オフ              | 適応型思考        | 拡張思考（非推奨）                     | 400エラー                 | 思考オフ                 |
| Claude Opus 4.5       | 思考オフ              | 400エラー       | 拡張思考                          | 400エラー                 | 思考オフ                 |
| Claude Sonnet 4.5     | 思考オフ              | 400エラー       | 拡張思考                          | 400エラー                 | 思考オフ                 |
| Claude Haiku 4.5      | 思考オフ              | 400エラー       | 拡張思考                          | 400エラー                 | 思考オフ                 |

表中の「`high` effort以下」とは、リクエストが`low`、`medium`、`high`のeffortでは機能し、`xhigh`または`max`では400エラーを返すことを意味します。

Claude Opus 5.5、Claude Opus 5、Claude Sonnet 5.5、Claude Sonnet 5、Claude Fable 5.1、Claude Mythos 5.1、Claude Fable 5、Claude Mythos 5、Claude Mythos Preview、Claude Haiku 5.5では、思考はすでに有効になっており、設定は不要です。これらのモデルでは`display`のデフォルトが`"omitted"`であるため、オプトインするまで思考テキストは非表示になります。次の例のように、`thinking: {"type": "adaptive", "display": "summarized"}`でオプトインしてください。

Claude Opus 4.8、Claude Opus 4.7、Claude Opus 4.6、Claude Sonnet 4.6では、`thinking: {type: "adaptive"}`を設定するまで思考はオフです。この設定により、Claudeはリクエストに基づいて、いつ、どの程度深く思考するかを判断します。同じリクエストで[モデル文字列](https://platform.claude.com/docs/ja/models/overview)を差し替えるだけで、これらのモデルでも思考が有効になります。次の例では、思考テキストが表示されるように`display: "summarized"`を設定し、余裕のある`max_tokens`を使用しています：

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

  ```bash CLI
  ant messages create \
    --model claude-opus-5-5 \
    --max-tokens 16000 \
    --thinking '{type: adaptive, display: summarized}' \
    --message '{role: user, content: "What is the greatest common divisor of 1071 and 462?"}' \
    --transform content \
    --format yaml
  ```

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

  response = client.messages.create(
      model="claude-opus-5-5",
      max_tokens=16000,
      thinking={"type": "adaptive", "display": "summarized"},
      messages=[
          {
              "role": "user",
              "content": "What is the greatest common divisor of 1071 and 462?",
          }
      ],
  )

  for block in response.content:
      match block.type:
          case "thinking":
              print(f"\nThinking: {block.thinking}")
          case "text":
              print(f"\nResponse: {block.text}")
  ```

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

  const response = await client.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 16000,
    thinking: {
      type: "adaptive",
      display: "summarized"
    },
    messages: [
      {
        role: "user",
        content: "What is the greatest common divisor of 1071 and 462?"
      }
    ]
  });

  for (const block of response.content) {
    switch (block.type) {
      case "thinking":
        console.log(`\nThinking: ${block.thinking}`);
        break;
      case "text":
        console.log(`\nResponse: ${block.text}`);
        break;
    }
  }
  ```

  ```csharp C#
  AnthropicClient client = new();

  var parameters = new MessageCreateParams
  {
      Model = Model.ClaudeOpus5_5,
      MaxTokens = 16000,
      Thinking = new ThinkingConfigAdaptive { Display = Display.Summarized },
      Messages = [
          new() {
              Role = Role.User,
              Content = "What is the greatest common divisor of 1071 and 462?"
          }
      ]
  };

  var message = await client.Messages.Create(parameters);

  foreach (var block in message.Content)
  {
      if (block.TryPickThinking(out ThinkingBlock? thinking))
      {
          Console.WriteLine($"\nThinking: {thinking.Thinking}");
      }
      else if (block.TryPickText(out TextBlock? text))
      {
          Console.WriteLine($"\nResponse: {text.Text}");
      }
  }
  ```

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

  response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 16000,
  	Thinking: anthropic.ThinkingConfigParamUnion{
  		OfAdaptive: &anthropic.ThinkingConfigAdaptiveParam{
  			Display: anthropic.ThinkingConfigAdaptiveDisplaySummarized,
  		},
  	},
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("What is the greatest common divisor of 1071 and 462?")),
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }

  for _, block := range response.Content {
  	switch v := block.AsAny().(type) {
  	case anthropic.ThinkingBlock:
  		fmt.Printf("\nThinking: %s", v.Thinking)
  	case anthropic.TextBlock:
  		fmt.Printf("\nResponse: %s", v.Text)
  	}
  }
  ```

  ```java Java
  import com.anthropic.models.messages.ThinkingConfigAdaptive;

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

      MessageCreateParams params = MessageCreateParams.builder()
          .model(Model.CLAUDE_OPUS_5_5)
          .maxTokens(16000L)
          .thinking(ThinkingConfigAdaptive.builder()
              .display(ThinkingConfigAdaptive.Display.SUMMARIZED)
              .build())
          .addUserMessage("What is the greatest common divisor of 1071 and 462?")
          .build();

      Message response = client.messages().create(params);

      response.content().forEach(block -> {
          block.thinking().ifPresent(thinkingBlock ->
              IO.println("\nThinking: " + thinkingBlock.thinking())
          );
          block.text().ifPresent(textBlock ->
              IO.println("\nResponse: " + textBlock.text())
          );
      });
  }
  ```

  ```php PHP
  use Anthropic\Messages\TextBlock;
  use Anthropic\Messages\ThinkingBlock;

  $client = new Client();

  $message = $client->messages->create(
      maxTokens: 16000,
      messages: [
          [
              'role' => 'user',
              'content' => 'What is the greatest common divisor of 1071 and 462?'
          ]
      ],
      model: 'claude-opus-5-5',
      thinking: ['type' => 'adaptive', 'display' => 'summarized'],
  );

  foreach ($message->content as $block) {
      switch (true) {
          case $block instanceof ThinkingBlock:
              echo "\nThinking: " . $block->thinking;
              break;
          case $block instanceof TextBlock:
              echo "\nResponse: " . $block->text;
              break;
      }
  }
  ```

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

  message = client.messages.create(
    model: "claude-opus-5-5",
    max_tokens: 16000,
    thinking: {
      type: "adaptive",
      # このようなプレーンなハッシュでは display: を使います。型付きの ThinkingConfigAdaptive クラスでは
      # Ruby の Kernel#display を隠さないよう display_（末尾にアンダースコア）と表記します。
      # リクエストでは引き続き display が送信されます。
      display: "summarized"
    },
    messages: [
      {
        role: "user",
        content: "What is the greatest common divisor of 1071 and 462?"
      }
    ]
  )

  message.content.each do |block|
    case block
    when Anthropic::Models::ThinkingBlock
      puts "\nThinking: #{block.thinking}"
    when Anthropic::Models::TextBlock
      puts "\nResponse: #{block.text}"
    end
  end
  ```
</CodeGroup>

この例を実行すると、要約された思考が出力され、その後に回答が出力されます：

```text Output wrap
Thinking: Use Euclidean algorithm.
1071 = 2*462 + 147
462 = 3*147 + 21
147 = 7*21 + 0
GCD = 21

Response: ## Finding GCD of 1071 and 462

I'll use the **Euclidean algorithm**, repeatedly dividing and taking remainders...
```

思考トークンは`max_tokens`にカウントされるため、思考と応答テキストの両方に十分な余裕を残せるよう高めに設定してください。ステアリングページの[コスト制御](https://platform.claude.com/docs/ja/build-with-claude/thinking-steering-and-cost#cost-control)と[思考とコンテキストウィンドウ](https://platform.claude.com/docs/ja/build-with-claude/thinking#thinking-and-the-context-window)を参照してください。

### 思考をオフにする

思考がデフォルトで有効になっているClaude Sonnet 5では、思考をオフにできます：

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-sonnet-5",
      "max_tokens": 4096,
      "thinking": {"type": "disabled"},
      "messages": [
        {
          "role": "user",
          "content": "Summarize this article in one sentence."
        }
      ]
    }'
  ```

  ```bash CLI
  ant messages create \
    --model claude-sonnet-5 \
    --max-tokens 4096 \
    --thinking '{type: disabled}' \
    --message '{role: user, content: "Summarize this article in one sentence."}'
  ```

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

  response = client.messages.create(
      model="claude-sonnet-5",
      max_tokens=4096,
      thinking={"type": "disabled"},
      messages=[{"role": "user", "content": "Summarize this article in one sentence."}],
  )
  ```

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

  const response = await client.messages.create({
    model: "claude-sonnet-5",
    max_tokens: 4096,
    thinking: { type: "disabled" },
    messages: [{ role: "user", content: "Summarize this article in one sentence." }]
  });
  ```

  ```csharp C#
  AnthropicClient client = new();

  var parameters = new MessageCreateParams
  {
      Model = Model.ClaudeSonnet5,
      MaxTokens = 4096,
      Thinking = new ThinkingConfigDisabled(),
      Messages = [
          new() {
              Role = Role.User,
              Content = "Summarize this article in one sentence."
          }
      ]
  };

  var message = await client.Messages.Create(parameters);
  ```

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

  response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeSonnet5,
  	MaxTokens: 4096,
  	Thinking: anthropic.ThinkingConfigParamUnion{
  		OfDisabled: &anthropic.ThinkingConfigDisabledParam{},
  	},
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("Summarize this article in one sentence.")),
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }
  ```

  ```java Java
  import com.anthropic.models.messages.ThinkingConfigDisabled;

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

      MessageCreateParams params = MessageCreateParams.builder()
          .model(Model.CLAUDE_SONNET_5)
          .maxTokens(4096L)
          .thinking(ThinkingConfigDisabled.builder().build())
          .addUserMessage("Summarize this article in one sentence.")
          .build();

      Message response = client.messages().create(params);
  }
  ```

  ```php PHP
  $client = new Client();

  $message = $client->messages->create(
      maxTokens: 4096,
      messages: [
          [
              'role' => 'user',
              'content' => 'Summarize this article in one sentence.'
          ]
      ],
      model: 'claude-sonnet-5',
      thinking: ['type' => 'disabled'],
  );
  ```

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

  message = client.messages.create(
    model: "claude-sonnet-5",
    max_tokens: 4096,
    thinking: { type: "disabled" },
    messages: [
      {
        role: "user",
        content: "Summarize this article in one sentence."
      }
    ]
  )
  ```
</CodeGroup>

Claude Opus 5も思考がデフォルトで有効になっており、[effort](https://platform.claude.com/docs/ja/build-with-claude/effort)が`high`以下の場合に`thinking: {type: "disabled"}`を受け付けます。`xhigh`または`max`のeffortでは思考をオフにできません。`thinking: {type: "disabled"}`とこれらのeffortレベルを組み合わせたリクエストは400エラーを返します。この制限はリクエストごとに適用されます。思考が無効な場合、Claude Opus 5はまれにツール呼び出しをプレーンテキストとして出力したり、表示される出力に内部XMLタグを含めたりすることがあります。プロンプトによる緩和策については、[思考を無効にして実行する](https://platform.claude.com/docs/ja/build-with-claude/prompt-engineering/prompting-claude-opus-5#running-with-thinking-disabled)を参照してください。

Claude Sonnet 5.5も思考がデフォルトで有効になっており、`thinking: {type: "disabled"}`を400エラーで拒否します。事前思考をオフにするには、代わりに`thinking: {type: "between_tools"}`を送信してください。これはClaude Sonnet 5.5で最も低い思考設定であり、[effort](https://platform.claude.com/docs/ja/build-with-claude/effort)が`high`以下の場合に受け付けられます。モデルは引き続き[ツール呼び出し間の進捗更新](https://platform.claude.com/docs/ja/build-with-claude/thinking#progress-updates)を返します。ツールがない場合、Claude Sonnet 5での`disabled`と同様に、応答にはテキストのみが含まれます。プロンプトのガイダンスについては、[事前思考なしでの実行](https://platform.claude.com/docs/ja/build-with-claude/prompt-engineering/prompting-claude-sonnet-5-5#running-without-up-front-thinking)を参照してください。

Claude Haiku 5.5も思考がデフォルトで有効になっており、[effort](https://platform.claude.com/docs/ja/build-with-claude/effort)が`high`以下の場合に`thinking: {type: "disabled"}`を受け付けます。`xhigh`または`max`のeffortでは、その組み合わせは400エラーを返します。思考を減らすには、まずeffortレベルを下げてください。思考がオフの場合、JSON出力も要求すると、モデルが必要なツール呼び出しをスキップすることがあります。思考がオフの間は、有効なレベルと異なる[メッセージごとの`output_config.effort`](https://platform.claude.com/docs/ja/build-with-claude/effort#change-effort-mid-conversation-beta)も400エラーを返します。[エフォートを使用して思考を制御する](https://platform.claude.com/docs/ja/build-with-claude/prompt-engineering/prompting-claude-haiku-5-5#use-effort-to-control-thinking)と[JSON出力と独自のツールで適応型思考を使用する](https://platform.claude.com/docs/ja/build-with-claude/prompt-engineering/prompting-claude-haiku-5-5#json-output-with-your-own-tools)を参照してください。

Claude Fable 5.1、Claude Mythos 5.1、Claude Fable 5、Claude Mythos 5、Claude Opus 5.5、Claude Mythos Previewは`thinking: {type: "disabled"}`を拒否します。これらのモデルでは思考をオフにできません。

リクエストを送信する前にモデルが`"disabled"`を受け付けるかどうかを確認するには、Models APIからその`capabilities.thinking.types.disabled.supported`値を読み取ってください。このフィールドについては[Models APIの使用](https://platform.claude.com/docs/ja/models/overview#using-the-models-api)で説明しています。

モデルが拡張思考のみをサポートしている場合（[モデルごとの設定表](https://platform.claude.com/docs/ja/build-with-claude/thinking-troubleshooting#supported-models)を参照）、代わりに`type: "enabled"`と`budget_tokens`値で設定してください。その設定については[拡張思考](https://platform.claude.com/docs/ja/build-with-claude/extended-thinking)ページで説明しています。また、いずれかの思考設定で400エラーが返された場合は、[思考のトラブルシューティング](https://platform.claude.com/docs/ja/build-with-claude/thinking-troubleshooting)で各エラーメッセージとその修正方法を確認できます。

## 思考出力の読み取り

### 思考表示の制御

思考設定の`display`フィールドは、APIレスポンスで思考コンテンツがどのように返されるかを制御します。`display`は両方のモードで機能し、`type: "adaptive"`または`type: "enabled"`と一緒に設定します。次の値を受け付けます：

* `"summarized"`：思考ブロックには[要約された思考](https://platform.claude.com/docs/ja/build-with-claude/thinking#summarized-thinking)テキスト、つまりClaudeの推論の読みやすい要約が含まれます。これはClaude Opus 4.6、Claude Sonnet 4.6、およびそれ以前のモデルでのデフォルトです。
* `"omitted"`：思考ブロックは`thinking`フィールドが空の状態で返されます。`signature`フィールドには、マルチターンの継続性のために暗号化された完全な思考が引き続き含まれます（[思考の暗号化](https://platform.claude.com/docs/ja/build-with-claude/thinking#thinking-encryption)を参照）。これはClaude Fable 5.1、Claude Mythos 5.1、Claude Fable 5、Claude Mythos 5、Claude Opus 5.5、Claude Opus 5、Claude Sonnet 5.5、Claude Sonnet 5、Claude Opus 4.8、Claude Opus 4.7、[Claude Mythos Preview](https://anthropic.com/glasswing)、Claude Haiku 5.5でのデフォルトです。
* `"updates"`（ベータ）：推論ブロックは`"omitted"`と同様に`thinking`フィールドが空の状態で返され、一部のモデルがツール呼び出しの間に書く短い[進捗更新](https://platform.claude.com/docs/ja/build-with-claude/thinking#progress-updates)は読み取り可能なテキストとして返されます。ベータヘッダー`thinking-display-updates-2026-08-18`が必要です。

アプリケーションが思考コンテンツをユーザーに表示しない場合は、`display: "omitted"`を設定してください。主な利点は、ストリーミング時に最初のテキストトークンまでの時間が短縮されることです。サーバーは思考トークンのストリーミングを完全にスキップし、署名のみを配信するため、最終的なテキスト応答のストリーミングがより早く始まります。

`display: "omitted"`の場合、レスポンスには`thinking`フィールドが空の`thinking`ブロックが含まれます：

```json Output
{
  "content": [
    {
      "type": "thinking",
      "thinking": "",
      "signature": "EosnCkYICxIMMb3LzNrMu..."
    },
    {
      "type": "text",
      "text": "The answer is 12,231."
    }
  ]
}
```

省略された思考を扱う際は、次の点に留意してください：

* 完全な思考トークンに対して引き続き課金されます。省略によって削減されるのはレイテンシであり、コストではありません。
* マルチターンの会話で思考ブロックを返す場合は、変更せずにそのまま返してください。サーバーは`signature`を復号して、プロンプト構築のために元の思考を再構築します（[思考ブロックの保持](https://platform.claude.com/docs/ja/build-with-claude/thinking#preserving-thinking-blocks)を参照）。往復させた省略ブロックの`thinking`フィールドに配置したテキストは無視されます。
* `display`は`thinking.type: "disabled"`（表示するものがないため）および`thinking.type: "between_tools"`（Claude Sonnet 5.5のみ）では無効です。後者は他のフィールドを受け付けません。`between_tools`では、`display: "updates"`の場合と同様に、進捗更新は引き続き要約テキスト付きで返されます（[進捗更新](https://platform.claude.com/docs/ja/build-with-claude/thinking#progress-updates)を参照）。
* `thinking.type: "adaptive"`を使用していて、モデルが単純なリクエストに対して思考をスキップした場合、`display`に関係なく思考ブロックは生成されません。
* `display: "omitted"`でストリーミングする場合、思考テキストはストリーミングされません。各思考ブロックは空の`thinking`文字列を持つ`thinking_delta`をストリーミングし、その後に`signature_delta`をストリーミングします。`display: "updates"`の場合、テキストを含む`thinking_delta`イベントをストリーミングするのは[進捗更新ブロック](https://platform.claude.com/docs/ja/build-with-claude/thinking#progress-updates)のみです。イベントシーケンスについては[思考のストリーミング](https://platform.claude.com/docs/ja/build-with-claude/thinking#streaming-thinking)を参照してください。

<Note>
  `signature`フィールドは、どの`display`値を設定しても同一です。会話のターン間で`display`値を切り替えることはサポートされています。
</Note>

### 要約された思考

`display`が`"summarized"`の場合、受け取る思考テキストは生の思考の連鎖ではなく、Claudeの完全な思考プロセスの要約です。「summarized thinking」（要約された思考）は、悪用を防ぎながら、思考による知能面の利点をすべて提供します。生の思考の連鎖を返す`display`設定はありません。

要約された思考を扱う際は、次の点に留意してください：

* 課金されるのは、要約トークンではなく、元のリクエストによって生成された完全な思考トークンです。課金される出力トークン数は、レスポンスで確認できるトークン数と一致しません。
* Claude Opus 4.6、Claude Sonnet 4.6、およびそれ以前のモデルでは、思考出力の最初の数行がより詳細で、プロンプトエンジニアリングの目的に特に役立つ詳細な推論が提供されます。[Claude Mythos Preview](https://anthropic.com/glasswing)は最初のトークンから要約するため、その思考ブロックにはこの詳細な前置きは表示されません。
* 要約は、追加のレイテンシを最小限に抑えながらClaudeの思考プロセスの主要なアイデアを保持するため、要約は届き次第ストリーミングできます。
* 要約は、リクエストで対象とするモデルとは異なるモデルによって処理されます。思考モデルは要約された出力を参照しません。
* Anthropicは思考機能の改善に取り組んでいるため、要約の動作は変更される可能性があります。

<Note>
  完全な思考出力へのアクセスが必要なまれなケースでは、[Anthropicの営業チームにお問い合わせください](mailto:sales@anthropic.com)。
</Note>

モデルの推論を確認するには、応答テキストで推論を求めるプロンプトを使用するのではなく、`thinking`ブロックを読み取ってください。Claude Fable 5.1、Claude Opus 5.5、Claude Opus 5、Claude Sonnet 5.5、Claude Fable 5では、応答テキストの一部としてモデルの内部推論を引き出そうとするリクエストは、`stop_details.category: "reasoning_extraction"`で拒否される場合があります。フィールドのリファレンスについては[拒否カテゴリ](https://platform.claude.com/docs/ja/build-with-claude/refusals-and-fallback#refusal-response)を、代わりに何を求めるべきかについては[推論を思考ブロック内に保つ](https://platform.claude.com/docs/ja/build-with-claude/refusals-and-fallback#keep-reasoning-in-thinking-blocks)を参照してください。

### 思考のストリーミング

思考は[ストリーミング](https://platform.claude.com/docs/ja/build-with-claude/streaming)と連携して機能します。思考ブロックは`content_block_delta`イベント内の`thinking_delta`イベントとしてストリーミングされ、ブロックの`content_block_stop`の直前に単一の`signature_delta`イベントが続きます。テキストブロックはその後、通常どおりストリーミングされます。

<Frame>
  ![思考を伴うストリーミングイベントシーケンスの図：「thinking block」（思考ブロック）が開き、display設定がテキストを返す場合（summarized、または進捗更新ブロックに対するupdates）にのみthinking deltaがテキストを運び、単一のsignature deltaがブロックを閉じ、その後text deltaがストリーミングされます](https://platform.claude.com/docs/ja/images/how-thinking-streams.svg)
</Frame>

次の例では、適応型思考を使用して応答をストリーミングし、思考とテキストのデルタを届き次第出力します：

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-opus-5-5",
      "max_tokens": 16000,
      "stream": true,
      "thinking": {
        "type": "adaptive",
        "display": "summarized"
      },
      "messages": [
        {
          "role": "user",
          "content": "What is the greatest common divisor of 1071 and 462?"
        }
      ]
    }'
  ```

  ```bash CLI
  ant messages create \
    --model claude-opus-5-5 \
    --max-tokens 16000 \
    --thinking '{type: adaptive, display: summarized}' \
    --message '{role: user, content: "What is the greatest common divisor of 1071 and 462?"}' \
    --stream \
    --format jsonl
  ```

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

  with client.messages.stream(
      model="claude-opus-5-5",
      max_tokens=16000,
      thinking={"type": "adaptive", "display": "summarized"},
      messages=[
          {
              "role": "user",
              "content": "What is the greatest common divisor of 1071 and 462?",
          }
      ],
  ) as stream:
      for event in stream:
          match event.type:
              case "content_block_start":
                  print(f"\nStarting {event.content_block.type} block...")
              case "content_block_delta":
                  delta = event.delta
                  match delta.type:
                      case "thinking_delta":
                          print(delta.thinking, end="", flush=True)
                      case "text_delta":
                          print(delta.text, end="", flush=True)
  ```

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

  const stream = client.messages.stream({
    model: "claude-opus-5-5",
    max_tokens: 16000,
    thinking: { type: "adaptive", display: "summarized" },
    messages: [{ role: "user", content: "What is the greatest common divisor of 1071 and 462?" }]
  });

  for await (const event of stream) {
    switch (event.type) {
      case "content_block_start":
        console.log(`\nStarting ${event.content_block.type} block...`);
        break;
      case "content_block_delta":
        switch (event.delta.type) {
          case "thinking_delta":
            process.stdout.write(event.delta.thinking);
            break;
          case "text_delta":
            process.stdout.write(event.delta.text);
            break;
        }
        break;
    }
  }
  ```

  ```csharp C#
  AnthropicClient client = new();

  var parameters = new MessageCreateParams
  {
      Model = Model.ClaudeOpus5_5,
      MaxTokens = 16000,
      Thinking = new ThinkingConfigAdaptive { Display = Display.Summarized },
      Messages = [new() { Role = Role.User, Content = "What is the greatest common divisor of 1071 and 462?" }]
  };

  await foreach (var rawEvent in client.Messages.CreateStreaming(parameters))
  {
      if (rawEvent.TryPickContentBlockStart(out var start))
      {
          Console.WriteLine($"\nStarting {start.ContentBlock.Type} block...");
      }
      else if (rawEvent.TryPickContentBlockDelta(out var delta))
      {
          if (delta.Delta.TryPickThinking(out var thinkingDelta))
          {
              Console.Write(thinkingDelta.Thinking);
          }
          else if (delta.Delta.TryPickText(out var textDelta))
          {
              Console.Write(textDelta.Text);
          }
      }
  }
  ```

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

  stream := client.Messages.NewStreaming(context.TODO(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 16000,
  	Thinking: anthropic.ThinkingConfigParamUnion{
  		OfAdaptive: &anthropic.ThinkingConfigAdaptiveParam{
  			Display: anthropic.ThinkingConfigAdaptiveDisplaySummarized,
  		},
  	},
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("What is the greatest common divisor of 1071 and 462?")),
  	},
  })

  for stream.Next() {
  	event := stream.Current()
  	switch eventVariant := event.AsAny().(type) {
  	case anthropic.ContentBlockStartEvent:
  		fmt.Printf("\nStarting %s block...\n", eventVariant.ContentBlock.Type)
  	case anthropic.ContentBlockDeltaEvent:
  		switch deltaVariant := eventVariant.Delta.AsAny().(type) {
  		case anthropic.ThinkingDelta:
  			fmt.Print(deltaVariant.Thinking)
  		case anthropic.TextDelta:
  			fmt.Print(deltaVariant.Text)
  		}
  	}
  }
  if err := stream.Err(); err != nil {
  	log.Fatal(err)
  }
  ```

  ```java Java
  import com.anthropic.models.messages.ThinkingConfigAdaptive;

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

      MessageCreateParams params = MessageCreateParams.builder()
          .model(Model.CLAUDE_OPUS_5_5)
          .maxTokens(16000L)
          .thinking(ThinkingConfigAdaptive.builder()
              .display(ThinkingConfigAdaptive.Display.SUMMARIZED)
              .build())
          .addUserMessage("What is the greatest common divisor of 1071 and 462?")
          .build();

      try (var streamResponse = client.messages().createStreaming(params)) {
          streamResponse.stream().forEach(event -> {
              switch (event.type().value()) {
                  case CONTENT_BLOCK_START -> {
                      var startEvent = event.asContentBlockStart();
                      var block = startEvent.contentBlock();
                      switch (block.type().value()) {
                          case THINKING -> IO.println("\nStarting thinking block...");
                          case TEXT -> IO.println("\nStarting text block...");
                      }
                  }
                  case CONTENT_BLOCK_DELTA -> {
                      var deltaEvent = event.asContentBlockDelta();
                      deltaEvent.delta().thinking().ifPresent(td ->
                          IO.print(td.thinking())
                      );
                      deltaEvent.delta().text().ifPresent(td ->
                          IO.print(td.text())
                      );
                  }
              }
          });
      }
  }
  ```

  ```php PHP
  use Anthropic\Messages\RawContentBlockDeltaEvent;
  use Anthropic\Messages\RawContentBlockStartEvent;
  use Anthropic\Messages\TextDelta;
  use Anthropic\Messages\ThinkingDelta;

  $client = new Client();

  $stream = $client->messages->createStream(
      maxTokens: 16000,
      messages: [
          ['role' => 'user', 'content' => 'What is the greatest common divisor of 1071 and 462?']
      ],
      model: 'claude-opus-5-5',
      thinking: ['type' => 'adaptive', 'display' => 'summarized'],
  );

  foreach ($stream as $event) {
      switch (true) {
          case $event instanceof RawContentBlockStartEvent:
              echo "\nStarting {$event->contentBlock->type} block...\n";
              break;
          case $event instanceof RawContentBlockDeltaEvent:
              switch (true) {
                  case $event->delta instanceof ThinkingDelta:
                      echo $event->delta->thinking;
                      break;
                  case $event->delta instanceof TextDelta:
                      echo $event->delta->text;
                      break;
              }
              break;
      }
  }
  ```

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

  stream = client.messages.stream(
    model: "claude-opus-5-5",
    max_tokens: 16000,
    # このようなプレーンなハッシュでは display: を使用します。型付きの ThinkingConfigAdaptive クラスでは
    # Ruby の Kernel#display を隠さないよう、display_（末尾にアンダースコア）と表記します。
    # リクエストでは引き続き display が送信されます。
    thinking: { type: "adaptive", display: "summarized" },
    messages: [
      { role: "user", content: "What is the greatest common divisor of 1071 and 462?" }
    ]
  )

  stream.each do |event|
    case event
    when Anthropic::Streaming::ThinkingEvent
      print event.thinking
    when Anthropic::Streaming::TextEvent
      print event.text
    end
  end
  ```
</CodeGroup>

ストリーミング後に署名付きの完全な思考ブロックを再構築するには、デルタを自分で連結するのではなく、SDKのメッセージ蓄積ヘルパーである`stream.get_final_message()` (typescript: `stream.finalMessage()`; ruby: `stream.accumulated_message`; csharp: `.Aggregate()`; go: `message.Accumulate(event)`; java, php: `MessageAccumulator`)を使用してください。

<Accordion title="完全なストリーミングイベントトレース">
  ```sse Output
  event: message_start
  data: {"type": "message_start", "message": {"id": "msg_01...", "type": "message", "role": "assistant", "content": [], "model": "claude-opus-5-5", "stop_reason": null, "stop_sequence": null}}

  event: content_block_start
  data: {"type": "content_block_start", "index": 0, "content_block": {"type": "thinking", "thinking": "", "signature": ""}}

  event: content_block_delta
  data: {"type": "content_block_delta", "index": 0, "delta": {"type": "thinking_delta", "thinking": "I need to find the GCD of 1071 and 462 using the Euclidean algorithm.\n\n1071 = 2 × 462 + 147"}}

  event: content_block_delta
  data: {"type": "content_block_delta", "index": 0, "delta": {"type": "thinking_delta", "thinking": "\n462 = 3 × 147 + 21\n147 = 7 × 21 + 0\n\nSo GCD(1071, 462) = 21"}}

  // Additional thinking deltas...

  event: content_block_delta
  data: {"type": "content_block_delta", "index": 0, "delta": {"type": "signature_delta", "signature": "EqQBCgIYAhIM1gbcDa9GJwZA2b..."}}

  event: content_block_stop
  data: {"type": "content_block_stop", "index": 0}

  event: content_block_start
  data: {"type": "content_block_start", "index": 1, "content_block": {"type": "text", "text": ""}}

  event: content_block_delta
  data: {"type": "content_block_delta", "index": 1, "delta": {"type": "text_delta", "text": "The greatest common divisor of 1071 and 462 is **21**."}}

  // Additional text deltas...

  event: content_block_stop
  data: {"type": "content_block_stop", "index": 1}

  event: message_delta
  data: {"type": "message_delta", "delta": {"stop_reason": "end_turn", "stop_sequence": null}}

  event: message_stop
  data: {"type": "message_stop"}
  ```
</Accordion>

`display: "omitted"`が設定されている場合、思考ブロックが開き、空の`thinking`文字列を持つ`thinking_delta`が届き、単一の`signature_delta`が続いて、ブロックが閉じます。テキストのストリーミングはその直後に始まります：

```sse Output
event: content_block_start
data: {"type":"content_block_start","index":0,"content_block":{"type":"thinking","thinking":"","signature":""}}

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"thinking_delta","thinking":""}}

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"signature_delta","signature":"EosnCkYICxIMMb3LzNrMu..."}}

event: content_block_stop
data: {"type":"content_block_stop","index":0}

event: content_block_start
data: {"type":"content_block_start","index":1,"content_block":{"type":"text","text":""}}
```

`display: "updates"`（ベータ）の場合、推論ブロックは`"omitted"`の場合と同様にストリーミングされます。各[進捗更新ブロック](https://platform.claude.com/docs/ja/build-with-claude/thinking#progress-updates)は、それが導入する`tool_use`ブロックの前に、そのテキストを`thinking_delta`イベントとしてストリーミングします。進捗更新ブロックが開く前に数秒間の一時停止があるのは正常です：

```sse Output
event: content_block_start
data: {"type":"content_block_start","index":1,"content_block":{"type":"thinking","thinking":"","signature":""}}

event: content_block_delta
data: {"type":"content_block_delta","index":1,"delta":{"type":"thinking_delta","thinking":"Confirmed the retry path never refreshes the expired token. Editing auth.py to add the refresh call."}}

event: content_block_delta
data: {"type":"content_block_delta","index":1,"delta":{"type":"signature_delta","signature":"Es8CCkYICxIM..."}}

event: content_block_stop
data: {"type":"content_block_stop","index":1}

event: content_block_start
data: {"type":"content_block_start","index":2,"content_block":{"type":"tool_use","id":"toolu_01D7FLrfh4GYq7yT1ULFeyMV","name":"edit_file","input":{}}}
```

`"updates"`では、ブロックの`thinking_delta`イベントのいずれかが空でないテキストを含んだ時点で、そのブロックを進捗更新として扱ってください。

<Note>
  思考を有効にしてストリーミングを使用すると、テキストが大きなチャンクで届く場合と、トークンごとの小さな配信が交互に発生することに気付く場合があります。これは、特に思考コンテンツにおいて想定される動作です。

  ストリーミングシステムはコンテンツをバッチで処理するため、ストリーミングイベントが遅延し、このような「チャンク状」の配信パターンにまとめられることがあります。
</Note>

ストリーミングの一般的な仕組みについては、[メッセージのストリーミング](https://platform.claude.com/docs/ja/build-with-claude/streaming)を参照してください。

## 思考とeffort

`thinking` パラメータは、Claudeが回答する前に[思考ブロック](https://platform.claude.com/docs/ja/build-with-claude/thinking)で思考するかどうかを制御します。`effort` パラメータは、Claudeが応答全体にどれだけの労力を費やすかを制御し、アダプティブモードではどのくらいの頻度で、どのくらい深く思考するかも含まれます。`effort` の値として `adaptive` を渡さないでください。`adaptive` は思考モードであり、effortレベルではありません。

各effortレベルが思考の動作に何をもたらすかについては、[思考のステアリング](https://platform.claude.com/docs/ja/build-with-claude/thinking-steering-and-cost)ページの[レベルごとの思考動作の表](https://platform.claude.com/docs/ja/build-with-claude/thinking-steering-and-cost#effort-levels)を参照してください。[Effort](https://platform.claude.com/docs/ja/build-with-claude/effort)ページでは、各モデルがサポートするレベルを含め、パラメータ自体について説明しています。effortをサポートする唯一の拡張思考専用モデルであるClaude Opus 4.5では、effortは`budget_tokens`と組み合わせて機能します。[予算のルールと調整](https://platform.claude.com/docs/ja/build-with-claude/extended-thinking#budget-rules-and-tuning)を参照してください。

2つの制御がこのように分離されているため、目的に合ったものを選択してください：

* **思考が有効なワークロードでコストやレイテンシを下げたい場合：** まず`effort`を下げてください。思考を含む応答全体が縮小されます。
* **Claudeの思考の頻度が低すぎる、または浅すぎる場合：** `effort`を上げるか、ステアリングページの[Claudeが思考する頻度のステアリング](https://platform.claude.com/docs/ja/build-with-claude/thinking-steering-and-cost#tuning-thinking-behavior)を参照してください。
* **思考を完全にオフにする必要がある場合：** それを許可するモデルでは`thinking: {type: "disabled"}`を使用してください（[モデルごとの設定表](https://platform.claude.com/docs/ja/build-with-claude/thinking-troubleshooting#supported-models)を参照）。Claude Sonnet 5.5は`"disabled"`を拒否します。その最も低い設定は`thinking: {type: "between_tools"}`で、事前思考をオフにします。
* **支出に厳格な上限が必要な場合：** `max_tokens`を使用してください。effortはソフトなガイダンスです。`max_tokens`は厳格な制限です。

## ツール使用と思考

思考は[ツール使用](https://platform.claude.com/docs/ja/agents-and-tools/tool-use/overview)と連携して機能し、Claudeがツールの選択について推論し、ツールの結果を処理できるようにします。2つの制約が適用されます：

1. **ツール選択の制限（手動モード）：** 手動の拡張思考（`thinking: {type: "enabled"}`）を使用したツール使用は、`tool_choice: {"type": "auto"}`（デフォルト）または`tool_choice: {"type": "none"}`のみをサポートします。`tool_choice: {"type": "any"}`または`tool_choice: {"type": "tool", "name": "..."}`を使用するとエラーになります。これらのオプションはツール使用を強制するため、手動の拡張思考と互換性がないからです。適応型思考は、思考がデフォルトで有効なモデルを含め、強制ツール使用をサポートしますが、Claude Opus 5.5、Claude Sonnet 5.5、Claude Fable 5.1、Claude Mythos 5.1は例外です（[レスポンスのプリフィルと強制ツール使用](https://platform.claude.com/docs/ja/build-with-claude/thinking#limits-and-feature-compatibility)を参照）。強制ツール使用が受け付けられる場合、レスポンスはツール呼び出しから始まり、`thinking`ブロックは含まれません。
2. **思考ブロックの保持：** ツールの結果を返す際は、アシスタントメッセージの思考ブロックを完全かつ変更されていない状態でAPIに返す必要があります。[思考ブロックの保持](https://platform.claude.com/docs/ja/build-with-claude/thinking#preserving-thinking-blocks)を参照してください。

**ツール使用ループは1つのアシスタントターンです。** モデルの観点からは、アシスタントターンはClaudeが完全な応答を終えるまで完了しません。この応答には複数のツール呼び出しと結果が含まれる場合があります。この一連のシーケンス全体が単一のアシスタントターンです：

```text wrap
User: "What's the weather in Paris?"
Assistant: [thinking] + [tool_use: get_weather]
User: [tool_result: "20°C, sunny"]
Assistant: [text: "The weather in Paris is 20°C and sunny"]
```

ターン全体は単一の思考モードで実行されます。ツール使用ループ中を含め、ターンの途中で思考を切り替えることはできません。拡張（手動）モードでは、APIはさらに、思考が有効なリクエストの最後のアシスタントターンが思考ブロックで始まることを強制します。適応型モードではこれが緩和され、どのアシスタントターンも思考ブロックで始まる必要はありません。

**ターン途中の競合は穏やかに処理されます。** ターンの途中で思考を切り替えた場合（たとえば、ツール呼び出しを送信してからその結果を返すまでの間）、APIはエラーを返しません。代わりに、そのリクエストの思考を暗黙的に無効にします。モデルの品質を維持するため、APIは無効なターン構造を生じさせる思考ブロックを削除したり、会話履歴が思考の有効化と互換性がない場合に思考を無効にしたりすることがあります。思考が有効だったかどうかを確認するには、レスポンスに`thinking`ブロックが存在するかどうかを確認してください。

**ターン内ではなく、ターン間で切り替えてください。** 各ターンの開始時に思考戦略を計画してください。アシスタントターンを完了してから、次のターンの思考設定を変更します：

```text wrap
User: "What's the weather?"
Assistant: [tool_use] (thinking disabled)
User: [tool_result]
Assistant: [text: "It's sunny"]
User: "What about tomorrow?"
Assistant: [thinking] + [text: "..."] (thinking enabled - new turn)
```

思考モードを切り替えると、プロンプトキャッシングも無効になります。[思考とプロンプトキャッシング](https://platform.claude.com/docs/ja/build-with-claude/thinking#thinking-and-prompt-caching)を参照してください。

### 思考ブロックの保持

Claudeがツールを呼び出すと、外部情報を待つためにレスポンスの構築を一時停止します。ツールの結果を返すと、Claudeは同じレスポンスの構築を再開するため、それまでの推論が引き続き存在している必要があります。すべての`thinking`ブロックを、それに付随していた`tool_use`ブロックとともに、完全かつ変更されていない状態でAPIに返してください。これが重要な理由は2つあります。

1. **推論の継続性：** 思考ブロックには、ツールリクエストに至った段階的な推論が記録されています。これらを含めることで、Claudeは中断したところから推論を続けられます。
2. **コンテキストの維持：** ツールの結果はAPI構造上ではユーザーメッセージとして表示されますが、1つの連続した推論フローの一部です。思考ブロックを保持することで、API呼び出しをまたいでそのフローが維持されます。

要約すると、次のとおりです。

* **必須：** ツール使用のターン内では、思考ブロックを返してください。
* **推奨：** ターン間では、すべてを返してください。
* **許容：** ツール使用以外では、以前のターンの思考を省略できます。

古い思考を自分で削除する必要はありません。マルチターン会話ではすべての思考ブロックを返してください。APIが自動的にフィルタリングし、モデルの推論を保持するために必要なブロックを残し、実際にClaudeに提示されたブロックに対してのみ入力トークンを課金します。以前のターンのどのブロックが保持されるかはモデルによって異なります。[モデル別の思考ブロックの保持](https://platform.claude.com/docs/ja/build-with-claude/thinking#thinking-block-preservation-by-model)を参照してください。デフォルトを上書きするには、[`clear_thinking_20251015`コンテキスト編集戦略](https://platform.claude.com/docs/ja/build-with-claude/context-editing#thinking-block-clearing)を使用してください。

最新のアシスタントメッセージ内では、連続する`thinking`ブロックの並びが、元のリクエストでモデルが生成したものと一致している必要があります。並べ替え、編集、一部の削除はできません。これには[`redacted_thinking`ブロック](https://platform.claude.com/docs/ja/build-with-claude/thinking#redacted-thinking-blocks)も含まれます。

<Note>
  変更された思考ブロックは400エラーで拒否されます。正確なメッセージ、一般的な原因、修正方法については、[思考ブロックは変更できないという400エラー](https://platform.claude.com/docs/ja/build-with-claude/thinking-troubleshooting#error-thinking-blocks-modified)を参照してください。唯一の例外として、[省略された](https://platform.claude.com/docs/ja/build-with-claude/thinking#controlling-thinking-display)ブロックの空の`thinking`フィールドに入れたテキストは、拒否されずに無視されます。
</Note>

すべてのSDKのコードを含む2ターンの完全なウォークスルーについては、[ツールおよびマルチターンワークフローでの思考](https://platform.claude.com/docs/ja/build-with-claude/thinking-tool-workflows#two-turn-tool-use-round-trip)を参照してください。ツールを定義し、思考とツール使用を含むレスポンスを受け取り、ツールの結果とともにアシスタントターンを返す流れを示しています。

### インターリーブ思考

「interleaved thinking」（インターリーブ思考）により、Claudeはツール呼び出しの間に思考し、各ツールの結果について推論してから行動できます。インターリーブ思考により、Claudeは次のことができます：

* 次に何をするかを決定する前に、ツール呼び出しの結果について推論する
* 間に推論ステップを挟みながら複数のツール呼び出しを連鎖させる
* 中間結果に基づいて、よりきめ細かな判断を行う

<Note>
  連続するツール呼び出しにインターリーブ思考は必要ありません。Claudeはインターリーブ思考の有無にかかわらずツール呼び出しを連鎖させることができます。インターリーブによって変わるのは、ツール呼び出しの間に思考ブロックが現れる位置であり、ツール呼び出しを連鎖できるかどうかではありません。
</Note>

適応型思考では、適応型思考をサポートするすべてのモデルでインターリーブ思考が自動的に有効になります。ベータヘッダーは不要です。Claude Fable 5.1、Claude Mythos 5.1、Claude Fable 5、Claude Mythos 5、Claude Mythos Preview、Claude Opus 5.5、Claude Opus 5、Claude Sonnet 5.5、Claude Opus 4.8、Claude Opus 4.7では、ツール呼び出し間の推論は常に思考ブロックに表示されます。Claude Haiku 4.5はインターリーブ思考をサポートしていません。手動の拡張思考を使用するモデルでは、インターリーブにはベータヘッダーが必要であり、思考予算のカウント方法が変わります。モデルごとのルールとプラットフォーム固有のヘッダーの動作については、[手動モードでのインターリーブ思考](https://platform.claude.com/docs/ja/build-with-claude/extended-thinking#interleaved-thinking)で説明しています。

インターリーブ思考では、思考の割り当ては単一の応答ではなく、アシスタントターン全体にわたることがあります。インターリーブ思考は、[Messages APIを通じて使用されるツール](https://platform.claude.com/docs/ja/agents-and-tools/tool-use/overview)でのみサポートされています。

2つのツールを使用するワークフローでインターリーブ思考が何を変えるかを示す実例の比較については、[インターリーブ思考によってフローがどのように変わるか](https://platform.claude.com/docs/ja/build-with-claude/thinking-tool-workflows#how-interleaved-thinking-changes-the-flow)を参照してください。

### ツール呼び出し間の進捗更新

Claude Fable 5.1、Claude Mythos 5.1、Claude Opus 5.5、Claude Sonnet 5.5、Claude Fable 5では、モデルはツール呼び出しの間に「progress update」（進捗更新）を書くことができます。進捗更新とは、モデルが今見つけたことと次に何をしようとしているかについてのメモであり、推論としてではなく、エージェントを見ている人に向けて書かれたものです。各進捗更新は、独自の`signature`を持つ独自の`thinking`ブロックとして返され、同じ位置にある推論ブロックとは別になります。それが導入する`tool_use`または`server_tool_use`ブロックの直前に配置されます。各ツール呼び出しの前に置かれる進捗更新は最大1つであり、モデルはそのいずれもスキップできます。進捗更新は[インターリーブ思考](https://platform.claude.com/docs/ja/build-with-claude/thinking#interleaved-thinking)ではありません。ツール呼び出しの間に推論ブロックが現れるかどうかにかかわらず表示され、1つの応答に両方が含まれることもあります。

進捗更新ブロックに何が含まれるかは[`display`](https://platform.claude.com/docs/ja/build-with-claude/thinking#controlling-thinking-display)によって異なります：

| `display`                   | 推論ブロック            | 進捗更新ブロック              |
| --------------------------- | ----------------- | --------------------- |
| `"omitted"`（これらのモデルでのデフォルト） | 空の`thinking`フィールド | 空の`thinking`フィールド     |
| `"updates"`（ベータ）            | 空の`thinking`フィールド | 要約テキスト                |
| `"summarized"`              | 要約テキスト            | 要約テキスト（推論ブロックと区別できない） |

Claude Sonnet 5.5では、最も低い思考設定は`thinking: {type: "between_tools"}`です。これは事前思考をオフにし、各進捗更新は`display: "updates"`の場合と同様に要約テキスト付きで返されます。`between_tools`は[effort](https://platform.claude.com/docs/ja/build-with-claude/effort)が`high`以下の場合にのみ受け付けられます。`xhigh`または`max`では、これを含むリクエストは400エラーを返します。`between_tools`は他のフィールドを受け付けません。`display`、`budget_tokens`、または`block_binding`を一緒に送信すると400エラーが返されます。この設定にはベータヘッダーは不要で、Claude Sonnet 5.5を提供するすべてのプラットフォームで機能します。ブロックは変更せずにそのまま返してください。返した進捗更新ブロックは、要約ではなく、モデルが書いた完全なメモをモデルに提供します。

推論を非表示にしたまま、各ステップでユーザーにステータス行を表示するエージェントインターフェースには、`display: "updates"`を使用してください。この設定では、空でないテキストを持つ`thinking`ブロックはすべて進捗更新であるため、それらのみをレンダリングしてください。これはベータ版であり、ベータヘッダー`thinking-display-updates-2026-08-18`が必要です（Amazon Bedrock、Google Cloud、またはMicrosoft Foundryで送信する方法については、[他のプラットフォームでのベータ機能](https://platform.claude.com/docs/ja/api/beta-headers#beta-features-on-other-platforms)を参照してください）。ヘッダーがない場合、この値は不明な`display`値と同じ400 `invalid_request_error`で拒否されます。

```json
{
  "model": "claude-fable-5-1",
  "max_tokens": 16000,
  "thinking": { "type": "adaptive", "display": "updates" },
  "tools": [
    {
      "name": "edit_file",
      "description": "Replace the contents of a file in the repository.",
      "input_schema": {
        "type": "object",
        "properties": {
          "path": { "type": "string" },
          "content": { "type": "string" }
        },
        "required": ["path", "content"]
      }
    }
  ],
  "messages": [
    {
      "role": "user",
      "content": "The login test fails after an hour of uptime. Find out why and fix it."
    }
  ]
}
```

`"updates"`では、`tool_result`に続く応答の冒頭は次のようになります。最初のブロックは推論であり、`"omitted"`の場合と同様に空のままです。2番目のブロックはテキストを含むため、進捗更新です。`"summarized"`では両方のブロックがテキストを含み、`"omitted"`では両方とも空です。

```json Output
{
  "content": [
    {
      "type": "thinking",
      "thinking": "",
      "signature": "EqMBCkYICxIM..."
    },
    {
      "type": "thinking",
      "thinking": "Confirmed the retry path never refreshes the expired token. Editing auth.py to add the refresh call.",
      "signature": "Es8CCkYICxIM..."
    },
    {
      "type": "tool_use",
      "id": "toolu_01D7FLrfh4GYq7yT1ULFeyMV",
      "name": "edit_file",
      "input": { "path": "auth.py", "content": "..." }
    }
  ]
}
```

進捗更新を扱う際は、次の点に留意してください：

* 進捗更新ブロックは、他の`thinking`ブロックと同様に、アシスタントターンの残りの部分とともに変更せずにそのまま返してください。
* 受け取るテキストは進捗更新の要約であり、通常は1〜2文です。その長さに依存しないでください。進捗更新は、要約の長さではなく完全な長さで`usage.output_tokens`にカウントされます。
* 進捗更新ブロックは、どの`display`値でも`thinking`フィールドが空の状態で返されることがあります。空のブロックには何もレンダリングしないでください。`"updates"`では、空の推論ブロックと同じように見え、個別の処理は必要ありません。
* ツール呼び出しまたはツール結果の直後に応答が`max_tokens`、`model_context_window_exceeded`、または`stop_sequence`で停止した場合、その最後のブロックは、モデルが完了していなかった作業の代わりとなる進捗更新ブロックである可能性があります。`"updates"`と`"summarized"`では、そのテキストは正確に`This part of the response was interrupted before it finished.`であり、他の更新と同様に表示できます。`"omitted"`では空です。続行するには、アシスタントターンを変更せずにそのまま返し、新しい`user`メッセージを追加してください（そのターン内の各`tool_use`ブロックに対する`tool_result`を含めます）。
* [ストリーミング](https://platform.claude.com/docs/ja/build-with-claude/thinking#streaming-thinking)時は、進捗更新ブロックが開く前に数秒間の一時停止があることを想定してください。[思考のストリーミング](https://platform.claude.com/docs/ja/build-with-claude/thinking#streaming-thinking)の`"updates"`トレースを参照してください。
* これらのモデルは、より高い[effort](https://platform.claude.com/docs/ja/build-with-claude/effort)や長いツールチェーンでは、進捗更新を書く頻度が少なくなります。インターフェースが進捗更新に依存している場合は、[ユーザー向けの進捗更新を求める](https://platform.claude.com/docs/ja/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#ask-for-user-facing-progress-updates)を参照するか、Claude Opus 5.5の場合は[ユーザー向けの進捗更新](https://platform.claude.com/docs/ja/build-with-claude/prompt-engineering/prompting-claude-opus-5-5#user-facing-progress-updates)を参照してください。Claude Sonnet 5.5については、[ユーザー向けの進捗更新](https://platform.claude.com/docs/ja/build-with-claude/prompt-engineering/prompting-claude-sonnet-5-5#user-facing-progress-updates)を参照してください。

### モデル別の思考ブロックの保持

以前のアシスタントターンの思考ブロックがデフォルトでコンテキストに残るかどうかは、モデルによって異なります。

* **以前のすべてのターンを保持：** Claude Opus 4.5以降のOpusモデル、Claude Sonnet 4.6以降のSonnetモデル、Claude Haiku 5.5、Claude Fable 5.1、Claude Mythos 5.1、Claude Fable 5、Claude Mythos 5、およびClaude Mythos Preview。
* **最後のターンのみを保持：** それ以前のOpusおよびSonnetモデル、ならびにClaude Haiku 4.5までのすべてのHaikuモデル。古い思考ブロックを送り返すと、APIが自動的にそれらを除去します。自分で削除する必要はありません。

保持には2つの利点があります。

* **キャッシュの最適化：** 保持された思考ブロックは、ツール結果とともに送り返され、アシスタントターン全体で段階的にキャッシュされるため、ツール使用中のキャッシュヒットを可能にし、マルチステップのワークフローでトークンを節約できます。
* **知能への影響なし：** 思考ブロックを保持しても、モデルのパフォーマンスに悪影響はありません。

トレードオフはコンテキストの使用量です。保持された思考ブロックは他の会話履歴と同様に入力としてカウントされるため、すべてを保持するモデルでは、長い会話ほど多くのコンテキスト領域を消費します（[思考とコンテキストウィンドウ](https://platform.claude.com/docs/ja/build-with-claude/thinking#thinking-and-the-context-window)を参照）。この動作はどちらの方式でも自動的に行われます。コードの変更やベータヘッダーは不要で、[思考ブロックの保持](https://platform.claude.com/docs/ja/build-with-claude/thinking#preserving-thinking-blocks)で説明されているとおり、完全で変更されていない思考ブロックを引き続き送り返してください。どちらの方向にもデフォルトを上書きするには、[思考ブロックのクリア](https://platform.claude.com/docs/ja/build-with-claude/context-editing#thinking-block-clearing)を使用します。

**会話の途中でのモデルの切り替え。** モデルを切り替える場合（たとえば[分類器による拒否のフォールバック](https://platform.claude.com/docs/ja/build-with-claude/refusals-and-fallback)の後など）も、思考ブロックを変更せずに渡し返し続けてください。思考ブロックは、それを生成したモデルと特定の他のモデルのみが読み取ることができ、APIは切り替え先のモデルが読み取れないブロックを無視または破棄します。Claude Fable 5.1とClaude Mythos 5.1では方向が重要です。これらは以前のモデルの思考ブロックを読み取り、互いの思考ブロックを読み取れるのはこの2つだけです。そのため、これらのモデルへ切り替えると会話の推論が保持され、これらのモデルから他のモデルへ切り替えると推論が破棄されます（[破棄されたブロックの課金と報告方法](https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking#switching-models)を参照）。Claude Opus 5.5は、Claude Opus 5の思考ブロック、それ以前のOpus、Sonnet、Haikuモデルの思考ブロック、そしてClaude APIとGoogle CloudではClaude Haiku 5.5の思考ブロックを読み取りますが、Claude FableおよびClaude Mythosモデルの思考ブロックは読み取りません。Claude APIでは、Claude Fable 5.1とClaude Mythos 5.1がClaude Opus 5.5のブロックを読み取ります。Claude APIでClaude Opus 5.5からClaude Fable 5.1へ切り替えると以前のターンの推論が保持され、Claude Fable 5.1からClaude Opus 5.5へ切り替えると推論が破棄されます。Claude Sonnet 5.5は、Claude Sonnet 5、Claude Opus 4.8、Claude Haiku 4.5、およびそれ以前のモデルの思考ブロック、そしてClaude APIとGoogle CloudではClaude Haiku 5.5の思考ブロックを読み取りますが、Claude Opus 5、Claude Opus 5.5、またはいずれのClaude FableやClaude Mythosモデルの思考ブロックも読み取りません。Claude APIとGoogle Cloudでは、Claude Sonnet 5.5のブロックを読み取るのはClaude Opus 5.5のみです。Claude APIとGoogle CloudでClaude Sonnet 5.5からClaude Opus 5.5へ切り替えると以前のターンの推論が保持され、Claude Sonnet 5.5からのそれ以外の切り替えでは推論が破棄されます。Claude Haiku 5.5は、Claude Sonnet 5、Claude Opus 4.8、Claude Haiku 4.5、およびそれ以前のモデルの思考ブロックを読み取りますが、Claude Opus 5、Claude Opus 5.5、Claude Sonnet 5.5、またはいずれのClaude FableやClaude Mythosモデルの思考ブロックも読み取りません。Claude APIとGoogle Cloudでは、Claude Haiku 5.5のブロックを読み取るのはClaude Opus 5.5とClaude Sonnet 5.5のみです。以前の`thinking`および`redacted_thinking`ブロックを自分で除去するのは、それらを破棄するのではなく無視するモデルで入力トークンを節約する場合に限ってください。また、本文を変更しないことが必要な[フォールバッククレジット](https://platform.claude.com/docs/ja/build-with-claude/fallback-credit)を引き換える場合は、決して除去しないでください。

## 保持された思考

[保持された思考](https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking)は、以前のターンから送り返した思考ブロックをモデルが使用できるかどうかを決定します。Claude Fable 5.1以降、APIはリクエスト内のすべての`thinking`または`redacted_thinking`ブロックの`signature`について、次の2点を確認します。

* **それを生成したモデル。** 各モデルは、自身の思考ブロックと、固定された一連の他のモデルの思考ブロックを読み取ります。Claude Fable 5.1は、Claude Opus 5のブロック、およびClaude APIではClaude Opus 5.5のブロックを読み取ります。Claude Opus 5もClaude Opus 5.5も、Claude Fable 5.1のブロックは読み取りません。APIは、現在のモデルが読み取れないブロックを、エラーを出さず課金もせずに破棄します。[会話の途中でのモデルの切り替え](https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking#switching-models)を参照してください。
* **それより前に送信されたすべての内容。** ブロックが有効なのは、トップレベルの`system`プロンプト、`tools`、およびそれより前のメッセージが変更されていない間のみです。いずれかが変更されると、そのブロックとそれ以降のすべての思考ブロックが無効になり、APIは選択に応じて、400エラーでリクエストを拒否するか、無効なブロックを破棄します。[プレフィックスを変更しないようにする](https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking#prefix-check)を参照してください。

Claude Sonnet 5.5およびClaude Haiku 5.5の思考ブロックは、それを生成したアカウントにも紐付けられています。APIがこれをどこで適用するかについては、[思考ブロックはそれを生成したアカウントに留まる](https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking#account-bound-thinking)を参照してください。

モデルのチェックはすべてのアカウントに適用されます。APIは、2026年8月31日00:00 UTC以降に作成されたアカウントに対して、デフォルトでプレフィックスのチェックを適用します。それより古いアカウントでは、`thinking.block_binding.prefix_mismatch_behavior`を設定したリクエストに対してのみチェックを適用します。アカウントの作成時期にかかわらず、統合を追記のみ（append-only）にしてください。そうすれば、デフォルトで適用される新しいアカウントを含め、すべてのアカウントで同じコードが動作します。

思考を有効に保つには、すべてのアシスタントターンを受け取ったとおりに正確に送り返し、新しいメッセージは`messages`の末尾にのみ追加してください。コードで`messages`配列を自分で構築している場合、保持された思考のページでは次の内容を説明しています。

* [何が編集とみなされるか](https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking#what-counts-as-an-edit)、および[コードが編集を行っているかどうかを確認する方法](https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking#how-to-tell-whether-your-integration-is-impacted)。
* [一般的な各編集を置き換えるAPI機能](https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking#replace-prefix-edits)：新しい指示やターンごとのリマインダーには会話途中のシステムメッセージ、ツールの変更には`tool_addition`および`tool_removal`ブロック、effortの変更にはメッセージごとの`output_config`、トリミングにはサーバー側のコンパクションとコンテキスト編集。
* [クライアント側のコンパクション](https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking#custom-compaction-on-the-client)：どのパターンが思考を有効に保ち、どのパターンが保たないか。
* [`thinking-binding-controls-2026-08-01`ベータヘッダー](https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking#preserved-thinking-controls)。これにより、思考の設定に`block_binding.prefix_mismatch_behavior`フィールド（`"error"`または`"drop_block"`）が追加され、すべてのレスポンスに`input_transformations`配列が追加されます。この配列には、APIが破棄した思考ブロック、またはプレフィックスのチェックに失敗したものの通過させた思考ブロックがそれぞれ列挙されます。

## 思考とプロンプトキャッシング

「[prompt caching](https://platform.claude.com/docs/ja/build-with-claude/prompt-caching)」（プロンプトキャッシング）は、いくつかの特定の方法で思考と相互作用します。以下のルールは、どちらの思考モードにも適用されます。

**設定の変更はキャッシュを無効にします。** 思考の設定と解決された[`effort`](https://platform.claude.com/docs/ja/build-with-claude/effort)レベルはプロンプト自体にレンダリングされるため、いずれかを変更すると新しいキャッシュプレフィックスが始まります。`adaptive`、`enabled`、`disabled`の切り替え、`budget_tokens`の変更、およびeffort値の変更はすべてキャッシュブレークポイントを無効にします。メッセージレベルのブレークポイントは常にミスし、ツールおよびシステムプロンプトのブレークポイントも、モデルが設定をレンダリングする位置によってはミスする可能性があります。思考またはトップレベルのeffortの変更は、キャッシュを最初からやり直すものとして扱ってください。[メッセージごとのeffort](https://platform.claude.com/docs/ja/build-with-claude/effort#change-effort-mid-conversation-beta)をサポートするモデルでは、`messages`内の`role: "system"`メッセージで伝えられたeffortの変更は、キャッシュされたプレフィックスをそのまま維持します。同じ設定を維持する連続したリクエストはキャッシュを保持し、パラメータを明示的にデフォルト値に設定することは、それを省略することと同等です。いずれかの[保持された思考の条件](https://platform.claude.com/docs/ja/build-with-claude/thinking#preserved-thinking)によってAPIが破棄した思考ブロックは、そのブロックの位置以降のキャッシュされたプレフィックスを変更します。変更せずに送り返されたブロックはキャッシュをそのまま維持します。使用量の出力を含む実例は、[思考のステアリング](https://platform.claude.com/docs/ja/build-with-claude/thinking-steering-and-cost#prompt-caching)のページにあります。

**思考ブロックはツール結果とともにキャッシュされます。** ツール使用のループ中、キャッシュはツール結果を含むフォローアップリクエストを行ったときに発生します。その時点で、思考ブロックを含む以前の会話履歴がキャッシュされる可能性があり、キャッシュされた思考ブロックはキャッシュから読み取られる際に使用量メトリクスで入力トークンとしてカウントされます。これは明示的な`cache_control`マーカーがなくても自動的に行われ、通常の思考とインターリーブ思考で同じように動作します。トレードオフとして、レスポンスで二度と目にすることのない思考ブロックも、キャッシュから読み取られる際には入力トークンの使用量に加算されます。

**以前のブロックがそもそもコンテキストに含まれるかどうかはモデルごとに異なります。** これは[保持のデフォルト](https://platform.claude.com/docs/ja/build-with-claude/thinking#thinking-block-preservation-by-model)によって決まります。すべてを保持するモデルでは、以前のターンの思考ブロックはキャッシュされたままコンテキストに残ります。最後のターンのみを保持するモデルでは、ツール結果ではないユーザーメッセージを送信すると、以前のすべての思考ブロックがコンテキストから除去されます。これらのモデルでは、次のような会話は：

```text wrap
User: ["What's the weather in Paris?"],
Assistant: [thinking_block_1] + [tool_use block 1],
User: [tool_result_1, cache=True],
Assistant: [thinking_block_2] + [text block 2],
User: [Text response, cache=True]
```

思考ブロックが最初から存在しなかったかのように処理されます：

```text wrap
User: ["What's the weather in Paris?"],
Assistant: [tool_use block 1],
User: [tool_result_1, cache=True],
Assistant: [text block 2],
User: [Text response, cache=True]
```

すべてを保持するモデルでは、同じリクエストで`thinking_block_1`と`thinking_block_2`がコンテキストとキャッシュに保持されます。

**機能低下により、キャッシュ可能な履歴から思考が除去されます。** ターンの途中で思考が無効になり、現在のツール使用ターンで思考コンテンツを渡した場合、思考コンテンツは除去され、そのリクエストでは思考が無効のままになります（[グレースフルデグラデーション](https://platform.claude.com/docs/ja/build-with-claude/thinking#thinking-with-tool-use)を参照）。[インターリーブ思考](https://platform.claude.com/docs/ja/build-with-claude/thinking#interleaved-thinking)では、複数のツール呼び出しの間に思考ブロックが発生する可能性があるため、キャッシュ無効化の影響が増幅されます。

<Tip>
  思考の多いタスクは、完了までにデフォルトの5分間のキャッシュ有効期間よりも長くかかることがよくあります。より長い思考セッションやマルチステップのワークフロー全体でキャッシュヒットを維持するには、[1時間のキャッシュ期間](https://platform.claude.com/docs/ja/build-with-claude/prompt-caching#1-hour-cache-duration)を検討してください。
</Tip>

## 思考とコンテキストウィンドウ

現在のターンでClaudeが生成するすべての思考を含む`max_tokens`は、厳格な上限として適用されます。Claude 4.5モデル以降では、入力トークンと`max_tokens`の合計が「context window」（コンテキストウィンドウ）のサイズを超えても、APIはリクエストを受け付けます。その後、生成がコンテキストウィンドウの上限に達した場合は、エラーを返す代わりに`stop_reason: "model_context_window_exceeded"`で停止します。それ以前のモデルでは、APIは代わりに検証エラーを返します。[停止理由の処理](https://platform.claude.com/docs/ja/build-with-claude/handling-stop-reasons)を参照してください。

思考がウィンドウに対してどのようにカウントされるかは、それがいつ生成されたかによって異なります。

* **現在のターンの思考**は、常に`max_tokens`にカウントされ、出力トークンとして課金され、それを生成したターンのコンテキストウィンドウ領域を占有します。
* **以前のターンの思考**は、[保持のデフォルト](https://platform.claude.com/docs/ja/build-with-claude/thinking#thinking-block-preservation-by-model)によって異なります。[以前のすべてのターンを保持するモデル](https://platform.claude.com/docs/ja/build-with-claude/thinking#thinking-block-preservation-by-model)では、以前の思考ブロックはコンテキストに残り、ウィンドウにカウントされ、会話履歴の他の部分と同様に入力トークンとして課金されます。最後のターンのみを保持するモデルでは、古い思考ブロックを送り返すとAPIが自動的に除去するため、ウィンドウ領域や入力トークンを消費しません。

実際には：

* すべてを保持するモデルでは、思考を通常の会話履歴であるかのように（実際にそうであるため）コンテキストウィンドウの予算を立ててください。長いエージェントセッションでは、思考がコンテキストに蓄積されます。領域を回収する必要がある場合は、[思考ブロックのクリア](https://platform.claude.com/docs/ja/build-with-claude/context-editing#thinking-block-clearing)を使用してください。
* 最後のターンのみを保持するモデルでは、思考はターンごとのコストにすぎません。各ターンの思考はそのターンの`max_tokens`にカウントされ、その後ウィンドウから外れます。

以下の図は、最後のターンのみを保持する（除去する）方式を示しています。1つ目はマルチターンの会話を示しています。各ターンの「thinking block」（思考ブロック）は出力で生成されますが、後のターンの入力には引き継がれません。

<Frame>
  ![以前の思考ブロックを除去するモデルでの思考の図：各ターンの「thinking block」（思考ブロック）は出力で生成され、後のターンの入力には引き継がれない](https://platform.claude.com/docs/ja/images/context-window-thinking.svg)
</Frame>

2つ目は、同じ方式で「tool use」（ツール使用）を行う場合を示しています。思考はアシスタントターンの間、そのツール結果とともにコンテキストに留まり、次のユーザーターンで外れます。

<Frame>
  ![以前の思考ブロックを除去するモデルでの「tool use」（ツール使用）を伴う思考の図：思考はそのツール結果とともに保持され、次のユーザーターンで破棄される](https://platform.claude.com/docs/ja/images/context-window-thinking-tools.svg)
</Frame>

特に思考を含むマルチターンの会話では、[トークンカウントAPI](https://platform.claude.com/docs/ja/build-with-claude/token-counting)を使用して、特定のユースケースに対する正確なカウントを取得してください。

## 思考の暗号化

完全な思考コンテンツは暗号化され、各思考ブロックの`signature`フィールドに格納されて返されます。思考ブロックが返送されると、APIはこの署名を使って、そのブロックがClaudeによって生成されたものであることを検証します。

署名を扱う際は、次の点に注意してください：

* 思考ブロックの返送が必須となるのは、[思考とともにツールを使用する](https://platform.claude.com/docs/ja/build-with-claude/thinking#thinking-with-tool-use)場合のみです。それ以外の場合は、以前のターンの思考ブロックを省略できます。返送した場合に、APIがそれを保持するか削除するかはモデルによって異なります（[モデル別の思考ブロックの保持](https://platform.claude.com/docs/ja/build-with-claude/thinking#thinking-block-preservation-by-model)を参照）。この動作は[コンテキスト編集](https://platform.claude.com/docs/ja/build-with-claude/context-editing)で設定できます。
* 思考ブロックを返送する際は、一貫性を保ち、問題の発生を防ぐために、受け取った内容をすべてそのまま返してください。
* [レスポンスをストリーミングする](https://platform.claude.com/docs/ja/build-with-claude/thinking#streaming-thinking)場合、署名は`content_block_stop`イベントの直前に、`content_block_delta`イベント内の`signature_delta`として送られてきます。
* Claude 4以降のモデルでは、`signature`の値が以前のモデルよりも大幅に長くなっています。
* `signature`フィールドは不透明な値です。内容を解釈したり解析したりしないでください。
* `signature`の値はプラットフォーム間（Claude API、[Amazon Bedrock](https://platform.claude.com/docs/ja/build-with-claude/claude-in-amazon-bedrock)、[Google Cloud](https://platform.claude.com/docs/ja/build-with-claude/claude-on-vertex-ai)）で互換性があります。あるプラットフォームで生成された値は別のプラットフォームでも機能しますが、Claude Sonnet 5.5とClaude Haiku 5.5の思考ブロックは、それを生成したアカウントまたはそれにリンクされたアカウントでのみ機能します。[思考ブロックはそれを生成したアカウントに留まる](https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking#account-bound-thinking)を参照してください。

## 秘匿化された思考ブロック

Claudeの推論の一部が安全上の理由で秘匿化された場合、APIは通常の`thinking`ブロックに加えて`redacted_thinking`ブロックを返すことがあります。`redacted_thinking`ブロックには読み取り可能なテキストは含まれず、暗号化された思考コンテンツが`data`フィールドに格納されています：

```json
{
  "type": "redacted_thinking",
  "data": "..."
}
```

`data`フィールドは不透明な値で、暗号化されています。[ツール](https://platform.claude.com/docs/ja/build-with-claude/thinking#thinking-with-tool-use)を使ったマルチターン会話を続ける際は、通常の思考ブロックの`signature`フィールドと同じく、`redacted_thinking`ブロックも変更せずにAPIへ返してください。

<Tip>
  ツール使用を伴うレスポンスをやり取りする際に、コードでコンテンツブロックをタイプ別にフィルタリングしている場合（例：`block.type == "thinking"`）は、`redacted_thinking`ブロックも対象に含めてください。`block.type == "thinking"`だけでフィルタリングすると、`redacted_thinking`ブロックが警告なく除外され、[思考ブロックの保持](https://platform.claude.com/docs/ja/build-with-claude/thinking#preserving-thinking-blocks)で説明しているマルチターンプロトコルが正しく機能しなくなります。
</Tip>

<Note>
  `redacted_thinking`ブロックは、思考が安全上の理由で秘匿化された場合に返される、独立したコンテンツブロックタイプです。[`display: "omitted"`](https://platform.claude.com/docs/ja/build-with-claude/thinking#controlling-thinking-display)オプションとは別物です。このオプションでは、`thinking`フィールドが空の通常の`thinking`ブロックが返されます。
</Note>

## 制限と機能の互換性

### サンプリングパラメータ

Claude Fable 5.1、Claude Mythos 5.1、Claude Fable 5、Claude Mythos 5、Claude Mythos Preview、Claude Opus 5.5、Claude Opus 5、Claude Opus 4.8、Claude Opus 4.7、Claude Sonnet 5.5、Claude Sonnet 5、およびClaude Haiku 5.5では、デフォルト以外の`temperature`、`top_p`、または`top_k`の値は、思考を使用しているかどうかにかかわらず、すべてのリクエストで400エラーを返します。これらのモデルでは`top_p`のデフォルトは`0.99`であるため、`top_p`が`1`の場合は400エラーが返されます。また、`temperature`と`top_p`の両方を含むリクエストも、それらがデフォルト値であっても400エラーが返されます。[サンプリングパラメータを削除する](https://platform.claude.com/docs/ja/models/haiku-5-5/migration-guide#remove-sampling-parameters)を参照してください。それより古いモデルでは、この制限は思考がオンの間のみ適用されます。`temperature`と`top_k`は思考と互換性がなく、`top_p`は0.95から1の間の値で許可されます。

### レスポンスのプリフィルと強制ツール使用

Claude 4.6以降のモデルおよびClaude Mythos Previewは、思考がオンかどうかにかかわらず、プリフィルされた最後のアシスタントターンを400エラーで拒否します（[プリフィルはサポートされていません](https://platform.claude.com/docs/ja/api/errors#prefill-not-supported)を参照）。それ以前のモデルでは、思考がオンの間はアシスタントのレスポンスをプリフィルできません。強制ツール使用（`tool_choice: {"type": "any"}`または`{"type": "tool", ...}`）は手動の拡張思考とは互換性がありませんが、適応型思考では機能します。例外はClaude Opus 5.5、Claude Sonnet 5.5、Claude Fable 5.1、およびClaude Mythos 5.1で、これらはすべてのリクエストで強制ツール使用を400エラーで拒否します。これらのモデルでは、代わりに[厳密なツール使用](https://platform.claude.com/docs/ja/agents-and-tools/tool-use/strict-tool-use)または[構造化出力](https://platform.claude.com/docs/ja/build-with-claude/structured-outputs)とともに`tool_choice: {"type": "auto"}`を使用してください。強制ツール使用が受け付けられる場合、レスポンスはツール呼び出しから始まり、`thinking`ブロックは含まれません。ツールを呼び出す前にモデルに思考させるには、`tool_choice: {"type": "auto"}`を使用し、いつツールを使用するかをプロンプトで指示してください。[ツール使用と思考](https://platform.claude.com/docs/ja/build-with-claude/thinking#thinking-with-tool-use)を参照してください。

### 出力制限

各モデルで指定できる`max_tokens`の上限は、以下の表のとおりです。[Message Batches API](https://platform.claude.com/docs/ja/build-with-claude/batch-processing#extended-output-beta)では、`output-300k-2026-03-24` [ベータヘッダー](https://platform.claude.com/docs/ja/api/beta-headers)を使用すると、バッチの上限が記載されているモデルについて上限が引き上げられます。

| Model                 | Max output tokens | Batches beta ceiling |
| :-------------------- | :---------------- | :------------------- |
| Claude Fable 5.1      | 128K              | —                    |
| Claude Mythos 5.1     | 128K              | —                    |
| Claude Fable 5        | 128K              | —                    |
| Claude Mythos 5       | 128K              | —                    |
| Claude Mythos Preview | 128K              | Not available        |
| Claude Opus 5.5       | 128K              | 300K                 |
| Claude Opus 5         | 128K              | 300K                 |
| Claude Opus 4.8       | 128K              | 300K                 |
| Claude Opus 4.7       | 128K              | 300K                 |
| Claude Opus 4.6       | 128K              | 300K                 |
| Claude Opus 4.5       | 64K               | Not available        |
| Claude Sonnet 5.5     | 128K              | 300K                 |
| Claude Sonnet 5       | 128K              | 300K                 |
| Claude Sonnet 4.6     | 128K              | 300K                 |
| Claude Sonnet 4.5     | 64K               | Not available        |
| Claude Haiku 5.5      | 128K              | 300K                 |
| Claude Haiku 4.5      | 64K               | Not available        |

レガシーモデルの制限については、[モデルの概要](https://platform.claude.com/docs/ja/models/overview)を参照してください。

### 長いリクエスト

SDKは、長時間実行されるリクエストでのHTTPタイムアウトを避けるため、`max_tokens`が21,333を超える場合に「streaming」（ストリーミング）を必須としています。これはクライアント側の検証であり、APIの制限ではありません。イベントを段階的に処理する必要がない場合は、`.stream()` (java: `.createStreaming()`; csharp: `.CreateStreaming()`; go: `.NewStreaming()`; php: `->createStream()`)を`.get_final_message()` (typescript: `.finalMessage()`; ruby: `.accumulated_message`; csharp: `.Aggregate()`; go: `message.Accumulate(event)`; java, php: `MessageAccumulator`)とともに使用すると、個々のイベントから自分で組み立てることなく、完全な`Message`オブジェクトを取得できます。[メッセージのストリーミング](https://platform.claude.com/docs/ja/build-with-claude/streaming#get-the-final-message-without-handling-events)を参照してください。思考ブロックの生成には処理時間がかかるため、思考が有効な場合はレスポンス時間が長くなることを想定してください。リクエストあたりの思考がおよそ32kトークンを超えるワークロードでは、ネットワークの問題を避けるために[バッチ処理](https://platform.claude.com/docs/ja/build-with-claude/batch-processing)を使用してください。そのようなリクエストは、システムのタイムアウトやオープン接続の制限に達するほど長時間実行される可能性があります。

## 次のステップ

<CardGroup cols={2}>
  <Card title="思考の制御" icon="compass" href="https://platform.claude.com/docs/ja/build-with-claude/thinking-steering-and-cost">
    effortレベル、システムプロンプトでの指示、メッセージごとの制御を使って、Claudeが思考する頻度と深さを調整する方法を説明します。思考のコストと料金についても解説します。
  </Card>

  <Card title="ツールおよびマルチターンワークフローにおける思考" icon="wrench" href="https://platform.claude.com/docs/ja/build-with-claude/thinking-tool-workflows">
    思考ブロックを正しく保持する、2ターンのツール使用のやり取り全体を順を追って説明します。インターリーブ思考によって流れがどう変わるかも確認できます。
  </Card>

  <Card title="保持された思考" icon="stack" href="https://platform.claude.com/docs/ja/build-with-claude/preserved-thinking">
    Messages APIとの統合で会話履歴を編集しているかどうかを確認し、各編集を、以前の思考ブロックを有効なまま保てるAPI機能に置き換える方法を説明します。
  </Card>

  <Card title="思考のトラブルシューティング" icon="hammer" href="https://platform.claude.com/docs/ja/build-with-claude/thinking-troubleshooting">
    設定に起因する400エラー、空または欠落した思考ブロック、max\_tokensによる停止、キャッシュミスなど、思考に関するよくある問題の原因を特定して解決します。
  </Card>

  <Card title="Effort" icon="sliders" href="https://platform.claude.com/docs/ja/build-with-claude/effort">
    effortパラメータを使って、Claudeが応答時に使用するトークン数を制御し、応答の網羅性とトークン効率のバランスを調整します。
  </Card>
</CardGroup>