--- title: Compactação e pensamento preservado url: https://platform.claude.com/docs/pt-BR/build-with-claude/compaction-thinking-blocks description: Quando os blocos de pensamento em turnos mantidos após a compactação sob demanda permanecem válidos em modelos com pensamento preservado, e como verificar. featureMetadata: status: beta betaHeader: compact-2026-09-04 supportedModels: - claude-fable-5-1 - claude-mythos-5-1 - claude-fable-5 - claude-mythos-5 - claude-mythos-preview - claude-opus-5-5 - claude-opus-5 - claude-sonnet-5-5 - claude-sonnet-5 - claude-haiku-5-5 - claude-opus-4-8 - claude-opus-4-7 - claude-opus-4-6 - claude-sonnet-4-6 supportedPlatforms: Claude API: beta Claude Platform on AWS: beta Claude Models on Google Cloud (Google managed): beta Microsoft Foundry: beta --- Ignore esta página, a menos que você envie “thinking blocks” (blocos de pensamento) de volta a um modelo com [“preserved thinking” (pensamento preservado)](https://platform.claude.com/docs/pt-BR/build-with-claude/preserved-thinking) e mantenha turnos após o bloco de “compaction” (compactação). “Kept turns” (turnos mantidos) são os turnos que seguem o bloco: turnos recentes que você deixou de fora da solicitação de compactação, como em [Compactação que mantém turnos recentes](https://platform.claude.com/docs/pt-BR/build-with-claude/compaction-keep-recent-turns), ou turnos que chegaram enquanto o resumo estava sendo escrito, como em [Compactação em segundo plano](https://platform.claude.com/docs/pt-BR/build-with-claude/compaction-background). Modelos com pensamento preservado verificam blocos de pensamento anteriores em relação à conversa que os produziu. Um resumo substitui parte dessa conversa, mas a verificação aceita a substituição quando a API escreveu o resumo, de modo que o pensamento nos turnos mantidos pode permanecer válido. ## Condições para que o pensamento mantido permaneça válido Os blocos de pensamento nos turnos mantidos permanecem válidos enquanto todas estas condições forem atendidas: * **A solicitação de compactação é executada em um modelo com pensamento preservado.** Esta condição abrange todas as solicitações de compactação desde que um bloco de pensamento foi produzido, não apenas a mais recente. Uma maneira de atendê-la é enviar todas as solicitações de compactação para o modelo que a conversa usa. * **Os turnos mantidos seguem diretamente as mensagens resumidas, e você os envia sem alterações.** Envie cada mensagem mantida exatamente como está no seu histórico. Não pule nem adicione uma mensagem entre a última mensagem resumida e a primeira mantida. A primeira mensagem mantida também deve ter um papel (role) diferente da última mensagem resumida, e não pode ser uma mensagem `role: "system"` no meio da conversa. Caso contrário, a API a mescla na última mensagem resumida. Uma maneira de acertar a primeira mensagem mantida é compactar exatamente as `messages` de uma solicitação que você já enviou. Os turnos mantidos então começam com a resposta de Claude a ela. * **`system` e as `tools` não marcadas com `defer_loading: true` não mudam.** Eles são os mesmos na solicitação de compactação e nas solicitações que produziram o pensamento mantido, e permanecem os mesmos nas solicitações seguintes. [Alterar o prompt do sistema ou as ferramentas](https://platform.claude.com/docs/pt-BR/build-with-claude/compaction-thinking-blocks#change-the-system-prompt-or-tools) explica como alterá-los com segurança. Se uma condição não for atendida, nada falha quando você compacta, e a API aceita o bloco de compactação em solicitações posteriores de qualquer forma. O que falha é o pensamento mantido, na primeira solicitação posterior que o envia. [O que a API faz com um bloco inválido](https://platform.claude.com/docs/pt-BR/build-with-claude/preserved-thinking#mismatch-behavior) descreve o que acontece então, e [Quando `prefix_mismatch_behavior` não está definido](https://platform.claude.com/docs/pt-BR/build-with-claude/preserved-thinking#enforcement) aborda solicitações que não definem o campo, incluindo itens de Message Batches. ## Compactar novamente sem quebrar pensamentos mais antigos Você pode [compactar novamente](https://platform.claude.com/docs/pt-BR/build-with-claude/compaction-on-demand#compact-again) e manter turnos: o novo bloco abrange o resumo antigo e todas as mensagens que o seguem na solicitação de compactação, e quaisquer turnos que você deixar de fora dessa solicitação são turnos mantidos do novo bloco. A primeira das [condições para o pensamento mantido](https://platform.claude.com/docs/pt-BR/build-with-claude/compaction-thinking-blocks#conditions-for-kept-thinking-to-stay-valid) conta todas as compactações desde que um bloco de pensamento foi produzido, então um turno que você mantém ao longo de duas compactações exige que ambas tenham sido executadas em um modelo com pensamento preservado. Compactações anteriores à produção de um bloco de pensamento não contam contra ele. O pensamento produzido depois que um bloco está em vigor fica vinculado a esse bloco e permanece válido em compactações posteriores que atendam às condições. ## Alterar o prompt do sistema ou as ferramentas Uma solicitação posterior pode usar um `system` diferente, `tools` diferentes ou um modelo diferente da solicitação de compactação, e a API ainda aceita o bloco. Essa alteração pode invalidar o pensamento nos turnos mantidos, mas não tem nenhum outro efeito. Para alterar `system` ou `tools` sem invalidar nenhum pensamento mantido, compacte primeiro a conversa inteira, para que nenhum turno seja mantido. Em seguida, altere-os na próxima solicitação. Para adicionar uma instrução ou alterar as ferramentas disponíveis sem mexer em `system` ou `tools`, anexe a alteração a `messages`, conforme descrito em [Fazer mudanças sem editar o prefixo](https://platform.claude.com/docs/pt-BR/build-with-claude/preserved-thinking#replace-prefix-edits). Mensagens de sistema no meio da conversa dentro dos turnos resumidos também são resumidas, então suas instruções de texto deixam de se aplicar após a substituição. Um nível de [esforço por mensagem](https://platform.claude.com/docs/pt-BR/build-with-claude/effort#change-effort-mid-conversation-beta) que elas definem também não é transferido: até que uma mensagem posterior defina um nível, os turnos são executados com o `output_config.effort` de nível superior da solicitação, ou com o padrão do modelo se você não definir um. Para manter uma instrução ou nível de esforço em vigor, declare-o novamente em uma mensagem `role: "system"` diretamente após o primeiro novo turno `user` que segue os turnos mantidos. Alterações de ferramentas dentro desses turnos são transferidas automaticamente quando a solicitação de compactação também inclui `inline-tools-2026-09-15`: o bloco retornado registra o efeito líquido delas em seu campo `tool_changes`, então envie o bloco de volta sem modificações. Se o bloco não tiver um campo `tool_changes`, declare novamente essas alterações de ferramentas da mesma forma. Uma mensagem de sistema colocada entre o bloco e os turnos mantidos quebra o pensamento deles. ## Verificar se o pensamento mantido continuou válido A resposta da compactação não informa se o pensamento mantido continua válido. A primeira solicitação após a substituição informa. Para verificar em seus testes: 1. Tenha uma conversa curta com o pensamento ativado. Use um modelo que execute a verificação de prefixo (consulte [Mantendo o prefixo inalterado](https://platform.claude.com/docs/pt-BR/build-with-claude/preserved-thinking#prefix-check)) e use-o em todas as etapas, porque um modelo que não consegue ler um bloco de pensamento o descarta sem erro. 2. Compacte os turnos mais antigos e mantenha pelo menos um turno que contenha um bloco de pensamento. 3. Envie a próxima solicitação, com o bloco primeiro, depois o turno mantido, depois uma nova mensagem `user`, e com `thinking.block_binding.prefix_mismatch_behavior` definido como `"error"`. 4. Leia o resultado. Uma resposta 200 cujo array `input_transformations` está vazio significa que nenhum bloco de pensamento falhou na verificação ou foi descartado. Um erro 400 que diz que o bloco está vinculado a uma conversa diferente significa que algum falhou. A mensagem começa com o caminho do primeiro bloco que falhou, e [O que a API faz com um bloco inválido](https://platform.claude.com/docs/pt-BR/build-with-claude/preserved-thinking#mismatch-behavior) a mostra por completo. O campo `prefix_mismatch_behavior` precisa do cabeçalho beta `thinking-binding-controls-2026-08-01` além do [cabeçalho beta `compact-2026-09-04`](https://platform.claude.com/docs/pt-BR/build-with-claude/compaction-on-demand#request-a-summary). O valor que uma requisição define se aplica em qualquer conta. O programa a seguir executa as quatro etapas. Ele imprime quantos blocos de pensamento o turno mantido contém e quantas entradas `input_transformations` tem; nenhuma entrada significa que o pensamento mantido continuou válido: ```python Python from anthropic.types.beta import BetaMessageParam, BetaThinkingConfigParam client = anthropic.Anthropic() # Claude Fable 5.1 é o primeiro modelo que verifica o pensamento reenviado em relação à conversa. MODEL = "claude-fable-5-1" BETAS = ["compact-2026-09-04", "thinking-binding-controls-2026-08-01"] SYSTEM = "You help plan a recipe app's release. Keep answers short." # Com "error", um bloco de pensamento que falha na verificação faz a requisição falhar com um 400. THINKING: BetaThinkingConfigParam = { "type": "adaptive", "block_binding": {"prefix_mismatch_behavior": "error"}, } # 1. Tenha uma conversa curta com o pensamento ativado. history: list[BetaMessageParam] = [ {"role": "user", "content": "What are the main entities in the app's data model?"} ] first = client.beta.messages.create( model=MODEL, max_tokens=8192, system=SYSTEM, betas=BETAS, thinking=THINKING, messages=history, ) history += [ {"role": "assistant", "content": first.content}, { "role": "user", "content": "Testing starts on Tuesday, March 3, 2026, takes 10 weekdays, and pauses on March 9 and March 16. On which date does it end?", }, ] second = client.beta.messages.create( model=MODEL, max_tokens=8192, system=SYSTEM, betas=BETAS, thinking=THINKING, messages=history, ) history.append({"role": "assistant", "content": second.content}) thinking_blocks = sum(block.type == "thinking" for block in second.content) print(f"Thinking blocks in the kept turn: {thinking_blocks}") # 2. Resuma o primeiro turno. O segundo turno fica fora da requisição. summary = client.beta.messages.create( model=MODEL, max_tokens=4096, system=SYSTEM, betas=BETAS, thinking=THINKING, messages=history[:2], compaction={"type": "summarize"}, ) if summary.stop_reason != "compaction": raise SystemExit(f"No summary: {summary.stop_reason}") # 3. Coloque o bloco antes do turno mantido e faça a próxima pergunta. history = [ {"role": "assistant", "content": summary.content}, *history[2:], {"role": "user", "content": "Which day should the release go out?"}, ] third = client.beta.messages.create( model=MODEL, max_tokens=8192, system=SYSTEM, betas=BETAS, thinking=THINKING, messages=history, ) # 4. Um 200 sem blocos descartados significa que o pensamento mantido foi aceito. print(f"Dropped thinking blocks: {len(third.input_transformations)}") ``` ```typescript TypeScript const client = new Anthropic(); // Claude Fable 5.1 é o primeiro modelo que verifica o pensamento reenviado em relação à conversa. const model: Anthropic.Model = "claude-fable-5-1"; const betas: Anthropic.Beta.AnthropicBeta[] = [ "compact-2026-09-04", "thinking-binding-controls-2026-08-01" ]; const systemPrompt = "You help plan a recipe app's release. Keep answers short."; // Com "error", um bloco de pensamento que falha na verificação faz a requisição falhar com um 400. const thinking: Anthropic.Beta.Messages.BetaThinkingConfigParam = { type: "adaptive", block_binding: { prefix_mismatch_behavior: "error" } }; // 1. Tenha uma conversa curta com o pensamento ativado. let history: Anthropic.Beta.Messages.BetaMessageParam[] = [ { role: "user", content: "What are the main entities in the app's data model?" } ]; const first = await client.beta.messages.create({ model, max_tokens: 8192, system: systemPrompt, betas, thinking, messages: history }); history.push( { role: "assistant", content: first.content }, { role: "user", content: "Testing starts on Tuesday, March 3, 2026, takes 10 weekdays, and pauses on March 9 and March 16. On which date does it end?" } ); const second = await client.beta.messages.create({ model, max_tokens: 8192, system: systemPrompt, betas, thinking, messages: history }); history.push({ role: "assistant", content: second.content }); const thinkingBlocks = second.content.filter((block) => block.type === "thinking").length; console.log(`Thinking blocks in the kept turn: ${thinkingBlocks}`); // 2. Resuma o primeiro turno. O segundo turno fica fora da requisição. const summary = await client.beta.messages.create({ model, max_tokens: 4096, system: systemPrompt, betas, thinking, messages: history.slice(0, 2), compaction: { type: "summarize" } }); if (summary.stop_reason !== "compaction") { throw new Error(`No summary: ${summary.stop_reason}`); } // 3. Coloque o bloco antes do turno mantido e faça a próxima pergunta. history = [ { role: "assistant", content: summary.content }, ...history.slice(2), { role: "user", content: "Which day should the release go out?" } ]; const third = await client.beta.messages.create({ model, max_tokens: 8192, system: systemPrompt, betas, thinking, messages: history }); // 4. Um 200 sem blocos descartados significa que o pensamento mantido foi aceito. console.log(`Dropped thinking blocks: ${third.input_transformations?.length ?? 0}`); ``` ```csharp C# using Anthropic.Models.Beta; using Anthropic.Models.Beta.Messages; using Model = Anthropic.Models.Messages.Model; AnthropicClient client = new(); // Claude Fable 5.1 é o primeiro modelo que verifica o pensamento reenviado em relação à conversa. const Model ModelId = Model.ClaudeFable5_1; AnthropicBeta[] betas = [AnthropicBeta.Compact2026_09_04, AnthropicBeta.ThinkingBindingControls2026_08_01]; const string SystemPrompt = "You help plan a recipe app's release. Keep answers short."; // Com "error", um bloco de pensamento que falha na verificação faz a requisição falhar com um 400. BetaThinkingConfigAdaptive thinking = new() { BlockBinding = new() { PrefixMismatchBehavior = BetaThinkingPrefixMismatchBehavior.Error }, }; // 1. Tenha uma conversa curta com o pensamento ativado. List history = [ new BetaUserMessageParam { Content = "What are the main entities in the app's data model?" }, ]; var first = await client.Beta.Messages.Create(new MessageCreateParams { Model = ModelId, MaxTokens = 8192, System = SystemPrompt, Betas = [.. betas], Thinking = thinking, Messages = history, }); history.AddRange( [ new BetaAssistantMessageParam { Content = first.Content.Select(block => new BetaContentBlockParam(block.Json)).ToList(), }, new BetaUserMessageParam { Content = "Testing starts on Tuesday, March 3, 2026, takes 10 weekdays, and pauses on March 9 and March 16. On which date does it end?", }, ]); var second = await client.Beta.Messages.Create(new MessageCreateParams { Model = ModelId, MaxTokens = 8192, System = SystemPrompt, Betas = [.. betas], Thinking = thinking, Messages = history, }); history.Add(new BetaAssistantMessageParam { Content = second.Content.Select(block => new BetaContentBlockParam(block.Json)).ToList(), }); var thinkingBlocks = second.Content.Count(block => block.TryPickThinking(out _)); Console.WriteLine($"Thinking blocks in the kept turn: {thinkingBlocks}"); // 2. Resuma o primeiro turno. O segundo turno fica fora da requisição. var summary = await client.Beta.Messages.Create(new MessageCreateParams { Model = ModelId, MaxTokens = 4096, System = SystemPrompt, Betas = [.. betas], Thinking = thinking, Messages = history[..2], Compaction = new BetaCompactionConfig(), // type defaults to "summarize" }); if (summary.StopReason != BetaStopReason.Compaction) { throw new InvalidOperationException($"No summary: {summary.StopReason?.Raw()}"); } // 3. Coloque o bloco antes do turno mantido e faça a próxima pergunta. history = [ new BetaAssistantMessageParam { Content = summary.Content.Select(block => new BetaContentBlockParam(block.Json)).ToList(), }, .. history[2..], new BetaUserMessageParam { Content = "Which day should the release go out?" }, ]; var third = await client.Beta.Messages.Create(new MessageCreateParams { Model = ModelId, MaxTokens = 8192, System = SystemPrompt, Betas = [.. betas], Thinking = thinking, Messages = history, }); // 4. Um 200 sem blocos descartados significa que o pensamento mantido foi aceito. Console.WriteLine($"Dropped thinking blocks: {third.InputTransformations?.Count ?? 0}"); ``` ```go Go ctx := context.Background() client := anthropic.NewClient() // Claude Fable 5.1 é o primeiro modelo que verifica o pensamento reenviado em relação à conversa. const model = anthropic.ModelClaudeFable5_1 betas := []anthropic.AnthropicBeta{ anthropic.AnthropicBetaCompact2026_09_04, anthropic.AnthropicBetaThinkingBindingControls2026_08_01, } system := []anthropic.BetaTextBlockParam{{Text: "You help plan a recipe app's release. Keep answers short."}} // Com "error", um bloco de pensamento que falha na verificação faz a requisição falhar com um 400. thinking := anthropic.BetaThinkingConfigParamUnion{ OfAdaptive: &anthropic.BetaThinkingConfigAdaptiveParam{ BlockBinding: anthropic.BetaThinkingBlockBindingParam{ PrefixMismatchBehavior: anthropic.BetaThinkingPrefixMismatchBehaviorError, }, }, } // 1. Tenha uma conversa curta com o pensamento ativado. history := []anthropic.BetaMessageParam{ anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("What are the main entities in the app's data model?")), } first, err := client.Beta.Messages.New(ctx, anthropic.BetaMessageNewParams{ Model: model, MaxTokens: 8192, System: system, Betas: betas, Thinking: thinking, Messages: history, }) if err != nil { log.Fatal(err) } history = append(history, first.ToParam(), anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Testing starts on Tuesday, March 3, 2026, takes 10 weekdays, and pauses on March 9 and March 16. On which date does it end?")), ) second, err := client.Beta.Messages.New(ctx, anthropic.BetaMessageNewParams{ Model: model, MaxTokens: 8192, System: system, Betas: betas, Thinking: thinking, Messages: history, }) if err != nil { log.Fatal(err) } history = append(history, second.ToParam()) thinkingBlocks := 0 for _, block := range second.Content { if _, ok := block.AsAny().(anthropic.BetaThinkingBlock); ok { thinkingBlocks++ } } fmt.Printf("Thinking blocks in the kept turn: %d\n", thinkingBlocks) // 2. Resuma o primeiro turno. O segundo turno fica fora da requisição. summary, err := client.Beta.Messages.New(ctx, anthropic.BetaMessageNewParams{ Model: model, MaxTokens: 4096, System: system, Betas: betas, Thinking: thinking, Messages: history[:2], Compaction: anthropic.BetaCompactionConfigUnionParam{ OfSummarize: &anthropic.BetaSummarizeCompactionParam{}, }, }) if err != nil { log.Fatal(err) } if summary.StopReason != anthropic.BetaStopReasonCompaction { log.Fatalf("No summary: %s", summary.StopReason) } // 3. Coloque o bloco antes do turno mantido e faça a próxima pergunta. history = slices.Concat( []anthropic.BetaMessageParam{summary.ToParam()}, history[2:], []anthropic.BetaMessageParam{anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Which day should the release go out?"))}, ) third, err := client.Beta.Messages.New(ctx, anthropic.BetaMessageNewParams{ Model: model, MaxTokens: 8192, System: system, Betas: betas, Thinking: thinking, Messages: history, }) if err != nil { log.Fatal(err) } // 4. Um 200 sem blocos descartados significa que o pensamento mantido foi aceito. fmt.Printf("Dropped thinking blocks: %d\n", len(third.InputTransformations)) ``` ```java Java import com.anthropic.models.beta.AnthropicBeta; import com.anthropic.models.beta.messages.BetaCompactionConfig; import com.anthropic.models.beta.messages.BetaContentBlock; import com.anthropic.models.beta.messages.BetaMessageParam; import com.anthropic.models.beta.messages.BetaStopReason; 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; // Claude Fable 5.1 é o primeiro modelo que verifica o pensamento reenviado em relação à conversa. static final Model MODEL = Model.CLAUDE_FABLE_5_1; static final List BETAS = List.of( AnthropicBeta.COMPACT_2026_09_04, AnthropicBeta.THINKING_BINDING_CONTROLS_2026_08_01 ); static final String SYSTEM = "You help plan a recipe app's release. Keep answers short."; // Com "error", um bloco de pensamento que falha na verificação faz a requisição falhar com um 400. static final BetaThinkingConfigAdaptive THINKING = BetaThinkingConfigAdaptive.builder() .blockBinding(BetaThinkingBlockBinding.builder() .prefixMismatchBehavior(BetaThinkingPrefixMismatchBehavior.ERROR) .build()) .build(); void main() { var client = AnthropicOkHttpClient.fromEnv(); // 1. Tenha uma conversa curta com o pensamento ativado. var history = new ArrayList(); history.add(BetaMessageParam.ofUser("What are the main entities in the app's data model?")); var firstParams = MessageCreateParams.builder() .model(MODEL) .maxTokens(8192) .system(SYSTEM) .betas(BETAS) .thinking(THINKING) .messages(history) .build(); var first = client.beta().messages().create(firstParams); history.add(first.toParam()); history.add(BetaMessageParam.ofUser( "Testing starts on Tuesday, March 3, 2026, takes 10 weekdays, and pauses on March 9 and March 16. On which date does it end?")); var secondParams = MessageCreateParams.builder() .model(MODEL) .maxTokens(8192) .system(SYSTEM) .betas(BETAS) .thinking(THINKING) .messages(history) .build(); var second = client.beta().messages().create(secondParams); history.add(second.toParam()); long thinkingBlocks = second.content().stream().filter(BetaContentBlock::isThinking).count(); IO.println("Thinking blocks in the kept turn: " + thinkingBlocks); // 2. Resuma o primeiro turno. O segundo turno fica fora da requisição. var firstTurn = history.subList(0, 2); var summaryParams = MessageCreateParams.builder() .model(MODEL) .maxTokens(4096) .system(SYSTEM) .betas(BETAS) .thinking(THINKING) .messages(firstTurn) .compaction(BetaCompactionConfig.builder().build()) // type defaults to "summarize" .build(); var summary = client.beta().messages().create(summaryParams); if (!summary.stopReason().map(BetaStopReason.COMPACTION::equals).orElse(false)) { throw new IllegalStateException("No summary: " + summary.stopReason().orElseThrow()); } // 3. Coloque o bloco antes do turno mantido e faça a próxima pergunta. firstTurn.clear(); history.addFirst(summary.toParam()); history.add(BetaMessageParam.ofUser("Which day should the release go out?")); var thirdParams = MessageCreateParams.builder() .model(MODEL) .maxTokens(8192) .system(SYSTEM) .betas(BETAS) .thinking(THINKING) .messages(history) .build(); var third = client.beta().messages().create(thirdParams); // 4. Um 200 sem blocos descartados significa que o pensamento mantido foi aceito. IO.println("Dropped thinking blocks: " + third.inputTransformations().map(List::size).orElse(0)); } ``` ```php PHP use Anthropic\Beta\AnthropicBeta; use Anthropic\Beta\Messages\BetaCompactionConfig; use Anthropic\Beta\Messages\BetaMessageParam; use Anthropic\Beta\Messages\BetaMessageParam\Role; use Anthropic\Beta\Messages\BetaStopReason; use Anthropic\Beta\Messages\BetaThinkingBlock; use Anthropic\Beta\Messages\BetaThinkingBlockBinding; use Anthropic\Beta\Messages\BetaThinkingConfigAdaptive; use Anthropic\Beta\Messages\BetaThinkingPrefixMismatchBehavior; $client = new Client(); // Claude Fable 5.1 é o primeiro modelo que verifica o pensamento reenviado em relação à conversa. const MODEL = Model::CLAUDE_FABLE_5_1; const BETAS = [AnthropicBeta::COMPACT_2026_09_04, AnthropicBeta::THINKING_BINDING_CONTROLS_2026_08_01]; const SYSTEM = "You help plan a recipe app's release. Keep answers short."; // Com "error", um bloco de pensamento que falha na verificação faz a requisição falhar com um 400. $thinking = BetaThinkingConfigAdaptive::with( blockBinding: BetaThinkingBlockBinding::with( prefixMismatchBehavior: BetaThinkingPrefixMismatchBehavior::ERROR, ), ); // 1. Tenha uma conversa curta com o pensamento ativado. $history = [ BetaMessageParam::with(role: Role::USER, content: "What are the main entities in the app's data model?"), ]; $first = $client->beta->messages->create( model: MODEL, maxTokens: 8192, system: SYSTEM, betas: BETAS, thinking: $thinking, messages: $history, ); $history[] = BetaMessageParam::with(role: Role::ASSISTANT, content: $first->content); $history[] = BetaMessageParam::with( role: Role::USER, content: 'Testing starts on Tuesday, March 3, 2026, takes 10 weekdays, and pauses on March 9 and March 16. On which date does it end?', ); $second = $client->beta->messages->create( model: MODEL, maxTokens: 8192, system: SYSTEM, betas: BETAS, thinking: $thinking, messages: $history, ); $history[] = BetaMessageParam::with(role: Role::ASSISTANT, content: $second->content); $thinkingBlocks = count(array_filter($second->content, fn ($block) => $block instanceof BetaThinkingBlock)); printf("Thinking blocks in the kept turn: %d\n", $thinkingBlocks); // 2. Resuma o primeiro turno. O segundo turno fica fora da requisição. $summary = $client->beta->messages->create( model: MODEL, maxTokens: 4096, system: SYSTEM, betas: BETAS, thinking: $thinking, messages: array_slice($history, 0, 2), compaction: new BetaCompactionConfig(), // type defaults to 'summarize' ); if ($summary->stopReason !== BetaStopReason::COMPACTION->value) { throw new \RuntimeException("No summary: {$summary->stopReason}"); } // 3. Coloque o bloco antes do turno mantido e faça a próxima pergunta. $history = [ BetaMessageParam::with(role: Role::ASSISTANT, content: $summary->content), ...array_slice($history, 2), BetaMessageParam::with(role: Role::USER, content: 'Which day should the release go out?'), ]; $third = $client->beta->messages->create( model: MODEL, maxTokens: 8192, system: SYSTEM, betas: BETAS, thinking: $thinking, messages: $history, ); // 4. Um 200 sem blocos descartados significa que o pensamento mantido foi aceito. printf("Dropped thinking blocks: %d\n", count($third->inputTransformations)); ``` ```ruby Ruby client = Anthropic::Client.new # Claude Fable 5.1 é o primeiro modelo que verifica o pensamento reenviado em relação à conversa. MODEL = Anthropic::Model::CLAUDE_FABLE_5_1 BETAS = [ Anthropic::AnthropicBeta::COMPACT_2026_09_04, Anthropic::AnthropicBeta::THINKING_BINDING_CONTROLS_2026_08_01 ] SYSTEM = "You help plan a recipe app's release. Keep answers short." # Com "error", um bloco de pensamento que falha na verificação faz a requisição falhar com um 400. THINKING = Anthropic::Beta::BetaThinkingConfigAdaptive.new( block_binding: Anthropic::Beta::BetaThinkingBlockBinding.new( prefix_mismatch_behavior: Anthropic::Beta::BetaThinkingPrefixMismatchBehavior::ERROR ) ) # 1. Tenha uma conversa curta com o pensamento ativado. history = [{ role: "user", content: "What are the main entities in the app's data model?" }] first = client.beta.messages.create( model: MODEL, max_tokens: 8192, system_: SYSTEM, betas: BETAS, thinking: THINKING, messages: history ) history += [ { role: "assistant", content: first.content }, { role: "user", content: "Testing starts on Tuesday, March 3, 2026, takes 10 weekdays, and pauses on March 9 and March 16. On which date does it end?" } ] second = client.beta.messages.create( model: MODEL, max_tokens: 8192, system_: SYSTEM, betas: BETAS, thinking: THINKING, messages: history ) history << { role: "assistant", content: second.content } thinking_blocks = second.content.count { it.is_a?(Anthropic::Beta::BetaThinkingBlock) } puts "Thinking blocks in the kept turn: #{thinking_blocks}" # 2. Resuma o primeiro turno. O segundo turno fica fora da requisição. summary = client.beta.messages.create( model: MODEL, max_tokens: 4096, system_: SYSTEM, betas: BETAS, thinking: THINKING, messages: history.first(2), compaction: { type: "summarize" } ) abort "No summary: #{summary.stop_reason}" unless summary.stop_reason == :compaction # 3. Coloque o bloco antes do turno mantido e faça a próxima pergunta. history = [ { role: "assistant", content: summary.content }, *history.drop(2), { role: "user", content: "Which day should the release go out?" } ] third = client.beta.messages.create( model: MODEL, max_tokens: 8192, system_: SYSTEM, betas: BETAS, thinking: THINKING, messages: history ) # 4. Um 200 sem blocos descartados significa que o pensamento mantido foi aceito. puts "Dropped thinking blocks: #{third.input_transformations.length}" ``` ```text Output wrap Thinking blocks in the kept turn: 1 Dropped thinking blocks: 0 ``` Em produção, `"drop_block"` mantém as requisições bem-sucedidas quando uma condição não é atendida. A resposta lista cada bloco descartado em `input_transformations` com `reason: "prefix_binding_mismatch"`. Uma entrada cujo `path` está em um turno mantido significa que uma condição não foi atendida para o pensamento desse turno. [O que a API faz com um bloco inválido](https://platform.claude.com/docs/pt-BR/build-with-claude/preserved-thinking#mismatch-behavior) descreve o que é descartado e explica como configurar alertas para isso. No Claude Sonnet 5.5 e no Claude Haiku 5.5, `block_binding` funciona apenas com `thinking: {"type": "adaptive"}`. Com qualquer outra configuração de pensamento nesses modelos, você não pode enviar `block_binding`, então certifique-se de que todas as condições sejam atendidas ou remova os blocos `thinking` e `redacted_thinking` dos turnos mantidos. ## Disponibilidade Compactação e pensamento preservado estão em beta em modelos selecionados. ### Suporte da API #### [Messages API](https://platform.claude.com/docs/pt-BR/build-with-claude/working-with-messages) * Disponibilidade: Disponível | Status | Plataformas de nuvem | Modelos | | ------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Beta | Claude API, [Claude Platform on AWS](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws), [Claude Models on Google Cloud (Google managed)](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/google-managed), [Microsoft Foundry](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-in-microsoft-foundry) | [Claude Fable 5.1](https://platform.claude.com/docs/pt-BR/models/fable-5-1/overview), [Claude Mythos 5.1](https://platform.claude.com/docs/pt-BR/models/mythos-5-1/overview), [Claude Fable 5](https://platform.claude.com/docs/pt-BR/models/fable-5/overview), [Claude Mythos 5](https://platform.claude.com/docs/pt-BR/models/mythos-5/overview), Claude Mythos Preview, [Claude Opus 5.5](https://platform.claude.com/docs/pt-BR/models/opus-5-5/overview), [Claude Opus 5](https://platform.claude.com/docs/pt-BR/models/opus-5/overview), [Claude Sonnet 5.5](https://platform.claude.com/docs/pt-BR/models/sonnet-5-5/overview), [Claude Sonnet 5](https://platform.claude.com/docs/pt-BR/models/sonnet-5/overview), [Claude Haiku 5.5](https://platform.claude.com/docs/pt-BR/models/haiku-5-5/overview), [Claude Opus 4.8](https://platform.claude.com/docs/pt-BR/models/opus-4-8/overview), [Claude Opus 4.7](https://platform.claude.com/docs/pt-BR/models/opus-4-7/overview), [Claude Opus 4.6](https://platform.claude.com/docs/pt-BR/models/opus-4-6/overview), [Claude Sonnet 4.6](https://platform.claude.com/docs/pt-BR/models/sonnet-4-6/overview) | ### Cabeçalhos beta obrigatórios [Visão geral dos cabeçalhos beta](https://platform.claude.com/docs/pt-BR/api/beta-headers) Os cabeçalhos beta permitem que você acesse recursos experimentais e novas capacidades de modelos antes que eles se tornem parte da API padrão. * `compact-2026-09-04`