---
title: Correggi un blocco di ragionamento vincolato a una conversazione diversa
url: https://platform.claude.com/docs/it/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation
description: Fai ripartire una conversazione dopo l'errore 400 che indica che un blocco di ragionamento è vincolato a una conversazione diversa, trova cosa ha modificato il tuo codice e verifica con un test che la modifica non ci sia più.
featureMetadata:
status: stable
supportedModels:
- claude-fable-5-2
- claude-mythos-5-2
- claude-fable-5-1
- claude-mythos-5-1
- claude-opus-5-5
- claude-sonnet-5-5
- claude-haiku-5-5
supportedPlatforms:
Claude API: stable
Amazon Bedrock: stable
Amazon Bedrock (bedrock-runtime): stable
Claude Platform on AWS: stable
Claude Models on Google Cloud (Anthropic managed): stable
Claude Models on Google Cloud (Google managed): stable
Microsoft Foundry: stable
---
Inviare di nuovo la stessa richiesta non può funzionare, perché la tua cronologia contiene ancora ciò che il tuo codice ha modificato. Invia `"drop_block"` e [ferma subito gli errori](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#prefix-mismatch-error). La soluzione a lungo termine è rendere il tuo codice [append-only](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking/prefix-checks#prefix-check) (solo in aggiunta).
## Errore: The block is bound to a different conversation
Il “thinking block” (blocco di ragionamento) non ha superato il [“prefix check” (controllo del prefisso)](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking/prefix-checks#prefix-check): qualcosa prima di esso è cambiato dopo che Claude lo ha prodotto (vedi [Cosa conta come modifica](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking/prefix-checks#what-counts-as-an-edit)), oppure un blocco di ragionamento tra altri è stato omesso o spostato. L’errore appare così e può proseguire [indicando cosa è cambiato](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#prefix-mismatch-error-details):
```text wrap
messages.1.content.0: Invalid `signature` in `thinking` block. The block is bound to a different conversation. Remove the block, or set `thinking.block_binding.prefix_mismatch_behavior` to "drop_block".
```
“A different conversation” significa un contenuto diverso prima del blocco: il [controllo del prefisso](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking/prefix-checks#prefix-check) non confronta sessioni o utenti. Il messaggio di errore dice di rimuovere il blocco, ma [rimuovere solo quel blocco non basta](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#remove-by-hand). [Altri errori](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#similar-errors) possono sembrare simili.
Se l’app non è tua, avvia una nuova conversazione e avvisa chi la mantiene. Se hai [rimosso un segreto, dati personali o testo iniettato](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking/change-tools-or-instructions#remove-sensitive-content), oppure le tue richieste [disattivano il ragionamento](https://platform.claude.com/docs/it/build-with-claude/thinking#turning-thinking-off), [rimuovi a mano il ragionamento](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#remove-by-hand) invece di seguire il passaggio 1.
Imposta `thinking.block_binding.prefix_mismatch_behavior` su `"drop_block"` e invia l’[header beta](https://platform.claude.com/docs/it/api/beta-headers#beta-features-on-other-platforms) `anthropic-beta: thinking-binding-controls-2026-08-01`. Fallo su ogni richiesta successiva della conversazione, perché l’API non memorizza l’impostazione tra una richiesta e l’altra. Una conversazione salvata contiene ancora la modifica, anche dopo che hai corretto il tuo codice, quindi memorizza l’impostazione insieme a essa. Imposta `type` su `"adaptive"`, come mostrato:
```json
{
"thinking": {
"type": "adaptive",
"block_binding": {
"prefix_mismatch_behavior": "drop_block"
}
}
}
```
Nell’SDK, chiama il metodo Messages beta e passa il valore dell’header, come fa [il programma di test](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#how-to-tell-whether-your-integration-is-impacted-details). Se l’errore [chiede ancora l’header](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#setting-not-received), l’header non è arrivato.
Questo ferma gli errori scartando il ragionamento non valido, ma [può costare di più](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#drop-block-cost) e può influire sulla qualità dell’output e sulla latenza. La richiesta successiva va a buon fine e il suo array `input_transformations` elenca ogni blocco che l’API ha scartato.
Se le tue richieste non impostano il parametro `thinking`, aggiungerlo non cambia nient’altro, perché i [modelli con ragionamento preservato](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking/prefix-checks#outcomes) ragionano in modo adattivo per impostazione predefinita.
Rendi la tua integrazione append-only:
1. Trova la modifica. L’errore può indicarla. Per trovare dove il tuo codice la effettua, esegui `claude update`, poi esegui `/claude-api preserved-thinking-migration` in Claude Code nel repository del tuo codice. Oppure [cerca a mano](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#find-the-change-details).
2. Smetti di effettuare la modifica, altrimenti anche le nuove conversazioni possono ricevere l’errore. [Invia invece un aggiornamento alla fine](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking/change-tools-or-instructions).
3. Continua a inviare a ogni conversazione in corso il `system` e i `tools` della [sua ultima richiesta riuscita](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking/change-tools-or-instructions#saved-sessions).
Se la modifica è recente, puoi invece annullarla: ripristina ciò che il tuo codice ha modificato. Il ragionamento precedente alla modifica torna valido. Il ragionamento prodotto da allora non supera il controllo del prefisso, quindi rimuovilo oppure continua a inviare `"drop_block"`.
## Quanto costa scartare il ragionamento
Claude può spendere più token di output per ricostruire un ragionamento che non può più leggere. Scartare i blocchi invalida inoltre la cache dei prompt dal primo blocco scartato in poi.
Quando qualcosa cambia a ogni turno, ogni turno perde il ragionamento dei turni precedenti, quindi l’aumento si ripete. Esegui delle valutazioni sul tuo carico di lavoro prima di affidarti a `"drop_block"`.
Usa `"drop_block"` per far proseguire le conversazioni esistenti mentre contengono una modifica che stai correggendo, e per uno scarto pianificato, ad esempio [dopo un tuo riepilogo](https://platform.claude.com/docs/it/build-with-claude/compaction-thinking-blocks#own-summary). Non lasciarlo attivo per nascondere una modifica che il tuo codice continua a effettuare. Puoi [smettere di inviarlo](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#drop-block-cost-details) quando i blocchi non validi non sono più nella cronologia.
## Trova cosa ha modificato il tuo codice
La modifica si trova prima del primo blocco che l’API indica. L’errore 400 può dire cosa è cambiato, ad esempio `system`, `tools`, un blocco di ragionamento mancante o il primo messaggio che differisce. Senza errore, o con uno che non lo dice, [parti da ciò che hai](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#find-the-change-details), ad esempio una voce `prefix_binding_mismatch` o più token di output.
## Testa il tuo codice per i casi in cui non supera il controllo del prefisso
Puoi fidarti di un test dopo averlo visto fallire. Per prima cosa, tramite il tuo codice, esegui una sessione che faccia ragionare Claude e modifica qualcosa di proposito. Invia `"drop_block"` per questo passaggio, in modo che la risposta elenchi ogni blocco non valido invece di fermarsi al primo, come mostrano [cinque passaggi e un programma](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#how-to-tell-whether-your-integration-is-impacted-details).
Poi togli quella modifica ed esegui le tue sessioni reali. Su ogni richiesta, invia l’header beta `thinking-binding-controls-2026-08-01` e imposta [`prefix_mismatch_behavior`](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking/prefix-checks#preserved-thinking-controls) su `"error"`, in modo che una modifica effettuata dal tuo codice in quelle sessioni faccia fallire la build con l’errore 400.
Testa sessioni che eseguono la compattazione, aggiungono strumenti in ritardo, cambiano le istruzioni, [cambiano modello](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking#switching-models) o vengono riprese: i turni semplici non raggiungono quel codice.
Un’esecuzione pulita non ha alcuna voce `prefix_binding_mismatch` né errori. Mostra solo che i blocchi che ha controllato sono validi, nelle sessioni che hai eseguito. Non dimostra nulla se:
* la sessione non aveva blocchi di ragionamento
* il tuo codice rimuove tutto il ragionamento, oppure il modello non ha il ragionamento preservato
* non hai inviato l’header beta e [il modello potrebbe lasciar passare i blocchi che non superano il controllo del prefisso](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking/prefix-checks#outcomes) senza un errore
## Monitora la produzione e trova il ragionamento perso senza errori
Registra ogni errore 400 e [gestiscilo nel codice](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#handle-the-error-in-code) in modo che la conversazione prosegua. Se invece lasci `prefix_mismatch_behavior` non specificato, [monitora il traffico di produzione](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking/prefix-checks#watch-production-traffic) per individuare il ragionamento che non supera il controllo del prefisso e che ha raggiunto Claude.
Il ragionamento può andare perso senza errori tramite `"drop_block"`, un elemento di un batch, un cambio di modello, il passaggio a [un altro account](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking#account-bound-thinking) o un codice che non rinvia alcun ragionamento. Con l’header beta, ognuno di questi lascia una voce, tranne l’ultimo. Per quello, verifica che le tue richieste contengano blocchi `thinking`.
## Dettagli tecnici
### Cos’altro può dire il messaggio di errore
Il messaggio di errore prosegue indicando cosa è cambiato, dove l’API è in grado di stabilirlo, ad esempio `system`, `tools`, il primo messaggio o blocco che differisce, contenuto mancante o nuovo, oppure un blocco di ragionamento precedente mancante o fuori ordine. La formulazione di quella frase può cambiare, quindi non basarti su di essa per il confronto. Se la richiesta non aveva l’header beta, il messaggio di errore aggiunge questa frase:
```text wrap
That setting requires the `thinking-binding-controls-2026-08-01` value in the `anthropic-beta` header.
```
### L’errore chiede ancora l’header, oppure dice `Extra inputs are not permitted`
Se l’errore chiede ancora l’header, l’header non ha raggiunto l’API: un proxy o una libreria potrebbe averlo rimosso. Un errore diverso, che termina con `block_binding: Extra inputs are not permitted`, significa la stessa cosa, oppure che il ragionamento è disattivato.
### Rimuovi a mano il ragionamento non valido
Usa questo metodo dove non puoi inviare l’impostazione, o in uno di questi casi:
* Dopo aver rimosso un segreto, dati personali o testo iniettato, perché `"drop_block"` lascia il ragionamento nella tua cronologia memorizzata.
* Quando il ragionamento è disattivato (`"disabled"` o `"between_tools"`), perché `"drop_block"` richiede `"adaptive"`, che attiverebbe il ragionamento e aggiungerebbe token di output.
1. Rimuovi il blocco indicato dall’errore e ogni blocco `thinking` e [`redacted_thinking`](https://platform.claude.com/docs/it/build-with-claude/thinking#redacted-thinking-blocks) successivo, altrimenti lo stesso errore indicherà poi il successivo blocco non valido. Ma se la tua cronologia contiene messaggi `role: "system"`, o due messaggi dello stesso ruolo di seguito, rimuovi ogni blocco `thinking` e `redacted_thinking`. L’errore conta un messaggio di questo tipo come parte del messaggio precedente, quindi la posizione che indica può essere inferiore all’indice nel tuo array. Il `path` di una voce `input_transformations` conta ogni messaggio separatamente.
2. Mantieni ogni altro blocco e invia di nuovo la richiesta. Non reinserire i blocchi rimossi.
### Errori simili a questo
Questi errori non dicono che il blocco è vincolato a una conversazione diversa, e impostare `prefix_mismatch_behavior` potrebbe non risolverli:
* Un messaggio che si ferma dopo “Invalid `signature` in `thinking` block”, dice “cannot be modified” o riguarda `budget_tokens`: [Risoluzione dei problemi del ragionamento](https://platform.claude.com/docs/it/build-with-claude/thinking-troubleshooting)
* Un messaggio su `temperature` o su una risposta precompilata: [Limiti e compatibilità delle funzionalità](https://platform.claude.com/docs/it/build-with-claude/thinking#limits-and-feature-compatibility)
### Quando puoi smettere di inviare `"drop_block"`
Per smettere di inviare `"drop_block"`, rimuovi i blocchi che scarta e mantieni il ragionamento prodotto da allora. Se non è cambiato nient’altro, la conversazione supera quindi il controllo del prefisso con `"error"`.
### Gestisci l’errore nel codice
Per gestire l’errore nel codice, invia l’header beta e `"error"` su ogni richiesta, in modo che il mancato superamento del controllo del prefisso sia un errore 400 su ogni modello. Quando arriva, passa solo quella conversazione a `"drop_block"` per ogni richiesta successiva, memorizza quella scelta insieme alla conversazione, invia di nuovo una volta e registra l’errore. Se lo stesso errore si ripresenta, l’impostazione non ha raggiunto l’API: consulta [L’errore chiede ancora l’header, oppure dice `Extra inputs are not permitted`](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#setting-not-received).
Il tuo codice deve riconoscere questo errore tramite il suo campo `message`, l’eccezione al consiglio generale di non basarsi sul testo di un errore. Ogni errore 400 ha il tipo `invalid_request_error`, e questo non ha alcun `error.details.error_code`. Confronta solo “The block is bound to a different conversation”, perché il resto del messaggio può cambiare.
### Non hai alcun errore, oppure ne hai uno che non dice cosa è cambiato
* **L’errore 400, che non indica alcuna modifica:** Confronta tu stesso le richieste. Una causa è un blocco di compattazione inviato senza rimuovere i messaggi che riassume.
* **Una voce `prefix_binding_mismatch`:** Confronta `system`, `tools` e `messages` fino al `path` della prima voce con la conversazione com’era quando quel blocco è stato prodotto. Se ogni blocco è elencato, inizia da `system` e `tools`.
Se non differisce nulla, cerca [un URL di immagine o documento il cui contenuto è cambiato](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking/change-tools-or-instructions#files-by-id), un elenco di strumenti di un server MCP modificato (vedi [Fissa l’elenco degli strumenti di un server MCP](https://platform.claude.com/docs/it/agents-and-tools/mcp-connector#pin-mcp-tool-list)), oppure un blocco di ragionamento omesso, spostato o reinserito. Senza log delle richieste, invia di nuovo la richiesta con `"error"` e leggi la frase che dice cosa differisce, se presente.
* **Un proxy o una libreria non tuoi, nel mezzo:** Confronta ciò che invia con ciò che hai inviato tu, e indirizza chi lo mantiene a [Librerie, proxy e gateway](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking/change-tools-or-instructions#libraries-proxies-gateways).
* **Solo un sospetto, e niente Claude Code:** Cattura i corpi delle richieste di una conversazione, una con una compattazione o una modifica agli strumenti. Confronta ciascuno con il precedente, escludendo i suoi nuovi turni.
### Cinque passaggi per un test che può fallire, e un programma che li esegue
1. Nel tuo codice, invia l’header beta e `"drop_block"` su ogni richiesta di una sessione, a un [modello con ragionamento preservato](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking/prefix-checks#outcomes).
2. Usa prompt che facciano ragionare Claude e verifica che la prima risposta abbia un blocco `thinking`. Con il ragionamento adattivo, Claude può saltare il ragionamento su un prompt facile.
3. Fai fallire il test solo su una voce `input_transformations` il cui motivo è `prefix_binding_mismatch`. Un test che si aspetta un array vuoto fallisce anche dopo un cambio di modello, perché in quel caso sono previste voci con `model_binding_mismatch` o `organization_binding_mismatch`.
4. Modifica qualcosa di proposito, ad esempio aggiungendo un prompt `system` solo alla terza richiesta.
5. Verifica che `input_transformations` elenchi i blocchi di ragionamento che si trovano dopo la modifica. Se non ne elenca nessuno, verifica che la cronologia contenga un blocco di ragionamento.
Questo programma esegue i passaggi 1, 2, 4 e 5. Stampa quanti blocchi di ragionamento e quante voci `input_transformations` ha ogni risposta, poi ogni voce, che è ciò che verifica il passaggio 3:
Questo flusso di lavoro richiede più logica di un singolo comando shell. Usa l’[Anthropic SDK](https://platform.claude.com/docs/it/cli-sdks-libraries/overview) per eseguirlo.
Questo flusso di lavoro richiede più logica di un singolo comando shell. Usa l’[Anthropic SDK](https://platform.claude.com/docs/it/cli-sdks-libraries/overview) per eseguirlo.
```python Python
client = anthropic.Anthropic()
user_turns = [
"How many positive integers below 500 have exactly 6 positive divisors?",
"How many have exactly 8?",
"How many have exactly 10?",
]
messages = []
for turn, user_turn in enumerate(user_turns, start=1):
messages.append({"role": "user", "content": user_turn})
response = client.beta.messages.create(
model="claude-opus-5-5",
max_tokens=16000,
thinking={
"type": "adaptive",
"block_binding": {"prefix_mismatch_behavior": "drop_block"},
},
# Solo l'ultima richiesta aggiunge un prompt di sistema, che modifica il prefisso di proposito
system="Answer briefly." if turn == len(user_turns) else anthropic.omit,
messages=messages,
betas=["thinking-binding-controls-2026-08-01"],
)
messages.append({"role": "assistant", "content": response.content})
thinking_blocks = sum(block.type == "thinking" for block in response.content)
entries = response.input_transformations or []
print(f"thinking blocks: {thinking_blocks}, entries: {len(entries)}")
for entry in entries:
if entry.type == "thinking_dropped":
print(entry.type, entry.path, entry.reason)
```
```typescript TypeScript
const client = new Anthropic();
const userTurns = [
"How many positive integers below 500 have exactly 6 positive divisors?",
"How many have exactly 8?",
"How many have exactly 10?"
];
const messages: Anthropic.Beta.BetaMessageParam[] = [];
for (const [turnIndex, userTurn] of userTurns.entries()) {
messages.push({ role: "user", content: userTurn });
const response = await client.beta.messages.create({
model: "claude-opus-5-5",
max_tokens: 16000,
thinking: {
type: "adaptive",
block_binding: { prefix_mismatch_behavior: "drop_block" }
},
// Solo l'ultima richiesta aggiunge un prompt di sistema, che modifica il prefisso di proposito
system: turnIndex === userTurns.length - 1 ? "Answer briefly." : undefined,
messages,
betas: ["thinking-binding-controls-2026-08-01"]
});
messages.push({ role: "assistant", content: response.content });
const thinkingBlocks = response.content.filter((block) => block.type === "thinking");
const entries = response.input_transformations ?? [];
console.log(`thinking blocks: ${thinkingBlocks.length}, entries: ${entries.length}`);
for (const entry of entries) {
if (entry.type === "thinking_dropped") {
console.log(entry.type, entry.path, entry.reason);
}
}
}
```
```csharp C#
using Anthropic.Models.Beta;
using Anthropic.Models.Beta.Messages;
using Model = Anthropic.Models.Messages.Model;
AnthropicClient client = new();
string[] userTurns =
[
"How many positive integers below 500 have exactly 6 positive divisors?",
"How many have exactly 8?",
"How many have exactly 10?",
];
List messages = [];
foreach (var (turnIndex, userTurn) in userTurns.Index())
{
messages.Add(new BetaUserMessageParam { Content = userTurn });
var response = await client.Beta.Messages.Create(
new()
{
Model = Model.ClaudeOpus5_5,
MaxTokens = 16000,
Thinking = new BetaThinkingConfigAdaptive
{
BlockBinding = new()
{
PrefixMismatchBehavior = BetaThinkingPrefixMismatchBehavior.DropBlock,
},
},
// Solo l'ultima richiesta aggiunge un prompt di sistema, che modifica intenzionalmente il prefisso
System = turnIndex == userTurns.Length - 1 ? new("Answer briefly.") : null,
Messages = messages,
Betas = [AnthropicBeta.ThinkingBindingControls2026_08_01],
}
);
messages.Add(new BetaAssistantMessageParam
{
Content = response.Content.Select(block => new BetaContentBlockParam(block.Json)).ToList(),
});
var thinkingBlocks = response.Content.Count(block => block.TryPickThinking(out _));
var entries = response.InputTransformations ?? [];
Console.WriteLine($"thinking blocks: {thinkingBlocks}, entries: {entries.Count}");
foreach (var entry in entries)
{
if (entry.TryPickThinkingDropped(out var dropped))
{
Console.WriteLine($"{dropped.Type} {dropped.Path} {dropped.Reason.Raw()}");
}
}
}
```
```go Go
client := anthropic.NewClient()
userTurns := []string{
"How many positive integers below 500 have exactly 6 positive divisors?",
"How many have exactly 8?",
"How many have exactly 10?",
}
messages := []anthropic.BetaMessageParam{}
for turnIndex, userTurn := range userTurns {
messages = append(messages, anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock(userTurn)))
// Solo l'ultima richiesta aggiunge un prompt di sistema, che modifica il prefisso di proposito
var system []anthropic.BetaTextBlockParam
if turnIndex == len(userTurns)-1 {
system = []anthropic.BetaTextBlockParam{{Text: "Answer briefly."}}
}
response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 16000,
Thinking: anthropic.BetaThinkingConfigParamUnion{
OfAdaptive: &anthropic.BetaThinkingConfigAdaptiveParam{
BlockBinding: anthropic.BetaThinkingBlockBindingParam{
PrefixMismatchBehavior: anthropic.BetaThinkingPrefixMismatchBehaviorDropBlock,
},
},
},
System: system,
Messages: messages,
Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaThinkingBindingControls2026_08_01},
})
if err != nil {
log.Fatal(err)
}
messages = append(messages, response.ToParam())
thinkingBlocks := 0
for _, block := range response.Content {
if block.Type == "thinking" {
thinkingBlocks++
}
}
fmt.Printf("thinking blocks: %d, entries: %d\n", thinkingBlocks, len(response.InputTransformations))
for _, entry := range response.InputTransformations {
if entry.Type == "thinking_dropped" {
fmt.Println(entry.Type, entry.Path, entry.Reason)
}
}
}
```
```java Java
import com.anthropic.models.beta.AnthropicBeta;
import com.anthropic.models.beta.messages.BetaContentBlock;
import com.anthropic.models.beta.messages.BetaInputTransformation;
import com.anthropic.models.beta.messages.BetaMessage;
import com.anthropic.models.beta.messages.BetaThinkingBlockBinding;
import com.anthropic.models.beta.messages.BetaThinkingConfigAdaptive;
import com.anthropic.models.beta.messages.BetaThinkingPrefixMismatchBehavior;
import com.anthropic.models.beta.messages.MessageCreateParams;
import com.anthropic.models.messages.Model;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
List userTurns = List.of(
"How many positive integers below 500 have exactly 6 positive divisors?",
"How many have exactly 8?",
"How many have exactly 10?");
MessageCreateParams.Builder conversation = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(16000L)
.thinking(BetaThinkingConfigAdaptive.builder()
.blockBinding(BetaThinkingBlockBinding.builder()
.prefixMismatchBehavior(BetaThinkingPrefixMismatchBehavior.DROP_BLOCK)
.build())
.build())
.addBeta(AnthropicBeta.THINKING_BINDING_CONTROLS_2026_08_01);
for (int turnIndex = 0; turnIndex < userTurns.size(); turnIndex++) {
if (turnIndex == userTurns.size() - 1) {
// Solo l'ultima richiesta aggiunge un prompt di sistema, che modifica il prefisso di proposito
conversation.system("Answer briefly.");
}
conversation.addUserMessage(userTurns.get(turnIndex));
BetaMessage response = client.beta().messages().create(conversation.build());
conversation.addMessage(response);
long thinkingBlocks = response.content().stream()
.filter(BetaContentBlock::isThinking)
.count();
List entries = response.inputTransformations().orElse(List.of());
IO.println("thinking blocks: " + thinkingBlocks + ", entries: " + entries.size());
for (BetaInputTransformation entry : entries) {
entry.thinkingDropped().ifPresent(dropped ->
IO.println(entry.type() + " " + dropped.path() + " " + dropped.reason()));
}
}
}
```
```php PHP
use Anthropic\Beta\AnthropicBeta;
use Anthropic\Beta\Messages\BetaThinkingBlock;
use Anthropic\Beta\Messages\BetaThinkingBlockBinding;
use Anthropic\Beta\Messages\BetaThinkingConfigAdaptive;
use Anthropic\Beta\Messages\BetaThinkingDroppedInputTransformation;
use Anthropic\Beta\Messages\BetaThinkingPrefixMismatchBehavior;
use Anthropic\Client;
use Anthropic\Messages\Model;
$client = new Client();
$userTurns = [
'How many positive integers below 500 have exactly 6 positive divisors?',
'How many have exactly 8?',
'How many have exactly 10?',
];
$messages = [];
foreach ($userTurns as $turnIndex => $userTurn) {
$messages[] = ['role' => 'user', 'content' => $userTurn];
$response = $client->beta->messages->create(
model: Model::CLAUDE_OPUS_5_5,
maxTokens: 16000,
thinking: BetaThinkingConfigAdaptive::with(
blockBinding: BetaThinkingBlockBinding::with(
prefixMismatchBehavior: BetaThinkingPrefixMismatchBehavior::DROP_BLOCK,
),
),
// Solo l'ultima richiesta aggiunge un prompt di sistema, che modifica il prefisso di proposito
system: $turnIndex === array_key_last($userTurns) ? 'Answer briefly.' : null,
messages: $messages,
betas: [AnthropicBeta::THINKING_BINDING_CONTROLS_2026_08_01],
);
$messages[] = ['role' => 'assistant', 'content' => $response->content];
$thinkingBlocks = array_filter(
$response->content,
fn ($block) => $block instanceof BetaThinkingBlock,
);
$entries = $response->inputTransformations ?? [];
echo 'thinking blocks: ', count($thinkingBlocks), ', entries: ', count($entries), PHP_EOL;
foreach ($entries as $entry) {
if ($entry instanceof BetaThinkingDroppedInputTransformation) {
echo $entry->type, ' ', $entry->path, ' ', $entry->reason, PHP_EOL;
}
}
}
```
```ruby Ruby
client = Anthropic::Client.new
user_turns = [
"How many positive integers below 500 have exactly 6 positive divisors?",
"How many have exactly 8?",
"How many have exactly 10?"
]
messages = []
user_turns.each_with_index do |user_turn, turn_index|
messages << { role: "user", content: user_turn }
# Solo l'ultima richiesta aggiunge un prompt di sistema, che modifica di proposito il prefisso
system_param = (turn_index == user_turns.length - 1) ? { system_: "Answer briefly." } : {}
response = client.beta.messages.create(
model: Anthropic::Model::CLAUDE_OPUS_5_5,
max_tokens: 16_000,
thinking: {
type: "adaptive",
block_binding: { prefix_mismatch_behavior: "drop_block" }
},
messages: messages,
betas: [Anthropic::AnthropicBeta::THINKING_BINDING_CONTROLS_2026_08_01],
**system_param
)
messages << { role: "assistant", content: response.content }
thinking_blocks = response.content.count { |block| block.is_a?(Anthropic::Beta::BetaThinkingBlock) }
entries = response.input_transformations || []
puts "thinking blocks: #{thinking_blocks}, entries: #{entries.length}"
entries.each do |entry|
if entry.is_a?(Anthropic::Beta::BetaThinkingDroppedInputTransformation)
puts "#{entry.type} #{entry.path} #{entry.reason}"
end
end
end
```
```text Output wrap
thinking blocks: 1, entries: 0
thinking blocks: 1, entries: 0
thinking blocks: 1, entries: 2
thinking_dropped messages.1.content.0 prefix_binding_mismatch
thinking_dropped messages.3.content.0 prefix_binding_mismatch
```
Con `"error"` al posto di `"drop_block"`, la terza richiesta riceve [l’errore 400](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#prefix-mismatch-error).
### Cosa significa ogni voce `input_transformations` e quali spetta a te correggere
Con l’header beta, una risposta da un modello che supporta il ragionamento ha l’array `input_transformations` accanto a `usage`. È vuoto quando non è stato scartato nulla e non è stato lasciato passare nulla di non valido. Quando usi lo streaming, si trova nel `message` dell’evento `message_start`; dopo un fallback a metà stream, l’evento `message_delta` finale contiene quello che conta. A differenza della posizione indicata nell’errore, `path` è sempre la posizione del blocco così come l’hai inviato:
```json
{
"input_transformations": [
{
"type": "thinking_dropped",
"path": "messages.1.content.0",
"reason": "prefix_binding_mismatch"
}
]
}
```
Il `type` e il `reason` di ogni voce, e cosa significano:
* **`thinking_dropped`, `prefix_binding_mismatch`:** Ciò che precedeva questo blocco non è ciò che il blocco ha registrato. Spetta a te correggerlo: [Trova cosa ha modificato il tuo codice](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#find-the-change).
* **`thinking_mismatch_allowed`, `prefix_binding_mismatch`:** Lo stesso, ma Claude ha letto il blocco invariato, e viene fatturato. Questa voce compare solo quando l’impostazione non è specificata, su [alcuni modelli](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking/prefix-checks#outcomes). Spetta a te correggerlo.
* **`thinking_dropped`, `model_binding_mismatch`:** Questo modello non può leggere i blocchi del modello che ha prodotto il blocco. Non spetta a te correggerlo: [continua a inviare l’intera conversazione](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking#switching-models).
* **`thinking_dropped`, `organization_binding_mismatch`:** Un altro account ha prodotto il blocco, quindi [l’API lo ha scartato](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking#account-bound-thinking). Non spetta a te correggerlo.
Ignora una voce il cui `type` o `reason` non riconosci.
### Batch e conteggio dei token
* **[Message Batches](https://platform.claude.com/docs/it/build-with-claude/batch-processing):** Un elemento che lascia `prefix_mismatch_behavior` non specificato non riceve mai l’errore 400. L’API scarta i blocchi non validi oppure, su [alcuni modelli](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking/prefix-checks#outcomes), può lasciarli passare. Un elemento che imposta `"error"` si risolve come `errored` quando un blocco non supera il controllo del prefisso. `block_binding` va nei `params.thinking` dell’elemento.
* **[Conteggio dei token](https://platform.claude.com/docs/it/build-with-claude/token-counting):** Sulla Claude API, il conteggio dei token può restituire lo stesso errore 400 e accetta `prefix_mismatch_behavior` con lo stesso header. Esclude dal conteggio i blocchi scartati e non restituisce `input_transformations`.
## Passaggi successivi
Cosa inviare al posto di ogni modifica che il tuo codice apporta a una conversazione.
Cos’è il ragionamento preservato, a cosa è legato un blocco di ragionamento e come cambiare modello o account.
Soluzioni per altri errori di ragionamento, come una firma che non viene verificata.