---
title: Руководство по миграции на Claude Fable 5.1 и Claude Mythos 5.1
url: https://platform.claude.com/docs/ru/models/fable-5-1/migration-guide
description: Перейдите на Claude Fable 5.1 и Claude Mythos 5.1 с Claude Fable 5, Claude Mythos 5, Claude Opus 5 или Claude Opus 4.8 с помощью этого руководства по миграции. Инструкции по включению Claude Fable 5.1 и Claude Mythos 5.1 содержат идентификаторы моделей, критические изменения и контрольные списки миграции.
---

<Note>
  В этом руководстве рассматривается миграция кода [Messages API](https://platform.claude.com/docs/ru/build-with-claude/working-with-messages). Если вы используете [Claude Managed Agents](https://platform.claude.com/docs/ru/managed-agents/overview), никаких изменений, кроме обновления названия модели, не требуется.
</Note>

<Tip>
  **Автоматизируйте миграцию с помощью навыка Claude API.** В Claude Code выполните `/claude-api migrate`, чтобы вызвать встроенный [навык Claude API](https://platform.claude.com/docs/ru/agents-and-tools/agent-skills/claude-api-skill#migrating-to-a-newer-claude-model). Он работает с любой актуальной моделью Claude в качестве целевой:

  Позвольте Claude Code выполнить миграцию вашего кода за вас

  ```text
  /claude-api migrate этот проект на claude-fable-5-1
  ```

  Навык выполняет замену идентификатора модели и, при необходимости, применяет критические изменения параметров, замену предзаполнения (prefill) и калибровку уровня усилий (effort) для целевой модели по всей вашей кодовой базе, а затем формирует контрольный список пунктов для ручной проверки. Перед редактированием каких-либо файлов он просит вас подтвердить область миграции (весь рабочий каталог, подкаталог или конкретный список файлов). Навык также обнаруживает клиенты Amazon Bedrock и Claude Platform на AWS и корректирует форматы идентификаторов моделей и изменения функций для этих платформ.
</Tip>

[Claude Fable 5.1](https://platform.claude.com/docs/ru/models/fable-5-1/whats-new-fable-5-1) приходит на смену Claude Fable 5 по тем же ценам на входные и выходные токены, а чтение из кэша стоит в четыре раза дешевле. Модель доступна в Claude API, [Amazon Bedrock](https://platform.claude.com/docs/ru/build-with-claude/claude-in-amazon-bedrock), [Claude Platform on AWS](https://platform.claude.com/docs/ru/build-with-claude/claude-platform-on-aws), [Google Cloud](https://platform.claude.com/docs/ru/build-with-claude/claude-on-vertex-ai) и [Microsoft Foundry](https://platform.claude.com/docs/ru/build-with-claude/claude-in-microsoft-foundry). [Claude Mythos 5.1](https://platform.claude.com/docs/ru/models/mythos-5-1/overview) обладает теми же возможностями и доступна только организациям, прошедшим проверку в рамках программ верификации Anthropic, таких как [Cyber Verification Program](https://support.claude.com/en/articles/14604842). О различиях в поведении и приёмах составления подсказок см. [Составление подсказок для Claude Fable 5.1](https://platform.claude.com/docs/ru/build-with-claude/prompt-engineering/prompting-claude-fable-5-1).

Базовые настройки, общие для `claude-fable-5-1` и `claude-mythos-5-1`:

* **Размышления:** [«adaptive thinking» (адаптивные размышления)](https://platform.claude.com/docs/ru/build-with-claude/thinking) всегда включены, как и в Claude Fable 5. Модель сама определяет, когда и сколько размышлять. Настройка `thinking` не требуется. И `thinking: {type: "disabled"}`, и ручные расширенные размышления (`thinking: {type: "enabled", budget_tokens: N}`) возвращают ошибку 400.
* **Предзаполнение:** «prefill» (предзаполнение) сообщения ассистента возвращает ошибку 400, как и в Claude Fable 5. Вместо этого используйте инструкции в системной подсказке.
* **Выбор инструмента:** поддерживаются `{type: "auto"}` (по умолчанию) и `{type: "none"}`. Принудительный вызов инструмента с помощью `{type: "any"}` или `{type: "tool", name: "..."}` возвращает ошибку 400. См. [Критические изменения](https://platform.claude.com/docs/ru/models/fable-5-1/migration-guide#fable-5-1-breaking-changes).
* **Сохранение размышлений между моделями:** Claude Fable 5.1 читает блоки размышлений от Claude Opus 5, Claude Fable 5, Claude Mythos 5 и более ранних моделей Claude. Ни одна из этих моделей не может читать блоки Claude Fable 5.1. См. [Критические изменения](https://platform.claude.com/docs/ru/models/fable-5-1/migration-guide#fable-5-1-breaking-changes).
* **Контекстное окно и вывод:** по умолчанию [«context window» (контекстное окно) на 1M токенов](https://platform.claude.com/docs/ru/build-with-claude/context-windows) и до 128k выходных токенов на запрос.
* **Цены:** $10 USD за миллион входных токенов и $50 USD за миллион выходных токенов, как и у Claude Fable 5. Чтение из кэша подсказок стоит $0,25 USD за миллион токенов — четверть тарифа Claude Fable 5. См. [Цены Claude](https://platform.claude.com/docs/ru/about-claude/pricing).
* **Хранение данных:** обе модели требуют 30-дневного хранения данных, недоступны в рамках соглашений «zero data retention» (нулевое хранение данных), или ZDR, если это явно не разрешено Anthropic, и отнесены к категории Covered Models, как и Claude Fable 5 и Claude Mythos 5. В Claude API запрос от организации или рабочего пространства без 30-дневного хранения возвращает ошибку 400 `invalid_request_error`. Организациям с соглашением ZDR следует связаться со своей командой по работе с клиентами Anthropic или настроить хранение для отдельного рабочего пространства. Подробности по платформам см. в разделе [Требования к хранению данных для конкретных моделей](https://platform.claude.com/docs/ru/manage-claude/api-and-data-retention#model-specific-data-retention-requirements).

Чем различаются две модели:

* **Доступность:** Claude Fable 5.1 не требует одобрения доступа. Claude Mythos 5.1 доступна только организациям, прошедшим проверку в рамках программ верификации Anthropic, таких как [Cyber Verification Program](https://support.claude.com/en/articles/14604842). Чтобы запросить доступ, подайте заявку в программу, охватывающую ваш сценарий использования, или свяжитесь со своей командой по работе с клиентами Anthropic.
* **Priority Tier:** ни одна из моделей не поддерживается в [Priority Tier](https://platform.claude.com/docs/ru/api/service-tiers#supported-models). Claude Fable 5 поддерживается.

## Миграция на Claude Fable 5.1 с Claude Fable 5

В большинстве случаев достаточно просто заменить модель. Поверхность API, ограничения, цены за токен, токенизатор, постоянно включённые адаптивные размышления, обработка отказов и категории `stop_details` совпадают с Claude Fable 5. Что меняется: принудительный выбор инструмента возвращает ошибку 400; блоки размышлений Claude Fable 5.1 читают только Claude Fable 5.1 и Claude Mythos 5.1, и только в том разговоре, в котором они были созданы; чтение из кэша стоит дешевле; поведение в агентных циклах отличается в трёх аспектах. Те же изменения относятся и к [Claude Mythos 5.1](https://platform.claude.com/docs/ru/models/fable-5-1/migration-guide#migrating-from-claude-mythos-5-to-claude-mythos-5-1), за исключением проверки разговора для блоков размышлений, которую Claude Mythos 5.1 не выполняет.

### Обновите название модели

```python
model = "claude-fable-5"  # Before
model = "claude-fable-5-1"  # After

# Или для Claude Mythos 5.1, который предоставляет те же возможности верифицированным организациям:
model = "claude-mythos-5-1"  # After
```

### Критические изменения

1. **Принудительный выбор инструмента не поддерживается:** Claude Fable 5 принимает `tool_choice` со значениями `auto`, `none`, `any` и `tool`. В `claude-fable-5-1` значения `{type: "any"}` и `{type: "tool", name: "..."}` возвращают ошибку 400 `invalid_request_error`:

   ```text wrap
   tool_choice: type "tool" and "any" are not supported for this model.
   ```

   Проверка применяется в Messages API, Message Batches API и в эндпоинте [подсчёта токенов](https://platform.claude.com/docs/ru/build-with-claude/token-counting).

   До (Claude Fable 5):

   <CodeGroup>
     ```bash cURL
     curl -sS https://api.anthropic.com/v1/messages \
       -H "content-type: application/json" \
       -H "x-api-key: $ANTHROPIC_API_KEY" \
       -H "anthropic-version: 2023-06-01" \
       -d '{
         "model": "claude-fable-5",
         "max_tokens": 16000,
         "tools": [
           {
             "name": "record_summary",
             "description": "Record the structured summary of the document.",
             "input_schema": {
               "type": "object",
               "properties": {"summary": {"type": "string"}},
               "required": ["summary"]
             }
           }
         ],
         "tool_choice": {"type": "tool", "name": "record_summary"},
         "messages": [
           {"role": "user", "content": "Summarize: The meeting moved to Thursday."}
         ]
       }'
     ```

     ```bash CLI
     ant messages create <<'YAML'
     model: claude-fable-5
     max_tokens: 16000
     tools:
       - name: record_summary
         description: Record the structured summary of the document.
         input_schema:
           type: object
           properties:
             summary:
               type: string
           required: [summary]
     tool_choice:
       type: tool
       name: record_summary
     messages:
       - role: user
         content: "Summarize: The meeting moved to Thursday."
     YAML
     ```

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

     record_summary_tool = {
         "name": "record_summary",
         "description": "Record the structured summary of the document.",
         "input_schema": {
             "type": "object",
             "properties": {"summary": {"type": "string"}},
             "required": ["summary"],
         },
     }

     response = client.messages.create(
         model="claude-fable-5",
         max_tokens=16000,
         tools=[record_summary_tool],
         tool_choice={"type": "tool", "name": "record_summary"},
         messages=[{"role": "user", "content": "Summarize: The meeting moved to Thursday."}],
     )
     print(response.content)
     ```

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

     const response = await client.messages.create({
       model: "claude-fable-5",
       max_tokens: 16000,
       tools: [
         {
           name: "record_summary",
           description: "Record the structured summary of the document.",
           input_schema: {
             type: "object",
             properties: { summary: { type: "string" } },
             required: ["summary"]
           }
         }
       ],
       tool_choice: { type: "tool", name: "record_summary" },
       messages: [{ role: "user", content: "Summarize: The meeting moved to Thursday." }]
     });

     console.log(response.content);
     ```

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

     var parameters = new MessageCreateParams
     {
         Model = Model.ClaudeFable5,
         MaxTokens = 16000,
         Tools = [
             new ToolUnion(new Tool()
             {
                 Name = "record_summary",
                 Description = "Record the structured summary of the document.",
                 InputSchema = new InputSchema()
                 {
                     Properties = new Dictionary<string, JsonElement>
                     {
                         ["summary"] = JsonSerializer.SerializeToElement(new { type = "string" }),
                     },
                     Required = ["summary"],
                 },
             }),
         ],
         ToolChoice = new ToolChoiceTool { Name = "record_summary" },
         Messages = [
             new() { Role = Role.User, Content = "Summarize: The meeting moved to Thursday." }
         ]
     };

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

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

     response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
     	Model:     anthropic.ModelClaudeFable5,
     	MaxTokens: 16000,
     	Tools: []anthropic.ToolUnionParam{
     		{OfTool: &anthropic.ToolParam{
     			Name:        "record_summary",
     			Description: anthropic.String("Record the structured summary of the document."),
     			InputSchema: anthropic.ToolInputSchemaParam{
     				Properties: map[string]any{
     					"summary": map[string]any{"type": "string"},
     				},
     				Required: []string{"summary"},
     			},
     		}},
     	},
     	ToolChoice: anthropic.ToolChoiceUnionParam{OfTool: &anthropic.ToolChoiceToolParam{Name: "record_summary"}},
     	Messages: []anthropic.MessageParam{
     		anthropic.NewUserMessage(anthropic.NewTextBlock("Summarize: The meeting moved to Thursday.")),
     	},
     })
     if err != nil {
     	log.Fatal(err)
     }
     fmt.Println(response.RawJSON())
     ```

     ```java Java

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

         MessageCreateParams params = MessageCreateParams.builder()
             .model(Model.CLAUDE_FABLE_5)
             .maxTokens(16000L)
             .addTool(Tool.builder()
                 .name("record_summary")
                 .description("Record the structured summary of the document.")
                 .inputSchema(InputSchema.builder()
                     .properties(JsonValue.from(Map.of("summary", Map.of("type", "string"))))
                     .required(List.of("summary"))
                     .build())
                 .build())
             .toolChoice(ToolChoice.ofTool(ToolChoiceTool.builder()
                 .name("record_summary")
                 .build()))
             .addUserMessage("Summarize: The meeting moved to Thursday.")
             .build();

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

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

     $message = $client->messages->create(
         maxTokens: 16000,
         messages: [
             ['role' => 'user', 'content' => 'Summarize: The meeting moved to Thursday.']
         ],
         model: 'claude-fable-5',
         toolChoice: ['type' => 'tool', 'name' => 'record_summary'],
         tools: [
             [
                 'name' => 'record_summary',
                 'description' => 'Record the structured summary of the document.',
                 'input_schema' => [
                     'type' => 'object',
                     'properties' => [
                         'summary' => ['type' => 'string']
                     ],
                     'required' => ['summary']
                 ]
             ]
         ],
     );

     echo $message;
     ```

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

     message = client.messages.create(
       model: Anthropic::Model::CLAUDE_FABLE_5,
       max_tokens: 16000,
       tools: [
         {
           name: "record_summary",
           description: "Record the structured summary of the document.",
           input_schema: {
             type: "object",
             properties: { summary: { type: "string" } },
             required: ["summary"]
           }
         }
       ],
       tool_choice: { type: "tool", name: "record_summary" },
       messages: [
         { role: "user", content: "Summarize: The meeting moved to Thursday." }
       ]
     )
     puts message
     ```
   </CodeGroup>

   После (Claude Fable 5.1): оставьте `tool_choice` со значением `auto`, назовите инструмент в инструкции и установите `strict: true`, чтобы вызов соответствовал вашей схеме. (В организации с [CMEK](https://platform.claude.com/docs/ru/manage-claude/cmek), где [структурированные выходные данные](https://platform.claude.com/docs/ru/build-with-claude/structured-outputs), включая `strict: true`, недоступны для моделей Claude Fable, полагайтесь только на инструкцию.) Например:

   <CodeGroup>
     ```bash cURL
     curl -sS https://api.anthropic.com/v1/messages \
       -H "content-type: application/json" \
       -H "x-api-key: $ANTHROPIC_API_KEY" \
       -H "anthropic-version: 2023-06-01" \
       -d '{
         "model": "claude-fable-5-1",
         "max_tokens": 16000,
         "tools": [
           {
             "name": "record_summary",
             "description": "Record the structured summary of the document.",
             "strict": true,
             "input_schema": {
               "type": "object",
               "properties": {"summary": {"type": "string"}},
               "required": ["summary"],
               "additionalProperties": false
             }
           }
         ],
         "tool_choice": {"type": "auto"},
         "messages": [
           {"role": "user", "content": "Summarize: The meeting moved to Thursday. Call the record_summary tool with your result."}
         ]
       }'
     ```

     ```bash CLI
     ant messages create <<'YAML'
     model: claude-fable-5-1
     max_tokens: 16000
     tools:
       - name: record_summary
         description: Record the structured summary of the document.
         strict: true
         input_schema:
           type: object
           properties:
             summary:
               type: string
           required: [summary]
           additionalProperties: false
     tool_choice:
       type: auto
     messages:
       - role: user
         content: "Summarize: The meeting moved to Thursday. Call the record_summary tool with your result."
     YAML
     ```

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

     record_summary_tool = {
         "name": "record_summary",
         "description": "Record the structured summary of the document.",
         "strict": True,
         "input_schema": {
             "type": "object",
             "properties": {"summary": {"type": "string"}},
             "required": ["summary"],
             "additionalProperties": False,
         },
     }

     response = client.messages.create(
         model="claude-fable-5-1",
         max_tokens=16000,
         tools=[record_summary_tool],
         tool_choice={"type": "auto"},
         messages=[
             {
                 "role": "user",
                 "content": "Summarize: The meeting moved to Thursday. Call the record_summary tool with your result.",
             }
         ],
     )
     print(response.content)
     ```

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

     const response = await client.messages.create({
       model: "claude-fable-5-1",
       max_tokens: 16000,
       tools: [
         {
           name: "record_summary",
           description: "Record the structured summary of the document.",
           strict: true,
           input_schema: {
             type: "object",
             properties: { summary: { type: "string" } },
             required: ["summary"],
             additionalProperties: false
           }
         }
       ],
       tool_choice: { type: "auto" },
       messages: [
         {
           role: "user",
           content:
             "Summarize: The meeting moved to Thursday. Call the record_summary tool with your result."
         }
       ]
     });

     console.log(response.content);
     ```

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

     var parameters = new MessageCreateParams
     {
         Model = Model.ClaudeFable5_1,
         MaxTokens = 16000,
         Tools = [
             new ToolUnion(new Tool()
             {
                 Name = "record_summary",
                 Description = "Record the structured summary of the document.",
                 Strict = true,
                 InputSchema = new InputSchema(new Dictionary<string, JsonElement>
                 {
                     ["properties"] = JsonSerializer.SerializeToElement(new Dictionary<string, object>
                     {
                         ["summary"] = new { type = "string" },
                     }),
                     ["required"] = JsonSerializer.SerializeToElement(new[] { "summary" }),
                     ["additionalProperties"] = JsonSerializer.SerializeToElement(false),
                 }),
             }),
         ],
         ToolChoice = new ToolChoiceAuto(),
         Messages = [
             new() { Role = Role.User, Content = "Summarize: The meeting moved to Thursday. Call the record_summary tool with your result." }
         ]
     };

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

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

     response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
     	Model:     anthropic.ModelClaudeFable5_1,
     	MaxTokens: 16000,
     	Tools: []anthropic.ToolUnionParam{
     		{OfTool: &anthropic.ToolParam{
     			Name:        "record_summary",
     			Description: anthropic.String("Record the structured summary of the document."),
     			Strict:      anthropic.Bool(true),
     			InputSchema: anthropic.ToolInputSchemaParam{
     				Properties: map[string]any{
     					"summary": map[string]any{"type": "string"},
     				},
     				Required: []string{"summary"},
     				ExtraFields: map[string]any{
     					"additionalProperties": false,
     				},
     			},
     		}},
     	},
     	ToolChoice: anthropic.ToolChoiceUnionParam{OfAuto: &anthropic.ToolChoiceAutoParam{}},
     	Messages: []anthropic.MessageParam{
     		anthropic.NewUserMessage(anthropic.NewTextBlock("Summarize: The meeting moved to Thursday. Call the record_summary tool with your result.")),
     	},
     })
     if err != nil {
     	log.Fatal(err)
     }
     fmt.Println(response.RawJSON())
     ```

     ```java Java

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

         MessageCreateParams params = MessageCreateParams.builder()
             .model(Model.CLAUDE_FABLE_5_1)
             .maxTokens(16000L)
             .addTool(Tool.builder()
                 .name("record_summary")
                 .description("Record the structured summary of the document.")
                 .inputSchema(InputSchema.builder()
                     .properties(JsonValue.from(Map.of("summary", Map.of("type", "string"))))
                     .putAdditionalProperty("required", JsonValue.from(List.of("summary")))
                     .putAdditionalProperty("additionalProperties", JsonValue.from(false))
                     .build())
                 .strict(true)
                 .build())
             .toolChoice(ToolChoice.ofAuto(ToolChoiceAuto.builder().build()))
             .addUserMessage("Summarize: The meeting moved to Thursday. Call the record_summary tool with your result.")
             .build();

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

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

     $message = $client->messages->create(
         maxTokens: 16000,
         messages: [
             ['role' => 'user', 'content' => 'Summarize: The meeting moved to Thursday. Call the record_summary tool with your result.']
         ],
         model: 'claude-fable-5-1',
         toolChoice: ['type' => 'auto'],
         tools: [
             [
                 'name' => 'record_summary',
                 'description' => 'Record the structured summary of the document.',
                 'strict' => true,
                 'input_schema' => [
                     'type' => 'object',
                     'properties' => [
                         'summary' => ['type' => 'string']
                     ],
                     'required' => ['summary'],
                     'additionalProperties' => false
                 ]
             ]
         ],
     );

     echo $message;
     ```

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

     message = client.messages.create(
       model: "claude-fable-5-1",
       max_tokens: 16000,
       tools: [
         {
           name: "record_summary",
           description: "Record the structured summary of the document.",
           strict: true,
           input_schema: {
             type: "object",
             properties: { summary: { type: "string" } },
             required: ["summary"],
             additionalProperties: false
           }
         }
       ],
       tool_choice: { type: "auto" },
       messages: [
         { role: "user", content: "Summarize: The meeting moved to Thursday. Call the record_summary tool with your result." }
       ]
     )
     puts message
     ```
   </CodeGroup>

   См. [Строгое использование инструментов](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/strict-tool-use) и [Принудительное использование инструментов](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/define-tools#forcing-tool-use). Если вы принудительно вызывали инструмент только для получения JSON, соответствующего схеме, используйте вместо этого [выходные данные JSON](https://platform.claude.com/docs/ru/build-with-claude/structured-outputs#usage) (`output_config.format`).

   Если конкретный вызов инструмента на текущем ходе многоходового разговора требуется вашему приложению, а не пользователю, добавьте [системное сообщение посреди разговора](https://platform.claude.com/docs/ru/build-with-claude/mid-conversation-system-messages) после последнего хода `user`. Назовите инструмент, укажите, что вызов обязателен на этом ходе, и попросите Claude начать ответ с него. Поскольку сообщение добавляется в конец, а не записывается в системную подсказку верхнего уровня `system`, предыдущие ходы остаются побайтово идентичными и сохраняют попадания в [кэш подсказок](https://platform.claude.com/docs/ru/build-with-claude/prompt-caching):

   <CodeGroup>
     ```bash cURL
     curl -sS https://api.anthropic.com/v1/messages \
       -H "content-type: application/json" \
       -H "x-api-key: $ANTHROPIC_API_KEY" \
       -H "anthropic-version: 2023-06-01" \
       -d '{
         "model": "claude-fable-5-1",
         "max_tokens": 16000,
         "system": "You are a customer support assistant for an online electronics store.",
         "tools": [
           {
             "name": "search_help_center",
             "description": "Search the help center for policy and troubleshooting articles.",
             "strict": true,
             "input_schema": {
               "type": "object",
               "properties": {"query": {"type": "string"}},
               "required": ["query"],
               "additionalProperties": false
             }
           }
         ],
         "messages": [
           {"role": "user", "content": "My headphones from order A1234 arrived yesterday."},
           {"role": "assistant", "content": "Thanks for confirming. How can I help with order A1234?"},
           {"role": "user", "content": "I opened the box. Can I still return them?"},
           {
             "role": "system",
             "content": "Tool-use requirement for the current turn: the application requires a call to the search_help_center tool in your response to the latest message from the user. Begin your response with the search_help_center tool call. Do not reply with text only."
           }
         ]
       }'
     ```

     ```bash CLI
     ant messages create <<'YAML'
     model: claude-fable-5-1
     max_tokens: 16000
     system: You are a customer support assistant for an online electronics store.
     tools:
       - name: search_help_center
         description: Search the help center for policy and troubleshooting articles.
         strict: true
         input_schema:
           type: object
           properties:
             query:
               type: string
           required: [query]
           additionalProperties: false
     messages:
       - role: user
         content: My headphones from order A1234 arrived yesterday.
       - role: assistant
         content: Thanks for confirming. How can I help with order A1234?
       - role: user
         content: I opened the box. Can I still return them?
       - role: system
         content: >-
           Tool-use requirement for the current turn: the application requires a call
           to the search_help_center tool in your response to the user's latest message.
           Begin your response with the search_help_center tool call. Do not reply with
           text only.
     YAML
     ```

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

     search_help_center_tool = {
         "name": "search_help_center",
         "description": "Search the help center for policy and troubleshooting articles.",
         "strict": True,
         "input_schema": {
             "type": "object",
             "properties": {"query": {"type": "string"}},
             "required": ["query"],
             "additionalProperties": False,
         },
     }

     response = client.messages.create(
         model="claude-fable-5-1",
         max_tokens=16000,
         system="You are a customer support assistant for an online electronics store.",
         tools=[search_help_center_tool],
         messages=[
             {
                 "role": "user",
                 "content": "My headphones from order A1234 arrived yesterday.",
             },
             {
                 "role": "assistant",
                 "content": "Thanks for confirming. How can I help with order A1234?",
             },
             {"role": "user", "content": "I opened the box. Can I still return them?"},
             # Приложение требует поиска в справочном центре перед любым ответом
             # о политике. Добавление требования как системного сообщения оставляет
             # предыдущие реплики без изменений.
             {
                 "role": "system",
                 "content": "Tool-use requirement for the current turn: the application requires a call to the search_help_center tool in your response to the user's latest message. Begin your response with the search_help_center tool call. Do not reply with text only.",
             },
         ],
     )
     print(response.content)
     ```

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

     const response = await client.messages.create({
       model: "claude-fable-5-1",
       max_tokens: 16000,
       system: "You are a customer support assistant for an online electronics store.",
       tools: [
         {
           name: "search_help_center",
           description: "Search the help center for policy and troubleshooting articles.",
           strict: true,
           input_schema: {
             type: "object",
             properties: { query: { type: "string" } },
             required: ["query"],
             additionalProperties: false
           }
         }
       ],
       messages: [
         { role: "user", content: "My headphones from order A1234 arrived yesterday." },
         { role: "assistant", content: "Thanks for confirming. How can I help with order A1234?" },
         { role: "user", content: "I opened the box. Can I still return them?" },
         // Приложение требует поиска в справочном центре перед любым ответом
         // о политике. Добавление требования как системного сообщения оставляет
         // предыдущие реплики без изменений.
         {
           role: "system",
           content:
             "Tool-use requirement for the current turn: the application requires a call to the search_help_center tool in your response to the user's latest message. Begin your response with the search_help_center tool call. Do not reply with text only."
         }
       ]
     });

     console.log(response.content);
     ```

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

     var parameters = new MessageCreateParams
     {
         Model = Model.ClaudeFable5_1,
         MaxTokens = 16000,
         System = "You are a customer support assistant for an online electronics store.",
         Tools = [
             new ToolUnion(new Tool()
             {
                 Name = "search_help_center",
                 Description = "Search the help center for policy and troubleshooting articles.",
                 Strict = true,
                 InputSchema = new InputSchema(new Dictionary<string, JsonElement>
                 {
                     ["properties"] = JsonSerializer.SerializeToElement(new Dictionary<string, object>
                     {
                         ["query"] = new { type = "string" },
                     }),
                     ["required"] = JsonSerializer.SerializeToElement(new[] { "query" }),
                     ["additionalProperties"] = JsonSerializer.SerializeToElement(false),
                 }),
             }),
         ],
         Messages = [
             new() { Role = Role.User, Content = "My headphones from order A1234 arrived yesterday." },
             new() { Role = Role.Assistant, Content = "Thanks for confirming. How can I help with order A1234?" },
             new() { Role = Role.User, Content = "I opened the box. Can I still return them?" },
             // Приложение требует поиска в справочном центре перед любым ответом
             // о политике. Добавление требования в виде системного сообщения оставляет
             // предыдущие реплики без изменений.
             new()
             {
                 Role = Role.System,
                 Content = "Tool-use requirement for the current turn: the application requires a call to the search_help_center tool in your response to the user's latest message. Begin your response with the search_help_center tool call. Do not reply with text only."
             }
         ]
     };

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

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

     response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
     	Model:     anthropic.ModelClaudeFable5_1,
     	MaxTokens: 16000,
     	System: []anthropic.TextBlockParam{
     		{Text: "You are a customer support assistant for an online electronics store."},
     	},
     	Tools: []anthropic.ToolUnionParam{
     		{OfTool: &anthropic.ToolParam{
     			Name:        "search_help_center",
     			Description: anthropic.String("Search the help center for policy and troubleshooting articles."),
     			Strict:      anthropic.Bool(true),
     			InputSchema: anthropic.ToolInputSchemaParam{
     				Properties: map[string]any{
     					"query": map[string]any{"type": "string"},
     				},
     				Required: []string{"query"},
     				ExtraFields: map[string]any{
     					"additionalProperties": false,
     				},
     			},
     		}},
     	},
     	Messages: []anthropic.MessageParam{
     		anthropic.NewUserMessage(anthropic.NewTextBlock("My headphones from order A1234 arrived yesterday.")),
     		anthropic.NewAssistantMessage(anthropic.NewTextBlock("Thanks for confirming. How can I help with order A1234?")),
     		anthropic.NewUserMessage(anthropic.NewTextBlock("I opened the box. Can I still return them?")),
     		// Приложение требует поиска в справочном центре перед любым ответом
     		// о политике. Добавление требования как системного сообщения оставляет
     		// предыдущие реплики без изменений.
     		{
     			Role: anthropic.MessageParamRoleSystem,
     			Content: []anthropic.ContentBlockParamUnion{
     				anthropic.NewTextBlock("Tool-use requirement for the current turn: the application requires a call to the search_help_center tool in your response to the user's latest message. Begin your response with the search_help_center tool call. Do not reply with text only."),
     			},
     		},
     	},
     })
     if err != nil {
     	log.Fatal(err)
     }
     fmt.Println(response.RawJSON())
     ```

     ```java Java

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

         MessageCreateParams params = MessageCreateParams.builder()
             .model(Model.CLAUDE_FABLE_5_1)
             .maxTokens(16000L)
             .system("You are a customer support assistant for an online electronics store.")
             .addTool(Tool.builder()
                 .name("search_help_center")
                 .description("Search the help center for policy and troubleshooting articles.")
                 .inputSchema(InputSchema.builder()
                     .properties(JsonValue.from(Map.of("query", Map.of("type", "string"))))
                     .putAdditionalProperty("required", JsonValue.from(List.of("query")))
                     .putAdditionalProperty("additionalProperties", JsonValue.from(false))
                     .build())
                 .strict(true)
                 .build())
             .addUserMessage("My headphones from order A1234 arrived yesterday.")
             .addAssistantMessage("Thanks for confirming. How can I help with order A1234?")
             .addUserMessage("I opened the box. Can I still return them?")
             // Приложение требует поиска в справочном центре перед любым ответом
             // о политике. Добавление требования в виде системного сообщения оставляет
             // предыдущие реплики без изменений.
             .addMessage(MessageParam.builder()
                 .role(MessageParam.Role.SYSTEM)
                 .content("Tool-use requirement for the current turn: the application requires a call to the search_help_center tool in your response to the user's latest message. Begin your response with the search_help_center tool call. Do not reply with text only.")
                 .build())
             .build();

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

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

     $message = $client->messages->create(
         maxTokens: 16000,
         messages: [
             ['role' => 'user', 'content' => 'My headphones from order A1234 arrived yesterday.'],
             ['role' => 'assistant', 'content' => 'Thanks for confirming. How can I help with order A1234?'],
             ['role' => 'user', 'content' => 'I opened the box. Can I still return them?'],
             // Приложение требует поиска в справочном центре перед любым ответом
             // о политике. Добавление требования как системного сообщения оставляет
             // предыдущие реплики без изменений.
             ['role' => 'system', 'content' => 'Tool-use requirement for the current turn: the application requires a call to the search_help_center tool in your response to the user\'s latest message. Begin your response with the search_help_center tool call. Do not reply with text only.']
         ],
         model: 'claude-fable-5-1',
         system: 'You are a customer support assistant for an online electronics store.',
         tools: [
             [
                 'name' => 'search_help_center',
                 'description' => 'Search the help center for policy and troubleshooting articles.',
                 'strict' => true,
                 'input_schema' => [
                     'type' => 'object',
                     'properties' => [
                         'query' => ['type' => 'string']
                     ],
                     'required' => ['query'],
                     'additionalProperties' => false
                 ]
             ]
         ],
     );

     echo $message;
     ```

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

     message = client.messages.create(
       model: "claude-fable-5-1",
       max_tokens: 16000,
       system: "You are a customer support assistant for an online electronics store.",
       tools: [
         {
           name: "search_help_center",
           description: "Search the help center for policy and troubleshooting articles.",
           strict: true,
           input_schema: {
             type: "object",
             properties: { query: { type: "string" } },
             required: ["query"],
             additionalProperties: false
           }
         }
       ],
       messages: [
         { role: "user", content: "My headphones from order A1234 arrived yesterday." },
         { role: "assistant", content: "Thanks for confirming. How can I help with order A1234?" },
         { role: "user", content: "I opened the box. Can I still return them?" },
         # Приложение требует поиска в справочном центре перед любым ответом
         # о политике. Добавление требования как системного сообщения оставляет
         # предыдущие реплики без изменений.
         {
           role: "system",
           content: "Tool-use requirement for the current turn: the application requires a call to the search_help_center tool in your response to the user's latest message. Begin your response with the search_help_center tool call. Do not reply with text only."
         }
       ]
     )
     puts message
     ```
   </CodeGroup>

   Сохраняйте сообщение `role: "system"` в истории в последующих запросах, как и любой другой ход. Системным сообщениям посреди разговора не нужен бета-заголовок. `tool_choice: {"type": "none"}` по-прежнему работает для хода, на котором нельзя вызывать инструменты.

2. **Блоки размышлений Claude Fable 5.1 читают только Claude Fable 5.1 и Claude Mythos 5.1:** каждый блок `thinking` фиксирует, какая модель его создала. Claude Fable 5.1 читает собственные блоки, а также блоки от Claude Mythos 5.1, Claude Opus 5, Claude Fable 5, Claude Mythos 5 и более ранних моделей Claude. Разговор, переходящий на `claude-fable-5-1` с любой из них, сохраняет свои предыдущие рассуждения. Это условие одностороннее: кроме Claude Mythos 5.1, ни одна из этих моделей не может читать блоки Claude Fable 5.1.

   Разговор, который выполнялся на Claude Fable 5.1, может попасть на другую модель, более старую или более новую, из-за переключения маршрутизатора, повторной попытки на стороне клиента или [резервного переключения при отказе классификатора](https://platform.claude.com/docs/ru/build-with-claude/refusals-and-fallback), включая [резервное переключение на стороне сервера](https://platform.claude.com/docs/ru/build-with-claude/refusals-and-fallback#server-side-fallback). API удаляет блоки, которые эта модель не может прочитать, до того как она их увидит, запрос выполняется успешно, и плата за отброшенные входные токены не взимается. Целевая модель заново планирует работу без этих рассуждений, что может увеличить стоимость и задержку на первом ходе после переключения. Чтобы увидеть, что было отброшено, отправьте [бета-заголовок](https://platform.claude.com/docs/ru/api/beta-headers) `thinking-binding-controls-2026-08-01`: тогда ответы будут содержать массив `input_transformations`, в котором каждый отброшенный блок указан с `reason: "model_binding_mismatch"`. См. [Переключение моделей посреди разговора](https://platform.claude.com/docs/ru/build-with-claude/preserved-thinking#switching-models).

3. **Редактирование предыдущих ходов делает блоки размышлений недействительными:** каждый блок `thinking` от Claude Fable 5.1 действителен только относительно системной подсказки `system`, `tools` и истории разговора, которые ему предшествовали. Если историей вашего разговора управляет Claude Code, claude.ai, [Claude Managed Agents](https://platform.claude.com/docs/ru/managed-agents/overview) или [Claude Agent SDK](https://code.claude.com/docs/ru/agent-sdk/overview), этот префикс уже сохраняется неизменным. Если ваш код сам формирует массив `messages`, этот пункт относится к вам, а полным руководством по интеграции служит раздел [Сохранённые размышления](https://platform.claude.com/docs/ru/build-with-claude/preserved-thinking). Там, где проверка применяется, запрос, который отправляет блок обратно после изменения любого из этих элементов, отклоняется с ошибкой 400:

   ```text wrap
   messages.5.content.0: Invalid `signature` in `thinking` block. The block is bound to a different conversation. Remove the block, or set `thinking.block_binding.prefix_mismatch_behavior` to "drop_block". That setting requires the `thinking-binding-controls-2026-08-01` value in the `anthropic-beta` header.
   ```

   API применяет проверку для новых аккаунтов, созданных 31 августа 2026 года или позже. Для аккаунтов, созданных ранее, API фиксирует несоответствие, но не реагирует на него, если только в запросе не задано `thinking.block_binding.prefix_mismatch_behavior`, что включает применение проверки. Если на таких аккаунтах вы отправляете бета-заголовок `thinking-binding-controls-2026-08-01` и оставляете это поле незаданным, ответ перечисляет каждый блок, не прошедший проверку, в `input_transformations` как запись `thinking_mismatch_allowed`. Сделайте своё приложение совместимым с проверкой независимо от возраста аккаунта: те же шаблоны поддерживают кэш подсказок «тёплым», а протестировать проверку можно с любого аккаунта, отправив `prefix_mismatch_behavior`. Если вы выпускаете инструмент или фреймворк, который люди запускают со своим собственным ключом API, протестируйте его таким образом до запуска: ваш ключ, вероятно, относится к более старому аккаунту, а ваши пользователи на новых аккаунтах столкнутся с проверкой раньше вас. Чтобы узнать, применяется ли проверка к вашему аккаунту по умолчанию, отправьте запрос, редактирующий историю, без бета-заголовка: ошибка 400 с упоминанием заголовка означает, что применяется.

   Ошибка постоянна для данного тела запроса: цикл автоматических повторных попыток её не устранит. Чтобы продолжить без недействительных рассуждений вместо сбоя, удалите блоки `thinking` из истории и повторите запрос один раз либо отправьте [бета-заголовок](https://platform.claude.com/docs/ru/api/beta-headers) `thinking-binding-controls-2026-08-01` и установите `prefix_mismatch_behavior` в `"drop_block"` (по умолчанию — `"error"`). При `"drop_block"` API отбрасывает несоответствующий блок и все блоки размышлений после него в разговоре и сообщает о каждом с `reason: "prefix_binding_mismatch"` в массиве `input_transformations` ответа:

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

     ```bash CLI
     ant beta:messages create \
       --beta thinking-binding-controls-2026-08-01 \
       --transform '{content.#(type=="text")#.text,input_transformations}' \
       --format yaml <<'YAML'
     model: claude-fable-5-1
     max_tokens: 16000
     thinking:
       type: adaptive
       block_binding:
         prefix_mismatch_behavior: drop_block
     messages:
       - role: user
         content: What is the greatest common divisor of 1071 and 462?
     YAML
     ```

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

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

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

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

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

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

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

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

     AnthropicClient client = new();

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

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

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

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

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

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

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

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

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

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

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

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

     $client = new Client();

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

     foreach ($response->content as $block) {
         if ($block->type === 'text') {
             echo $block->text, PHP_EOL;
         }
     }

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

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

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

     response.content.each do |block|
       puts block.text if block.type == :text
     end

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

   Эндпоинт [подсчёта токенов](https://platform.claude.com/docs/ru/build-with-claude/token-counting) выполняет ту же проверку. Формат ответа и размещение при потоковой передаче описаны в разделе [Управление несохранёнными блоками (бета)](https://platform.claude.com/docs/ru/build-with-claude/thinking#preserved-thinking-controls).

   Шаблоны, которые делают последующие блоки размышлений недействительными, и что делать вместо них:

   * Редактирование, изменение порядка или удаление предыдущих ходов. Сюда относятся удаление старых результатов инструментов, вырезание ходов из середины стенограммы и сжатие на стороне клиента, при котором последние ходы и их блоки размышлений сохраняются дословно после сводки (включая фоновое сжатие, которое подставляет свою сводку через несколько ходов). Вместо этого используйте серверное [«compaction» (сжатие)](https://platform.claude.com/docs/ru/build-with-claude/compaction) или [«context editing» (редактирование контекста)](https://platform.claude.com/docs/ru/build-with-claude/context-editing) ([очистку результатов инструментов](https://platform.claude.com/docs/ru/build-with-claude/context-editing#tool-result-clearing) для старых результатов инструментов) либо один из вариантов клиентского сжатия из раздела [Сокращайте контекст на сервере](https://platform.claude.com/docs/ru/models/fable-5-1/migration-guide#fable-5-1-trim-context).
   * Внедрение содержимого, которое вы не сохраняете, например напоминания на каждом ходе, добавляемого после блоков `tool_result` и удаляемого в следующем запросе. Вместо этого отправляйте напоминание как [системное сообщение, ограниченное ходом](https://platform.claude.com/docs/ru/build-with-claude/mid-conversation-system-messages#turn-scoped-system-messages) и оставляйте его в истории.
   * Перестроение системной подсказки верхнего уровня `system` или массива `tools` между запросами в одном разговоре, например для обновления текущей даты или для добавления или удаления инструмента. Вместо этого добавьте [системное сообщение посреди разговора](https://platform.claude.com/docs/ru/build-with-claude/mid-conversation-system-messages), содержащее новую инструкцию («Текущая дата — 2026-09-14.») или блоки `tool_addition` и `tool_removal`. Инструмент, который не был объявлен в `tools` в начале, можно [определить внутри блока `tool_addition`](https://platform.claude.com/docs/ru/build-with-claude/mid-conversation-system-messages#define-tools-in-a-message-beta) (бета-заголовок `inline-tools-2026-09-15`).
   * URL изображения или документа, который в последующем запросе отдаёт другие байты. Проверка охватывает байты, а не строку URL, поэтому ротируемый подписанный URL для того же файла допустим. Для содержимого, на которое вы ссылаетесь на нескольких ходах, загрузите его один раз через [Files API](https://platform.claude.com/docs/ru/build-with-claude/files) и отправляйте `file_id` либо отправляйте base64.

   Каждая из этих замен также сохраняет предыдущие ходы побайтово идентичными и сохраняет попадания в [кэш подсказок](https://platform.claude.com/docs/ru/build-with-claude/prompt-caching), которые были бы потеряны при редактировании истории, системной подсказки `system` или массива `tools`.

   Шаблоны, которые продолжают работать:

   * Истории только с добавлением: добавление ходов и передача предыдущих ходов обратно точно в том виде, в каком они были отправлены и получены, включая добавленные сообщения `role: "system"`.
   * Удаление блоков размышлений из предыдущих ходов ассистента, начиная с самых старых.
   * Изменение `effort`, `max_tokens` или любого другого параметра запроса вне `system`, `tools` и `messages`, а также добавление или перемещение маркеров `cache_control`.
   * Серверное сжатие и редактирование контекста, включая [очистку блоков размышлений](https://platform.claude.com/docs/ru/build-with-claude/context-editing#thinking-block-clearing). Они не считаются правками, поскольку проверка сравнивает разговор в том виде, в каком вы его отправили.

   Чтобы проверить существующую интеграцию:

   1. Зафиксируйте точные тела запросов, которые она отправляет на протяжении нескольких обычных ходов, включая сжатие или изменение инструментов, если они есть в вашем продукте. Для каждой пары последовательных запросов сравните системную подсказку `system`, массив `tools` и общий префикс `messages`. Они должны быть побайтово идентичны вплоть до вновь добавленных ходов. Ожидаемое исключение — запрос, который подставляет подписанный блок `compaction` из [сжатия по запросу](https://platform.claude.com/docs/ru/build-with-claude/compaction-on-demand): блок заменяет сообщения, которые он обобщает, в начале `messages`, а всё, что идёт после него, по-прежнему должно совпадать.
   2. Запустите обычный многоходовый сеанс с `claude-fable-5-1` с бета-заголовком `thinking-binding-controls-2026-08-01` и `prefix_mismatch_behavior: "drop_block"` и записывайте в журнал `input_transformations` для каждого ответа. Пустой массив на каждом ходе означает, что история не нарушена. Запись с `reason: "prefix_binding_mismatch"` означает, что что-то перед блоком по пути `path` изменилось с момента предыдущего запроса. Запись с `reason: "model_binding_mismatch"` означает, что разговор переключился на другую модель, и это не ошибка в вашем коде. Это работает с любого аккаунта, поскольку задание поля включает применение проверки для запроса. В CI установите вместо этого `"error"`, чтобы правка приводила к сбою прогона.
   3. Выберите настройку для продакшена. Оставьте значение по умолчанию `"error"`, если несоответствие префикса может означать только ошибку в вашем коде, или установите `"drop_block"`, чтобы отбрасывать затронутые блоки вместо сбоя, и в любом случае отслеживайте ошибки 400 или записи `input_transformations`.

   Однократное отбрасывание блоков размышлений, например на границе сжатия, мало на что влияет. Интеграция, которая делает предыдущие размышления недействительными при каждом запросе, каждый раз заново начинает заполнение кэша подсказок, что может увеличить стоимость задачи (см. [Ведите историю разговора в режиме только добавления](https://platform.claude.com/docs/ru/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#keep-the-conversation-history-append-only)).

### Изменения в поведении

1. **Меньше параллельных вызовов инструментов в длинных агентных циклах:** в длительных циклах, где следующие независимые операции чтения лишь подразумеваются задачей, Claude Fable 5.1 может делать по одному вызову инструмента за ход. Это касается, например, собственных агентов для программирования, сред с bash и редактором и computer use. Каждый лишний ход стоит токенов, дополнительного обмена запросом и ответом и реального времени. Добавляйте после каждого сообщения пользователя инструкцию из одного предложения с просьбой объединять вызовы. Передавайте её как [системное сообщение в рамках хода](https://platform.claude.com/docs/ru/build-with-claude/mid-conversation-system-messages#turn-scoped-system-messages) (`clear_at: "next_user_message"`, бета) или, без бета-функций, в текстовом блоке после блоков `tool_result`. В последующих запросах оставляйте предыдущие копии в истории. См. [Объединяйте независимые вызовы инструментов в агентных циклах](https://platform.claude.com/docs/ru/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#batch-independent-tool-calls-in-agent-loops).

2. **Меньше сообщений о ходе работы между вызовами инструментов:** во время длинных последовательностей вызовов Claude Fable 5.1 пишет меньше обновлений статуса, чем Claude Fable 5, а её итоговые сводки в агентном программировании короче. Если ваш интерфейс показывает такие обновления, установите для `thinking.display` значение `"updates"` (бета) или `"summarized"` и явно попросите о них в подсказке. См. [Обновления о ходе работы между вызовами инструментов](https://platform.claude.com/docs/ru/build-with-claude/thinking#progress-updates) и [Просите показывать пользователю обновления о ходе работы](https://platform.claude.com/docs/ru/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#ask-for-user-facing-progress-updates).

3. **Меньше вызовов поиска и извлечения данных при низком уровне усилий:** при уровне усилий `low` Claude Fable 5.1 чаще, чем Claude Fable 5, отвечает по памяти, не вызывая инструмент поиска или извлечения данных. Если ваш продукт рассчитывает на извлечение данных при низком уровне усилий, повысьте уровень усилий для таких запросов или укажите модели, когда нужно выполнять поиск. См. [Запуск поиска при низком уровне усилий](https://platform.claude.com/docs/ru/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#search-triggering-at-low-effort).

Различия в плотности текста, форматировании в чате, цитировании в сводках и редактировании файлов не влияют на интеграцию с API. Они описаны в разделе [Изменения по сравнению с Claude Fable 5](https://platform.claude.com/docs/ru/models/fable-5-1/whats-new-fable-5-1#changed-from-claude-fable-5).

### Рекомендуемые изменения

Эти изменения не обязательны, но каждое из них снижает стоимость или задержку либо устраняет один из сценариев сбоя:

1. **Изменяйте уровень усилий посреди разговора (бета):** в Claude Fable 5 `output_config.effort` задаётся на уровне запроса, и его изменение между запросами сбрасывает кэшированные префиксы предыдущих ходов. В `claude-fable-5-1` сообщение `role: "system"`, содержащее только `output_config`, повышает уровень усилий для сложного шага или понижает его для рутинных, не делая недействительным [кэш подсказок](https://platform.claude.com/docs/ru/build-with-claude/prompt-caching):

   <CodeGroup>
     ```bash cURL
     # Системное сообщение только с effort: новый уровень действует со следующего хода пользователя.
     curl https://api.anthropic.com/v1/messages \
       -H "x-api-key: $ANTHROPIC_API_KEY" \
       -H "anthropic-version: 2023-06-01" \
       -H "anthropic-beta: mid-conversation-output-config-2026-07-01" \
       -H "content-type: application/json" \
       -d '{
         "model": "claude-fable-5-1",
         "max_tokens": 4096,
         "output_config": {"effort": "high"},
         "messages": [
           {"role": "user", "content": "Plan a migration from SQLite to PostgreSQL in three short steps."},
           {"role": "assistant", "content": "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts."},
           {"role": "system", "content": [], "output_config": {"effort": "low"}},
           {"role": "user", "content": "Summarize the plan in one sentence."}
         ]
       }'
     ```

     ```bash CLI
     ant beta:messages create \
       --beta mid-conversation-output-config-2026-07-01 \
       --transform 'content.#(type=="text").text' \
       --raw-output <<'YAML'
     model: claude-fable-5-1
     max_tokens: 4096
     output_config:
       effort: high
     messages:
       - role: user
         content: Plan a migration from SQLite to PostgreSQL in three short steps.
       - role: assistant
         content: "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts."
       # Системное сообщение только с effort: новый уровень действует со следующего хода пользователя.
       - role: system
         content: []
         output_config:
           effort: low
       - role: user
         content: Summarize the plan in one sentence.
     YAML
     ```

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

     response = client.beta.messages.create(
         model="claude-fable-5-1",
         max_tokens=4096,
         output_config={"effort": "high"},
         messages=[
             {
                 "role": "user",
                 "content": "Plan a migration from SQLite to PostgreSQL in three short steps.",
             },
             {
                 "role": "assistant",
                 "content": "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts.",
             },
             # Системное сообщение только с effort: новый уровень действует со следующего хода пользователя.
             {"role": "system", "content": [], "output_config": {"effort": "low"}},
             {"role": "user", "content": "Summarize the plan in one sentence."},
         ],
         betas=["mid-conversation-output-config-2026-07-01"],
     )

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

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

     const response = await client.beta.messages.create({
       model: "claude-fable-5-1",
       max_tokens: 4096,
       output_config: { effort: "high" },
       messages: [
         {
           role: "user",
           content: "Plan a migration from SQLite to PostgreSQL in three short steps."
         },
         {
           role: "assistant",
           content:
             "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts."
         },
         // Системное сообщение только с effort: новый уровень действует со следующего хода пользователя.
         { role: "system", content: [], output_config: { effort: "low" } },
         { role: "user", content: "Summarize the plan in one sentence." }
       ],
       betas: ["mid-conversation-output-config-2026-07-01"]
     });

     for (const block of response.content) {
       if (block.type === "text") {
         console.log(block.text);
       }
     }
     ```

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

     AnthropicClient client = new();

     var response = await client.Beta.Messages.Create(new MessageCreateParams
     {
         Model = Model.ClaudeFable5_1,
         MaxTokens = 4096,
         OutputConfig = new() { Effort = Effort.High },
         Messages =
         [
             new() { Role = Role.User, Content = "Plan a migration from SQLite to PostgreSQL in three short steps." },
             new() { Role = Role.Assistant, Content = "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts." },
             // Системное сообщение только об уровне усилий: новый уровень вступает в силу со следующего хода пользователя.
             new()
             {
                 Role = Role.System,
                 Content = new([]),
                 OutputConfig = new() { Effort = BetaSystemMessageOutputConfigEffort.Low },
             },
             new() { Role = Role.User, Content = "Summarize the plan in one sentence." },
         ],
         Betas = [AnthropicBeta.MidConversationOutputConfig2026_07_01],
     });

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

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

     response, err := client.Beta.Messages.New(context.Background(), anthropic.BetaMessageNewParams{
     	Model:     anthropic.ModelClaudeFable5_1,
     	MaxTokens: 4096,
     	OutputConfig: anthropic.BetaOutputConfigParam{
     		Effort: anthropic.BetaOutputConfigEffortHigh,
     	},
     	Messages: []anthropic.BetaMessageParam{
     		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Plan a migration from SQLite to PostgreSQL in three short steps.")),
     		{
     			Role:    anthropic.BetaMessageParamRoleAssistant,
     			Content: []anthropic.BetaContentBlockParamUnion{anthropic.NewBetaTextBlock("1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts.")},
     		},
     		// Системное сообщение только с effort: новый уровень действует со следующего хода пользователя.
     		anthropic.NewBetaSystemMessage(anthropic.BetaSystemMessageOutputConfigParam{
     			Effort: anthropic.BetaSystemMessageOutputConfigEffortLow,
     		}),
     		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Summarize the plan in one sentence.")),
     	},
     	Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaMidConversationOutputConfig2026_07_01},
     })
     if err != nil {
     	log.Fatal(err)
     }

     for _, block := range response.Content {
     	if textBlock, ok := block.AsAny().(anthropic.BetaTextBlock); ok {
     		fmt.Println(textBlock.Text)
     	}
     }
     ```

     ```java Java
     import com.anthropic.models.beta.AnthropicBeta;
     import com.anthropic.models.beta.messages.BetaMessage;
     import com.anthropic.models.beta.messages.BetaMessageParam;
     import com.anthropic.models.beta.messages.BetaOutputConfig;
     import com.anthropic.models.beta.messages.BetaSystemMessageOutputConfig;
     import com.anthropic.models.beta.messages.MessageCreateParams;
     import com.anthropic.models.messages.Model;

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

         MessageCreateParams params = MessageCreateParams.builder()
             .model(Model.CLAUDE_FABLE_5_1)
             .maxTokens(4096L)
             .addBeta(AnthropicBeta.MID_CONVERSATION_OUTPUT_CONFIG_2026_07_01)
             .outputConfig(BetaOutputConfig.builder()
                 .effort(BetaOutputConfig.Effort.HIGH)
                 .build())
             .addUserMessage("Plan a migration from SQLite to PostgreSQL in three short steps.")
             .addAssistantMessage("1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts.")
             // Системное сообщение только с effort: новый уровень действует со следующего хода пользователя.
             .addMessage(BetaMessageParam.builder()
                 .role(BetaMessageParam.Role.SYSTEM)
                 .contentOfBetaContentBlockParams(List.of())
                 .outputConfig(BetaSystemMessageOutputConfig.builder()
                     .effort(BetaSystemMessageOutputConfig.Effort.LOW)
                     .build())
                 .build())
             .addUserMessage("Summarize the plan in one sentence.")
             .build();

         BetaMessage response = client.beta().messages().create(params);
         response.content().stream()
             .flatMap(block -> block.text().stream())
             .forEach(textBlock -> IO.println(textBlock.text()));
     }
     ```

     ```php PHP
     use Anthropic\Beta\AnthropicBeta;
     use Anthropic\Beta\Messages\BetaMessageParam;
     use Anthropic\Beta\Messages\BetaOutputConfig;
     use Anthropic\Beta\Messages\BetaSystemMessageOutputConfig;
     use Anthropic\Client;

     $client = new Client();

     $response = $client->beta->messages->create(
         model: 'claude-fable-5-1',
         maxTokens: 4096,
         outputConfig: BetaOutputConfig::with(effort: 'high'),
         messages: [
             BetaMessageParam::with(role: 'user', content: 'Plan a migration from SQLite to PostgreSQL in three short steps.'),
             BetaMessageParam::with(role: 'assistant', content: '1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts.'),
             // Системное сообщение только с effort: новый уровень действует со следующего хода пользователя.
             BetaMessageParam::with(
                 role: 'system',
                 content: [],
                 outputConfig: BetaSystemMessageOutputConfig::with(effort: 'low'),
             ),
             BetaMessageParam::with(role: 'user', content: 'Summarize the plan in one sentence.'),
         ],
         betas: [AnthropicBeta::MID_CONVERSATION_OUTPUT_CONFIG_2026_07_01],
     );

     foreach ($response->content as $block) {
         if ($block->type === 'text') {
             echo $block->text, PHP_EOL;
         }
     }
     ```

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

     response = client.beta.messages.create(
       model: "claude-fable-5-1",
       max_tokens: 4096,
       output_config: {effort: :high},
       messages: [
         {role: "user", content: "Plan a migration from SQLite to PostgreSQL in three short steps."},
         {role: "assistant", content: "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts."},
         # Системное сообщение только с effort: новый уровень действует со следующего хода пользователя.
         {role: "system", content: [], output_config: {effort: :low}},
         {role: "user", content: "Summarize the plan in one sentence."}
       ],
       betas: [Anthropic::AnthropicBeta::MID_CONVERSATION_OUTPUT_CONFIG_2026_07_01]
     )

     response.content.each do |block|
       puts block.text if block.type == :text
     end
     ```
   </CodeGroup>

   Если сообщение размещено между ходом `assistant` и следующим ходом `user`, как здесь, оно вступает в силу с этого хода `user`. Если оно размещено сразу после хода `user` с новыми входными данными, оно задаёт уровень для ответа Claude на этот ход. Ход `user`, содержащий только результаты инструментов, не считается новыми входными данными: изменение ожидает следующего хода `user` с новыми входными данными. Затем уровень сохраняется, пока другое сообщение `role: "system"` его не изменит. Принимаются только именованные уровни (`low`, `medium`, `high`, `xhigh`, `max`), и требуется бета-заголовок `mid-conversation-output-config-2026-07-01`. См. [Уровень усилий для отдельных сообщений](https://platform.claude.com/docs/ru/build-with-claude/effort#change-effort-mid-conversation-beta).

2. **Изменяйте инструкции и инструменты с помощью системных сообщений посреди разговора:** чтобы изменить инструкции или инструменты в ходе сеанса, добавьте [сообщение `role: "system"`](https://platform.claude.com/docs/ru/build-with-claude/mid-conversation-system-messages) с блоками `tool_addition` и `tool_removal` для изменения инструментов (бета-заголовок `inline-tools-2026-09-15` в Claude API). Блок `tool_addition` может ссылаться на инструмент, объявленный в `tools` в начале сеанса, или [содержать полное определение инструмента](https://platform.claude.com/docs/ru/build-with-claude/mid-conversation-system-messages#define-tools-in-a-message-beta), поэтому инструмент, неизвестный в начале сеанса, не обязательно должен быть в `tools`. Это сохраняет попадания в кэш подсказок для предыдущих ходов и сохраняет историю разговора только с добавлением. Более старый заголовок `mid-conversation-tool-changes-2026-07-01` по-прежнему работает для изменений, ссылающихся на инструмент по имени, в Claude API, Amazon Bedrock и Google Cloud. То же сообщение заменяет принудительный `tool_choice`, когда на текущем ходе должен быть выполнен конкретный инструмент (см. [Критические изменения](https://platform.claude.com/docs/ru/models/fable-5-1/migration-guide#fable-5-1-breaking-changes)). Напоминание, которое относится только к одному ходу, отправляйте как отдельное текстовое сообщение `role: "system"` с `clear_at: "next_user_message"` ([системные сообщения, ограниченные ходом](https://platform.claude.com/docs/ru/build-with-claude/mid-conversation-system-messages#turn-scoped-system-messages), бета-заголовок `mid-conversation-system-clear-at-2026-08-21`) и оставляйте его в истории: оно перестаёт отображаться после следующего сообщения пользователя и после очистки не расходует токены. Сообщение, содержащее блоки `tool_addition` или `tool_removal`, не может быть ограничено ходом.

3. **Используйте `fallbacks: "default"` для отказов:** продолжайте обрабатывать `stop_reason: "refusal"` и читать `stop_details.category` до содержимого ответа. Чтобы автоматически повторно выполнять отклонённые запросы на другой модели, установите `fallbacks: "default"` (бета, заголовок `server-side-fallback-2026-07-01`). `"default"` повторяет отклонённый запрос на модели, которую Anthropic рекомендует для данной категории. Допустимые резервные модели для Claude Fable 5.1 — Claude Opus 4.8 (`claude-opus-4-8`) и Claude Opus 5 (`claude-opus-5`). Явный список `fallbacks` может указывать любую из них. Резервная модель не получает блоки размышлений Claude Fable 5.1. Параметр `fallbacks` недоступен в Amazon Bedrock, Google Cloud и Microsoft Foundry. На этих платформах используйте вместо него [резервное переключение на стороне клиента](https://platform.claude.com/docs/ru/build-with-claude/refusals-and-fallback#client-side-fallback). Если вы реализуете повторную попытку самостоятельно, [кредит при резервном переключении](https://platform.claude.com/docs/ru/build-with-claude/fallback-credit) применяется на тех же условиях, что и для Claude Fable 5. См. [Отказы и резервная обработка](https://platform.claude.com/docs/ru/build-with-claude/refusals-and-fallback).

4. **Начинайте с уровня усилий `high` и проводите перебор:** значение [параметра effort](https://platform.claude.com/docs/ru/build-with-claude/effort) по умолчанию — `high`, и поддерживаются все пять уровней. Следуйте рекомендациям для Claude Fable 5: `high` для большинства задач и `medium` как способ контроля затрат, который стоит протестировать. Преимущества Claude Fable 5.1 перед Claude Fable 5 наиболее заметны на уровнях `xhigh` и `max`, но эти уровни также увеличивают время размышлений и время до первого ответа, поэтому переходите на них для задач, наиболее чувствительных к возможностям модели, и там, где ваши оценки показывают выигрыш. Проведите новый перебор на собственных оценках вместо того, чтобы переносить настройку, подобранную для Claude Fable 5. См. [Рекомендуемые уровни усилия для Claude Fable 5.1](https://platform.claude.com/docs/ru/build-with-claude/effort#recommended-effort-levels-for-claude-fable-5-1).

5. **Сокращайте контекст на сервере или сжимайте его в форме, не содержащей устаревших размышлений:** если ваш код усекает или обобщает старые ходы на стороне клиента, самое простое решение — перенести эту работу на серверное [сжатие](https://platform.claude.com/docs/ru/build-with-claude/compaction) или [редактирование контекста](https://platform.claude.com/docs/ru/build-with-claude/context-editing). Ни то, ни другое не считается правкой, поскольку [проверка истории](https://platform.claude.com/docs/ru/models/fable-5-1/migration-guide#fable-5-1-preserved-thinking) сравнивает разговор в том виде, в каком вы его отправили, поэтому ничто из удалённого ими не делает последующие блоки размышлений недействительными, а [параметр `instructions`](https://platform.claude.com/docs/ru/build-with-claude/compaction-threshold#custom-summarization-instructions) сжатия принимает вашу собственную подсказку для обобщения. Если вы сохраняете последние ходы дословно после сводки или обобщаете в фоновом режиме, пока разговор продолжается, используйте [сжатие по запросу](https://platform.claude.com/docs/ru/build-with-claude/compaction-on-demand) (бета-заголовок `compact-2026-09-04`) вместо сводки, написанной клиентом. API создаёт подписанный блок сводки, который вы помещаете на место обобщаемых им сообщений. Блоки размышлений в сохраняемых вами ходах могут оставаться действительными при условиях, описанных в разделе [Сжатие и сохранённые размышления](https://platform.claude.com/docs/ru/build-with-claude/compaction-thinking-blocks#conditions-for-kept-thinking-to-stay-valid). Если вы оставляете сжатие на стороне клиента, выберите один из трёх вариантов:

   * **Простое сжатие (рекомендуется):** замените всю историю одним сообщением со сводкой плюс новым ходом пользователя и больше ничего не воспроизводите. Блоки размышлений не переносятся, поэтому ничего не ломается. Модели Claude обучены на долгосрочных задачах с этой схемой, и для большинства рабочих нагрузок она работает сопоставимо с более сложными.
   * **Сжатие с сохранением хвоста:** если вы сохраняете последние ходы дословно после сводки, удалите из этих ходов блоки `thinking` и `redacted_thinking` (текст и вызовы инструментов можно оставить) или установите `prefix_mismatch_behavior: "drop_block"`. Их размышления были созданы относительно полной истории, и в противном случае после сводки они не пройдут проверку.
   * **Фоновое сжатие:** если вы создаёте сводку вне критического пути и подставляете её позже, каждый ход, созданный за это время, содержит размышления, предшествующие подстановке. Отправляйте `"drop_block"` в каждом запросе, который всё ещё содержит блоки размышлений, созданные до подстановки (или удаляйте эти блоки самостоятельно; `input_transformations` в первом ответе после подстановки точно перечисляет, какие именно), либо выполняйте сжатие синхронно.

   Не вырезайте отдельные ходы из середины стенограммы: это делает недействительными все последующие блоки размышлений, и ни один клиентский вариант этого не избегает. Используйте [системное сообщение посреди разговора](https://platform.claude.com/docs/ru/build-with-claude/mid-conversation-system-messages) для изменения инструкций, которое вы вносили, или серверное [редактирование контекста](https://platform.claude.com/docs/ru/build-with-claude/context-editing) для выборочного удаления. См. [Обратная передача блоков сжатия](https://platform.claude.com/docs/ru/build-with-claude/compaction-threshold#passing-compaction-blocks-back).

### Контрольный список миграции

* Обновите название модели с `claude-fable-5` на `claude-fable-5-1` (или с `claude-mythos-5` на `claude-mythos-5-1`).
* Замените принудительный `tool_choice` (`{type: "any"}` или `{type: "tool", ...}`). Он возвращает ошибку 400. Используйте `{type: "auto"}` вместе с явной инструкцией и инструментами со `strict: true` либо выходные данные JSON. Поместите инструкцию в ход `user` или в сообщение `role: "system"` посреди разговора, если вызов требуется вашему приложению.
* Продолжайте передавать блоки `thinking` обратно без изменений на каждом ходе, включая пустые. Claude Fable 5.1 читает блоки от Claude Opus 5, Claude Fable 5, Claude Mythos 5 и более ранних моделей. При переносе разговора с Claude Fable 5.1 на любую модель, кроме Claude Mythos 5.1, её блоки отбрасываются.
* Если ваш код сам формирует массив `messages`, проверьте, [редактирует ли он предыдущие ходы](https://platform.claude.com/docs/ru/models/fable-5-1/migration-guide#fable-5-1-preserved-thinking): запустите сеанс с бета-заголовком `thinking-binding-controls-2026-08-01` и `prefix_mismatch_behavior: "drop_block"`, записывайте в журнал `input_transformations` и исправьте каждый `prefix_binding_mismatch`. Записи `model_binding_mismatch` после переключения модели ожидаемы.
* Ведите историю разговора в режиме только добавления: зафиксируйте `system` и `tools` в начале сеанса и переносите изменения в ходе сеанса в сообщения `role: "system"` и блоки `tool_addition` / `tool_removal`, отправляйте напоминания для каждого хода как системные сообщения в рамках хода, которые вы никогда не удаляете, сокращайте контекст на стороне сервера или удаляйте блоки размышлений из всех ходов, которые вы переносите через клиентскую сводку, и ссылайтесь на файлы, используемые на нескольких ходах, по `file_id`.
* Выберите значение `prefix_mismatch_behavior` для продакшена (`"error"` по умолчанию или `"drop_block"`) и отслеживайте его. Если вы поддерживаете инструмент, который другие запускают со своим ключом API, тестируйте с заданным полем: для новых аккаунтов проверка применяется по умолчанию, даже если для вашего — нет.
* Проверьте агентные циклы на поведение «один вызов инструмента за ход» и добавьте инструкцию с просьбой объединять вызовы.
* Если ваш интерфейс отображает текст о ходе работы между вызовами инструментов, установите `thinking.display` в `"updates"` (бета) или `"summarized"` и запрашивайте обновления в подсказке.
* Если вы меняете уровень усилий между запросами, перенесите изменение в сообщение `role: "system"` с [уровнем усилий для отдельного сообщения](https://platform.claude.com/docs/ru/build-with-claude/effort#change-effort-mid-conversation-beta) (бета), чтобы сохранить попадания в кэш.
* Обрабатывайте `stop_reason: "refusal"` и читайте `stop_details.category`. Рассмотрите использование `fallbacks: "default"` (бета).
* Заново оцените `effort` с помощью нового перебора, начиная с `high`, и заново определите базовые показатели стоимости и задержки на собственных рабочих нагрузках. Токенизатор не изменился. Чтение из кэша подсказок стоит четверть тарифа Claude Fable 5.

## Миграция на Claude Fable 5.1 с Claude Opus 5

Claude Fable 5.1 использует те же приёмы работы с [Messages API](https://platform.claude.com/docs/ru/build-with-claude/working-with-messages) и [«tool use» (использование инструментов)](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/overview), что и Claude Opus 5. Сохраняются:

* [контекстное окно размером 1M токенов](https://platform.claude.com/docs/ru/build-with-claude/context-windows) по умолчанию;
* [максимум 128k выходных токенов](https://platform.claude.com/docs/ru/models/overview);
* минимальный размер в 512 токенов для «prompt caching» (кэширование подсказок);
* поддержка [системных сообщений в середине разговора](https://platform.claude.com/docs/ru/build-with-claude/mid-conversation-system-messages).

Также остаются в силе запрет на предварительное заполнение, ограничение на параметры сэмплирования и значение `"omitted"` по умолчанию для `thinking.display`. Выполните всё, что описано в разделе [Миграция на Claude Fable 5.1 с Claude Fable 5](https://platform.claude.com/docs/ru/models/fable-5-1/migration-guide#migrating-from-claude-fable-5-to-claude-fable-5-1), а также следующее.

### Обновите название модели

```python
model = "claude-opus-5"  # Before
model = "claude-fable-5-1"  # After

# Или для Claude Mythos 5.1, который предоставляет те же возможности верифицированным организациям:
model = "claude-mythos-5-1"  # After
```

### Что изменилось

1. **Размышления больше нельзя отключить:** Claude Opus 5 принимает `thinking: {type: "disabled"}` при уровне [усилий](https://platform.claude.com/docs/ru/build-with-claude/effort) `high` или ниже. В `claude-fable-5-1` и `claude-mythos-5-1` [адаптивные размышления](https://platform.claude.com/docs/ru/build-with-claude/thinking) всегда включены, и `thinking: {type: "disabled"}` возвращает ошибку 400 при любом уровне усилий. Удалите это поле, контролируйте расход токенов с помощью более низких уровней усилий и пересмотрите `max_tokens` для рабочих нагрузок, которые выполнялись с отключёнными размышлениями.

2. **Принудительный выбор инструмента не поддерживается:** Claude Opus 5 принимает `tool_choice` со значениями `any` и `tool`. `claude-fable-5-1` возвращает ошибку 400. См. [Критические изменения](https://platform.claude.com/docs/ru/models/fable-5-1/migration-guide#fable-5-1-breaking-changes).

3. **Сохранение размышлений между моделями:** Claude Fable 5.1 читает блоки размышлений Claude Opus 5: разговоры, переходящие с `claude-opus-5` на `claude-fable-5-1`, сохраняют свои рассуждения. Claude Opus 5 не может читать блоки Claude Fable 5.1. Блоки Claude Fable 5.1 также [перестают быть действительными при изменении предыдущих ходов](https://platform.claude.com/docs/ru/models/fable-5-1/migration-guide#fable-5-1-preserved-thinking): если ваш код редактирует предыдущие сообщения, перестраивает `system` или `tools` или выполняет сжатие на стороне клиента между запросами, Claude Opus 5 не возражала, но `claude-fable-5-1` отклоняет или отбрасывает все последующие блоки размышлений. Выполните трёхшаговую проверку из того раздела, прежде чем переключать трафик. См. [Критические изменения](https://platform.claude.com/docs/ru/models/fable-5-1/migration-guide#fable-5-1-breaking-changes).

4. **Текст между вызовами инструментов возвращается в блоках размышлений:** в Claude Opus 5 текст, который модель пишет между вызовами инструментов, возвращается как блоки `text`. В `claude-fable-5-1`, как и в Claude Fable 5, это повествование возвращается как блоки `thinking` с обновлениями о ходе работы, по одному перед каждым вызовом инструмента. При значении `thinking.display` по умолчанию `"omitted"` они не содержат читаемого текста. Если ваш интерфейс отображает это повествование, установите `display: "updates"` (бета), чтобы получать обновления о ходе работы в виде текста, пока рассуждения остаются скрытыми, или `"summarized"`, чтобы получать и то, и другое. Затем отображайте непустые блоки `thinking` между блоками `tool_use`. См. [Обновления о ходе работы между вызовами инструментов](https://platform.claude.com/docs/ru/build-with-claude/thinking#progress-updates).

5. **Классификаторы безопасности и маршрутизация при резервном переключении:** Claude Fable 5.1 использует классификаторы безопасности, охватывающие те же категории `stop_details`, что и Claude Fable 5, — более широкий набор, чем у классификаторов Claude Opus 5. Ожидайте дополнительных значений `stop_details.category`, таких как `"bio"`; полный набор см. в [таблице категорий отказов](https://platform.claude.com/docs/ru/build-with-claude/refusals-and-fallback#refusal-response). О настройке `fallbacks` и допустимых целевых моделях см. [Используйте `fallbacks: "default"` для отказов](https://platform.claude.com/docs/ru/models/fable-5-1/migration-guide#fable-5-1-recommended-changes).

6. **Цены:** $10 USD за миллион входных токенов и $50 USD за миллион выходных токенов по сравнению с $5 USD и $25 USD для Claude Opus 5. Чтение из кэша подсказок стоит $0,25 USD за миллион токенов — половина тарифа Claude Opus 5. См. [Цены Claude](https://platform.claude.com/docs/ru/about-claude/pricing).

7. **Хранение данных:** Claude Fable 5.1 и Claude Mythos 5.1 требуют 30-дневного хранения данных, недоступны в рамках соглашений о нулевом хранении данных (ZDR), если это явно не разрешено Anthropic, и отнесены к категории Covered Models. Claude Opus 5 доступна в рамках ZDR. См. [Требования к хранению данных для конкретных моделей](https://platform.claude.com/docs/ru/manage-claude/api-and-data-retention#model-specific-data-retention-requirements).

### Контрольный список миграции

* Если в вашей организации действует соглашение о «zero data retention» (нулевом хранении данных), или ZDR, сначала подтвердите право на использование: эти модели недоступны в рамках ZDR, если это явно не разрешено Anthropic. См. [Требования к хранению данных для конкретных моделей](https://platform.claude.com/docs/ru/manage-claude/api-and-data-retention#model-specific-data-retention-requirements).
* Измените имя модели с `claude-opus-5` на `claude-fable-5-1` (или `claude-mythos-5-1`).
* Удалите любую конфигурацию `thinking: {type: "disabled"}`: на `claude-fable-5-1` она возвращает ошибку 400. Контролируйте расход токенов с помощью более низких уровней [effort](https://platform.claude.com/docs/ru/build-with-claude/effort) (уровня усилий) и пересмотрите `max_tokens`.
* Замените принудительный `tool_choice` (`any` или `tool`) на `auto` в сочетании с явной инструкцией (ход `user` или системное сообщение посреди разговора) и инструментами со `strict: true` либо на «JSON outputs» (выходные данные JSON).
* Если ваш интерфейс отображает текст между вызовами инструментов, установите `display: "updates"` (бета) или `"summarized"` и отображайте непустые блоки `thinking`.
* Примените пункты о сохранённых размышлениях, редактировании истории, поведении, effort и «fallback» (резервном переключении) из [контрольного списка для Claude Fable 5](https://platform.claude.com/docs/ru/models/fable-5-1/migration-guide#migration-checklist-fable-5-1-from-fable-5).
* Заново определите базовый уровень затрат на собственных рабочих нагрузках. «Tokenizer» (токенизатор) не изменился. Цены за токен отличаются.

## Миграция на Claude Fable 5.1 с Claude Opus 4.8 или более ранних версий

Пройдите по контрольному списку ниже. Если вы используете Claude Opus 4.7 или более раннюю версию, начните с соответствующего раздела [руководства по миграции на Claude Opus 5.5](https://platform.claude.com/docs/ru/models/opus-5-5/migration-guide).

### Обновите имя модели

```python
model = "claude-opus-4-8"  # Before
model = "claude-fable-5-1"  # After

# Или для Claude Mythos 5.1, который предоставляет те же возможности верифицированным организациям:
model = "claude-mythos-5-1"  # After
```

### Контрольный список миграции

* Если у вашей организации есть соглашение о нулевом хранении данных (ZDR), сначала подтвердите право на использование: эти модели недоступны в рамках ZDR, если это явно не разрешено Anthropic. Claude Opus 4.8 доступна в рамках ZDR.
* Измените имя модели с `claude-opus-4-8` на `claude-fable-5-1` (или `claude-mythos-5-1`).
* Удалите любую конфигурацию `thinking: {type: "disabled"}` и пересмотрите `max_tokens`. Запросы без поля `thinking` выполняются с адаптивными размышлениями.
* Обновите разбор ответов, который читает содержимое по позиции, например `content[0].text`: теперь ответ может начинаться с блоков `thinking`, поэтому выбирайте блоки содержимого по `type`.
* Замените принудительный `tool_choice` (`any` или `tool`) на `auto` в сочетании с явной инструкцией (ход `user` или системное сообщение посреди разговора) и инструментами со `strict: true` либо на выходные данные JSON.
* Передавайте блоки `thinking` обратно без изменений и рассматривайте их текст только как предназначенный для отображения. Claude Fable 5.1 читает блоки размышлений Claude Opus 4.8: разговор, который переходит на `claude-fable-5-1`, сохраняет своё предыдущее рассуждение. Claude Opus 4.8 не может читать блоки Claude Fable 5.1.
* Если ваш код сам формирует массив `messages`, проверьте, [редактирует ли он предыдущие ходы](https://platform.claude.com/docs/ru/models/fable-5-1/migration-guide#fable-5-1-preserved-thinking). Интеграции, написанные для Claude Opus 4.8 и более ранних версий, часто обрезают старые ходы, удаляют или перестраивают предыдущие сообщения или обновляют подсказку `system` при каждом запросе, и Claude Opus 4.8 никогда против этого не возражала. На `claude-fable-5-1` каждое из этих действий делает недействительными последующие блоки размышлений.
* Обрабатывайте `stop_reason: "refusal"`, считывайте `stop_details.category` и рассмотрите возможность использования `fallbacks: "default"` (бета).
* Примените пункты о сохранённых размышлениях, редактировании истории, поведении, effort для отдельных сообщений и обновлениях о ходе выполнения из [контрольного списка для Claude Fable 5](https://platform.claude.com/docs/ru/models/fable-5-1/migration-guide#migration-checklist-fable-5-1-from-fable-5).
* Заново оцените `effort` (начните с `high`), проверьте подсказки, близкие к [минимуму для кэширования](https://platform.claude.com/docs/ru/build-with-claude/prompt-caching#cache-limitations) в 512 токенов (1 024 токена на Claude Opus 4.8), и заново определите базовые уровни затрат и задержки. Цены за токен отличаются, а токены размышлений оплачиваются как выходные токены, поэтому рабочие нагрузки, которые выполнялись без размышлений на Claude Opus 4.8, могут генерировать больше выходных токенов на запрос.

## Миграция на Claude Mythos 5.1 с Claude Mythos 5

[Claude Mythos 5.1](https://platform.claude.com/docs/ru/models/mythos-5-1/overview) — это аналог Claude Fable 5.1 для организаций, прошедших проверку в рамках программ верификации Anthropic, таких как [Cyber Verification Program](https://support.claude.com/en/articles/14604842). Прежде чем менять идентификаторы моделей, убедитесь, что у вашей организации есть доступ к Claude Mythos 5.1.

Отличия на уровне API совпадают с описанными в разделе [Миграция на Claude Fable 5.1 с Claude Fable 5](https://platform.claude.com/docs/ru/models/fable-5-1/migration-guide#migrating-from-claude-fable-5-to-claude-fable-5-1): принудительный выбор инструмента возвращает ошибку 400, и только Claude Mythos 5.1 и Claude Fable 5.1 читают блоки размышлений Claude Mythos 5.1 (Claude Mythos 5.1 читает блоки Claude Mythos 5, но не наоборот). В отличие от Claude Fable 5.1, Claude Mythos 5.1 не выполняет проверку разговора, поэтому редактирование предыдущих ходов не [делает блоки размышлений недействительными](https://platform.claude.com/docs/ru/models/fable-5-1/migration-guide#fable-5-1-preserved-thinking), хотя по-прежнему сбрасывает кэш подсказок.

### Обновите имя модели

```python
model = "claude-mythos-5"  # Before
model = "claude-mythos-5-1"  # After
```

### Контрольный список миграции

* Измените имя модели с `claude-mythos-5` на `claude-mythos-5-1`.
* Замените принудительный `tool_choice` (`any` или `tool`) на `auto` в сочетании с явной инструкцией (ход `user` или системное сообщение посреди разговора) и инструментами со `strict: true` либо на выходные данные JSON.
* Обрабатывайте `stop_reason: "refusal"` и считывайте `stop_details.category` перед содержимым ответа. См. [Отказы и резервное переключение](https://platform.claude.com/docs/ru/build-with-claude/refusals-and-fallback).
* Продолжайте передавать блоки `thinking` обратно без изменений на каждом ходе, включая пустые.
* Если ваш код сам формирует массив `messages`, сохраняйте историю разговора в режиме только добавления, чтобы кэш подсказок оставался «тёплым». Claude Mythos 5.1 не выполняет [проверку разговора](https://platform.claude.com/docs/ru/build-with-claude/thinking#preserved-in-conversation), поэтому правки не делают её блоки размышлений недействительными.
* Примените изменения поведения и рекомендуемые изменения из [раздела о Claude Fable 5](https://platform.claude.com/docs/ru/models/fable-5-1/migration-guide#migrating-from-claude-fable-5-to-claude-fable-5-1), за исключением пунктов о редактировании истории, которые не относятся к Claude Mythos 5.1.
* Заново оцените `effort` с помощью нового перебора значений и заново определите базовые уровни затрат и задержки. Чтение из кэша подсказок стоит четверть от тарифа Claude Mythos 5.