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

<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-sonnet-5-5
  ```

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

Цены Claude Sonnet 5.5 совпадают с ценами Claude Sonnet 5, за исключением чтения из кэша подсказок, которое стоит $0,10 USD за миллион токенов — вдвое меньше, чем у Claude Sonnet 5. См. [цены Claude](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» (усилий), а вкладки SDK читают ответ по типу блока. В нём отсутствуют пять настроек, которые возвращают ошибку 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: 2023-06-01" \
    -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 is Anthropic.TextBlock => block.type === "text"
  );
  console.log(textBlock?.text);
  ```

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

  var parameters = new MessageCreateParams
  {
      Model = Model.ClaudeSonnet5_5,
      MaxTokens = 4096,
      Messages = [
          new() {
              Role = Role.User,
              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: 'claude-sonnet-5-5',
      outputConfig: ['effort' => 'medium'],
  );

  echo "Stop reason: {$message->stopReason}", PHP_EOL;
  foreach ($message->content as $block) {
      if ($block->type === 'text') {
          echo $block->text, PHP_EOL;
      }
  }
  ```

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

  message = 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"
    }
  )

  puts "Stop reason: #{message.stop_reason}"
  message.content.each do |block|
    puts block.text if block.type == :text
  end
  ```
</CodeGroup>

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

На Claude Sonnet 5.5 запрос без поля `thinking` выполняется с [«adaptive thinking» (адаптивными размышлениями)](https://platform.claude.com/docs/ru/build-with-claude/thinking), как и запрос с `thinking: {"type": "adaptive"}`. На Claude Sonnet 4.6 и более ранних моделях, а также на Claude Haiku 4.5 такой запрос выполнялся без размышлений. Чтобы и дальше работать без «up-front thinking» (предварительных размышлений), см. [Отключение предварительных размышлений](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` обратно без изменений** в циклах «tool use» (использования инструментов), включая пустые блоки. См. [Сохранение блоков размышлений](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: 2023-06-01" \
    -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() { Role = Role.User, 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: 2023-06-01" \
    -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() { Role = Role.User, 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) при уровне усилий `high` или ниже.
* Замените [принудительное использование инструментов](https://platform.claude.com/docs/ru/models/sonnet-5-5/migration-guide#forced-tool-use) на `auto` и строгие инструменты, а на Amazon Bedrock — только на `auto`.
* Ведите разговоры [только с добавлением](https://platform.claude.com/docs/ru/models/sonnet-5-5/migration-guide#thinking-blocks).
* В Claude API и Google Cloud переведите использование компьютера на [набор инструментов](https://platform.claude.com/docs/ru/models/sonnet-5-5/migration-guide#computer-use-toolset) без бета-заголовка `fine-grained-tool-streaming-2025-05-14`.
* Используйте [инструмент-советник](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) и настройте резервное переключение.
* [Повторите подбор уровня усилий](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).
* Разбирайте входные данные вызовов инструментов стандартным JSON-парсером.
* В Amazon Bedrock перенесите использование компьютера с `computer_20250124` на [`computer_20251124`](https://platform.claude.com/docs/ru/models/sonnet-5-5/migration-guide#computer-use-toolset).
* Явно задайте `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

Изменения из этого раздела нужны для любой исходной модели. Замените ID модели на `claude-sonnet-5-5` — у него нет суффикса с датой. На других платформах используйте ID, указанный в разделе [Доступность](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). В Amazon Bedrock [структурированные выходные данные](https://platform.claude.com/docs/ru/build-with-claude/structured-outputs), включающие строгое использование инструментов, недоступны для Claude Sonnet 5.5. Там отправляйте `auto` без `strict`, указывайте в подсказке, когда вызывать инструмент, и проверяйте входные данные инструмента в своём коде.

До (Claude Sonnet 5):

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-sonnet-5",
      "max_tokens": 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?"}]
    }'
  ```

  ```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() { Role = Role.User, 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: 2023-06-01" \
    -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'\''s 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()
          {
              Role = Role.User,
              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 и более ранних моделей, а в Claude API и Google Cloud — также от 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).

Каждый блок размышлений Claude Sonnet 5.5 также подписывается с учётом предшествующей ему части разговора. Для аккаунтов, созданных 31 августа 2026 года в 00:00 UTC или позже, API применяет это правило по умолчанию в Claude API, Amazon Bedrock и Google Cloud. Для таких аккаунтов запрос, который повторно передаёт блок после изменения более ранней истории, возвращает ошибку 400. Ведите разговоры в режиме только добавления, а инструкции или инструменты меняйте с помощью [системных сообщений посреди разговора](https://platform.claude.com/docs/ru/build-with-claude/mid-conversation-system-messages). Блоки размышлений, созданные Claude Sonnet 5.5, работают только в аккаунте, в котором они были созданы, или в связанном с ним аккаунте. См. [Сохранённые размышления](https://platform.claude.com/docs/ru/build-with-claude/preserved-thinking#account-bound-thinking).

### Для использования компьютера в Claude API и Google Cloud нужен набор инструментов

В Claude API и Google Cloud Claude Sonnet 5.5 поддерживает использование компьютера только через набор инструментов `computer_toolset_20260801`. Там `computer_20251124` возвращает ошибку 400. Claude Sonnet 5.5 не принимает `computer_20250124` ни на одной платформе. Найдите версию, которую вы отправляете сейчас:

| Версия, которую вы отправляете сейчас | Исходные модели, которые её отправляют               | Что отправлять в Claude API и Google Cloud | Что отправлять в Amazon Bedrock |
| ------------------------------------- | ---------------------------------------------------- | ------------------------------------------ | ------------------------------- |
| `computer_20251124`                   | Claude Sonnet 5, Claude Sonnet 4.6                   | `computer_toolset_20260801`                | `computer_20251124`             |
| `computer_20250124`                   | Claude Sonnet 4.5, Claude Haiku 4.5, Claude Sonnet 4 | `computer_toolset_20260801`                | `computer_20251124`             |

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

Код, который уже отправляет набор инструментов, изменять не нужно. В разделе [Миграция с `computer_20251124`](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/computer-use-tool#migrate-from-computer-20251124) перечислены изменения запроса и агентного цикла. Сведения о других платформах см. в разделе [Совместимость](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/computer-use-tool#compatibility).

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

При использовании [«advisor tool» (инструмента-советника)](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 Mythos 5 или Claude Mythos 5.1. Советники 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"`:** Запрос может помочь в разработке конкурирующих моделей «artificial intelligence» (искусственного интеллекта), или AI.
* **`"reasoning_extraction"`:** Запрос просит модель воспроизвести свои внутренние рассуждения в тексте ответа.
* **`"general_harms"`:** Запрос относится к другой области политики использования. Эту категорию может вызвать и безобидная работа.

[Резервное переключение на стороне сервера](https://platform.claude.com/docs/ru/build-with-claude/refusals-and-fallback#server-side-fallback) (`fallbacks: "default"`, бета-версия, только Claude API) повторяет на Claude Sonnet 5 запросы, отклонённые по категориям `"cyber"` и `"frontier_llm"`. Запросы, отклонённые по категориям `"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).

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

* **«Prompt caching» (кэширование подсказок):** Минимальный размер кэшируемой подсказки — 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: 2023-06-01" \
    -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() { Role = Role.User, 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: 'claude-sonnet-4-6',
      thinking: ['type' => 'enabled', 'budget_tokens' => 10000],
  );
  ```

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

  message = client.messages.create(
    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: 2023-06-01" \
    -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() { Role = Role.User, 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: '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: "claude-sonnet-5-5",
    max_tokens: 16000,
    thinking: {
      type: "adaptive"
    },
    output_config: {
      effort: "high" # or "max", "xhigh", "medium", "low"
    },
    messages: [
      { role: "user", content: "..." }
    ]
  )
  ```
</CodeGroup>

**Параметры сэмплирования возвращают ошибку.** Claude Sonnet 4.6 и более ранние модели, а также Claude Haiku 4.5 принимают `temperature`, `top_p` и `top_k`. На Claude Sonnet 5.5 значение, отличное от значения по умолчанию, возвращает ошибку 400. Удалите эти параметры.

**Текст размышлений по умолчанию опускается.** См. [Обработка размышлений в ответах](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` и затраты.
* **Уровень усилий:** Уровень `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 для классификации. В Amazon Bedrock структурированные выходные данные недоступны для Claude Sonnet 5.5. Там опишите формат в подсказке или используйте инструмент без `strict` и проверяйте вывод в своём коде.
* **Вступления:** попросите в системной подсказке давать прямой ответ.
* **Нежелательные отказы:** обычно достаточно чётких инструкций в сообщении пользователя.
* **Продолжения:** перенесите их в сообщение пользователя, например: «Ваш предыдущий ответ был прерван и закончился на `[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 более крупное контекстное окно без бета-заголовка и более высокий лимит вывода. См. [страницу модели](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 вместе с элементом набора инструментов использования компьютера или браузера. См. [«Fine-grained tool streaming» (детализированная потоковая передача инструментов)](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, но по-прежнему доступен в Amazon Bedrock и Google Cloud. 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. Затем внесите следующие изменения:

* **ID модели:** Замените `claude-haiku-4-5-20251001` или псевдоним `claude-haiku-4-5` на `claude-sonnet-5-5`.
* **Затраты:** Цена за токен выше, а один и тот же текст даёт больше токенов. Пересчитайте токены и заново определите базовый уровень затрат. См. [цены Claude](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.