---
title: Guida alla migrazione a Claude Sonnet 5.5
url: https://platform.claude.com/docs/it/models/sonnet-5-5/migration-guide
description: Passa a Claude Sonnet 5.5 dai modelli Sonnet precedenti o da Claude Haiku 4.5 con questa guida alla migrazione. Le indicazioni per abilitare Claude Sonnet 5.5 includono le impostazioni che restituiscono errori, le modifiche al ragionamento e una checklist per ciascun modello di partenza.
---

Questa guida elenca le modifiche al codice necessarie per passare a Claude Sonnet 5.5 da Claude Sonnet 5, Claude Sonnet 4.6, Claude Sonnet 4.5, Claude Sonnet 4, Claude 3.7 Sonnet o Claude Haiku 4.5. Leggi le prime due sezioni, poi prosegui fino alla sezione relativa al tuo modello attuale. La [checklist di migrazione](https://platform.claude.com/docs/it/models/sonnet-5-5/migration-guide#migration-checklist) elenca ogni modifica in base al modello di partenza.

<Note>
  Questa guida copre la migrazione del codice della [Messages API](https://platform.claude.com/docs/it/build-with-claude/working-with-messages). Se usi [Claude Managed Agents](https://platform.claude.com/docs/it/managed-agents/overview), non sono necessarie modifiche oltre all'aggiornamento del nome del modello.
</Note>

<Tip>
  **Automatizza la tua migrazione con la skill Claude API.** In Claude Code, esegui `/claude-api migrate` per invocare la [skill Claude API](https://platform.claude.com/docs/it/agents-and-tools/agent-skills/claude-api-skill#migrating-to-a-newer-claude-model) inclusa. Funziona con qualsiasi modello Claude attuale come destinazione:

  Lascia che Claude Code migri il tuo codice per te

  ```text
  /claude-api migrate questo progetto a claude-sonnet-5-5
  ```

  La skill applica la sostituzione dell'ID del modello e, se necessario, le modifiche incompatibili ai parametri, la sostituzione del prefill e la calibrazione dell'effort per il modello di destinazione in tutta la tua base di codice, quindi produce una checklist di elementi da verificare manualmente. Ti chiede di confermare l'ambito della migrazione (l'intera directory di lavoro, una sottodirectory o un elenco specifico di file) prima di modificare qualsiasi file. La skill rileva inoltre i client Amazon Bedrock e Claude Platform su AWS e adatta i formati degli ID dei modelli e le modifiche alle funzionalità per tali piattaforme.
</Tip>

Claude Sonnet 5.5 ha gli stessi prezzi di Claude Sonnet 5, ad eccezione delle letture dalla cache dei prompt, che costano $0,10 USD per milione di token, la metà della tariffa di Claude Sonnet 5. Consulta [Prezzi di Claude](https://platform.claude.com/docs/it/about-claude/pricing). Per la sua "context window" (finestra di contesto) e i limiti di output, consulta la [pagina del modello Claude Sonnet 5.5](https://platform.claude.com/docs/it/models/sonnet-5-5/overview). Per funzionalità e prompting, consulta [Novità di Claude Sonnet 5.5](https://platform.claude.com/docs/it/models/sonnet-5-5/whats-new-sonnet-5-5#feature-support) e [Scrivere prompt per Claude Sonnet 5.5](https://platform.claude.com/docs/it/build-with-claude/prompt-engineering/prompting-claude-sonnet-5-5).

## Invia una richiesta a Claude Sonnet 5.5

Questa richiesta funziona su Claude Sonnet 5.5 così com'è scritta. Imposta un livello di "effort" (sforzo) e le schede degli SDK leggono la risposta in base al tipo di blocco. Omette cinque impostazioni che restituiscono un errore 400: [budget di ragionamento](https://platform.claude.com/docs/it/models/sonnet-5-5/migration-guide#sonnet-46-breaking-changes), [parametri di campionamento](https://platform.claude.com/docs/it/models/sonnet-5-5/migration-guide#sonnet-46-breaking-changes), [precompilazione dell'assistente](https://platform.claude.com/docs/it/models/sonnet-5-5/migration-guide#migrating-from-sonnet-45), [scelta forzata dello strumento](https://platform.claude.com/docs/it/models/sonnet-5-5/migration-guide#forced-tool-use) e [`thinking: {"type": "disabled"}`](https://platform.claude.com/docs/it/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>

## Il ragionamento è attivo per impostazione predefinita

Su Claude Sonnet 5.5, una richiesta senza campo `thinking` viene eseguita con ["adaptive thinking" (ragionamento adattivo)](https://platform.claude.com/docs/it/build-with-claude/thinking), così come `thinking: {"type": "adaptive"}`. Su Claude Sonnet 4.6 e modelli precedenti e su Claude Haiku 4.5, quella richiesta veniva eseguita senza ragionamento. Per continuare a eseguire senza "up-front thinking" (ragionamento iniziale), consulta [Disattivare il ragionamento iniziale](https://platform.claude.com/docs/it/models/sonnet-5-5/migration-guide#turn-off-up-front-thinking).

| Modello                              | Ragionamento senza campo `thinking` | Valori di `thinking.type` accettati                 | `display` predefinito |
| ------------------------------------ | ----------------------------------- | --------------------------------------------------- | --------------------- |
| Claude Sonnet 5.5                    | Attivo                              | `"adaptive"`, `"between_tools"`                     | `"omitted"`           |
| Claude Sonnet 5                      | Attivo                              | `"adaptive"`, `"disabled"`                          | `"omitted"`           |
| Claude Sonnet 4.6                    | Disattivo                           | `"adaptive"`, `"disabled"`, `"enabled"` (deprecato) | `"summarized"`        |
| Claude Sonnet 4.5 e Claude Haiku 4.5 | Disattivo                           | `"disabled"`, `"enabled"`                           | `"summarized"`        |

### Gestire il ragionamento nelle risposte

Il codice che veniva eseguito senza ragionamento necessita di tutti e tre gli elementi. Il codice proveniente da Claude Sonnet 5 probabilmente ha già i primi due.

* **Leggi i blocchi di contenuto in base al `type`.** Una risposta può iniziare con blocchi `thinking`, quindi il codice che legge `content[0].text` smette di funzionare.
* **Restituisci i blocchi `thinking` invariati** nei cicli di uso degli strumenti, compresi quelli vuoti. Consulta [Preservare i blocchi di ragionamento](https://platform.claude.com/docs/it/build-with-claude/thinking#preserving-thinking-blocks).
* **Rivedi `max_tokens`.** Copre il ragionamento più il testo, e i token di ragionamento vengono fatturati come token di output. Consulta [Controllo dei costi](https://platform.claude.com/docs/it/build-with-claude/thinking-steering-and-cost#cost-control).

Il testo del ragionamento è omesso per impostazione predefinita. I blocchi `thinking` arrivano con un campo `thinking` vuoto e una `signature`. Per ottenere riepiloghi leggibili, imposta `display: "summarized"`, il valore predefinito su Claude Sonnet 4.6 e modelli precedenti e su Claude Haiku 4.5. Consulta [Controllare la visualizzazione del ragionamento](https://platform.claude.com/docs/it/build-with-claude/thinking#controlling-thinking-display).

### Disattivare il ragionamento iniziale

Per disattivare il ragionamento iniziale su Claude Sonnet 5.5, invia `thinking: {"type": "between_tools"}`. È l'impostazione di ragionamento più bassa. I suoi aggiornamenti di avanzamento tra le chiamate agli strumenti vengono comunque restituiti come blocchi `thinking` con il relativo testo di riepilogo. Senza strumenti, la risposta contiene solo testo. Claude Sonnet 5 disattiva invece il ragionamento con `thinking: {"type": "disabled"}`, e i modelli precedenti vengono eseguiti senza ragionamento per impostazione predefinita. Su Claude Sonnet 5.5, `disabled` restituisce un errore 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` funziona su ogni piattaforma che offre Claude Sonnet 5.5, senza header beta. È accettato con sforzo `low`, `medium` e `high`. Con `xhigh` o `max`, restituisce un errore 400. Per eseguire a quei livelli, usa il ragionamento adattivo: ometti il campo `thinking` oppure invia `thinking: {"type": "adaptive"}`. `between_tools` non accetta altri campi: `display`, `budget_tokens` o `block_binding` inviati insieme a esso restituiscono un errore 400. Con il [fallback lato server](https://platform.claude.com/docs/it/build-with-claude/refusals-and-fallback#server-side-fallback), una richiesta `between_tools` che ricade su Claude Sonnet 5 viene eseguita lì con `thinking: {"type": "disabled"}`.

Con `between_tools`, lo sforzo non può cambiare a metà conversazione: un `output_config.effort` per messaggio diverso dal livello in vigore restituisce un errore 400. Per variare lo sforzo a ogni turno, usa il ragionamento adattivo. Per indicazioni sul prompting, consulta [Esecuzione senza ragionamento iniziale](https://platform.claude.com/docs/it/build-with-claude/prompt-engineering/prompting-claude-sonnet-5-5#running-without-up-front-thinking).

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

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

## Checklist di migrazione per modello di partenza

Procedi attraverso i gruppi e fermati dopo quello che nomina il tuo modello. Su Claude Haiku 4.5, applica ogni gruppo tranne "Claude Sonnet 4 o precedenti", terminando con "Solo Claude Haiku 4.5".

### Ogni modello di partenza

* Cambia l'ID del modello in `claude-sonnet-5-5`.
* [Leggi i blocchi di contenuto in base al `type`](https://platform.claude.com/docs/it/models/sonnet-5-5/migration-guide#thinking-in-responses) e restituisci i blocchi `thinking` invariati.
* Per continuare a eseguire senza ragionamento iniziale, invia [l'impostazione di ragionamento più bassa](https://platform.claude.com/docs/it/models/sonnet-5-5/migration-guide#turn-off-up-front-thinking) con effort `high` o inferiore.
* Sostituisci l'[uso forzato degli strumenti](https://platform.claude.com/docs/it/models/sonnet-5-5/migration-guide#forced-tool-use) con `auto` e strumenti strict, oppure con il solo `auto` su Amazon Bedrock.
* Mantieni le conversazioni [in sola aggiunta](https://platform.claude.com/docs/it/models/sonnet-5-5/migration-guide#thinking-blocks).
* Sulla Claude API e su Google Cloud, sposta il computer use al [toolset](https://platform.claude.com/docs/it/models/sonnet-5-5/migration-guide#computer-use-toolset), senza il beta header `fine-grained-tool-streaming-2025-05-14`.
* Abbina l'[advisor tool](https://platform.claude.com/docs/it/models/sonnet-5-5/migration-guide#advisor-tool) a un advisor supportato e aspettati consigli crittografati.
* Leggi il [testo tra le chiamate agli strumenti](https://platform.claude.com/docs/it/models/sonnet-5-5/migration-guide#text-between-tool-calls) dai blocchi `thinking`.
* [Gestisci i rifiuti](https://platform.claude.com/docs/it/models/sonnet-5-5/migration-guide#safety-classifiers-and-fallback) e configura il fallback.
* [Ripeti la tua analisi dei livelli di effort](https://platform.claude.com/docs/it/models/sonnet-5-5/migration-guide#recommended-changes) e ricalcola la base dei costi.

### Claude Sonnet 4.6 o precedenti

* Aspettati il [ragionamento nelle richieste senza campo `thinking`](https://platform.claude.com/docs/it/models/sonnet-5-5/migration-guide#thinking-on-by-default) e rivedi `max_tokens`.
* Sostituisci i [budget di ragionamento](https://platform.claude.com/docs/it/models/sonnet-5-5/migration-guide#sonnet-46-breaking-changes) con un livello di sforzo.
* Rimuovi i valori non predefiniti di `temperature`, `top_p` e `top_k`.
* Se [mostri il testo del ragionamento](https://platform.claude.com/docs/it/models/sonnet-5-5/migration-guide#thinking-in-responses), imposta `display: "summarized"`.
* [Riconta i token](https://platform.claude.com/docs/it/models/sonnet-5-5/migration-guide#other-changes-from-claude-sonnet-4-6) e ricalcola il budget dei token delle immagini.

### Claude Sonnet 4.5 o precedenti

* Sostituisci le [precompilazioni dell'assistente](https://platform.claude.com/docs/it/models/sonnet-5-5/migration-guide#migrating-from-sonnet-45).
* Analizza l'input delle chiamate agli strumenti con un parser JSON standard.
* Su Amazon Bedrock, sposta computer use da `computer_20250124` a [`computer_20251124`](https://platform.claude.com/docs/it/models/sonnet-5-5/migration-guide#computer-use-toolset).
* Imposta `output_config.effort` esplicitamente.
* Rimuovi qualsiasi header beta relativo alla finestra di contesto.
* Rimuovi `interleaved-thinking-2025-05-14` e sostituisci `fine-grained-tool-streaming-2025-05-14` con `eager_input_streaming`.
* Sposta `output_format` in `output_config.format`.

### Claude Sonnet 4 o precedenti

* Aggiorna le [versioni degli strumenti](https://platform.claude.com/docs/it/models/sonnet-5-5/migration-guide#migrating-from-claude-sonnet-4-or-earlier) a `text_editor_20250728` e `code_execution_20260521`.
* Gestisci i motivi di arresto `refusal` e `model_context_window_exceeded`.
* Controlla i parametri stringa degli strumenti per individuare caratteri di nuova riga finali.
* Rimuovi `token-efficient-tools-2025-02-19` e `output-128k-2025-02-19`.
* Rivedi i tuoi prompt.

### Solo Claude Haiku 4.5

* Sostituisci [`claude-haiku-4-5-20251001`](https://platform.claude.com/docs/it/models/sonnet-5-5/migration-guide#migrating-from-claude-haiku-4-5) o il suo alias.
* Ricalcola la baseline dei costi con il prezzo per token più alto.
* Rivedi i prompt che erano troppo brevi per essere memorizzati nella cache su Claude Haiku 4.5.

## Migrazione a Claude Sonnet 5.5 da Claude Sonnet 5

Ogni modello di partenza richiede le modifiche di questa sezione. Sostituisci l'ID del modello con `claude-sonnet-5-5`, che non ha suffisso di data. Su altre piattaforme, usa l'ID elencato in [Disponibilità](https://platform.claude.com/docs/it/models/sonnet-5-5/whats-new-sonnet-5-5#availability).

### L'uso forzato degli strumenti non è supportato

Ogni modello precedente in questa pagina accetta un `tool_choice` di tipo `any` o `tool`. Claude Sonnet 5.5 li rifiuta entrambi con un errore 400, anche sull'endpoint di [conteggio dei token](https://platform.claude.com/docs/it/build-with-claude/token-counting):

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

Invia `tool_choice: {"type": "auto"}` e contrassegna lo strumento con `strict: true` in modo che il suo input corrisponda allo schema. Il modello può quindi rispondere senza chiamare lo strumento, perciò indica nel prompt quando usarlo. L'[uso rigoroso degli strumenti](https://platform.claude.com/docs/it/agents-and-tools/tool-use/strict-tool-use) supporta un sottoinsieme di JSON Schema e richiede `additionalProperties: false` su ogni oggetto. Consulta [Limitazioni di JSON Schema](https://platform.claude.com/docs/it/build-with-claude/structured-outputs#json-schema-limitations). Su Amazon Bedrock, gli [output strutturati](https://platform.claude.com/docs/it/build-with-claude/structured-outputs), che includono l'uso rigoroso degli strumenti, non sono disponibili per Claude Sonnet 5.5. Lì, invia `auto` senza `strict`, indica nel prompt quando chiamare lo strumento e convalida l'input dello strumento nel tuo codice.

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

Dopo (Claude Sonnet 5.5):

<CodeGroup>
  ```bash cURL
  # uso degli strumenti rigoroso: ogni chiamata rispetta l'input_schema dello strumento
  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
      # uso degli strumenti rigoroso: ogni chiamata rispetta l'input_schema dello strumento
      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,
      # uso degli strumenti rigoroso: ogni chiamata rispetta l'input_schema dello strumento
      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,
    // strict tool use (uso degli strumenti rigoroso): ogni chiamata rispetta l'input_schema dello strumento
    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,
      // strict tool use (uso degli strumenti rigoroso): ogni chiamata rispetta l'input_schema dello strumento
      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
  // strict tool use (uso degli strumenti rigoroso): ogni chiamata rispetta l'input_schema dello strumento
  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)
      // strict tool use (uso degli strumenti rigoroso): ogni chiamata rispetta l'input_schema dello strumento
      .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,
      // uso degli strumenti rigoroso: ogni chiamata rispetta l'input_schema dello strumento
      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,
    # uso degli strumenti rigoroso: ogni chiamata rispetta l'input_schema dello strumento
    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>

L'esempio contrassegna come strict ogni strumento dell'elenco. Una richiesta può avere al massimo 20 strumenti strict, e le voci dei toolset MCP, computer use e browser use non accettano `strict`. In un elenco di strumenti più lungo, contrassegna solo gli strumenti che ne hanno bisogno.

### I blocchi di ragionamento sono legati al modello e alla conversazione

Claude Sonnet 5.5 legge i blocchi di ragionamento di Claude Sonnet 5, Claude Opus 4.8, Claude Haiku 4.5 e dei modelli precedenti e, sulla Claude API e su Google Cloud, di Claude Haiku 5.5. Non legge i blocchi di Claude Opus 5, Claude Opus 5.5 o di qualsiasi modello Claude Fable o Claude Mythos. L'API scarta i blocchi che il modello non può leggere. La richiesta restituisce comunque 200 e i blocchi scartati non vengono fatturati. Consulta [Cambiare modello a metà conversazione](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking#switching-models).

Ogni blocco di ragionamento di Claude Sonnet 5.5 è inoltre firmato sulla conversazione che lo precede. Per gli account creati a partire dal 31 agosto 2026, 00:00 UTC, l'API applica questo vincolo per impostazione predefinita, sulla Claude API, su Amazon Bedrock e su Google Cloud. Su questi account, una richiesta che ripropone un blocco dopo una modifica alla cronologia precedente restituisce un errore 400. Mantieni le conversazioni in sola aggiunta e modifica istruzioni o strumenti con i [messaggi di sistema a metà conversazione](https://platform.claude.com/docs/it/build-with-claude/mid-conversation-system-messages). I blocchi di ragionamento prodotti da Claude Sonnet 5.5 funzionano solo nell'account che li ha prodotti o in un account collegato a esso. Consulta [Ragionamento preservato](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking#account-bound-thinking).

### Computer use richiede il toolset sull'API Claude e su Google Cloud

Sull'API Claude e su Google Cloud, Claude Sonnet 5.5 supporta computer use solo tramite il toolset `computer_toolset_20260801`. Lì, `computer_20251124` restituisce un errore 400. Claude Sonnet 5.5 non accetta `computer_20250124` su nessuna piattaforma. Trova la versione che invii oggi:

| Versione che invii oggi | Modelli di partenza che la inviano                   | Da inviare sull'API Claude e su Google Cloud | Da inviare su 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`          |

Se invii l'header beta `fine-grained-tool-streaming-2025-05-14`, rimuovilo quando passi al toolset. Insieme a una voce di toolset, restituisce un errore 400. Imposta invece `eager_input_streaming: true` su ogni strumento che ne ha bisogno.

Il codice che invia già il toolset non richiede modifiche. [Migrare da `computer_20251124`](https://platform.claude.com/docs/it/agents-and-tools/tool-use/computer-use-tool#migrate-from-computer-20251124) elenca le modifiche alla richiesta e al ciclo dell'agente. Per altre piattaforme, consulta [Compatibilità](https://platform.claude.com/docs/it/agents-and-tools/tool-use/computer-use-tool#compatibility).

### Lo strumento advisor accetta meno advisor

Con lo [strumento advisor](https://platform.claude.com/docs/it/agents-and-tools/tool-use/advisor-tool), un executor Claude Sonnet 5.5 necessita di uno di questi advisor: Claude Opus 5, Claude Opus 5.5, Claude Sonnet 5.5, Claude Fable 5, Claude Fable 5.1, Claude Mythos 5 o Claude Mythos 5.1. Gli advisor Claude Opus 4.8, Claude Opus 4.7, Claude Opus 4.6, Claude Sonnet 5, Claude Sonnet 4.6 e Claude Haiku 5.5 restituiscono un errore 400. Il consiglio viene restituito crittografato come blocco `advisor_redacted_result`, quindi il suo testo non è leggibile nella risposta. Consulta [Compatibilità dei modelli](https://platform.claude.com/docs/it/agents-and-tools/tool-use/advisor-tool#model-compatibility).

### Il testo tra le chiamate agli strumenti viene restituito nei blocchi di ragionamento

Su Claude Sonnet 5.5, le note più lunghe di una o due frasi che il modello scrive tra le chiamate agli strumenti tornano come [blocchi `thinking` di aggiornamento sull'avanzamento](https://platform.claude.com/docs/it/build-with-claude/thinking#progress-updates), vuoti con il `display` predefinito. Le osservazioni più brevi restano `text`. Su Claude Sonnet 5 e modelli precedenti, tutto il testo tra le chiamate agli strumenti torna come blocchi `text`. Nessuna richiesta fallisce, ma un'interfaccia che mostra quelle note smette di visualizzarle.

Con il ragionamento adattivo, imposta `display` su `"updates"` (beta, header `thinking-display-updates-2026-08-18`) per ottenere solo gli aggiornamenti, oppure su `"summarized"` per ottenerli mescolati al ragionamento. Visualizza ogni blocco `thinking` non vuoto prima del blocco `tool_use` che lo segue. Con [`between_tools`](https://platform.claude.com/docs/it/models/sonnet-5-5/migration-guide#turn-off-up-front-thinking), il testo torna senza `display`. Consulta [Aggiornamenti sull'avanzamento per l'utente](https://platform.claude.com/docs/it/build-with-claude/prompt-engineering/prompting-claude-sonnet-5-5#user-facing-progress-updates).

### Classificatori di sicurezza e fallback

Claude Sonnet 5.5 rifiuta in più categorie rispetto a Claude Sonnet 5. Un rifiuto restituisce `stop_reason: "refusal"`, e il suo `stop_details` può indicare una di queste [categorie](https://platform.claude.com/docs/it/build-with-claude/refusals-and-fallback#refusal-response):

* **`"cyber"`:** La richiesta potrebbe consentire danni informatici, come lo sviluppo di malware o exploit.
* **`"bio"`:** La richiesta potrebbe consentire danni biologici, come metodi di laboratorio pericolosi.
* **`"frontier_llm"`:** La richiesta potrebbe favorire lo sviluppo di modelli di IA concorrenti.
* **`"reasoning_extraction"`:** La richiesta chiede al modello di riprodurre il suo ragionamento interno nel testo della risposta.
* **`"general_harms"`:** La richiesta rientra in un'altra area delle norme di utilizzo. Anche attività innocue possono attivare questa categoria.

Il [fallback lato server](https://platform.claude.com/docs/it/build-with-claude/refusals-and-fallback#server-side-fallback) (`fallbacks: "default"`, beta, solo API Claude) ritenta i rifiuti `"cyber"` e `"frontier_llm"` su Claude Sonnet 5. Non ritenta i rifiuti `"bio"`, `"reasoning_extraction"` o `"general_harms"`. Consulta [Rifiuti e fallback](https://platform.claude.com/docs/it/build-with-claude/refusals-and-fallback) e [Come vengono fatturati i rifiuti](https://platform.claude.com/docs/it/build-with-claude/refusals-and-fallback#how-refusals-are-billed).

Le protezioni informatiche in tempo reale sono una novità per il codice proveniente da Claude Sonnet 4.6, Claude Sonnet 4.5 e Claude Haiku 4.5. Per attività di sicurezza legittime, fai domanda per il [Cyber Verification Program](https://support.claude.com/en/articles/14604842-real-time-cyber-safeguards-on-claude-opus-and-sonnet).

### Altre modifiche

* **"Prompt caching" (cache dei prompt):** Il prompt minimo memorizzabile nella cache è di 512 token, in calo rispetto ai 1.024 di Claude Sonnet 5, Claude Sonnet 4.6 e Claude Sonnet 4.5. Consulta [Cache dei prompt](https://platform.claude.com/docs/it/build-with-claude/prompt-caching#cache-limitations).
* **Nuove funzionalità:** Per i messaggi di sistema a metà conversazione, le modifiche agli strumenti a metà conversazione e lo sforzo per messaggio, consulta [Novità di Claude Sonnet 5.5](https://platform.claude.com/docs/it/models/sonnet-5-5/whats-new-sonnet-5-5#feature-support). Con [`between_tools`](https://platform.claude.com/docs/it/models/sonnet-5-5/migration-guide#turn-off-up-front-thinking), lo sforzo non può cambiare a metà conversazione.

### Modifiche consigliate

Ripeti la tua analisi comparativa dei livelli di sforzo. Claude Sonnet 5.5 ha cinque livelli di sforzo: `low`, `medium`, `high`, `xhigh` e `max`. Il valore predefinito sull'API Claude è `high`. I livelli sono stati ricalibrati, quindi un livello non produce la stessa quantità di ragionamento che su Claude Sonnet 5. Inizia con `high` a meno che il tuo carico di lavoro non sia agentico o sensibile alla "latency" (latenza). Per la programmazione agentica e l'uso degli strumenti in più passaggi, inizia con `medium` per attività ben specificate e passa a `high` per quelle più difficili o più lunghe. Per la chat e altre attività sensibili alla latenza, inizia con `medium` o `low`. Imposta il livello in `output_config.effort`. Consulta [Livelli di sforzo consigliati per Claude Sonnet 5.5](https://platform.claude.com/docs/it/build-with-claude/effort#recommended-effort-levels-for-claude-sonnet-5-5). Poi rivaluta le istruzioni dei prompt specifiche per il modello rispetto a [Prompting per Claude Sonnet 5.5](https://platform.claude.com/docs/it/build-with-claude/prompt-engineering/prompting-claude-sonnet-5-5).

## Migrazione a Claude Sonnet 5.5 da Claude Sonnet 4.6 e modelli Sonnet precedenti

Applica prima ogni sezione precedente, sostituendo `claude-sonnet-4-6`. Poi apporta queste modifiche. Su Claude Sonnet 4.5 o precedenti, prosegui con le sottosezioni che seguono.

### Modifiche che causano incompatibilità

**Il ragionamento viene eseguito nelle richieste che lo omettevano.** Consulta [Il ragionamento è attivo per impostazione predefinita](https://platform.claude.com/docs/it/models/sonnet-5-5/migration-guide#thinking-on-by-default) e [Disattivare il ragionamento iniziale](https://platform.claude.com/docs/it/models/sonnet-5-5/migration-guide#turn-off-up-front-thinking).

**I budget di ragionamento restituiscono un errore.** Claude Sonnet 4.6 accetta `thinking: {"type": "enabled", "budget_tokens": N}` come impostazione deprecata. Claude Sonnet 4.5 e Claude Haiku 4.5 la usano per tutto il ragionamento. Claude Sonnet 5.5 restituisce un errore 400:

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

Rimuovi il budget e imposta un livello di [sforzo](https://platform.claude.com/docs/it/build-with-claude/effort). Non esiste una corrispondenza fissa tra un budget e un livello di sforzo, quindi esegui le tue valutazioni a due o tre livelli.

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

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

**I parametri di campionamento restituiscono un errore.** Claude Sonnet 4.6 e modelli precedenti e Claude Haiku 4.5 accettano `temperature`, `top_p` e `top_k`. Su Claude Sonnet 5.5, un valore non predefinito restituisce un errore 400. Rimuovili.

**Il testo del ragionamento è omesso per impostazione predefinita.** Consulta [Gestire il ragionamento nelle risposte](https://platform.claude.com/docs/it/models/sonnet-5-5/migration-guide#thinking-in-responses).

### Altre modifiche

* **Circa il 30% di token in più:** Claude Sonnet 5.5 usa il tokenizer di Claude Sonnet 5. Rispetto a Claude Sonnet 4.6, Claude Sonnet 4.5 e Claude Haiku 4.5, lo stesso testo produce circa il 30% di token in più, a seconda del contenuto. Riconta con il [conteggio dei token](https://platform.claude.com/docs/it/build-with-claude/token-counting) e rivedi `max_tokens` e i costi.
* **Sforzo:** `xhigh` è nuovo, e i livelli sono stati ricalibrati. Consulta [Modifiche consigliate](https://platform.claude.com/docs/it/models/sonnet-5-5/migration-guide#recommended-changes).
* **Immagini:** Claude Sonnet 5.5 usa il livello di immagini ad alta risoluzione, fino a 2576 pixel sul lato lungo e 4.784 token visivi per immagine. Claude Sonnet 4.6, Claude Sonnet 4.5 e Claude Haiku 4.5 si fermano a 1568 pixel e 1.568 token. Un'immagine 2000×1500 costa circa 2,5 volte più token su Claude Sonnet 5.5. Consulta [Risoluzione e costo in token](https://platform.claude.com/docs/it/build-with-claude/vision#evaluate-image-size).

### Migrazione da Claude Sonnet 4.5 o precedenti

Su Claude Sonnet 4.5, Claude Sonnet 4 o Claude 3.7 Sonnet, applica prima ogni sezione precedente, poi queste modifiche.

**La precompilazione restituisce un errore.** Claude Sonnet 5.5 rifiuta un ultimo turno dell'assistente precompilato con un errore 400, come fanno Claude Sonnet 4.6 e Claude Sonnet 5. Claude Sonnet 4.5, Claude Haiku 4.5 e i modelli più vecchi lo accettano. L'errore recita:

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

Sostituisci ogni precompilazione in base al suo scopo:

* **Formato di output:** usa gli [output strutturati](https://platform.claude.com/docs/it/build-with-claude/structured-outputs), oppure strumenti con campi enum per la classificazione. Su Amazon Bedrock, gli output strutturati non sono disponibili per Claude Sonnet 5.5. Lì, descrivi il formato nel prompt o usa uno strumento senza `strict`, e convalida l'output nel tuo codice.
* **Preamboli:** chiedi nel prompt di sistema una risposta diretta.
* **Rifiuti indesiderati:** istruzioni chiare nel messaggio dell'utente sono di solito sufficienti.
* **Continuazioni:** spostale nel messaggio dell'utente, ad esempio "La tua risposta precedente è stata interrotta e terminava con `[previous_response]`. Continua da dove avevi lasciato."
* **Promemoria di contesto:** inseriscili nel turno dell'utente.

**Escaping dell'input degli strumenti.** L'escaping negli argomenti delle chiamate agli strumenti può differire. Analizza `input` con un parser JSON standard.

**Computer use.** Claude Sonnet 5.5 non accetta `computer_20250124`. Consulta la [tabella del computer use](https://platform.claude.com/docs/it/models/sonnet-5-5/migration-guide#computer-use-toolset).

**Sforzo.** Claude Sonnet 4.5 non ha un parametro effort. Imposta un livello di sforzo in modo esplicito, come descritto in [Modifiche consigliate](https://platform.claude.com/docs/it/models/sonnet-5-5/migration-guide#recommended-changes).

**Contesto e output.** Claude Sonnet 5.5 ha una finestra di contesto più ampia, senza header beta, e un limite di output più alto. Consulta la [pagina del modello](https://platform.claude.com/docs/it/models/sonnet-5-5/overview). Rimuovi qualsiasi header beta relativo alla finestra di contesto.

**Header beta.** Rimuovi `interleaved-thinking-2025-05-14`, poiché il ragionamento adattivo si intercala automaticamente. Sostituisci `fine-grained-tool-streaming-2025-05-14` con `eager_input_streaming: true` su ogni strumento che ne ha bisogno. Quell'header restituisce un errore 400 insieme a una voce di toolset computer use o browser use. Consulta [Streaming granulare degli strumenti](https://platform.claude.com/docs/it/agents-and-tools/tool-use/fine-grained-tool-streaming).

**Output strutturati.** Il parametro `output_format` è deprecato e verrà rimosso in futuro. Per usarlo comunque, aggiungi l'header beta `structured-outputs-2025-11-13`. Senza di esso, l'API restituisce un errore 400. Usa invece `output_config.format`.

### Migrazione da Claude Sonnet 4 o precedenti

Claude Sonnet 4 è ritirato sull'API Claude ed è ancora disponibile su Amazon Bedrock e Google Cloud. Claude 3.7 Sonnet è ritirato. Da entrambi i modelli, applica prima ogni sezione precedente, poi queste modifiche:

* **Versioni degli strumenti:** Usa `text_editor_20250728`, con il nome dello strumento `str_replace_based_edit_tool` e senza il comando `undo_edit`. Usa `code_execution_20260521`. Consulta lo [strumento editor di testo](https://platform.claude.com/docs/it/agents-and-tools/tool-use/text-editor-tool) e lo [strumento di esecuzione del codice](https://platform.claude.com/docs/it/agents-and-tools/tool-use/code-execution-tool#upgrade-to-latest-tool-version).
* **Motivi di arresto:** Gestisci `refusal`. Claude 4.5 e i modelli successivi si fermano anche con `model_context_window_exceeded` al limite della finestra di contesto. Consulta [Gestione dei motivi di arresto](https://platform.claude.com/docs/it/build-with-claude/handling-stop-reasons).
* **Caratteri di nuova riga finali:** Claude 4.5 e i modelli successivi li mantengono nei parametri stringa delle chiamate agli strumenti.
* **Header beta legacy:** Rimuovi `token-efficient-tools-2025-02-19` e `output-128k-2025-02-19`.
* **Prompt:** Rivedili rispetto alle [best practice di prompting](https://platform.claude.com/docs/it/build-with-claude/prompt-engineering/claude-prompting-best-practices).

## Migrazione a Claude Sonnet 5.5 da Claude Haiku 4.5

Applica prima ogni sezione fino a [Migrazione da Claude Sonnet 4.5 o precedenti](https://platform.claude.com/docs/it/models/sonnet-5-5/migration-guide#migrating-from-sonnet-45) inclusa, saltando la sottosezione su Claude Sonnet 4. Poi apporta queste modifiche:

* **ID del modello:** Sostituisci `claude-haiku-4-5-20251001`, o l'alias `claude-haiku-4-5`, con `claude-sonnet-5-5`.
* **Costi:** Il prezzo per token è più alto, e lo stesso testo produce più token. Riconta i token e ricalcola la baseline dei costi. Consulta [Prezzi di Claude](https://platform.claude.com/docs/it/about-claude/pricing).
* **Cache dei prompt:** Il prompt minimo memorizzabile nella cache scende da 4.096 token al [minimo di Claude Sonnet 5.5](https://platform.claude.com/docs/it/models/sonnet-5-5/migration-guide#other-changes-from-claude-sonnet-5).
* **Ragionamento alternato:** Il ragionamento adattivo viene eseguito automaticamente tra le chiamate agli strumenti, senza header beta.
* **Instradamento:** Claude Sonnet 5.5 legge i blocchi di ragionamento di Claude Haiku 4.5. Una conversazione che passa al modello superiore mantiene il suo ragionamento. Una che torna a Claude Haiku 4.5 scarta i blocchi di Claude Sonnet 5.5.