---
title: Руководство по миграции на Claude Sonnet 5.5
url: https://platform.claude.com/docs/ru/models/sonnet-5-5/migration-guide
description: Перейдите на Claude Sonnet 5.5 с более ранних моделей Sonnet или Claude Haiku 4.5 с помощью этого руководства по миграции. Рекомендации по включению Claude Sonnet 5.5 охватывают настройки, которые возвращают ошибки, изменения в размышлениях и контрольный список для каждой исходной модели.
---

В этом руководстве перечислены изменения в коде, необходимые для перехода на Claude Sonnet 5.5 с Claude Sonnet 5, Claude Sonnet 4.6, Claude Sonnet 4.5, Claude Sonnet 4, Claude 3.7 Sonnet или Claude Haiku 4.5. Прочитайте первые два раздела, затем читайте дальше до раздела, посвящённого вашей текущей модели. В [контрольном списке миграции](https://platform.claude.com/docs/ru/models/sonnet-5-5/migration-guide#migration-checklist) перечислены все изменения в зависимости от исходной модели.

<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>

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

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

Цены Claude Sonnet 5.5 такие же, как у Claude Sonnet 5, за исключением чтения из кэша подсказок, которое стоит $0,10 USD за миллион токенов — вдвое меньше тарифа Claude Sonnet 5. См. [Цены](https://platform.claude.com/docs/ru/about-claude/pricing). Сведения о «context window» (контекстное окно) и ограничениях на вывод см. на странице модели [Claude Sonnet 5.5](https://platform.claude.com/docs/ru/models/sonnet-5-5/overview). Сведения о функциях и составлении подсказок см. в разделах [Что нового в Claude Sonnet 5.5](https://platform.claude.com/docs/ru/models/sonnet-5-5/whats-new-sonnet-5-5#feature-support) и [Составление подсказок для Claude Sonnet 5.5](https://platform.claude.com/docs/ru/build-with-claude/prompt-engineering/prompting-claude-sonnet-5-5).

## Отправка запроса к Claude Sonnet 5.5

Этот запрос работает на Claude Sonnet 5.5 в том виде, в котором он написан. Он задаёт уровень «effort» (усилия) и не использует пять настроек, которые возвращают ошибку 400: [бюджеты размышлений](https://platform.claude.com/docs/ru/models/sonnet-5-5/migration-guide#sonnet-46-breaking-changes), [параметры сэмплирования](https://platform.claude.com/docs/ru/models/sonnet-5-5/migration-guide#sonnet-46-breaking-changes), [предзаполнение ответа ассистента](https://platform.claude.com/docs/ru/models/sonnet-5-5/migration-guide#migrating-from-sonnet-45), [принудительный выбор инструмента](https://platform.claude.com/docs/ru/models/sonnet-5-5/migration-guide#forced-tool-use) и [`thinking: {"type": "disabled"}`](https://platform.claude.com/docs/ru/models/sonnet-5-5/migration-guide#turn-off-up-front-thinking).

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-sonnet-5-5",
      "max_tokens": 4096,
      "messages": [{
        "role": "user",
        "content": "Analyze the trade-offs between microservices and monolithic architectures"
      }],
      "output_config": {
        "effort": "medium"
      }
    }'
  ```

  ```bash CLI
  ant messages create \
    --model claude-sonnet-5-5 \
    --max-tokens 4096 \
    --output-config '{effort: medium}' \
    --message '{role: user, content: "Analyze the trade-offs between microservices and monolithic architectures"}'
  ```

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

  response = client.messages.create(
      model="claude-sonnet-5-5",
      max_tokens=4096,
      messages=[
          {
              "role": "user",
              "content": "Analyze the trade-offs between microservices and monolithic architectures",
          }
      ],
      output_config={"effort": "medium"},
  )

  print(f"Stop reason: {response.stop_reason}")
  for block in response.content:
      if block.type == "text":
          print(block.text)
  ```

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

  const response = await client.messages.create({
    model: "claude-sonnet-5-5",
    max_tokens: 4096,
    messages: [
      {
        role: "user",
        content: "Analyze the trade-offs between microservices and monolithic architectures"
      }
    ],
    output_config: {
      effort: "medium"
    }
  });

  console.log(`Stop reason: ${response.stop_reason}`);
  const textBlock = response.content.find((block) => block.type === "text");
  console.log(textBlock?.text);
  ```

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

  var parameters = new MessageCreateParams
  {
      Model = Model.ClaudeSonnet5_5,
      MaxTokens = 4096,
      Messages = [
          new UserMessageParam
          {
              Content = "Analyze the trade-offs between microservices and monolithic architectures"
          }
      ],
      OutputConfig = new OutputConfig
      {
          Effort = Effort.Medium
      }
  };

  var message = await client.Messages.Create(parameters);
  Console.WriteLine($"Stop reason: {message.StopReason?.Raw()}");
  foreach (var block in message.Content)
  {
      if (block.TryPickText(out var textBlock))
      {
          Console.WriteLine(textBlock.Text);
      }
  }
  ```

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

  response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeSonnet5_5,
  	MaxTokens: 4096,
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("Analyze the trade-offs between microservices and monolithic architectures")),
  	},
  	OutputConfig: anthropic.OutputConfigParam{
  		Effort: anthropic.OutputConfigEffortMedium,
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }
  fmt.Println("Stop reason:", response.StopReason)
  for _, block := range response.Content {
  	if textBlock, ok := block.AsAny().(anthropic.TextBlock); ok {
  		fmt.Println(textBlock.Text)
  	}
  }
  ```

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

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

      MessageCreateParams params = MessageCreateParams.builder()
          .model(Model.CLAUDE_SONNET_5_5)
          .maxTokens(4096L)
          .addUserMessage("Analyze the trade-offs between microservices and monolithic architectures")
          .outputConfig(OutputConfig.builder()
              .effort(OutputConfig.Effort.MEDIUM)
              .build())
          .build();

      Message response = client.messages().create(params);
      response.stopReason().ifPresent(reason -> IO.println("Stop reason: " + reason));
      response.content().stream()
          .flatMap(block -> block.text().stream())
          .forEach(textBlock -> IO.println(textBlock.text()));
  }
  ```

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

  $message = $client->messages->create(
      maxTokens: 4096,
      messages: [
          ['role' => 'user', 'content' => 'Analyze the trade-offs between microservices and monolithic architectures']
      ],
      model: Model::CLAUDE_SONNET_5_5,
      outputConfig: ['effort' => 'medium'],
  );

  echo "Stop reason: {$message->stopReason}", PHP_EOL;
  foreach ($message->content as $block) {
      if ($block instanceof \Anthropic\Messages\TextBlock) {
          echo $block->text, PHP_EOL;
      }
  }
  ```

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

  message = client.messages.create(
    model: Anthropic::Model::CLAUDE_SONNET_5_5,
    max_tokens: 4096,
    messages: [
      { role: "user", content: "Analyze the trade-offs between microservices and monolithic architectures" }
    ],
    output_config: {
      effort: "medium"
    }
  )

  puts "Stop reason: #{message.stop_reason}"
  message.content.each do |block|
    puts block.text if block.is_a?(Anthropic::Models::TextBlock)
  end
  ```
