--- title: Размышления url: https://platform.claude.com/docs/ru/build-with-claude/thinking description: "Узнайте, как работают размышления Claude: как их включить, как читать вывод размышлений, как управлять глубиной размышлений с помощью уровня усилий и как использовать размышления с инструментами, кэшированием и потоковой передачей." --- Чтобы узнать, как «zero data retention» (нулевое хранение данных), или ZDR, применяется к этой функции, см. раздел [API и хранение данных](https://platform.claude.com/docs/ru/manage-claude/api-and-data-retention). Модель, которая отвечает за один проход, должна сделать всё правильно с первой попытки: без черновой работы, без проверки, без смены курса на полпути. Для доказательства, сложной ошибки или длительной агентной задачи первый подход часто оказывается не лучшим. «Thinking» (размышления) снимают это ограничение. Когда размышления активны, Claude прорабатывает задачу своими словами, прежде чем ответить. Он переформулирует вопрос, пробует разные подходы, проверяет промежуточные результаты и отказывается от путей, которые не выдерживают проверки. Эти предварительные размышления поступают в блоках содержимого `thinking` перед ответом, и Claude опирается на них при формировании окончательного ответа. Поэтому размышления повышают качество работы над сложными задачами: математикой, программированием, анализом и длительной агентной работой. В таких задачах качество ответа зависит от промежуточной работы, которая без размышлений была бы сжата в сам ответ или пропущена. У размышлений есть цена: токены, которые Claude тратит на рассуждения, оплачиваются как выходные токены, даже если текст размышлений вам не возвращается, и они учитываются в `max_tokens` наряду с текстом ответа. На этой странице описано, как размышления ведут себя во всех частях API: как их включить, как читать их вывод и как управлять их взаимодействием с инструментами, «streaming» (потоковой передачей), кэшированием и «context window» (контекстным окном). ## Как работают размышления ![Диаграмма: Claude определяет, нужно ли размышлять заранее («up-front thinking» (предварительные размышления)), может размышлять между вызовами инструментов и возвращает блоки размышлений перед текстом](https://platform.claude.com/docs/ru/images/how-thinking-works.svg) Будет ли Claude размышлять при конкретном запросе и насколько глубоко, зависит от вашей конфигурации размышлений и сложности запроса. Вот как выглядят предварительные размышления в ответе: один или несколько блоков содержимого `thinking` поступают перед блоками `text`. Блок размышлений — это тоже сгенерированное содержимое, как и следующий за ним блок `text`, но он отделён от канонического ответа. Каждый блок размышлений также содержит поле `signature` — зашифрованную копию полного рассуждения, которую вы передаёте обратно без изменений в многоходовых диалогах и диалогах с использованием инструментов (см. [Шифрование размышлений](https://platform.claude.com/docs/ru/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/ru/build-with-claude/thinking#summarized-thinking). Поле `display` в конфигурации размышлений определяет, возвращается ли эта сводка вообще: `"summarized"` возвращает её, а `"omitted"`, значение по умолчанию на многих моделях, возвращает блоки размышлений с пустым полем `thinking`. В любом случае блок оплачивается одинаково и одинаково передаётся обратно в многоходовых диалогах. Значения по умолчанию для каждой модели и подробности см. в разделе [Управление отображением размышлений](https://platform.claude.com/docs/ru/build-with-claude/thinking#controlling-thinking-display). Если Claude использует инструменты, размышления также могут появляться между вызовами инструментов. См. [Размышления при использовании инструментов](https://platform.claude.com/docs/ru/build-with-claude/thinking#thinking-with-tool-use). Полный формат ответа см. в [справочнике по Messages API](https://platform.claude.com/docs/ru/api/messages/create). ## Настройка размышлений На большинстве моделей размышления включены по умолчанию или включаются одним параметром. В следующей таблице показано, что делает каждая модель с каждым значением `thinking`, которое может быть отправлено в запросе. Ошибка 400 означает, что API отклоняет запрос; в разделе [Устранение неполадок размышлений](https://platform.claude.com/docs/ru/build-with-claude/thinking-troubleshooting) описана каждая ошибка и способ её исправления. | Модель | Без поля `thinking` | `"adaptive"` | `"enabled"` с `budget_tokens` | `"between_tools"` | `"disabled"` | | --------------------- | ---------------------- | ---------------------- | ---------------------------------- | ---------------------------------------------------------------- | ------------------------------------------------ | | Claude Opus 5.5 | Адаптивные размышления | Адаптивные размышления | Ошибка 400 | Ошибка 400 | Ошибка 400 | | Claude Sonnet 5.5 | Адаптивные размышления | Адаптивные размышления | Ошибка 400 | Предварительные размышления выключены при effort `high` или ниже | Ошибка 400 | | Claude Haiku 5.5 | Адаптивные размышления | Адаптивные размышления | Ошибка 400 | Ошибка 400 | Размышления выключены при effort `high` или ниже | | 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 | Размышления выключены при effort `high` или ниже | | 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 | Размышления выключены | В таблице «при effort `high` или ниже» означает, что запрос работает при «effort» (уровне усилий) `low`, `medium` и `high` и возвращает ошибку 400 при `xhigh` или `max`. На 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/ru/models/overview) включает их там. В следующих примерах задано `display: "summarized"`, чтобы текст размышлений был виден, и используется достаточно большое значение `max_tokens`: ```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 # пишет его как display_ (с подчёркиванием в конце), чтобы не затенять Kernel#display из Ruby. # В запросе по-прежнему отправляется 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 ``` При запуске примера выводится сводка размышлений, а затем ответ: ```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/ru/build-with-claude/thinking-steering-and-cost#cost-control) на странице об управлении размышлениями и [Размышления и контекстное окно](https://platform.claude.com/docs/ru/build-with-claude/thinking#thinking-and-the-context-window). ### Отключение размышлений На Claude Sonnet 5, где размышления включены по умолчанию, их можно отключить: ```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." } ] ) ``` У Claude Opus 5 размышления также включены по умолчанию, и модель принимает `thinking: {type: "disabled"}` при [effort](https://platform.claude.com/docs/ru/build-with-claude/effort) `high` или ниже. При effort `xhigh` или `max` размышления отключить нельзя: запросы, сочетающие `thinking: {type: "disabled"}` с этими уровнями effort, возвращают ошибку 400. Это ограничение применяется к каждому запросу. При отключённых размышлениях Claude Opus 5 может иногда выдавать вызовы инструментов в виде обычного текста или включать внутренние XML-теги в видимый вывод. Способы смягчения этого с помощью подсказок см. в разделе [Работа с отключёнными размышлениями](https://platform.claude.com/docs/ru/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/ru/build-with-claude/effort) `high` или ниже. Модель по-прежнему возвращает свои [обновления о ходе работы между вызовами инструментов](https://platform.claude.com/docs/ru/build-with-claude/thinking#progress-updates). Без инструментов ответ содержит только текст, как при `disabled` на Claude Sonnet 5. Рекомендации по подсказкам см. в разделе [Работа без предварительных размышлений](https://platform.claude.com/docs/ru/build-with-claude/prompt-engineering/prompting-claude-sonnet-5-5#running-without-up-front-thinking). У Claude Haiku 5.5 размышления также включены по умолчанию, и модель принимает `thinking: {type: "disabled"}` при [effort](https://platform.claude.com/docs/ru/build-with-claude/effort) `high` или ниже. При effort `xhigh` или `max` такое сочетание возвращает ошибку 400. Чтобы уменьшить объём размышлений, сначала понизьте уровень effort. При выключенных размышлениях модель может пропустить нужный ей вызов инструмента, если вы также запрашиваете вывод в формате JSON. [`output_config.effort` для отдельного сообщения](https://platform.claude.com/docs/ru/build-with-claude/effort#change-effort-mid-conversation-beta), отличающийся от действующего уровня, также возвращает ошибку 400, пока размышления выключены. См. [Используйте effort для управления размышлениями](https://platform.claude.com/docs/ru/build-with-claude/prompt-engineering/prompting-claude-haiku-5-5#use-effort-to-control-thinking) и [Используйте адаптивные размышления с выводом JSON и собственными инструментами](https://platform.claude.com/docs/ru/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"`, до отправки запроса, прочитайте её значение `capabilities.thinking.types.disabled.supported` из Models API. Это поле описано в разделе [Использование Models API](https://platform.claude.com/docs/ru/models/overview#using-the-models-api). Если ваша модель поддерживает только расширенные размышления (см. [таблицу конфигурации по моделям](https://platform.claude.com/docs/ru/build-with-claude/thinking-troubleshooting#supported-models)), настройте её с помощью `type: "enabled"` и значения `budget_tokens`. Эта конфигурация описана на странице [Расширенные размышления](https://platform.claude.com/docs/ru/build-with-claude/extended-thinking). А если какая-либо конфигурация размышлений возвращает ошибку 400, в разделе [Устранение неполадок размышлений](https://platform.claude.com/docs/ru/build-with-claude/thinking-troubleshooting) каждому сообщению об ошибке сопоставлен способ её исправления. ## Чтение вывода размышлений ### Управление отображением размышлений Поле `display` в конфигурации размышлений определяет, как содержимое размышлений возвращается в ответах API. `display` работает в обоих режимах: задавайте его вместе с `type: "adaptive"` или `type: "enabled"`. Оно принимает следующие значения: * `"summarized"`: блоки размышлений содержат текст [сводки размышлений](https://platform.claude.com/docs/ru/build-with-claude/thinking#summarized-thinking) — удобочитаемую сводку рассуждений Claude. Это значение по умолчанию на Claude Opus 4.6, Claude Sonnet 4.6 и более ранних моделях. * `"omitted"`: блоки размышлений возвращаются с пустым полем `thinking`. Поле `signature` по-прежнему содержит зашифрованные полные размышления для непрерывности многоходового диалога (см. [Шифрование размышлений](https://platform.claude.com/docs/ru/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"` (бета): блоки рассуждений возвращаются с пустым полем `thinking`, как при `"omitted"`, а короткие [обновления о ходе работы](https://platform.claude.com/docs/ru/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/ru/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/ru/build-with-claude/thinking#progress-updates)). * При использовании `thinking.type: "adaptive"`, если модель пропускает размышления для простого запроса, блок размышлений не создаётся независимо от `display`. * При потоковой передаче с `display: "omitted"` текст размышлений не передаётся. Каждый блок размышлений передаёт `thinking_delta` с пустой строкой `thinking`, а затем свой `signature_delta`. При `display: "updates"` события `thinking_delta`, содержащие текст, передают только [блоки обновлений о ходе работы](https://platform.claude.com/docs/ru/build-with-claude/thinking#progress-updates). Последовательность событий см. в разделе [Потоковая передача размышлений](https://platform.claude.com/docs/ru/build-with-claude/thinking#streaming-thinking). Поле `signature` одинаково при любом заданном значении `display`. Переключение значений `display` между ходами диалога поддерживается. ### Сводные размышления Когда `display` имеет значение `"summarized"`, получаемый вами текст размышлений — это сводка полного процесса размышлений Claude, а не необработанная цепочка рассуждений. Сводные размышления обеспечивают все интеллектуальные преимущества размышлений, одновременно предотвращая злоупотребления. Ни одна настройка `display` не возвращает необработанную цепочку рассуждений. При работе со сводными размышлениями учитывайте следующее: * С вас взимается плата за все токены размышлений, сгенерированные исходным запросом, а не за токены сводки. Количество оплачиваемых выходных токенов не совпадает с количеством токенов, которые вы видите в ответе. * На Claude Opus 4.6, Claude Sonnet 4.6 и более ранних моделях первые несколько строк вывода размышлений более подробны и содержат детальные рассуждения, что особенно полезно для целей инженерии подсказок. [Claude Mythos Preview](https://anthropic.com/glasswing) формирует сводку с первого токена, поэтому его блоки размышлений не содержат этой подробной преамбулы. * Формирование сводки сохраняет ключевые идеи процесса размышлений Claude с минимальной дополнительной задержкой, поэтому сводки могут передаваться потоком по мере поступления. * Сводка формируется другой моделью, а не той, к которой вы обращаетесь в своих запросах. Модель, выполняющая размышления, не видит вывод сводки. * Поскольку Anthropic стремится улучшить функцию размышлений, поведение формирования сводки может меняться. В редких случаях, когда вам нужен доступ к полному выводу размышлений, [свяжитесь с отделом продаж Anthropic](mailto:sales@anthropic.com). Чтобы увидеть рассуждения модели, читайте блоки `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/ru/build-with-claude/refusals-and-fallback#refusal-response), а о том, что запрашивать вместо этого, — в разделе [Храните рассуждения в блоках размышлений](https://platform.claude.com/docs/ru/build-with-claude/refusals-and-fallback#keep-reasoning-in-thinking-blocks). ### Потоковая передача размышлений Размышления работают с «streaming» ([потоковой передачей](https://platform.claude.com/docs/ru/build-with-claude/streaming)). Блоки размышлений передаются потоком как события `thinking_delta` внутри событий `content_block_delta`, за которыми следует одно событие `signature_delta` непосредственно перед `content_block_stop` блока. Текстовые блоки передаются после этого как обычно. ![Диаграмма последовательности событий «streaming» (потоковой передачи) с «thinking» (размышлениями): блок размышлений открывается, дельты размышлений содержат текст только тогда, когда настройка display возвращает текст (summarized или updates для блоков обновлений о ходе работы), одна дельта подписи закрывает блок, затем передаются текстовые дельты](https://platform.claude.com/docs/ru/images/how-thinking-streams.svg) Следующие примеры передают потоком ответ с адаптивными размышлениями, выводя дельты размышлений и текста по мере их поступления: ```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 # пишет его как display_ (с подчёркиванием в конце), чтобы не затенять Kernel#display в Ruby. # В запросе по-прежнему отправляется 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 ``` Чтобы собрать полные блоки размышлений с их подписями после потоковой передачи, используйте вспомогательную функцию накопления сообщений вашего SDK, `stream.get_final_message()` (typescript: `stream.finalMessage()`; ruby: `stream.accumulated_message`; csharp: `.Aggregate()`; go: `message.Accumulate(event)`; java, php: `MessageAccumulator`), вместо того чтобы самостоятельно объединять дельты. ```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"} ``` Когда задано `display: "omitted"`, блок размышлений открывается, поступает `thinking_delta` с пустой строкой `thinking`, за ним следует одно событие `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/ru/build-with-claude/thinking#progress-updates) передаёт свой текст в виде событий `thinking_delta` перед блоком `tool_use`, который он предваряет. Пауза в несколько секунд перед открытием блока обновления о ходе работы — это нормально: ```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` содержит непустой текст. При использовании потоковой передачи с включёнными размышлениями вы можете заметить, что текст иногда поступает более крупными фрагментами, чередующимися с более мелкой, потокенной доставкой. Это ожидаемое поведение, особенно для содержимого размышлений. Система потоковой передачи обрабатывает содержимое пакетами, что может задерживать и группировать события потоковой передачи в такой «фрагментарный» шаблон доставки. Общие механизмы потоковой передачи см. в разделе [Потоковая передача сообщений](https://platform.claude.com/docs/ru/build-with-claude/streaming). ## Размышления и уровень усилий Параметр `thinking` управляет тем, размышляет ли Claude в [блоках размышлений](https://platform.claude.com/docs/ru/build-with-claude/thinking) перед ответом; параметр `effort` управляет тем, сколько усилий Claude вкладывает в весь ответ, что в адаптивном режиме включает то, как часто и насколько глубоко он размышляет. Не передавайте `adaptive` в качестве значения `effort`: `adaptive` — это режим размышлений, а не уровень усилий. Чтобы узнать, как каждый уровень effort влияет на поведение размышлений, см. [таблицу поведения размышлений по уровням](https://platform.claude.com/docs/ru/build-with-claude/thinking-steering-and-cost#effort-levels) на странице [Управление размышлениями](https://platform.claude.com/docs/ru/build-with-claude/thinking-steering-and-cost). На странице [Уровень усилий](https://platform.claude.com/docs/ru/build-with-claude/effort) описан сам параметр, включая то, какие уровни поддерживает каждая модель. На Claude Opus 4.5, единственной модели только с расширенными размышлениями, которая поддерживает effort, effort сочетается с `budget_tokens`. См. [Правила и настройка бюджета](https://platform.claude.com/docs/ru/build-with-claude/extended-thinking#budget-rules-and-tuning). Поскольку эти два элемента управления разделены таким образом, выберите тот, который соответствует вашей цели: * **Снизить стоимость или задержку для рабочей нагрузки с включёнными размышлениями:** сначала понизьте `effort`. Это уменьшает весь ответ, включая размышления. * **Claude размышляет слишком редко или слишком поверхностно:** повысьте `effort` или см. раздел [Управление частотой размышлений Claude](https://platform.claude.com/docs/ru/build-with-claude/thinking-steering-and-cost#tuning-thinking-behavior) на странице об управлении размышлениями. * **Вам нужно полностью отключить размышления:** используйте `thinking: {type: "disabled"}` на моделях, которые это допускают (см. [таблицу конфигурации по моделям](https://platform.claude.com/docs/ru/build-with-claude/thinking-troubleshooting#supported-models)). Claude Sonnet 5.5 отклоняет `"disabled"`. Его самая низкая настройка — `thinking: {type: "between_tools"}`, которая отключает предварительные размышления. * **Вам нужен жёсткий предел расходов:** используйте `max_tokens`. Effort — это мягкая рекомендация. `max_tokens` — строгое ограничение. ## Размышления при использовании инструментов Размышления работают вместе с «tool use» ([использованием инструментов](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/overview)), позволяя Claude рассуждать при выборе инструментов и обрабатывать результаты инструментов. Действуют два ограничения: 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/ru/build-with-claude/thinking#limits-and-feature-compatibility)). Там, где принудительное использование инструментов принимается, ответ начинается с вызова инструмента и не содержит блока `thinking`. 2. **Сохранение блоков размышлений:** когда вы возвращаете результаты инструментов, вы должны передать блоки размышлений из сообщения ассистента обратно в API полностью и без изменений. См. [Сохранение блоков размышлений](https://platform.claude.com/docs/ru/build-with-claude/thinking#preserving-thinking-blocks). **Цикл использования инструментов — это один ход ассистента.** С точки зрения модели ход ассистента не завершается, пока 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/ru/build-with-claude/thinking#thinking-and-prompt-caching). ### Сохранение блоков размышлений Когда Claude вызывает инструмент, он приостанавливает построение своего ответа в ожидании внешней информации. Когда вы возвращаете результат инструмента, Claude продолжает строить тот же ответ, поэтому его предыдущие рассуждения должны по-прежнему присутствовать. Передавайте каждый блок `thinking` обратно в API полностью и без изменений вместе с блоком `tool_use`, который он сопровождал. Это важно по двум причинам: 1. **Непрерывность рассуждений:** блоки размышлений фиксируют пошаговые рассуждения, которые привели к запросам инструментов. Их включение позволяет Claude продолжить рассуждения с того места, где он остановился. 2. **Сохранение контекста:** результаты инструментов отображаются как сообщения пользователя в структуре API, но они являются частью одного непрерывного потока рассуждений. Сохранение блоков размышлений поддерживает этот поток между вызовами API. Вкратце: * **Обязательно:** в пределах хода с использованием инструментов передавайте блоки размышлений обратно. * **Рекомендуется:** между ходами передавайте обратно всё. * **Допускается:** вне использования инструментов можно опускать размышления предыдущих ходов. Вам не нужно самостоятельно удалять старые размышления. Передавайте все блоки размышлений обратно в многоходовых диалогах, и API автоматически отфильтрует их, сохранит блоки, необходимые для сохранения рассуждений модели, и выставит счёт за входные токены только для блоков, фактически показанных Claude. Какие блоки предыдущих ходов сохраняются, зависит от модели. См. [Сохранение блоков размышлений по моделям](https://platform.claude.com/docs/ru/build-with-claude/thinking#thinking-block-preservation-by-model). Чтобы переопределить поведение по умолчанию, используйте [стратегию редактирования контекста `clear_thinking_20251015`](https://platform.claude.com/docs/ru/build-with-claude/context-editing#thinking-block-clearing). В последнем сообщении ассистента последовательность идущих подряд блоков `thinking` должна совпадать с тем, что модель сгенерировала в исходном запросе: их нельзя переставлять, редактировать или частично удалять. Это относится и к [блокам `redacted_thinking`](https://platform.claude.com/docs/ru/build-with-claude/thinking#redacted-thinking-blocks). Изменённые блоки размышлений отклоняются с ошибкой 400. Точное сообщение, распространённые причины и способ исправления см. в разделе [Ошибка 400 сообщает, что блоки размышлений нельзя изменять](https://platform.claude.com/docs/ru/build-with-claude/thinking-troubleshooting#error-thinking-blocks-modified). Единственное исключение: текст, помещённый в пустое поле `thinking` [скрытого](https://platform.claude.com/docs/ru/build-with-claude/thinking#controlling-thinking-display) блока, игнорируется, а не отклоняется. Полное пошаговое руководство для двух ходов с кодом для каждого SDK см. в разделе [Размышления в рабочих процессах с инструментами и многоходовых диалогах](https://platform.claude.com/docs/ru/build-with-claude/thinking-tool-workflows#two-turn-tool-use-round-trip). В нём определяется инструмент, принимается ответ с размышлениями и использованием инструмента, а ход ассистента отправляется обратно вместе с результатом инструмента. ### Чередующиеся размышления «Interleaved thinking» (чередующиеся размышления) позволяет Claude размышлять между вызовами инструментов, рассуждая о каждом результате инструмента, прежде чем действовать на его основе. С чередующимися размышлениями Claude может: * Рассуждать о результатах вызова инструмента, прежде чем определить, что делать дальше * Выстраивать цепочки из нескольких вызовов инструментов с шагами рассуждений между ними * Принимать более взвешенные решения на основе промежуточных результатов Последовательные вызовы инструментов не требуют чередующихся размышлений. Claude может выстраивать цепочки вызовов инструментов как с чередующимися размышлениями, так и без них. Чередование меняет то, где появляются блоки размышлений между вызовами инструментов, а не то, могут ли вызовы инструментов выстраиваться в цепочку. При адаптивных размышлениях чередующиеся размышления включаются автоматически на каждой модели, поддерживающей адаптивные размышления. Бета-заголовок не нужен. На 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/ru/build-with-claude/extended-thinking#interleaved-thinking). При чередующихся размышлениях выделенный объём размышлений может охватывать весь ход ассистента, а не отдельный ответ. Чередующиеся размышления поддерживаются только для [инструментов, используемых через Messages API](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/overview). Наглядное сравнение того, что меняют чередующиеся размышления в рабочем процессе с двумя инструментами, см. в разделе [Как чередующиеся размышления меняют поток](https://platform.claude.com/docs/ru/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 модель может писать обновление о ходе работы между вызовами инструментов. Обновление о ходе работы — это заметка о том, что модель только что обнаружила и что собирается сделать дальше, написанная для человека, наблюдающего за агентом, а не в качестве рассуждения. Каждое такое обновление возвращается в виде отдельного блока `thinking` со своей `signature`, отдельно от любого блока рассуждений в той же точке. Оно располагается непосредственно перед блоком `tool_use` или `server_tool_use`, который оно предваряет. Каждому вызову инструмента предшествует не более одного обновления о ходе работы, и модель может пропустить любое из них. Обновления о ходе работы — это не [чередующиеся размышления](https://platform.claude.com/docs/ru/build-with-claude/thinking#interleaved-thinking): они появляются независимо от того, появляются ли блоки рассуждений между вызовами инструментов, и ответ может содержать и то, и другое. Содержимое блока обновления о ходе работы зависит от [`display`](https://platform.claude.com/docs/ru/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/ru/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/ru/api/beta-headers#beta-features-on-other-platforms)). Без него значение отклоняется с той же ошибкой 400 `invalid_request_error`, что и неизвестное значение `display`. ```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"`. Второй содержит текст, поэтому это обновление о ходе работы. При `"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`. * Получаемый вами текст — это сводка обновления о ходе работы, обычно одно-два предложения. Не полагайтесь на его длину. Обновление о ходе работы учитывается в `usage.output_tokens` в полном объёме, а не в объёме сводки. * Блок обновления о ходе работы может вернуться с пустым полем `thinking` при любом значении `display`. Для пустого блока ничего не отображайте. При `"updates"` он выглядит так же, как пустой блок рассуждений, и не требует отдельной обработки. * Когда ответ останавливается по `max_tokens`, `model_context_window_exceeded` или `stop_sequence` вскоре после вызова инструмента или результата инструмента, его последним блоком может быть блок обновления о ходе работы, заменяющий работу, которую модель не успела завершить. При `"updates"` и `"summarized"` его текст в точности равен `This part of the response was interrupted before it finished.`, и вы можете показать его, как любое другое обновление. При `"omitted"` он пуст. Чтобы продолжить, передайте ход ассистента обратно без изменений и добавьте новое сообщение `user` (с `tool_result` для каждого блока `tool_use` в этом ходе). * При [потоковой передаче](https://platform.claude.com/docs/ru/build-with-claude/thinking#streaming-thinking) ожидайте паузу в несколько секунд перед открытием блока обновления о ходе работы. См. трассировку `"updates"` в разделе [Потоковая передача размышлений](https://platform.claude.com/docs/ru/build-with-claude/thinking#streaming-thinking). * Эти модели пишут меньше обновлений о ходе работы при более высоком [effort](https://platform.claude.com/docs/ru/build-with-claude/effort) и в длинных цепочках инструментов. Если ваш интерфейс зависит от них, см. [Запросите обновления о ходе работы для пользователя](https://platform.claude.com/docs/ru/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/ru/build-with-claude/prompt-engineering/prompting-claude-opus-5-5#user-facing-progress-updates). Для Claude Sonnet 5.5 см. [Обновления о ходе работы для пользователя](https://platform.claude.com/docs/ru/build-with-claude/prompt-engineering/prompting-claude-sonnet-5-5#user-facing-progress-updates). ### Сохранение блоков размышлений по моделям Остаются ли «thinking blocks» (блоки размышлений) из предыдущих ходов ассистента в контексте по умолчанию, зависит от модели: * **Сохраняются все предыдущие ходы:** 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, а также все модели Haiku вплоть до Claude Haiku 4.5. Когда вы передаёте более старые блоки размышлений обратно, API автоматически удаляет их. Вам не нужно удалять их самостоятельно. Сохранение даёт два преимущества: * **Оптимизация кэша:** сохранённые блоки размышлений обеспечивают попадания в кэш при использовании инструментов, поскольку они передаются обратно вместе с результатами инструментов и кэшируются инкрементально на протяжении хода ассистента, что приводит к экономии токенов в многошаговых рабочих процессах. * **Отсутствие влияния на интеллект:** сохранение блоков размышлений не оказывает негативного влияния на производительность модели. Компромисс заключается в использовании контекста: на моделях, сохраняющих все ходы, длинные диалоги занимают больше места в контексте, поскольку сохранённые блоки размышлений учитываются как входные данные, как и любая другая история диалога (см. [Размышления и контекстное окно](https://platform.claude.com/docs/ru/build-with-claude/thinking#thinking-and-the-context-window)). Поведение автоматическое в обоих режимах. Никаких изменений кода или бета-заголовков не требуется, и вам следует продолжать передавать полные, неизменённые блоки размышлений обратно, как описано в разделе [Сохранение блоков размышлений](https://platform.claude.com/docs/ru/build-with-claude/thinking#preserving-thinking-blocks). Чтобы переопределить поведение по умолчанию в любую сторону, используйте [очистку блоков размышлений](https://platform.claude.com/docs/ru/build-with-claude/context-editing#thinking-block-clearing). **Переключение моделей посреди разговора.** Продолжайте передавать блоки размышлений обратно без изменений при переключении моделей, например после [резервного переключения при отказе классификатора](https://platform.claude.com/docs/ru/build-with-claude/refusals-and-fallback). Блок размышлений может прочитать только модель, которая его создала, и некоторые другие модели, а API игнорирует или отбрасывает блоки, которые целевая модель не может прочитать. Для Claude Fable 5.1 и Claude Mythos 5.1 направление имеет значение: они читают блоки размышлений более ранних моделей, и только эти две модели читают блоки друг друга, поэтому переключение на них сохраняет рассуждения разговора, а переключение с них на любую другую модель отбрасывает их (см. [как тарифицируются и отображаются отброшенные блоки](https://platform.claude.com/docs/ru/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 Opus 5.5 на Claude Fable 5.1 в Claude API сохраняет рассуждения предыдущих ходов; переключение с 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 Sonnet 5.5 на Claude Opus 5.5 в Claude API и Google Cloud сохраняет рассуждения предыдущих ходов, а любое другое переключение с 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/ru/build-with-claude/fallback-credit), для которого требуется неизменённое тело запроса. ## Сохранённые размышления [Сохранённые размышления](https://platform.claude.com/docs/ru/build-with-claude/preserved-thinking) определяют, может ли модель использовать блок размышлений, который вы отправляете обратно из предыдущего хода. Начиная с Claude Fable 5.1, API проверяет `signature` каждого блока `thinking` или `redacted_thinking` в запросе на две вещи: * **Модель, которая его создала.** Каждая модель читает собственные блоки размышлений и блоки фиксированного набора других моделей. 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/ru/build-with-claude/preserved-thinking#switching-models). * **Всё, что было отправлено до него.** Блок остаётся действительным только до тех пор, пока системная подсказка верхнего уровня `system`, `tools` и сообщения перед ним остаются неизменными. Если что-либо из этого изменится, этот блок и все последующие блоки размышлений становятся недействительными, и API либо отклоняет запрос с ошибкой 400, либо отбрасывает недействительные блоки — в зависимости от вашего выбора. См. [Сохранение префикса неизменным](https://platform.claude.com/docs/ru/build-with-claude/preserved-thinking#prefix-check). Блоки размышлений Claude Sonnet 5.5 и Claude Haiku 5.5 также привязаны к аккаунту, который их создал. См. [Блоки размышлений остаются в аккаунте, который их создал](https://platform.claude.com/docs/ru/build-with-claude/preserved-thinking#account-bound-thinking), чтобы узнать, где API применяет это правило. Проверка модели применяется ко всем аккаунтам. API применяет проверку префикса по умолчанию для аккаунтов, созданных 31 августа 2026 года, 00:00 UTC или позже. Для более старых аккаунтов проверка применяется только к запросам, в которых задано `thinking.block_binding.prefix_mismatch_behavior`. Сделайте вашу интеграцию работающей только на добавление (append-only) независимо от возраста вашего аккаунта, чтобы один и тот же код работал на любом аккаунте, включая более новые аккаунты, где проверка применяется по умолчанию. Чтобы размышления оставались действительными, отправляйте каждый ход ассистента обратно точно в том виде, в каком вы его получили, и добавляйте новые сообщения только в конец `messages`. Если ваш код сам формирует массив `messages`, на странице «Сохранённые размышления» описано: * [Что считается редактированием](https://platform.claude.com/docs/ru/build-with-claude/preserved-thinking#what-counts-as-an-edit) и [как проверить, выполняет ли его ваш код](https://platform.claude.com/docs/ru/build-with-claude/preserved-thinking#how-to-tell-whether-your-integration-is-impacted). * [Функция API, заменяющая каждое распространённое редактирование](https://platform.claude.com/docs/ru/build-with-claude/preserved-thinking#replace-prefix-edits): системные сообщения посреди разговора для новых инструкций и напоминаний на каждом ходе, блоки `tool_addition` и `tool_removal` для изменения инструментов, `output_config` на уровне сообщения для изменения effort, а также серверное сжатие и редактирование контекста для сокращения. * [Сжатие на стороне клиента](https://platform.claude.com/docs/ru/build-with-claude/preserved-thinking#custom-compaction-on-the-client): какие шаблоны сохраняют размышления действительными, а какие нет. * [Бета-заголовок `thinking-binding-controls-2026-08-01`](https://platform.claude.com/docs/ru/build-with-claude/preserved-thinking#preserved-thinking-controls). Он добавляет поле `block_binding.prefix_mismatch_behavior` (`"error"` или `"drop_block"`) в конфигурацию размышлений и массив `input_transformations` в каждый ответ. В массиве перечислены все блоки размышлений, которые API отбросил или которые не прошли проверку префикса и были пропущены. ## Размышления и кэширование подсказок [Кэширование подсказок](https://platform.claude.com/docs/ru/build-with-claude/prompt-caching) взаимодействует с размышлениями несколькими определёнными способами. Следующие правила применяются в обоих режимах размышлений. **Изменения конфигурации делают кэш недействительным.** Конфигурация размышлений и итоговый уровень [`effort`](https://platform.claude.com/docs/ru/build-with-claude/effort) встраиваются в саму подсказку, поэтому изменение любого из них начинает новый префикс кэша. Переключение между `adaptive`, `enabled` и `disabled`, изменение `budget_tokens` и изменение значения effort делают точки останова кэша недействительными: точки останова на уровне сообщений всегда дают промах, а точки останова инструментов и системной подсказки тоже могут дать промах — в зависимости от того, где модель отображает конфигурацию. Считайте любое изменение размышлений или effort верхнего уровня началом кэша заново. На моделях, поддерживающих [effort на уровне сообщения](https://platform.claude.com/docs/ru/build-with-claude/effort#change-effort-mid-conversation-beta), изменение effort, переданное в сообщении `role: "system"` внутри `messages`, оставляет кэшированный префикс нетронутым. Последовательные запросы с одинаковой конфигурацией сохраняют кэш, а явная установка параметра в значение по умолчанию эквивалентна его отсутствию. Блок размышлений, который API отбрасывает при любом [условии сохранённых размышлений](https://platform.claude.com/docs/ru/build-with-claude/thinking#preserved-thinking), изменяет кэшированный префикс начиная с позиции этого блока. Блоки, переданные обратно без изменений, сохраняют кэш нетронутым. Наглядная демонстрация с выводом использования приведена на странице [Управление размышлениями](https://platform.claude.com/docs/ru/build-with-claude/thinking-steering-and-cost#prompt-caching). **Блоки размышлений кэшируются вместе с результатами инструментов.** Во время цикла использования инструментов кэширование происходит, когда вы делаете последующий запрос, включающий результаты инструментов. В этот момент предыдущая история диалога, включая её блоки размышлений, может быть закэширована, и эти закэшированные блоки размышлений учитываются как входные токены в ваших метриках использования при чтении из кэша. Это происходит автоматически, даже без явных маркеров `cache_control`, и работает одинаково для обычных и чередующихся размышлений. Компромисс: блоки размышлений, которые вы больше никогда не увидите в ответах, всё равно вносят вклад в использование входных токенов при чтении из кэша. **Находятся ли предыдущие блоки в контексте вообще, зависит от модели.** Это определяется [поведением сохранения по умолчанию](https://platform.claude.com/docs/ru/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/ru/build-with-claude/thinking#thinking-with-tool-use)). [Чередующиеся размышления](https://platform.claude.com/docs/ru/build-with-claude/thinking#interleaved-thinking) усиливают эффекты инвалидации кэша, поскольку блоки размышлений могут появляться между несколькими вызовами инструментов. Задачи с интенсивными размышлениями часто выполняются дольше, чем стандартное 5-минутное время жизни кэша. Рассмотрите возможность использования [1-часовой длительности кэша](https://platform.claude.com/docs/ru/build-with-claude/prompt-caching#1-hour-cache-duration), чтобы сохранять попадания в кэш в более длительных сеансах размышлений и многошаговых рабочих процессах. ## Размышления и контекстное окно `max_tokens`, включающий все размышления, которые Claude генерирует в текущем ходе, применяется как строгий лимит. На моделях Claude 4.5 и новее, если сумма входных токенов и `max_tokens` превышает размер контекстного окна, API принимает запрос. Если затем генерация достигает предела контекстного окна, она останавливается с `stop_reason: "model_context_window_exceeded"` вместо возврата ошибки. На более ранних моделях API вместо этого возвращает ошибку валидации. См. [Обработка причин остановки](https://platform.claude.com/docs/ru/build-with-claude/handling-stop-reasons). То, как размышления учитываются в окне, зависит от того, когда они были сгенерированы: * **Размышления текущего хода** всегда учитываются в `max_tokens`, тарифицируются как выходные токены и занимают место в контекстном окне для хода, в котором они были сгенерированы. * **Размышления предыдущих ходов** зависят от [поведения сохранения по умолчанию](https://platform.claude.com/docs/ru/build-with-claude/thinking#thinking-block-preservation-by-model). На [моделях, сохраняющих все предыдущие ходы](https://platform.claude.com/docs/ru/build-with-claude/thinking#thinking-block-preservation-by-model), предыдущие блоки размышлений остаются в контексте, учитываются в окне и тарифицируются как входные токены, как и остальная история диалога. На моделях, сохраняющих только последний ход, API автоматически удаляет более старые блоки размышлений, когда вы передаёте их обратно, поэтому они не занимают место в окне и не расходуют входные токены. На практике: * На моделях, сохраняющих все ходы, планируйте контекстное окно так, как если бы размышления были обычной историей диалога, — потому что так и есть. В длительных агентных сеансах размышления накапливаются в контексте. Используйте [очистку блоков размышлений](https://platform.claude.com/docs/ru/build-with-claude/context-editing#thinking-block-clearing), если вам нужно освободить место. * На моделях, сохраняющих только последний ход, размышления — это затраты только в пределах хода: размышления каждого хода учитываются в `max_tokens` этого хода, а затем выпадают из окна. Следующие диаграммы иллюстрируют режим сохранения только последнего хода (с удалением). Первая показывает многоходовой диалог: блок размышлений каждого хода генерируется в выводе, но не переносится во входные данные последующих ходов. ![Диаграмма «thinking» (размышлений) на модели, которая удаляет предыдущие блоки размышлений: блок размышлений каждого хода генерируется в выводе и не переносится во входные данные последующих ходов](https://platform.claude.com/docs/ru/images/context-window-thinking.svg) Вторая показывает тот же режим с использованием инструментов: размышления остаются в контексте вместе с результатом инструмента на протяжении хода ассистента, а затем выпадают на следующем ходе пользователя. ![Диаграмма «thinking» (размышлений) с «tool use» (использованием инструментов) на модели, которая удаляет предыдущие блоки размышлений: размышления сохраняются вместе с результатом инструмента, а затем отбрасываются на следующем ходе пользователя](https://platform.claude.com/docs/ru/images/context-window-thinking-tools.svg) Используйте [API подсчёта токенов](https://platform.claude.com/docs/ru/build-with-claude/token-counting), чтобы получить точные значения для вашего конкретного сценария, особенно для многоходовых диалогов, включающих размышления. ## Шифрование размышлений Полное содержимое размышлений шифруется и возвращается в поле `signature` каждого блока размышлений. Когда вы передаёте блоки размышлений обратно, API по подписи проверяет, что они были сгенерированы Claude. При работе с подписями учитывайте следующее: * Передавать блоки размышлений обратно строго необходимо только при [использовании инструментов с размышлениями](https://platform.claude.com/docs/ru/build-with-claude/thinking#thinking-with-tool-use). В остальных случаях блоки размышлений из предыдущих ходов можно не передавать. Если вы всё же передаёте их, то сохранит их API или удалит, зависит от модели (см. [Сохранение блоков размышлений в зависимости от модели](https://platform.claude.com/docs/ru/build-with-claude/thinking#thinking-block-preservation-by-model)). Для настройки этого поведения используйте [редактирование контекста](https://platform.claude.com/docs/ru/build-with-claude/context-editing). * Передавайте блоки размышлений обратно в точности в том виде, в каком вы их получили. Это обеспечивает согласованность и помогает избежать возможных проблем. * При [«streaming» (потоковой передаче) ответов](https://platform.claude.com/docs/ru/build-with-claude/thinking#streaming-thinking) подпись приходит как `signature_delta` внутри события `content_block_delta` непосредственно перед событием `content_block_stop`. * В моделях Claude 4 и новее значения `signature` значительно длиннее, чем в предыдущих моделях. * Поле `signature` непрозрачно: не интерпретируйте и не разбирайте его. * Значения `signature` совместимы между платформами (Claude API, [Amazon Bedrock](https://platform.claude.com/docs/ru/build-with-claude/claude-in-amazon-bedrock) и [Google Cloud](https://platform.claude.com/docs/ru/build-with-claude/claude-on-vertex-ai)). Значения, сгенерированные на одной платформе, работают на другой, за исключением того, что блоки размышлений Claude Sonnet 5.5 и Claude Haiku 5.5 работают только в аккаунте, который их создал, или в связанном с ним аккаунте. См. [Блоки размышлений остаются в аккаунте, который их создал](https://platform.claude.com/docs/ru/build-with-claude/preserved-thinking#account-bound-thinking). ## Скрытые блоки размышлений Помимо обычных блоков `thinking`, API может возвращать блоки `redacted_thinking`, когда части рассуждений Claude скрыты по соображениям безопасности. Блок `redacted_thinking` содержит зашифрованное содержимое размышлений в поле `data` и не содержит читаемого текста: ```json { "type": "redacted_thinking", "data": "..." } ``` Поле `data` непрозрачно и зашифровано. Как и поле `signature` в обычных блоках размышлений, блоки `redacted_thinking` нужно передавать обратно в API без изменений, когда вы продолжаете многоходовой разговор с [инструментами](https://platform.claude.com/docs/ru/build-with-claude/thinking#thinking-with-tool-use). Если при передаче ответов с использованием инструментов ваш код фильтрует блоки содержимого по типу (например, `block.type == "thinking"`), включайте также блоки `redacted_thinking`. Фильтрация только по `block.type == "thinking"` незаметно отбрасывает блоки `redacted_thinking` и нарушает многоходовой протокол, описанный в разделе [Сохранение блоков размышлений](https://platform.claude.com/docs/ru/build-with-claude/thinking#preserving-thinking-blocks). Блоки `redacted_thinking` — это отдельный тип блока содержимого, который возвращается, когда размышления скрыты по соображениям безопасности. Их не следует путать с параметром [`display: "omitted"`](https://platform.claude.com/docs/ru/build-with-claude/thinking#controlling-thinking-display), который возвращает обычные блоки `thinking` с пустым полем `thinking`. ## Ограничения и совместимость функций ### Параметры сэмплирования На 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`, даже со значениями по умолчанию. См. [Удалите параметры сэмплирования](https://platform.claude.com/docs/ru/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/ru/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. На этих моделях вместо этого используйте `tool_choice: {"type": "auto"}` со [строгим использованием инструментов](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/strict-tool-use) или [структурированными выходными данными](https://platform.claude.com/docs/ru/build-with-claude/structured-outputs). Там, где принудительное использование инструментов принимается, ответ начинается с вызова инструмента и не содержит блока `thinking`. Чтобы модель могла поразмышлять перед вызовом инструмента, используйте `tool_choice: {"type": "auto"}` и укажите в подсказке, когда использовать инструмент. См. [Размышления при использовании инструментов](https://platform.claude.com/docs/ru/build-with-claude/thinking#thinking-with-tool-use). ### Ограничения вывода Каждая модель принимает `max_tokens` вплоть до указанного здесь потолка. В [Message Batches API](https://platform.claude.com/docs/ru/build-with-claude/batch-processing#extended-output-beta) [бета-заголовок](https://platform.claude.com/docs/ru/api/beta-headers) `output-300k-2026-03-24` повышает этот потолок для моделей, у которых указан потолок для пакетов. | 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/ru/models/overview). ### Длительные запросы SDK требует потоковой передачи, когда `max_tokens` больше 21 333, чтобы избежать тайм-аутов HTTP при длительных запросах. Это проверка на стороне клиента, а не ограничение 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/ru/build-with-claude/streaming#get-the-final-message-without-handling-events). Ожидайте более длительного времени ответа при активных размышлениях, поскольку генерация блоков размышлений увеличивает время обработки. Для рабочих нагрузок, в которых размышления превышают примерно 32 тыс. токенов на запрос, используйте [пакетную обработку](https://platform.claude.com/docs/ru/build-with-claude/batch-processing), чтобы избежать сетевых проблем: такие запросы могут выполняться достаточно долго, чтобы упереться в системные тайм-ауты и ограничения на открытые соединения. ## Следующие шаги Управляйте тем, как часто и насколько глубоко думает Claude, с помощью уровней effort, указаний в системной подсказке и управления на уровне отдельных сообщений. Узнайте, сколько стоят размышления и как они тарифицируются. Разберите полный двухходовой цикл использования инструментов с корректным сохранением блоков размышлений и посмотрите, как чередующиеся размышления меняют этот процесс. Выясните, редактирует ли ваша интеграция с Messages API историю разговора, и замените каждое такое редактирование функцией API, которая сохраняет действительность прежних блоков размышлений. Диагностируйте и устраняйте самые распространённые сбои размышлений: ошибки конфигурации 400, пустые или отсутствующие блоки размышлений, остановки по max\_tokens и промахи кэша. С помощью параметра effort управляйте тем, сколько токенов Claude расходует на ответ, находя баланс между полнотой ответа и экономией токенов.