---
title: Verificações de prefixo em blocos de pensamento
url: https://platform.claude.com/docs/pt-BR/build-with-claude/preserved-thinking/prefix-checks
description: O que a verificação de prefixo compara, quais modelos a executam, o que acontece quando uma requisição falha nela e como lidar com o erro 400 e com o caso sem erro.
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
---
Cada requisição que envia blocos de pensamento de volta a um [modelo com pensamento preservado](https://platform.claude.com/docs/pt-BR/build-with-claude/preserved-thinking/prefix-checks#outcomes) passa por uma “prefix check” (verificação de prefixo). Uma verificação de prefixo falha se `system`, `tools` ou uma mensagem anterior mudou depois que Claude produziu um bloco. Ela também falha se um bloco de pensamento entre outros foi deixado de fora ou movido.
Falhar na verificação de prefixo pode ou não resultar em um erro 400, [dependendo do modelo](https://platform.claude.com/docs/pt-BR/build-with-claude/preserved-thinking/prefix-checks#outcomes), então [trate os dois casos](https://platform.claude.com/docs/pt-BR/build-with-claude/preserved-thinking/prefix-checks#handle-either-outcome).
## A quem a verificação de prefixo afeta
Você não tem nada a mudar se uma destas afirmações for verdadeira:
* Claude Code, claude.ai ou Claude Managed Agents gerencia o seu histórico de conversa.
* O Claude Agent SDK gerencia o histórico, e o prompt do sistema que você fornece ao SDK permanece o mesmo.
* O seu código segue [os três hábitos de uma integração append-only](https://platform.claude.com/docs/pt-BR/build-with-claude/preserved-thinking/prefix-checks#prefix-check), e nada reescreve as requisições dele no caminho.
* Você não chama nenhum [modelo com pensamento preservado](https://platform.claude.com/docs/pt-BR/build-with-claude/preserved-thinking/prefix-checks#outcomes).
Se as suas requisições passam por uma biblioteca, proxy ou gateway, [compare o que ele envia com o que você enviou](https://platform.claude.com/docs/pt-BR/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#find-the-change-details). Se você opera um, consulte [Bibliotecas, proxies e gateways](https://platform.claude.com/docs/pt-BR/build-with-claude/preserved-thinking/change-tools-or-instructions#libraries-proxies-gateways) para saber o que repassar.
## O que deve permanecer igual, e por quê
Torne a sua integração “append-only” (somente acréscimo). Três hábitos fazem isso:
1. Envie cada turno do assistente de volta exatamente como a API o retornou, incluindo blocos de pensamento cujo texto está vazio.
2. Construa `system` e `tools` uma vez para cada conversa e envie essa cópia todas as vezes.
3. Coloque cada atualização em uma nova mensagem no final e deixe-a lá.
O raciocínio de cada bloco de pensamento trata exatamente do que veio antes dele: `system`, `tools` e cada mensagem anterior. Esse conteúdo é o *prefixo* do bloco, e é o que a [verificação de prefixo](https://platform.claude.com/docs/pt-BR/build-with-claude/preserved-thinking/prefix-checks#prefix-check-details) compara.
A verificação de prefixo é semelhante ao cache de prompt, exceto que uma mudança torna inválido o pensamento posterior a ela, em vez de apenas perder o cache.
Considere um app que coloca a data de hoje no seu prompt do sistema. À meia-noite a data muda, e com ela o prefixo do pensamento que já está na conversa. Esse pensamento se torna inválido, e a próxima requisição pode falhar. Um app append-only mantém o prompt do sistema como estava e informa a nova data em [uma mensagem no final](https://platform.claude.com/docs/pt-BR/build-with-claude/preserved-thinking/change-tools-or-instructions#changing-context).
Uma mudança torna inválido apenas o pensamento que já vem depois dela. O pensamento anterior a ela e o pensamento que Claude produz em seguida permanecem válidos.
## Se o seu código altera o prompt do sistema, as ferramentas ou o histórico
| Se o seu código… | O que fazer |
| ---------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Reconstrói o prompt do sistema com a data, um modo ou arquivos de instruções | Pare de alterar `system`. [Acrescente as suas próprias instruções como uma mensagem de sistema](https://platform.claude.com/docs/pt-BR/build-with-claude/preserved-thinking/change-tools-or-instructions#new-instructions), uma entrada `role: "system"` em `messages`, e [informe novos valores no turno mais recente](https://platform.claude.com/docs/pt-BR/build-with-claude/preserved-thinking/change-tools-or-instructions#changing-context). Para texto que outras pessoas podem editar, consulte [Texto que outras pessoas podem editar](https://platform.claude.com/docs/pt-BR/build-with-claude/preserved-thinking/change-tools-or-instructions#untrusted-text) em vez disso. |
| Adiciona, remove ou reformula uma ferramenta, ou ganha ferramentas quando um servidor MCP se conecta | Pare de alterar `tools` e [adicione ou remova ferramentas em uma mensagem de sistema](https://platform.claude.com/docs/pt-BR/build-with-claude/preserved-thinking/change-tools-or-instructions#tool-changes). |
| Corta, condensa ou resume turnos mais antigos e mantém os mais recentes inalterados | [Deixe a API escrever o resumo, ou remova o pensamento dos turnos mantidos](https://platform.claude.com/docs/pt-BR/build-with-claude/preserved-thinking/change-tools-or-instructions#server-side-trimming). |
Outras causas, como pular blocos de pensamento cujo texto está vazio ou reconstruir uma conversa salva, têm correções próprias: consulte [Altere ferramentas ou instruções sem falhar na verificação de prefixo](https://platform.claude.com/docs/pt-BR/build-with-claude/preserved-thinking/change-tools-or-instructions). Para encontrar a sua, [peça a um agente que verifique o seu código](https://platform.claude.com/docs/pt-BR/build-with-claude/preserved-thinking#hand-to-an-agent).
## O que cada modelo faz quando a verificação de prefixo falha
Na Claude API e em [algumas plataformas de nuvem](https://platform.claude.com/docs/pt-BR/build-with-claude/preserved-thinking#feature-availability), o resultado de falhar na verificação de prefixo com [`prefix_mismatch_behavior`](https://platform.claude.com/docs/pt-BR/build-with-claude/preserved-thinking/prefix-checks#preserved-thinking-controls) omitido da requisição depende do modelo:
| Modelo com pensamento preservado | Resultado |
| -------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- |
| Claude Fable 5.2 | Erro 400 |
| Claude Mythos 5.2 | Erro 400 |
| Claude Mythos 5.1 | Erro 400 |
| Claude Fable 5.1 | [Possível erro 400](https://platform.claude.com/docs/pt-BR/build-with-claude/preserved-thinking/prefix-checks#possible-400-error) |
| Claude Opus 5.5 | [Possível erro 400](https://platform.claude.com/docs/pt-BR/build-with-claude/preserved-thinking/prefix-checks#possible-400-error) |
| Claude Sonnet 5.5 | [Possível erro 400](https://platform.claude.com/docs/pt-BR/build-with-claude/preserved-thinking/prefix-checks#possible-400-error) |
| Claude Haiku 5.5 | [Possível erro 400](https://platform.claude.com/docs/pt-BR/build-with-claude/preserved-thinking/prefix-checks#possible-400-error) |
Onde a tabela diz “Possível erro 400”, há dois casos: uma requisição que falha na verificação de prefixo pode receber um erro 400 ou nenhum erro. Quando nenhum erro é retornado, os blocos que falharam chegam ao modelo. Claude os lê como qualquer outra entrada, você é cobrado por eles, e Claude trabalha a partir de um raciocínio sobre conteúdo que, desde então, mudou.
Nesses modelos, você pode [verificar qual caso uma requisição recebe](https://platform.claude.com/docs/pt-BR/build-with-claude/preserved-thinking/prefix-checks#check-which-case), mas [trate os dois casos](https://platform.claude.com/docs/pt-BR/build-with-claude/preserved-thinking/prefix-checks#handle-either-outcome).
Um código que segue [os três hábitos de uma integração append-only](https://platform.claude.com/docs/pt-BR/build-with-claude/preserved-thinking/prefix-checks#prefix-check) não causa falhas na verificação de prefixo.
[Itens de Message Batches](https://platform.claude.com/docs/pt-BR/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#batches) que deixam `prefix_mismatch_behavior` omitido da requisição não recebem erro, e a API pode descartar os blocos que falharam.
## Trate os dois casos
Para ter um único resultado em todas as requisições, torne a sua integração append-only ou defina `prefix_mismatch_behavior`. Caso contrário, o seu código deve lidar com os dois comportamentos.
* **Append-only:** com [os três hábitos](https://platform.claude.com/docs/pt-BR/build-with-claude/preserved-thinking/prefix-checks#prefix-check), o seu código não faz uma requisição falhar na verificação de prefixo.
* **A configuração:** com `"error"` em todas as requisições, cada falha é um erro 400, e você [o captura no código](https://platform.claude.com/docs/pt-BR/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#handle-the-error-in-code).
* **Os dois comportamentos:** se você deixar a configuração omitida da requisição, capture o erro 400 e [fique atento a pensamento que falhou na verificação de prefixo e chegou a Claude](https://platform.claude.com/docs/pt-BR/build-with-claude/preserved-thinking/prefix-checks#watch-production-traffic).
Após um erro 400, envie `"drop_block"` nas requisições posteriores dessa conversa para se recuperar. Isso tem um custo: consulte [Quanto custa descartar pensamento](https://platform.claude.com/docs/pt-BR/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#drop-block-cost). Não o envie em todas as suas conversas para esconder erros.
## Detalhes técnicos
### Como a verificação de prefixo funciona
Os modelos com pensamento preservado registram uma impressão digital do prefixo de cada bloco de pensamento em sua `signature`. A referência da API chama a verificação de prefixo de verificação de conversa, e o erro 400 diz que um bloco que falhou na verificação de prefixo `is bound to a different conversation`.
### Quais modelos executam a verificação de prefixo
A verificação de prefixo é executada na Claude API e em [algumas plataformas de nuvem](https://platform.claude.com/docs/pt-BR/build-with-claude/preserved-thinking#feature-availability). Ela verifica blocos de pensamento que um [modelo com pensamento preservado](https://platform.claude.com/docs/pt-BR/build-with-claude/preserved-thinking/prefix-checks#outcomes) produziu, em requisições a um desses modelos. Na Claude API, outros modelos, como Claude Opus 5, não a executam, e ela não abrange os blocos deles.
### O que conta como uma mudança
* **Cada bloco é verificado em relação ao seu próprio registro.** A API compara o que está antes de um bloco nesta requisição com o que a assinatura dele registrou quando Claude o produziu. A sua última requisição não participa disso. A verificação de prefixo olha apenas para o conteúdo, não para sessões, IDs ou usuários. O mesmo conteúdo em uma nova requisição ou em uma bifurcação passa nela.
* **A verificação de prefixo compara o que você enviou, não o que Claude leu.** [Compactação em um limite de tokens](https://platform.claude.com/docs/pt-BR/build-with-claude/compaction-threshold) e edição de contexto alteram apenas o que Claude lê, então nunca contam. Após um bloco de compactação por limite, a API compara apenas as mensagens a partir desse bloco, mais `system` e `tools`. A compactação sob demanda tem condições próprias: consulte [Condições para que o pensamento mantido permaneça válido](https://platform.claude.com/docs/pt-BR/build-with-claude/compaction-thinking-blocks#conditions-for-kept-thinking-to-stay-valid). Para um arquivo enviado por URL e, na Claude API, para [uma lista de ferramentas MCP](https://platform.claude.com/docs/pt-BR/agents-and-tools/mcp-connector#pin-mcp-tool-list), a API compara, em vez disso, o que ela buscou.
* **O pensamento que você envia deve ser uma sequência ininterrupta.** Blocos de pensamento não são comparados como conteúdo. Mas cada um que você envia, exceto o primeiro, deve ter o mesmo bloco de pensamento anterior que tinha quando Claude o produziu. Assim, você pode [deixar de fora o mais antigo, o mais recente ou todos eles](https://platform.claude.com/docs/pt-BR/build-with-claude/preserved-thinking/change-tools-or-instructions#leave-out-thinking), mas não um no meio.
Uma mudança pode ser tão pequena quanto uma palavra da descrição de uma ferramenta. Alterar, inserir, mover ou excluir uma mensagem anterior conta, qualquer que seja o seu papel. O mesmo vale para alterar texto antes de um bloco de pensamento na própria mensagem dele.
### O que não conta
| Isto não conta | Porque |
| -------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------- |
| `model`, `effort`, `max_tokens`, `tool_choice`, `metadata`, `thinking.display` e outros parâmetros | Apenas `system`, `tools` e as mensagens são comparados |
| Formatação JSON ou ordem das chaves | A API compara o JSON analisado, não o seu texto |
| Marcadores `cache_control` | Eles dizem onde armazenar em cache e não são conteúdo que Claude lê |
| Uma ferramenta com `defer_loading: true` à qual nada fez referência | Ela não está no contexto de Claude até que algo faça referência a ela |
### Defina `prefix_mismatch_behavior`
O [cabeçalho beta](https://platform.claude.com/docs/pt-BR/api/beta-headers#beta-features-on-other-platforms) `thinking-binding-controls-2026-08-01` adiciona a configuração `thinking.block_binding.prefix_mismatch_behavior` e o array `input_transformations` da resposta.
| Valor | Se um bloco falhar na verificação de prefixo |
| ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `"error"` | A API rejeita a requisição com um erro 400 que nomeia o primeiro bloco inválido |
| `"drop_block"` | A API descarta os blocos inválidos, e a requisição é bem-sucedida. Você não é cobrado por esses blocos, mas [descartá-los pode custar mais](https://platform.claude.com/docs/pt-BR/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#drop-block-cost) |
| Não definido, ou `null` | [Depende do modelo](https://platform.claude.com/docs/pt-BR/build-with-claude/preserved-thinking/prefix-checks#outcomes) |
Blocos que falham na verificação de prefixo permanecem inválidos em todas as requisições posteriores que os enviam, enquanto a mudança estiver em vigor. A configuração atua apenas na requisição que a carrega. Com o pensamento desligado (`"disabled"` ou `"between_tools"`), enviá-la resulta em um erro 400 em todos os modelos.
A requisição a seguir define `prefix_mismatch_behavior` como `"drop_block"`. Em um primeiro turno não há pensamento a enviar de volta, então `input_transformations` volta vazio:
```bash cURL
curl https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2026-10-21" \
-H "anthropic-beta: thinking-binding-controls-2026-08-01" \
-H "content-type: application/json" \
-d '{
"model": "claude-opus-5-5",
"max_tokens": 16000,
"thinking": {
"type": "adaptive",
"block_binding": {
"prefix_mismatch_behavior": "drop_block"
}
},
"messages": [
{
"role": "user",
"content": "What is the greatest common divisor of 1071 and 462?"
}
]
}'
```
```bash CLI
ant beta:messages create --beta thinking-binding-controls-2026-08-01 <<'YAML'
model: claude-opus-5-5
max_tokens: 16000
thinking:
type: adaptive
block_binding:
prefix_mismatch_behavior: drop_block
messages:
- role: user
content: What is the greatest common divisor of 1071 and 462?
YAML
```
```python Python
client = anthropic.Anthropic()
response = client.beta.messages.create(
model="claude-opus-5-5",
max_tokens=16000,
thinking={
"type": "adaptive",
"block_binding": {"prefix_mismatch_behavior": "drop_block"},
},
messages=[
{
"role": "user",
"content": "What is the greatest common divisor of 1071 and 462?",
}
],
betas=["thinking-binding-controls-2026-08-01"],
)
for block in response.content:
if block.type == "text":
print(block.text)
print(f"Input transformations: {len(response.input_transformations or [])}")
```
```typescript TypeScript
const client = new Anthropic();
const response = await client.beta.messages.create({
model: "claude-opus-5-5",
max_tokens: 16000,
thinking: {
type: "adaptive",
block_binding: { prefix_mismatch_behavior: "drop_block" }
},
messages: [
{ role: "user", content: "What is the greatest common divisor of 1071 and 462?" }
],
betas: ["thinking-binding-controls-2026-08-01"]
});
for (const block of response.content) {
if (block.type === "text") {
console.log(block.text);
}
}
console.log(`Input transformations: ${response.input_transformations?.length ?? 0}`);
```
```csharp C#
using Anthropic.Models.Beta;
using Anthropic.Models.Beta.Messages;
using Model = Anthropic.Models.Messages.Model;
AnthropicClient client = new();
var response = await client.Beta.Messages.Create(
new()
{
Model = Model.ClaudeOpus5_5,
MaxTokens = 16000,
Thinking = new BetaThinkingConfigAdaptive
{
BlockBinding = new()
{
PrefixMismatchBehavior = BetaThinkingPrefixMismatchBehavior.DropBlock,
},
},
Messages =
[
new BetaUserMessageParam
{
Content = "What is the greatest common divisor of 1071 and 462?",
},
],
Betas = [AnthropicBeta.ThinkingBindingControls2026_08_01],
}
);
foreach (var block in response.Content)
{
if (block.TryPickText(out var textBlock))
{
Console.WriteLine(textBlock.Text);
}
}
Console.WriteLine($"Input transformations: {response.InputTransformations?.Count ?? 0}");
```
```go Go
client := anthropic.NewClient()
response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 16000,
Thinking: anthropic.BetaThinkingConfigParamUnion{
OfAdaptive: &anthropic.BetaThinkingConfigAdaptiveParam{
BlockBinding: anthropic.BetaThinkingBlockBindingParam{
PrefixMismatchBehavior: anthropic.BetaThinkingPrefixMismatchBehaviorDropBlock,
},
},
},
Messages: []anthropic.BetaMessageParam{
anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("What is the greatest common divisor of 1071 and 462?")),
},
Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaThinkingBindingControls2026_08_01},
})
if err != nil {
log.Fatal(err)
}
for _, block := range response.Content {
if textBlock, ok := block.AsAny().(anthropic.BetaTextBlock); ok {
fmt.Println(textBlock.Text)
}
}
fmt.Printf("Input transformations: %d\n", len(response.InputTransformations))
```
```java Java
import com.anthropic.models.beta.AnthropicBeta;
import com.anthropic.models.beta.messages.BetaMessage;
import com.anthropic.models.beta.messages.BetaThinkingBlockBinding;
import com.anthropic.models.beta.messages.BetaThinkingConfigAdaptive;
import com.anthropic.models.beta.messages.BetaThinkingPrefixMismatchBehavior;
import com.anthropic.models.beta.messages.MessageCreateParams;
import com.anthropic.models.messages.Model;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(16000L)
.addBeta(AnthropicBeta.THINKING_BINDING_CONTROLS_2026_08_01)
.thinking(BetaThinkingConfigAdaptive.builder()
.blockBinding(BetaThinkingBlockBinding.builder()
.prefixMismatchBehavior(BetaThinkingPrefixMismatchBehavior.DROP_BLOCK)
.build())
.build())
.addUserMessage("What is the greatest common divisor of 1071 and 462?")
.build();
BetaMessage response = client.beta().messages().create(params);
response.content().stream()
.flatMap(block -> block.text().stream())
.forEach(textBlock -> IO.println(textBlock.text()));
IO.println("Input transformations: "
+ response.inputTransformations().map(List::size).orElse(0));
}
```
```php PHP
use Anthropic\Beta\AnthropicBeta;
use Anthropic\Beta\Messages\BetaTextBlock;
use Anthropic\Beta\Messages\BetaThinkingBlockBinding;
use Anthropic\Beta\Messages\BetaThinkingConfigAdaptive;
use Anthropic\Beta\Messages\BetaThinkingPrefixMismatchBehavior;
use Anthropic\Client;
use Anthropic\Messages\Model;
$client = new Client();
$response = $client->beta->messages->create(
model: Model::CLAUDE_OPUS_5_5,
maxTokens: 16000,
thinking: BetaThinkingConfigAdaptive::with(
blockBinding: BetaThinkingBlockBinding::with(
prefixMismatchBehavior: BetaThinkingPrefixMismatchBehavior::DROP_BLOCK,
),
),
messages: [
['role' => 'user', 'content' => 'What is the greatest common divisor of 1071 and 462?'],
],
betas: [AnthropicBeta::THINKING_BINDING_CONTROLS_2026_08_01],
);
foreach ($response->content as $block) {
if ($block instanceof BetaTextBlock) {
echo $block->text, PHP_EOL;
}
}
echo 'Input transformations: ', count($response->inputTransformations ?? []), PHP_EOL;
```
```ruby Ruby
client = Anthropic::Client.new
response = client.beta.messages.create(
model: Anthropic::Model::CLAUDE_OPUS_5_5,
max_tokens: 16_000,
thinking: {
type: "adaptive",
block_binding: { prefix_mismatch_behavior: "drop_block" }
},
messages: [
{ role: "user", content: "What is the greatest common divisor of 1071 and 462?" }
],
betas: [Anthropic::AnthropicBeta::THINKING_BINDING_CONTROLS_2026_08_01]
)
response.content.each do |block|
puts block.text if block.is_a?(Anthropic::Beta::BetaTextBlock)
end
puts "Input transformations: #{response.input_transformations&.length || 0}"
```
### Monitore o tráfego de produção
Com `prefix_mismatch_behavior` omitido da requisição, uma requisição que falha na verificação de prefixo pode não receber erro em [alguns modelos](https://platform.claude.com/docs/pt-BR/build-with-claude/preserved-thinking/prefix-checks#outcomes). Os blocos de pensamento que falharam nela chegam, então, ao modelo. Para encontrar esses blocos no tráfego de produção, envie o cabeçalho beta `thinking-binding-controls-2026-08-01`, deixe a configuração omitida da requisição e registre em log o array `input_transformations` de cada resposta. O cabeçalho adiciona esse array e não altera o que o modelo recebe.
Cada um desses blocos recebe sua própria entrada `thinking_mismatch_allowed` nesse array. Uma entrada tem esta aparência:
```json
{
"input_transformations": [
{
"type": "thinking_mismatch_allowed",
"path": "messages.1.content.0",
"reason": "prefix_binding_mismatch"
}
]
}
```
Para encontrar a mudança, consulte [Encontre o que seu código alterou](https://platform.claude.com/docs/pt-BR/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#find-the-change).
### Verifique qual caso você recebe
Em [alguns modelos](https://platform.claude.com/docs/pt-BR/build-with-claude/preserved-thinking/prefix-checks#outcomes), uma requisição que falha na verificação de prefixo pode receber o erro 400 ou nenhum erro. Este teste mostra qual deles uma requisição recebe:
1. Pegue uma conversa que contenha um bloco de pensamento de um desses modelos. Altere ou adicione o prompt do sistema (`system`). O bloco então falha na verificação de prefixo, porque o prompt do sistema mudou depois que Claude produziu o bloco.
2. Envie-a ao mesmo modelo com o cabeçalho beta `thinking-binding-controls-2026-08-01` e deixe `prefix_mismatch_behavior` omitido da requisição.
A resposta é uma destas:
* **Um [erro 400](https://platform.claude.com/docs/pt-BR/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#prefix-mismatch-error) que diz `bound to a different conversation`:** A requisição recebeu o erro 400.
* **Uma resposta 200 cujo array `input_transformations` tem entradas `thinking_mismatch_allowed`:** A requisição não recebeu erro. Cada entrada nomeia um bloco de pensamento que falhou na verificação de prefixo e chegou a Claude.
* **Uma resposta 200 cujo array `input_transformations` está vazio:** Nenhum bloco falhou na verificação de prefixo, então o teste não mostra nada. Verifique se a conversa contém um bloco de pensamento desse modelo.
O resultado descreve aquela única requisição e não promete nada sobre as posteriores, então escreva o seu código para [tratar os dois casos](https://platform.claude.com/docs/pt-BR/build-with-claude/preserved-thinking/prefix-checks#handle-either-outcome).
## Próximos passos
O que enviar em vez de cada mudança que o seu código faz em uma conversa.
Recupere uma conversa que está falhando, encontre o que o seu código altera e teste se isso acabou.
O que é o pensamento preservado, a que um bloco de pensamento está vinculado e como trocar de modelo ou de conta.