</CodeGroup>

## Размышления выполняются по умолчанию

На Claude Sonnet 5.5 запрос без поля `thinking` выполняется с [адаптивными размышлениями](https://platform.claude.com/docs/ru/build-with-claude/thinking) («adaptive thinking»), как и запрос с `thinking: {"type": "adaptive"}`. На Claude Sonnet 4.6 и более ранних моделях, а также на Claude Haiku 4.5 такой запрос выполнялся без размышлений. Чтобы по-прежнему работать без предварительных размышлений, см. раздел [Отключение предварительных размышлений](https://platform.claude.com/docs/ru/models/sonnet-5-5/migration-guide#turn-off-up-front-thinking).

| Модель                               | Размышления без поля `thinking` | Допустимые значения `thinking.type`                | `display` по умолчанию |
| ------------------------------------ | ------------------------------- | -------------------------------------------------- | ---------------------- |
| Claude Sonnet 5.5                    | Включены                        | `"adaptive"`, `"between_tools"`                    | `"omitted"`            |
| Claude Sonnet 5                      | Включены                        | `"adaptive"`, `"disabled"`                         | `"omitted"`            |
| Claude Sonnet 4.6                    | Выключены                       | `"adaptive"`, `"disabled"`, `"enabled"` (устарело) | `"summarized"`         |
| Claude Sonnet 4.5 и Claude Haiku 4.5 | Выключены                       | `"disabled"`, `"enabled"`                          | `"summarized"`         |

### Обработка размышлений в ответах

Коду, который работал без размышлений, нужны все три пункта. В коде для Claude Sonnet 5, скорее всего, уже есть первые два.

* **Читайте блоки содержимого по `type`.** Ответ может начинаться с блоков `thinking`, поэтому код, который читает `content[0].text`, перестаёт работать.
* **Передавайте блоки `thinking` обратно без изменений** в циклах использования инструментов, включая пустые блоки. См. [Сохранение блоков размышлений](https://platform.claude.com/docs/ru/build-with-claude/thinking#preserving-thinking-blocks).
* **Пересмотрите `max_tokens`.** Это значение охватывает размышления и текст, а токены размышлений оплачиваются как выходные токены. См. [Контроль затрат](https://platform.claude.com/docs/ru/build-with-claude/thinking-steering-and-cost#cost-control).

Текст размышлений по умолчанию опускается. Блоки `thinking` приходят с пустым полем `thinking` и полем `signature`. Чтобы получать читаемые сводки, задайте `display: "summarized"` — это значение по умолчанию на Claude Sonnet 4.6 и более ранних моделях, а также на Claude Haiku 4.5. См. [Управление отображением размышлений](https://platform.claude.com/docs/ru/build-with-claude/thinking#controlling-thinking-display).

### Отключение предварительных размышлений

Чтобы отключить предварительные размышления на Claude Sonnet 5.5, отправьте `thinking: {"type": "between_tools"}`. Это самая низкая настройка размышлений. Её промежуточные сообщения о ходе работы между вызовами инструментов по-прежнему возвращаются как блоки `thinking` с текстом сводки. Без инструментов ответ содержит только текст. Claude Sonnet 5 вместо этого отключает размышления с помощью `thinking: {"type": "disabled"}`, а более ранние модели по умолчанию работают без размышлений. На Claude Sonnet 5.5 значение `disabled` возвращает ошибку 400 `invalid_request_error`:

```text wrap
To turn thinking off on this model, send "thinking": {"type": "between_tools"} instead of {"type": "disabled"}. The model does not think before responding. The short updates it writes between tool calls come back as thinking blocks.
```

`between_tools` работает на всех платформах, где доступна Claude Sonnet 5.5. Эта настройка допускается при уровнях усилий `low`, `medium` и `high`. При `xhigh` или `max` она возвращает ошибку 400. Чтобы работать на этих уровнях, используйте адаптивные размышления: опустите поле `thinking` или отправьте `thinking: {"type": "adaptive"}`. `between_tools` не принимает других полей: `display`, `budget_tokens` или `block_binding`, отправленные вместе с ней, возвращают ошибку 400. При [резервном переключении на стороне сервера](https://platform.claude.com/docs/ru/build-with-claude/refusals-and-fallback#server-side-fallback) запрос с `between_tools`, переключённый на Claude Sonnet 5, выполняется там с `thinking: {"type": "disabled"}`.

С `between_tools` уровень усилий нельзя изменить посреди разговора: значение `output_config.effort` для отдельного сообщения, отличающееся от действующего уровня, возвращает ошибку 400. Чтобы менять уровень усилий для каждого хода, используйте адаптивные размышления. Рекомендации по составлению подсказок см. в разделе [Работа без предварительных размышлений](https://platform.claude.com/docs/ru/build-with-claude/prompt-engineering/prompting-claude-sonnet-5-5#running-without-up-front-thinking).

До (Claude Sonnet 5):

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-sonnet-5",
      "max_tokens": 16000,
      "thinking": {"type": "disabled"},
      "output_config": {"effort": "xhigh"},
      "messages": [{"role": "user", "content": "..."}]
    }'
  ```

  ```bash CLI
  ant messages create \
    --model claude-sonnet-5 \
    --max-tokens 16000 \
    --thinking '{type: disabled}' \
    --output-config '{effort: xhigh}' \
    --message '{role: user, content: "..."}'
  ```

  ```python Python
  client.messages.create(
      model="claude-sonnet-5",
      max_tokens=16000,
      thinking={"type": "disabled"},
      output_config={"effort": "xhigh"},
      messages=[{"role": "user", "content": "..."}],
  )
  ```

  ```typescript TypeScript
  await client.messages.create({
    model: "claude-sonnet-5",
    max_tokens: 16000,
    thinking: { type: "disabled" },
    output_config: { effort: "xhigh" },
    messages: [{ role: "user", content: "..." }]
  });
  ```

  ```csharp C#
  await client.Messages.Create(new MessageCreateParams
  {
      Model = Model.ClaudeSonnet5,
      MaxTokens = 16000,
      Thinking = new ThinkingConfigDisabled(),
      OutputConfig = new() { Effort = Effort.Xhigh },
      Messages = [new UserMessageParam { Content = "..." }],
  });
  ```

  ```go Go
  client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeSonnet5,
  	MaxTokens: 16000,
  	Thinking: anthropic.ThinkingConfigParamUnion{
  		OfDisabled: &anthropic.ThinkingConfigDisabledParam{},
  	},
  	OutputConfig: anthropic.OutputConfigParam{
  		Effort: anthropic.OutputConfigEffortXhigh,
  	},
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("...")),
  	},
  })
  ```

  ```java Java
  MessageCreateParams params = MessageCreateParams.builder()
      .model(Model.CLAUDE_SONNET_5)
      .maxTokens(16000L)
      .thinking(ThinkingConfigDisabled.builder().build())
      .outputConfig(OutputConfig.builder()
          .effort(OutputConfig.Effort.XHIGH)
          .build())
      .addUserMessage("...")
      .build();

  client.messages().create(params);
  ```

  ```php PHP
  $client->messages->create(
      model: Model::CLAUDE_SONNET_5,
      maxTokens: 16000,
      thinking: ThinkingConfigDisabled::with(),
      outputConfig: OutputConfig::with(effort: Effort::XHIGH),
      messages: [['role' => 'user', 'content' => '...']],
  );
  ```

  ```ruby Ruby
  client.messages.create(
    model: Anthropic::Model::CLAUDE_SONNET_5,
    max_tokens: 16000,
    thinking: Anthropic::ThinkingConfigDisabled.new,
    output_config: { effort: Anthropic::OutputConfig::Effort::XHIGH },
    messages: [{ role: "user", content: "..." }]
  )
  ```
</CodeGroup>

После (Claude Sonnet 5.5):

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-sonnet-5-5",
      "max_tokens": 16000,
      "thinking": {"type": "between_tools"},
      "output_config": {"effort": "high"},
      "messages": [{"role": "user", "content": "..."}]
    }'
  ```

  ```bash CLI
  ant messages create \
    --model claude-sonnet-5-5 \
    --max-tokens 16000 \
    --thinking '{type: between_tools}' \
    --output-config '{effort: high}' \
    --message '{role: user, content: "..."}'
  ```

  ```python Python
  client.messages.create(
      model="claude-sonnet-5-5",
      max_tokens=16000,
      thinking={"type": "between_tools"},
      output_config={"effort": "high"},
      messages=[{"role": "user", "content": "..."}],
  )
  ```

  ```typescript TypeScript
  await client.messages.create({
    model: "claude-sonnet-5-5",
    max_tokens: 16000,
    thinking: { type: "between_tools" },
    output_config: { effort: "high" },
    messages: [{ role: "user", content: "..." }]
  });
  ```

  ```csharp C#
  await client.Messages.Create(new MessageCreateParams
  {
      Model = Model.ClaudeSonnet5_5,
      MaxTokens = 16000,
      Thinking = new ThinkingConfigBetweenTools(),
      OutputConfig = new() { Effort = Effort.High },
      Messages = [new UserMessageParam { Content = "..." }],
  });
  ```

  ```go Go
  client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeSonnet5_5,
  	MaxTokens: 16000,
  	Thinking: anthropic.ThinkingConfigParamUnion{
  		OfBetweenTools: &anthropic.ThinkingConfigBetweenToolsParam{},
  	},
  	OutputConfig: anthropic.OutputConfigParam{
  		Effort: anthropic.OutputConfigEffortHigh,
  	},
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("...")),
  	},
  })
  ```

  ```java Java
  MessageCreateParams params = MessageCreateParams.builder()
      .model(Model.CLAUDE_SONNET_5_5)
      .maxTokens(16000L)
      .thinking(ThinkingConfigBetweenTools.builder().build())
      .outputConfig(OutputConfig.builder()
          .effort(OutputConfig.Effort.HIGH)
          .build())
      .addUserMessage("...")
      .build();

  client.messages().create(params);
  ```

  ```php PHP
  $client->messages->create(
      model: Model::CLAUDE_SONNET_5_5,
      maxTokens: 16000,
      thinking: ThinkingConfigBetweenTools::with(),
      outputConfig: OutputConfig::with(effort: Effort::HIGH),
      messages: [['role' => 'user', 'content' => '...']],
  );
  ```

  ```ruby Ruby
  client.messages.create(
    model: Anthropic::Model::CLAUDE_SONNET_5_5,
    max_tokens: 16000,
    thinking: Anthropic::ThinkingConfigBetweenTools.new,
    output_config: { effort: Anthropic::OutputConfig::Effort::HIGH },
    messages: [{ role: "user", content: "..." }]
  )
  ```
</CodeGroup>

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

Проходите группы сверху вниз и остановитесь после той, в которой названа ваша модель. Для Claude Haiku 4.5 примените все группы, кроме «Claude Sonnet 4 или более ранние», закончив группой «Только Claude Haiku 4.5».

### Все исходные модели

* Измените идентификатор модели на `claude-sonnet-5-5`.
* [Читайте блоки содержимого по `type`](https://platform.claude.com/docs/ru/models/sonnet-5-5/migration-guide#thinking-in-responses) и передавайте блоки `thinking` обратно без изменений.
* Чтобы продолжать работу без предварительных размышлений, отправляйте [самую низкую настройку размышлений](https://platform.claude.com/docs/ru/models/sonnet-5-5/migration-guide#turn-off-up-front-thinking) при уровне «effort» (усилие) `high` или ниже.
* Замените [принудительное использование инструментов](https://platform.claude.com/docs/ru/models/sonnet-5-5/migration-guide#forced-tool-use) («forced tool use») на `auto` и строгие инструменты.
* Ведите разговоры в режиме [только добавления](https://platform.claude.com/docs/ru/models/sonnet-5-5/migration-guide#thinking-blocks) («append-only»).
* Перенесите «computer use» (использование компьютера) в [набор инструментов](https://platform.claude.com/docs/ru/models/sonnet-5-5/migration-guide#computer-use-toolset) («toolset») без бета-заголовка `fine-grained-tool-streaming-2025-05-14`. В Amazon Bedrock также работает `computer_20251124`.
* [Используйте инструмент-советник в паре](https://platform.claude.com/docs/ru/models/sonnet-5-5/migration-guide#advisor-tool) с поддерживаемым советником и учитывайте, что советы будут зашифрованы.
* Читайте [текст между вызовами инструментов](https://platform.claude.com/docs/ru/models/sonnet-5-5/migration-guide#text-between-tool-calls) из блоков `thinking`.
* [Обрабатывайте отказы](https://platform.claude.com/docs/ru/models/sonnet-5-5/migration-guide#safety-classifiers-and-fallback) («refusals») и настройте резервный вариант («fallback»).
* [Повторно проведите подбор уровня effort](https://platform.claude.com/docs/ru/models/sonnet-5-5/migration-guide#recommended-changes) и заново определите базовый уровень стоимости.

### Claude Sonnet 4.6 или более ранние

* Учитывайте, что [размышления выполняются в запросах без поля `thinking`](https://platform.claude.com/docs/ru/models/sonnet-5-5/migration-guide#thinking-on-by-default), и пересмотрите `max_tokens`.
* Замените [бюджеты размышлений](https://platform.claude.com/docs/ru/models/sonnet-5-5/migration-guide#sonnet-46-breaking-changes) уровнем усилий.
* Удалите `temperature`, `top_p` и `top_k`.
* Если вы [показываете текст размышлений](https://platform.claude.com/docs/ru/models/sonnet-5-5/migration-guide#thinking-in-responses), задайте `display: "summarized"`.
* [Пересчитайте токены](https://platform.claude.com/docs/ru/models/sonnet-5-5/migration-guide#other-changes-from-claude-sonnet-4-6) и заново распределите бюджет токенов изображений.

### Claude Sonnet 4.5 или более ранние

* Замените [предварительное заполнение ответа ассистента](https://platform.claude.com/docs/ru/models/sonnet-5-5/migration-guide#migrating-from-sonnet-45) («assistant prefill»).
* Разбирайте входные данные вызовов инструментов стандартным парсером JSON.
* Явно задавайте `output_config.effort`.
* Удалите любой бета-заголовок для контекстного окна.
* Удалите `interleaved-thinking-2025-05-14` и замените `fine-grained-tool-streaming-2025-05-14` на `eager_input_streaming`.
* Перенесите `output_format` в `output_config.format`.

### Claude Sonnet 4 или более ранние

* Обновите [версии инструментов](https://platform.claude.com/docs/ru/models/sonnet-5-5/migration-guide#migrating-from-claude-sonnet-4-or-earlier) до `text_editor_20250728` и `code_execution_20260521`.
* Обрабатывайте причины остановки `refusal` и `model_context_window_exceeded`.
* Проверьте строковые параметры инструментов на наличие завершающих символов новой строки.
* Удалите `token-efficient-tools-2025-02-19` и `output-128k-2025-02-19`.
* Пересмотрите свои подсказки.

### Только Claude Haiku 4.5

* Замените [`claude-haiku-4-5-20251001`](https://platform.claude.com/docs/ru/models/sonnet-5-5/migration-guide#migrating-from-claude-haiku-4-5) или его псевдоним.
* Заново определите базовый уровень затрат с учётом более высокой цены за токен.
* Пересмотрите подсказки, которые были слишком короткими для кэширования на Claude Haiku 4.5.

## Миграция на Claude Sonnet 5.5 с Claude Sonnet 5

Изменения из этого раздела нужны для всех исходных моделей. Замените идентификатор модели на `claude-sonnet-5-5`, у которого нет суффикса с датой. На других платформах используйте идентификатор, указанный в разделе [Доступность](https://platform.claude.com/docs/ru/models/sonnet-5-5/whats-new-sonnet-5-5#availability).

### Принудительное использование инструментов не поддерживается

Все более ранние модели на этой странице принимают `tool_choice` типа `any` или `tool`. Claude Sonnet 5.5 отклоняет оба варианта с ошибкой 400, в том числе на эндпоинте [подсчёта токенов](https://platform.claude.com/docs/ru/build-with-claude/token-counting):

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

Отправьте `tool_choice: {"type": "auto"}` и пометьте инструмент как `strict: true`, чтобы его входные данные соответствовали схеме. В этом случае модель может ответить без вызова инструмента, поэтому укажите в подсказке, когда его использовать. [Строгое использование инструментов](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/strict-tool-use) поддерживает подмножество JSON Schema и требует `additionalProperties: false` для каждого объекта. См. [Ограничения JSON Schema](https://platform.claude.com/docs/ru/build-with-claude/structured-outputs#json-schema-limitations).

До (Claude Sonnet 5):

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-sonnet-5",
      "max_tokens": 1024,
      "tools": [{
        "name": "get_weather",
        "description": "Get the current weather in a given location",
        "input_schema": {
          "type": "object",
          "properties": {
            "location": {
              "type": "string",
              "description": "The city and state, e.g. San Francisco, CA"
            }
          },
          "required": ["location"],
          "additionalProperties": false
        }
      }],
      "tool_choice": {"type": "tool", "name": "get_weather"},
      "messages": [{"role": "user", "content": "What is the weather in Paris?"}]
    }'
  ```

  ```bash CLI
  ant messages create <<'YAML'
  model: claude-sonnet-5
  max_tokens: 1024
  tools:
    - name: get_weather
      description: Get the current weather in a given location
      input_schema:
        type: object
        properties:
          location:
            type: string
            description: The city and state, e.g. San Francisco, CA
        required: [location]
        additionalProperties: false
  tool_choice:
    type: tool
    name: get_weather
  messages:
    - role: user
      content: What's the weather in Paris?
  YAML
  ```

  ```python Python
  client.messages.create(
      model="claude-sonnet-5",
      max_tokens=1024,
      tools=tools,
      tool_choice={"type": "tool", "name": "get_weather"},
      messages=[{"role": "user", "content": "What's the weather in Paris?"}],
  )
  ```

  ```typescript TypeScript
  await client.messages.create({
    model: "claude-sonnet-5",
    max_tokens: 1024,
    tools,
    tool_choice: { type: "tool", name: "get_weather" },
    messages: [{ role: "user", content: "What's the weather in Paris?" }]
  });
  ```

  ```csharp C#
  await client.Messages.Create(new MessageCreateParams
  {
      Model = Model.ClaudeSonnet5,
      MaxTokens = 1024,
      Tools = [.. tools],
      ToolChoice = new ToolChoiceTool { Name = "get_weather" },
      Messages = [new UserMessageParam { Content = "What's the weather in Paris?" }],
  });
  ```

  ```go Go
  client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:      anthropic.ModelClaudeSonnet5,
  	MaxTokens:  1024,
  	Tools:      tools,
  	ToolChoice: anthropic.ToolChoiceParamOfTool("get_weather"),
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("What's the weather in Paris?")),
  	},
  })
  ```

  ```java Java
  MessageCreateParams params = MessageCreateParams.builder()
      .model(Model.CLAUDE_SONNET_5)
      .maxTokens(1024L)
      .tools(tools)
      .toolChoice(ToolChoiceTool.of("get_weather"))
      .addUserMessage("What's the weather in Paris?")
      .build();

  client.messages().create(params);
  ```

  ```php PHP
  $client->messages->create(
      model: Model::CLAUDE_SONNET_5,
      maxTokens: 1024,
      tools: $tools,
      toolChoice: ToolChoiceTool::with(name: 'get_weather'),
      messages: [['role' => 'user', 'content' => "What's the weather in Paris?"]],
  );
  ```

  ```ruby Ruby
  client.messages.create(
    model: Anthropic::Model::CLAUDE_SONNET_5,
    max_tokens: 1024,
    tools: tools,
    tool_choice: Anthropic::ToolChoiceTool.new(name: "get_weather"),
    messages: [{ role: "user", content: "What's the weather in Paris?" }]
  )
  ```
</CodeGroup>

После (Claude Sonnet 5.5):

<CodeGroup>
  ```bash cURL
  # строгое использование инструментов: каждый вызов соответствует input_schema инструмента
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-sonnet-5-5",
      "max_tokens": 1024,
      "tools": [{
        "name": "get_weather",
        "description": "Get the current weather in a given location",
        "input_schema": {
          "type": "object",
          "properties": {
            "location": {
              "type": "string",
              "description": "The city and state, e.g. San Francisco, CA"
            }
          },
          "required": ["location"],
          "additionalProperties": false
        },
        "strict": true
      }],
      "tool_choice": {"type": "auto"},
      "messages": [{
        "role": "user",
        "content": "What is the weather in Paris? Use the get_weather tool."
      }]
    }'
  ```

  ```bash CLI
  ant messages create <<'YAML'
  model: claude-sonnet-5-5
  max_tokens: 1024
  tools:
    - name: get_weather
      description: Get the current weather in a given location
      input_schema:
        type: object
        properties:
          location:
            type: string
            description: The city and state, e.g. San Francisco, CA
        required: [location]
        additionalProperties: false
      # строгое использование инструментов: каждый вызов соответствует input_schema инструмента
      strict: true
  tool_choice:
    type: auto
  messages:
    - role: user
      content: What's the weather in Paris? Use the get_weather tool.
  YAML
  ```

  ```python Python
  client.messages.create(
      model="claude-sonnet-5-5",
      max_tokens=1024,
      # строгое использование инструментов: каждый вызов соответствует input_schema инструмента
      tools=[{**tool, "strict": True} for tool in tools],
      tool_choice={"type": "auto"},
      messages=[
          {
              "role": "user",
              "content": "What's the weather in Paris? Use the get_weather tool.",
          }
      ],
  )
  ```

  ```typescript TypeScript
  await client.messages.create({
    model: "claude-sonnet-5-5",
    max_tokens: 1024,
    // строгое использование инструментов: каждый вызов соответствует input_schema инструмента
    tools: tools.map((tool) => ({ ...tool, strict: true })),
    tool_choice: { type: "auto" },
    messages: [
      {
        role: "user",
        content: "What's the weather in Paris? Use the get_weather tool."
      }
    ]
  });
  ```

  ```csharp C#
  await client.Messages.Create(new MessageCreateParams
  {
      Model = Model.ClaudeSonnet5_5,
      MaxTokens = 1024,
      // строгое использование инструментов: каждый вызов соответствует input_schema инструмента
      Tools = [.. tools.Select(tool => tool with { Strict = true })],
      ToolChoice = new ToolChoiceAuto(),
      Messages =
      [
          new UserMessageParam
          {
              Content = "What's the weather in Paris? Use the get_weather tool.",
          },
      ],
  });
  ```

  ```go Go
  // строгое использование инструментов: каждый вызов соответствует input_schema инструмента
  var strictTools []anthropic.ToolUnionParam
  for _, tool := range tools {
  	strictTool := *tool.OfTool
  	strictTool.Strict = anthropic.Bool(true)
  	strictTools = append(strictTools, anthropic.ToolUnionParam{OfTool: &strictTool})
  }
  client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:      anthropic.ModelClaudeSonnet5_5,
  	MaxTokens:  1024,
  	Tools:      strictTools,
  	ToolChoice: anthropic.ToolChoiceUnionParam{OfAuto: &anthropic.ToolChoiceAutoParam{}},
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(
  			anthropic.NewTextBlock("What's the weather in Paris? Use the get_weather tool."),
  		),
  	},
  })
  ```

  ```java Java
  MessageCreateParams params = MessageCreateParams.builder()
      .model(Model.CLAUDE_SONNET_5_5)
      .maxTokens(1024L)
      // строгое использование инструментов: каждый вызов соответствует input_schema инструмента
      .tools(tools.stream()
          .map(tool -> tool.tool()
              .map(customTool -> customTool.toBuilder()
                  .strict(true)
                  .build())
              .map(ToolUnion::ofTool)
              .orElse(tool))
          .toList())
      .toolChoice(ToolChoiceAuto.builder().build())
      .addUserMessage("What's the weather in Paris? Use the get_weather tool.")
      .build();

  client.messages().create(params);
  ```

  ```php PHP
  $client->messages->create(
      model: Model::CLAUDE_SONNET_5_5,
      maxTokens: 1024,
      // строгое использование инструментов: каждый вызов соответствует input_schema инструмента
      tools: array_map(fn (Tool $tool) => $tool->withStrict(true), $tools),
      toolChoice: ToolChoiceAuto::with(),
      messages: [
          [
              'role' => 'user',
              'content' => "What's the weather in Paris? Use the get_weather tool.",
          ],
      ],
  );
  ```

  ```ruby Ruby
  client.messages.create(
    model: Anthropic::Model::CLAUDE_SONNET_5_5,
    max_tokens: 1024,
    # строгое использование инструментов: каждый вызов соответствует input_schema инструмента
    tools: tools.map { |tool| tool.merge(strict: true) },
    tool_choice: Anthropic::ToolChoiceAuto.new,
    messages: [
      { role: "user", content: "What's the weather in Paris? Use the get_weather tool." }
    ]
  )
  ```
</CodeGroup>

В примере все инструменты в списке помечены как строгие. Запрос может содержать не более 20 строгих инструментов, а записи наборов инструментов MCP, использования компьютера и использования браузера не принимают `strict`. В более длинном списке инструментов помечайте только те инструменты, которым это нужно.

### Блоки размышлений привязаны к модели и разговору

Claude Sonnet 5.5 читает блоки размышлений от Claude Sonnet 5, Claude Opus 4.8, Claude Haiku 4.5 и [более ранних моделей](https://platform.claude.com/docs/ru/build-with-claude/preserved-thinking#earlier-models). В Claude API и Claude Models on Google Cloud (Google managed) она также читает их от Claude Haiku 5.5. Она не читает блоки от Claude Opus 5, Claude Opus 5.5 и любых моделей Claude Fable или Claude Mythos.

API отбрасывает блоки, которые модель не может прочитать. Запрос возвращает 200, а отброшенные блоки не оплачиваются. См. [Переключение моделей туда и обратно](https://platform.claude.com/docs/ru/build-with-claude/preserved-thinking#switching-models).

Ведите разговоры в режиме только добавления («append-only»), чтобы блоки размышлений проходили [проверку префикса](https://platform.claude.com/docs/ru/build-with-claude/preserved-thinking/prefix-checks#prefix-check). Чтобы изменить инструкции или инструменты, см. [Системные сообщения и изменения инструментов в середине разговора](https://platform.claude.com/docs/ru/build-with-claude/mid-conversation-system-messages).

Непройденная [«prefix check» (проверка префикса)](https://platform.claude.com/docs/ru/build-with-claude/preserved-thinking/prefix-checks#prefix-check) может привести к [ошибке 400](https://platform.claude.com/docs/ru/api/errors#thinking-block-conversation-mismatch), а может и не привести. Чтобы выявлять и обрабатывать оба случая, см. [Проверка префикса для блоков размышлений](https://platform.claude.com/docs/ru/build-with-claude/preserved-thinking/prefix-checks).

Проверка префикса выполняется в Claude API и на [некоторых облачных платформах](https://platform.claude.com/docs/ru/build-with-claude/preserved-thinking#feature-availability).

Блоки размышлений Claude Sonnet 5.5 работают только в аккаунте, который их создал, или в связанном с ним аккаунте. См. [Сохранённые размышления](https://platform.claude.com/docs/ru/build-with-claude/preserved-thinking#account-bound-thinking).

### Некоторые версии инструмента использования компьютера не поддерживаются

Claude Sonnet 5.5 поддерживает использование компьютера через набор инструментов `computer_toolset_20260801`. В Amazon Bedrock Claude Sonnet 5.5 также принимает инструмент `computer_20251124` с бета-заголовком `computer-use-2025-11-24`. Claude Sonnet 5.5 возвращает ошибку 400 для любой версии инструмента использования компьютера, которую он не принимает, например `computer_20251124` в Claude API. Он не принимает `computer_20250124` ни на одной платформе.

Интеграции, использующие набор инструментов, не требуют изменений. Чтобы перейти на набор инструментов, замените `computer_20251124` или `computer_20250124` на `computer_toolset_20260801` и удалите бета-заголовок этой версии. Изменения в запросах и в цикле агента см. в разделе [Миграция с `computer_20251124`](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/computer-use-tool#migrate-from-computer-20251124).

Если вы отправляете бета-заголовок `fine-grained-tool-streaming-2025-05-14`, удалите его при переходе на набор инструментов. Вместе с записью набора инструментов он возвращает ошибку 400. Вместо этого задайте `eager_input_streaming: true` для каждого инструмента, которому это нужно.

### Инструмент-советник принимает меньше советников

При использовании [инструмента-советника](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/advisor-tool) исполнителю Claude Sonnet 5.5 нужен один из следующих советников: Claude Opus 5, Claude Opus 5.5, Claude Sonnet 5.5, Claude Fable 5, Claude Fable 5.1, Claude Fable 5.2, Claude Mythos 5, Claude Mythos 5.1 или Claude Mythos 5.2. Советники Claude Opus 4.8, Claude Opus 4.7, Claude Opus 4.6, Claude Sonnet 5, Claude Sonnet 4.6 и Claude Haiku 5.5 возвращают ошибку 400. Совет возвращается в зашифрованном виде как блок `advisor_redacted_result`, поэтому его текст в ответе прочитать нельзя. См. [Совместимость моделей](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/advisor-tool#model-compatibility).

### Текст между вызовами инструментов возвращается в блоках размышлений

На Claude Sonnet 5.5 заметки длиннее одного-двух предложений, которые модель пишет между вызовами инструментов, возвращаются как [блоки `thinking` с сообщениями о ходе работы](https://platform.claude.com/docs/ru/build-with-claude/thinking#progress-updates), пустые при значении `display` по умолчанию. Более короткие замечания остаются блоками `text`. На Claude Sonnet 5 и более ранних моделях весь текст между вызовами инструментов возвращается как блоки `text`. Ни один запрос не завершается ошибкой, но интерфейс, который показывает эти заметки, перестаёт их отображать.

При адаптивных размышлениях задайте для `display` значение `"updates"` (бета, заголовок `thinking-display-updates-2026-08-18`), чтобы получать только сообщения о ходе работы, или `"summarized"`, чтобы получать их вместе с рассуждениями. Отображайте каждый непустой блок `thinking` перед следующим за ним блоком `tool_use`. При [`between_tools`](https://platform.claude.com/docs/ru/models/sonnet-5-5/migration-guide#turn-off-up-front-thinking) текст возвращается без `display`. См. [Сообщения о ходе работы для пользователя](https://platform.claude.com/docs/ru/build-with-claude/prompt-engineering/prompting-claude-sonnet-5-5#user-facing-progress-updates).

### Классификаторы безопасности и резервное переключение

Claude Sonnet 5.5 отказывает в большем числе категорий, чем Claude Sonnet 5. Отказ возвращает `stop_reason: "refusal"`, а его `stop_details` может указывать одну из следующих [категорий](https://platform.claude.com/docs/ru/build-with-claude/refusals-and-fallback#refusal-response):

* **`"cyber"`:** Запрос может способствовать киберугрозам, например разработке вредоносного ПО или эксплойтов.
* **`"bio"`:** Запрос может способствовать биологическому вреду, например через опасные лабораторные методы.
* **`"frontier_llm"`:** Запрос может помочь в разработке конкурирующих моделей ИИ.
* **`"reasoning_extraction"`:** Запрос просит модель воспроизвести её внутренние рассуждения в тексте ответа.
* **`"general_harms"`:** Запрос относится к другой области политики использования. Эту категорию может вызвать и безобидная работа.

[Резервное переключение на стороне сервера](https://platform.claude.com/docs/ru/build-with-claude/refusals-and-fallback#server-side-fallback) (`fallbacks: "default"`), доступное в бета-версии в Claude API и в [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/ru/build-with-claude/claude-models-on-google-cloud/anthropic-managed), повторяет запросы с отказами `"cyber"` и `"frontier_llm"` на Claude Sonnet 5. Оно не повторяет запросы с отказами `"bio"`, `"reasoning_extraction"` и `"general_harms"`. См. [Отказы и резервное переключение](https://platform.claude.com/docs/ru/build-with-claude/refusals-and-fallback) и [Как оплачиваются отказы](https://platform.claude.com/docs/ru/build-with-claude/refusals-and-fallback#how-refusals-are-billed).

Защитные меры в области кибербезопасности в реальном времени являются новыми для кода, перешедшего с Claude Sonnet 4.6, Claude Sonnet 4.5 и Claude Haiku 4.5. Для легитимной работы в области безопасности подайте заявку в [Cyber Verification Program](https://support.claude.com/en/articles/14604842-real-time-cyber-safeguards-on-claude-opus-and-sonnet).

### Другие изменения

* **Кэширование подсказок:** Минимальный размер кэшируемой подсказки составляет 512 токенов вместо 1024 на Claude Sonnet 5, Claude Sonnet 4.6 и Claude Sonnet 4.5. См. [Кэширование подсказок](https://platform.claude.com/docs/ru/build-with-claude/prompt-caching#cache-limitations).
* **Новые функции:** Сведения о системных сообщениях посреди разговора, изменении инструментов посреди разговора и уровне усилий для отдельных сообщений см. в разделе [Что нового в Claude Sonnet 5.5](https://platform.claude.com/docs/ru/models/sonnet-5-5/whats-new-sonnet-5-5#feature-support). При [`between_tools`](https://platform.claude.com/docs/ru/models/sonnet-5-5/migration-guide#turn-off-up-front-thinking) уровень усилий нельзя изменить посреди разговора.

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

Повторите подбор уровня усилий. У Claude Sonnet 5.5 пять уровней усилий: `low`, `medium`, `high`, `xhigh` и `max`. По умолчанию в Claude API используется `high`. Уровни откалиброваны заново, поэтому один и тот же уровень не даёт такого же объёма размышлений, как на Claude Sonnet 5. Начните с `high`, если ваша рабочая нагрузка не является агентной или чувствительной к «latency» (задержка). Для агентного программирования и многошагового использования инструментов начните с `medium` для чётко сформулированных задач и переходите на `high` для более сложных или длительных. Для чата и другой работы, чувствительной к задержке, начните с `medium` или `low`. Задайте уровень в `output_config.effort`. См. [Рекомендуемые уровни усилий для Claude Sonnet 5.5](https://platform.claude.com/docs/ru/build-with-claude/effort#recommended-effort-levels-for-claude-sonnet-5-5). Затем заново оцените инструкции в подсказках, специфичные для модели, с учётом раздела [Составление подсказок для Claude Sonnet 5.5](https://platform.claude.com/docs/ru/build-with-claude/prompt-engineering/prompting-claude-sonnet-5-5).

## Миграция на Claude Sonnet 5.5 с Claude Sonnet 4.6 и более ранних моделей Sonnet

Сначала примените все предыдущие разделы, заменив `claude-sonnet-4-6`. Затем внесите следующие изменения. Для Claude Sonnet 4.5 или более ранних моделей продолжите с последующими подразделами.

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

**Размышления выполняются в запросах, в которых они не были указаны.** См. [Размышления выполняются по умолчанию](https://platform.claude.com/docs/ru/models/sonnet-5-5/migration-guide#thinking-on-by-default) и [Отключение предварительных размышлений](https://platform.claude.com/docs/ru/models/sonnet-5-5/migration-guide#turn-off-up-front-thinking).

**Бюджеты размышлений возвращают ошибку.** Claude Sonnet 4.6 принимает `thinking: {"type": "enabled", "budget_tokens": N}` как устаревшую настройку. Claude Sonnet 4.5 и Claude Haiku 4.5 используют её для всех размышлений. Claude Sonnet 5.5 возвращает ошибку 400:

```text wrap
"thinking.type.enabled" is not supported for this model. Use "thinking.type.adaptive" and "output_config.effort" to control thinking behavior.
```

Удалите бюджет и задайте уровень [усилий](https://platform.claude.com/docs/ru/build-with-claude/effort). Фиксированного соответствия между бюджетом и уровнем усилий нет, поэтому проведите оценку на двух-трёх уровнях.

До (Claude Sonnet 4.6):

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-sonnet-4-6",
      "max_tokens": 16000,
      "thinking": {
        "type": "enabled",
        "budget_tokens": 10000
      },
      "messages": [
        {
          "role": "user",
          "content": "..."
        }
      ]
    }'
  ```

  ```bash CLI
  ant messages create <<'YAML'
  model: claude-sonnet-4-6
  max_tokens: 16000
  thinking:
    type: enabled
    budget_tokens: 10000
  messages:
    - role: user
      content: "..."
  YAML
  ```

  ```python Python
  client.messages.create(
      model="claude-sonnet-4-6",
      max_tokens=16000,
      thinking={"type": "enabled", "budget_tokens": 10000},
      messages=[{"role": "user", "content": "..."}],
  )
  ```

  ```typescript TypeScript
  await client.messages.create({
    model: "claude-sonnet-4-6",
    max_tokens: 16000,
    thinking: { type: "enabled", budget_tokens: 10000 },
    messages: [{ role: "user", content: "..." }]
  });
  ```

  ```csharp C#
  using Anthropic;
  using Anthropic.Models.Messages;

  AnthropicClient client = new();

  var parameters = new MessageCreateParams
  {
      Model = Model.ClaudeSonnet4_6,
      MaxTokens = 16000,
      Thinking = new ThinkingConfigEnabled(budgetTokens: 10000),
      Messages = [new UserMessageParam { Content = "..." }]
  };

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

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

  response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeSonnet4_6,
  	MaxTokens: 16000,
  	Thinking:  anthropic.ThinkingConfigParamOfEnabled(10000),
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("...")),
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }
  fmt.Println(response)
  ```

  ```java Java
  AnthropicClient client = AnthropicOkHttpClient.fromEnv();

  MessageCreateParams params = MessageCreateParams.builder()
      .model(Model.CLAUDE_SONNET_4_6)
      .maxTokens(16000L)
      .enabledThinking(10000L)
      .addUserMessage("...")
      .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' => '...']],
      model: Model::CLAUDE_SONNET_4_6,
      thinking: ['type' => 'enabled', 'budgetTokens' => 10000],
  );
  ```

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

  message = client.messages.create(
    model: Anthropic::Model::CLAUDE_SONNET_4_6,
    max_tokens: 16000,
    thinking: {
      type: "enabled",
      budget_tokens: 10000
    },
    messages: [
      { role: "user", content: "..." }
    ]
  )
  ```
</CodeGroup>

После (Claude Sonnet 5.5):

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-sonnet-5-5",
      "max_tokens": 16000,
      "thinking": {
        "type": "adaptive"
      },
      "output_config": {
        "effort": "high"
      },
      "messages": [
        {
          "role": "user",
          "content": "..."
        }
      ]
    }'
  ```

  ```bash CLI
  ant messages create <<'YAML'
  model: claude-sonnet-5-5
  max_tokens: 16000
  thinking:
    type: adaptive
  output_config:
    effort: high
  messages:
    - role: user
      content: "..."
  YAML
  ```

  ```python Python
  client.messages.create(
      model="claude-sonnet-5-5",
      max_tokens=16000,
      thinking={"type": "adaptive"},
      output_config={"effort": "high"},  # or "max", "xhigh", "medium", "low"
      messages=[{"role": "user", "content": "..."}],
  )
  ```

  ```typescript TypeScript
  await client.messages.create({
    model: "claude-sonnet-5-5",
    max_tokens: 16000,
    thinking: { type: "adaptive" },
    output_config: { effort: "high" }, // or "max", "xhigh", "medium", "low"
    messages: [{ role: "user", content: "..." }]
  });
  ```

  ```csharp C#
  using Anthropic;
  using Anthropic.Models.Messages;

  AnthropicClient client = new();

  var parameters = new MessageCreateParams
  {
      Model = Model.ClaudeSonnet5_5,
      MaxTokens = 16000,
      Thinking = new ThinkingConfigAdaptive(),
      OutputConfig = new OutputConfig { Effort = Effort.High }, // or Max, Xhigh, Medium, Low
      Messages = [new UserMessageParam { Content = "..." }]
  };

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

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

  response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeSonnet5_5,
  	MaxTokens: 16000,
  	Thinking: anthropic.ThinkingConfigParamUnion{
  		OfAdaptive: &anthropic.ThinkingConfigAdaptiveParam{},
  	},
  	OutputConfig: anthropic.OutputConfigParam{
  		Effort: anthropic.OutputConfigEffortHigh, // or Max, Xhigh, Medium, Low
  	},
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("...")),
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }
  fmt.Println(response)
  ```

  ```java Java
  AnthropicClient client = AnthropicOkHttpClient.fromEnv();

  MessageCreateParams params = MessageCreateParams.builder()
      .model(Model.CLAUDE_SONNET_5_5)
      .maxTokens(16000L)
      .thinking(ThinkingConfigAdaptive.builder().build())
      .outputConfig(OutputConfig.builder()
          .effort(OutputConfig.Effort.HIGH) // or MAX, XHIGH, MEDIUM, LOW
          .build())
      .addUserMessage("...")
      .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' => '...']],
      model: Model::CLAUDE_SONNET_5_5,
      thinking: ['type' => 'adaptive'],
      outputConfig: ['effort' => 'high'], // or 'max', 'xhigh', 'medium', 'low'
  );
  ```

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

  message = client.messages.create(
    model: Anthropic::Model::CLAUDE_SONNET_5_5,
    max_tokens: 16000,
    thinking: {
      type: "adaptive"
    },
    output_config: {
      effort: "high" # or "max", "xhigh", "medium", "low"
    },
    messages: [
      { role: "user", content: "..." }
    ]
  )
  ```
</CodeGroup>

**Параметры сэмплирования возвращают ошибку.** Удалите `temperature`, `top_p` и `top_k`.

**Текст размышлений по умолчанию опускается.** См. [Обработка размышлений в ответах](https://platform.claude.com/docs/ru/models/sonnet-5-5/migration-guide#thinking-in-responses).

### Другие изменения

* **Примерно на 30 процентов больше токенов:** Claude Sonnet 5.5 использует токенизатор Claude Sonnet 5. По сравнению с Claude Sonnet 4.6, Claude Sonnet 4.5 и Claude Haiku 4.5 тот же текст даёт примерно на 30 процентов больше токенов в зависимости от содержимого. Пересчитайте токены с помощью [подсчёта токенов](https://platform.claude.com/docs/ru/build-with-claude/token-counting) и пересмотрите `max_tokens` и затраты.
* **Уровень усилий:** Claude Sonnet 5.5 поддерживает `xhigh`, а уровни откалиброваны заново. См. [Рекомендуемые изменения](https://platform.claude.com/docs/ru/models/sonnet-5-5/migration-guide#recommended-changes).
* **Изображения:** Claude Sonnet 5.5 использует уровень изображений высокого разрешения — до 2576 пикселей по длинной стороне и до 4784 визуальных токенов на изображение. Claude Sonnet 4.6, Claude Sonnet 4.5 и Claude Haiku 4.5 ограничены 1568 пикселями и 1568 токенами. Изображение размером 2000×1500 на Claude Sonnet 5.5 стоит примерно в 2,5 раза больше токенов. См. [Разрешение и стоимость в токенах](https://platform.claude.com/docs/ru/build-with-claude/vision#evaluate-image-size).

### Миграция с Claude Sonnet 4.5 или более ранних моделей

Для Claude Sonnet 4.5, Claude Sonnet 4 или Claude 3.7 Sonnet сначала примените все предыдущие разделы, а затем следующие изменения.

**Предзаполнение возвращает ошибку.** Claude Sonnet 5.5 отклоняет предзаполненный последний ход ассистента с ошибкой 400, как и Claude Sonnet 4.6 и Claude Sonnet 5. Claude Sonnet 4.5, Claude Haiku 4.5 и более старые модели его принимают. Текст ошибки:

```text wrap
This model does not support assistant message prefill. The conversation must end with a user message.
```

Замените каждое предзаполнение в зависимости от его назначения:

* **Формат вывода:** используйте [структурированные выводы](https://platform.claude.com/docs/ru/build-with-claude/structured-outputs) или инструменты с полями enum для классификации.
* **Вступления:** попросите в системной подсказке давать прямой ответ.
* **Нежелательные отказы:** обычно достаточно чётких инструкций в сообщении пользователя.
* **Продолжения:** перенесите их в сообщение пользователя, например: «Ваш предыдущий ответ был прерван и закончился на `[previous_response]`. Продолжите с того места, где остановились».
* **Напоминания о контексте:** поместите их в ход пользователя.

**Экранирование входных данных инструментов.** Экранирование в аргументах вызовов инструментов может отличаться. Разбирайте `input` стандартным парсером JSON.

**Использование компьютера.** Claude Sonnet 5.5 не принимает `computer_20250124`. См. [Некоторые версии инструмента использования компьютера не поддерживаются](https://platform.claude.com/docs/ru/models/sonnet-5-5/migration-guide#computer-use-toolset).

**Уровень усилий.** У Claude Sonnet 4.5 нет параметра effort. Явно задайте уровень усилий (см. [Рекомендуемые изменения](https://platform.claude.com/docs/ru/models/sonnet-5-5/migration-guide#recommended-changes)).

**Контекст и вывод.** У Claude Sonnet 5.5 более крупное контекстное окно и более высокий предел вывода. См. страницу модели [Claude Sonnet 5.5](https://platform.claude.com/docs/ru/models/sonnet-5-5/overview). Удалите все бета-заголовки контекстного окна.

**Бета-заголовки.** Удалите `interleaved-thinking-2025-05-14`, поскольку адаптивные размышления автоматически чередуются с вызовами инструментов. Замените `fine-grained-tool-streaming-2025-05-14` на `eager_input_streaming: true` для каждого инструмента, которому это нужно. Этот заголовок возвращает ошибку 400 вместе с записью набора инструментов использования компьютера или браузера. См. [Детализированная потоковая передача инструментов](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/fine-grained-tool-streaming).

**Структурированные выводы.** Параметр `output_format` устарел. Чтобы всё же использовать его, добавьте бета-заголовок `structured-outputs-2025-11-13`. Без него API возвращает ошибку 400. Вместо этого используйте `output_config.format`.

### Миграция с Claude Sonnet 4 или более ранних моделей

Claude Sonnet 4 выведена из эксплуатации в Claude API, но доступна в Claude Models on Google Cloud (Google managed) и Amazon Bedrock. Claude 3.7 Sonnet выведена из эксплуатации. При переходе с любой из этих моделей сначала примените все предыдущие разделы, а затем следующие изменения:

* **Версии инструментов:** Используйте `text_editor_20250728` с именем инструмента `str_replace_based_edit_tool` и без команды `undo_edit`. Используйте `code_execution_20260521`. См. [инструмент текстового редактора](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/text-editor-tool) и [инструмент выполнения кода](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/code-execution-tool#upgrade-to-latest-tool-version).
* **Причины остановки:** Обрабатывайте `refusal`. Claude 4.5 и более поздние модели также останавливаются с `model_context_window_exceeded` при достижении предела контекстного окна. См. [Причины остановки и резервные модели](https://platform.claude.com/docs/ru/build-with-claude/handling-stop-reasons).
* **Завершающие символы новой строки:** Claude 4.5 и более поздние модели сохраняют их в строковых параметрах вызовов инструментов.
* **Бета-заголовки:** Удалите `token-efficient-tools-2025-02-19` и `output-128k-2025-02-19`.
* **Подсказки:** Пересмотрите их с учётом [рекомендаций по составлению подсказок](https://platform.claude.com/docs/ru/build-with-claude/prompt-engineering/claude-prompting-best-practices).

## Миграция на Claude Sonnet 5.5 с Claude Haiku 4.5

Сначала примените все разделы вплоть до раздела [Миграция с Claude Sonnet 4.5 или более ранних моделей](https://platform.claude.com/docs/ru/models/sonnet-5-5/migration-guide#migrating-from-sonnet-45) включительно, пропустив подраздел о Claude Sonnet 4. Затем внесите следующие изменения:

* **Идентификатор модели:** Замените `claude-haiku-4-5-20251001` или псевдоним `claude-haiku-4-5` на `claude-sonnet-5-5`.
* **Затраты:** Цена за токен выше, а тот же текст даёт больше токенов. Пересчитайте токены и заново определите базовый уровень затрат. См. [Цены](https://platform.claude.com/docs/ru/about-claude/pricing).
* **Кэширование подсказок:** Минимальный размер кэшируемой подсказки снижается с 4096 токенов до [минимума Claude Sonnet 5.5](https://platform.claude.com/docs/ru/models/sonnet-5-5/migration-guide#other-changes-from-claude-sonnet-5).
* **Чередующиеся размышления:** Адаптивные размышления автоматически выполняются между вызовами инструментов.
* **Маршрутизация:** Claude Sonnet 5.5 читает блоки размышлений Claude Haiku 4.5. Разговор, переходящий на более мощную модель, сохраняет свои рассуждения. Разговор, возвращающийся обратно на Claude Haiku 4.5, отбрасывает блоки Claude Sonnet 5.5.