--- title: Präfixprüfungen bei Thinking-Blöcken url: https://platform.claude.com/docs/de/build-with-claude/preserved-thinking/prefix-checks description: Was die Präfixprüfung vergleicht, welche Modelle sie ausführen, was passiert, wenn bei einer Anfrage die Präfixprüfung fehlschlägt, und wie du mit dem 400-Fehler und dem Fall ohne Fehler umgehst. 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 --- Jede Anfrage, die „thinking blocks“ (Thinking-Blöcke) an ein [Modell mit „preserved thinking“ (bewahrtes Nachdenken)](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking/prefix-checks#outcomes) zurücksendet, durchläuft einen „prefix check“ (Präfixprüfung). Eine Präfixprüfung schlägt fehl, wenn sich `system`, `tools` oder eine frühere Nachricht geändert hat, nachdem Claude einen Block erzeugt hat. Sie schlägt auch fehl, wenn ein Thinking-Block zwischen anderen weggelassen oder verschoben wurde. Schlägt die Präfixprüfung fehl, kann das zu einem 400-Fehler führen oder auch nicht, [je nach Modell](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking/prefix-checks#outcomes), also [behandle beide Fälle](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking/prefix-checks#handle-either-outcome). ## Wen die Präfixprüfung betrifft Du musst nichts ändern, wenn einer dieser Punkte zutrifft: * Claude Code, claude.ai oder Claude Managed Agents verwaltet deinen Konversationsverlauf. * Das Claude Agent SDK verwaltet den Verlauf, und der System-Prompt, den du dem SDK übergibst, bleibt gleich. * Dein Code folgt [den drei Gewohnheiten einer „append-only“ (nur anhängenden) Integration](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking/prefix-checks#prefix-check), und nichts schreibt seine Anfragen unterwegs um. * Du rufst kein [Modell mit bewahrtem Nachdenken](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking/prefix-checks#outcomes) auf. Wenn deine Anfragen durch eine Bibliothek, einen Proxy oder ein Gateway laufen, [vergleiche, was diese sendet, mit dem, was du gesendet hast](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#find-the-change-details). Wenn du selbst eines betreibst, sieh unter [Bibliotheken, Proxys und Gateways](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking/change-tools-or-instructions#libraries-proxies-gateways) nach, was du durchreichen solltest. ## Was gleich bleiben muss, und warum Mach deine Integration append-only. Drei Gewohnheiten erreichen das: 1. Sende jeden Assistant-Turn genau so zurück, wie die API ihn zurückgegeben hat, einschließlich Thinking-Blöcken, deren Text leer ist. 2. Erstelle `system` und `tools` einmal pro Konversation und sende jedes Mal diese Kopie. 3. Setze jede Aktualisierung in eine neue Nachricht am Ende und lass sie dort. Das Reasoning jedes Thinking-Blocks bezieht sich genau auf das, was vor ihm kam: `system`, `tools` und jede frühere Nachricht. Dieser Inhalt ist das *Präfix* des Blocks, und er ist das, was die [Präfixprüfung](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking/prefix-checks#prefix-check-details) vergleicht. Die Präfixprüfung ähnelt dem Prompt-Caching, nur dass eine Änderung das Nachdenken danach ungültig macht, statt nur den Cache zu verfehlen. Nimm eine App, die das heutige Datum in ihren System-Prompt schreibt. Um Mitternacht ändert sich das Datum und damit auch das Präfix des Nachdenkens, das bereits in der Konversation steht. Dieses Nachdenken wird ungültig, und die nächste Anfrage kann fehlschlagen. Eine append-only-App lässt den System-Prompt, wie er war, und nennt das neue Datum in [einer Nachricht am Ende](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking/change-tools-or-instructions#changing-context). ![Eine Aktualisierung am Ende hält alles Nachdenken gültig; eine Änderung an Turn 2 oder an system macht das Nachdenken danach ungültig](https://platform.claude.com/docs/de/images/preserved-thinking-add-or-change.svg) Eine Änderung macht nur das Nachdenken ungültig, das ihr bereits folgt. Das Nachdenken davor und das Nachdenken, das Claude danach erzeugt, bleiben gültig. ## Wenn dein Code den System-Prompt, die Tools oder den Verlauf ändert | Wenn dein Code… | Was zu tun ist | | ---------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Den System-Prompt mit dem Datum, einem Modus oder Anweisungsdateien neu erstellt | Hör auf, `system` zu ändern. [Hänge deine eigenen Anweisungen als System-Nachricht an](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking/change-tools-or-instructions#new-instructions), einen `role: "system"`-Eintrag in `messages`, und [nenne neue Werte im neuesten Turn](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking/change-tools-or-instructions#changing-context). Für Text, den andere Personen bearbeiten können, sieh stattdessen unter [Text, den andere Personen bearbeiten können](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking/change-tools-or-instructions#untrusted-text) nach. | | Ein Tool hinzufügt, entfernt oder umformuliert oder Tools erhält, wenn sich ein MCP-Server verbindet | Hör auf, `tools` zu ändern, und [füge Tools in einer System-Nachricht hinzu oder entferne sie dort](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking/change-tools-or-instructions#tool-changes). | | Ältere Turns kürzt, zusammenklappt oder zusammenfasst und die neuesten unverändert beibehält | [Lass die API die Zusammenfassung schreiben oder entferne das Nachdenken der beibehaltenen Turns](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking/change-tools-or-instructions#server-side-trimming). | Andere Ursachen, etwa das Überspringen von Thinking-Blöcken mit leerem Text oder das Neuaufbauen einer gespeicherten Konversation, haben eigene Lösungen: siehe [Tools oder Anweisungen ändern, ohne dass die Präfixprüfung fehlschlägt](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking/change-tools-or-instructions). Um deine Ursache zu finden, [lass einen Agenten deinen Code prüfen](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking#hand-to-an-agent). ## Was jedes Modell tut, wenn die Präfixprüfung fehlschlägt In der Claude API und auf [einigen Cloud-Plattformen](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking#feature-availability) hängt das Ergebnis einer fehlgeschlagenen Präfixprüfung, wenn [`prefix_mismatch_behavior`](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking/prefix-checks#preserved-thinking-controls) nicht gesetzt ist, vom Modell ab: | Modell mit bewahrtem Nachdenken | Ergebnis | | ------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- | | Claude Fable 5.2 | 400-Fehler | | Claude Mythos 5.2 | 400-Fehler | | Claude Mythos 5.1 | 400-Fehler | | Claude Fable 5.1 | [Möglicher 400-Fehler](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking/prefix-checks#possible-400-error) | | Claude Opus 5.5 | [Möglicher 400-Fehler](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking/prefix-checks#possible-400-error) | | Claude Sonnet 5.5 | [Möglicher 400-Fehler](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking/prefix-checks#possible-400-error) | | Claude Haiku 5.5 | [Möglicher 400-Fehler](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking/prefix-checks#possible-400-error) | Wo die Tabelle „Möglicher 400-Fehler“ angibt, gibt es zwei Fälle: Eine Anfrage, bei der die Präfixprüfung fehlschlägt, erhält möglicherweise einen 400-Fehler oder keinen Fehler. Wenn kein Fehler zurückgegeben wird, erreichen die Blöcke, bei denen die Präfixprüfung fehlschlägt, das Modell. Claude liest sie wie jede andere Eingabe, sie werden dir in Rechnung gestellt, und Claude arbeitet mit Reasoning über Inhalte, die sich inzwischen geändert haben. Bei diesen Modellen kannst du [prüfen, welchen Fall eine Anfrage erhält](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking/prefix-checks#check-which-case), solltest aber [beide Fälle behandeln](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking/prefix-checks#handle-either-outcome). Code, der [den drei Gewohnheiten einer append-only-Integration](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking/prefix-checks#prefix-check) folgt, führt nicht dazu, dass bei Anfragen die Präfixprüfung fehlschlägt. [Message-Batches-Elemente](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#batches), die `prefix_mismatch_behavior` nicht setzen, erhalten keinen Fehler, und die API kann die Blöcke, bei denen die Präfixprüfung fehlschlägt, weglassen. ## Beide Fälle behandeln Für ein einheitliches Ergebnis bei jeder Anfrage mach deine Integration append-only oder setze `prefix_mismatch_behavior`. Andernfalls muss dein Code beide Verhaltensweisen behandeln. * **Append-only:** Mit [den drei Gewohnheiten](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking/prefix-checks#prefix-check) führt dein Code nicht dazu, dass bei einer Anfrage die Präfixprüfung fehlschlägt. * **Die Einstellung:** Mit `"error"` bei jeder Anfrage ist jede fehlgeschlagene Präfixprüfung ein 400-Fehler, und du [fängst ihn im Code ab](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#handle-the-error-in-code). * **Beide Verhaltensweisen:** Wenn du die Einstellung nicht setzt, fang den 400-Fehler ab und [achte auf Nachdenken, bei dem die Präfixprüfung fehlgeschlagen ist und das Claude erreicht hat](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking/prefix-checks#watch-production-traffic). Sende nach einem 400-Fehler `"drop_block"` bei den späteren Anfragen dieser Konversation, um sie wiederherzustellen. Das hat seinen Preis: siehe [Was das Weglassen von Nachdenken kostet](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#drop-block-cost). Sende es nicht bei all deinen Konversationen, um Fehler zu verbergen. ## Technische Details ### Wie die Präfixprüfung funktioniert Die Modelle mit bewahrtem Nachdenken speichern einen Fingerabdruck des Präfixes jedes Thinking-Blocks in seiner `signature`. Die API-Referenz nennt die Präfixprüfung die Konversationsprüfung, und der 400-Fehler besagt, dass ein Block, bei dem die Präfixprüfung fehlschlägt, `is bound to a different conversation`. ### Welche Modelle die Präfixprüfung ausführen Die Präfixprüfung läuft in der Claude API und auf [einigen Cloud-Plattformen](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking#feature-availability). Sie prüft Thinking-Blöcke, die ein [Modell mit bewahrtem Nachdenken](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking/prefix-checks#outcomes) erzeugt hat, bei Anfragen an eines dieser Modelle. In der Claude API führen andere Modelle, etwa Claude Opus 5, sie nicht aus, und sie deckt deren Blöcke nicht ab. ### Was als Änderung zählt * **Jeder Block wird mit seinem eigenen Eintrag verglichen.** Die API vergleicht, was in dieser Anfrage vor einem Block steht, mit dem, was seine Signatur festgehalten hat, als Claude ihn erzeugt hat. Deine letzte Anfrage spielt keine Rolle. Die Präfixprüfung betrachtet nur Inhalte, nicht Sitzungen, IDs oder Benutzer. Derselbe Inhalt in einer neuen Anfrage oder einem Fork besteht sie. * **Die Präfixprüfung vergleicht, was du gesendet hast, nicht, was Claude gelesen hat.** [Komprimierung bei einem Token-Schwellenwert](https://platform.claude.com/docs/de/build-with-claude/compaction-threshold) und Context Editing ändern nur, was Claude liest, daher zählen sie nie. Nach einem Komprimierungsblock mit Schwellenwert vergleicht die API nur die Nachrichten ab diesem Block sowie `system` und `tools`. Komprimierung auf Anfrage hat eigene Bedingungen: siehe [Bedingungen, unter denen beibehaltenes Nachdenken gültig bleibt](https://platform.claude.com/docs/de/build-with-claude/compaction-thinking-blocks#conditions-for-kept-thinking-to-stay-valid). Für eine per URL gesendete Datei und, in der Claude API, [eine MCP-Tool-Liste](https://platform.claude.com/docs/de/agents-and-tools/mcp-connector#pin-mcp-tool-list) vergleicht die API stattdessen, was sie abgerufen hat. * **Das Nachdenken, das du sendest, muss eine ununterbrochene Folge sein.** Thinking-Blöcke werden nicht als Inhalt verglichen. Aber jeder, den du sendest, außer dem ersten, muss denselben vorherigen Thinking-Block haben wie zu dem Zeitpunkt, als Claude ihn erzeugt hat. Du kannst also [den ältesten, den neuesten oder alle weglassen](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking/change-tools-or-instructions#leave-out-thinking), aber nicht einen dazwischen. Eine Änderung kann so klein sein wie ein einzelnes Wort einer Tool-Beschreibung. Das Ändern, Einfügen, Verschieben oder Löschen einer früheren Nachricht zählt, unabhängig von ihrer Rolle. Ebenso das Ändern von Text vor einem Thinking-Block in dessen eigener Nachricht. ### Was nicht zählt | Das zählt nicht | Weil | | --------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------- | | `model`, `effort`, `max_tokens`, `tool_choice`, `metadata`, `thinking.display` und andere Parameter | Nur `system`, `tools` und Nachrichten verglichen werden | | JSON-Formatierung oder Reihenfolge der Schlüssel | Die API geparstes JSON vergleicht, nicht dessen Text | | `cache_control`-Markierungen | Sie angeben, wo gecacht werden soll, und kein Inhalt sind, den Claude liest | | Ein Tool mit `defer_loading: true`, auf das nichts verwiesen hat | Es erst in Claudes Kontext ist, wenn etwas darauf verweist | ### `prefix_mismatch_behavior` setzen Der [Beta-Header](https://platform.claude.com/docs/de/api/beta-headers#beta-features-on-other-platforms) `thinking-binding-controls-2026-08-01` fügt die Einstellung `thinking.block_binding.prefix_mismatch_behavior` und das Array `input_transformations` der Antwort hinzu. | Wert | Wenn bei einem Block die Präfixprüfung fehlschlägt | | ------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `"error"` | Die API lehnt die Anfrage mit einem 400-Fehler ab, der den ersten ungültigen Block nennt | | `"drop_block"` | Die API lässt die ungültigen Blöcke weg, und die Anfrage ist erfolgreich. Diese Blöcke werden dir nicht in Rechnung gestellt, aber [das Weglassen kann mehr kosten](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#drop-block-cost) | | Nicht gesetzt oder `null` | [Hängt vom Modell ab](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking/prefix-checks#outcomes) | Blöcke, bei denen die Präfixprüfung fehlschlägt, bleiben bei jeder späteren Anfrage, die sie sendet, ungültig, solange die Änderung besteht. Die Einstellung wirkt auf die eine Anfrage, die sie enthält. Bei ausgeschaltetem Nachdenken (`"disabled"` oder `"between_tools"`) ist das Senden der Einstellung bei jedem Modell ein 400-Fehler. Die folgende Anfrage setzt `prefix_mismatch_behavior` auf `"drop_block"`. Bei einem ersten Turn gibt es kein Nachdenken zum Zurücksenden, daher kommt `input_transformations` leer zurück: ```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}" ``` ### Produktionsverkehr beobachten Wenn `prefix_mismatch_behavior` nicht gesetzt ist, erhält eine Anfrage, bei der die Präfixprüfung fehlschlägt, bei [einigen Modellen](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking/prefix-checks#outcomes) möglicherweise keinen Fehler. Die Thinking-Blöcke, bei denen die Präfixprüfung fehlgeschlagen ist, erreichen dann das Modell. Um diese Blöcke im Produktionsverkehr zu finden, sende den Beta-Header `thinking-binding-controls-2026-08-01`, setze die Einstellung nicht und protokolliere das Array `input_transformations` jeder Antwort. Der Header fügt dieses Array hinzu und ändert nicht, was das Modell erhält. Jeder dieser Blöcke erhält einen eigenen `thinking_mismatch_allowed`-Eintrag in diesem Array. Ein Eintrag sieht so aus: ```json { "input_transformations": [ { "type": "thinking_mismatch_allowed", "path": "messages.1.content.0", "reason": "prefix_binding_mismatch" } ] } ``` Um die Änderung zu finden, siehe [Finde heraus, was dein Code geändert hat](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#find-the-change). ### Prüfen, welchen Fall du erhältst Bei [einigen Modellen](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking/prefix-checks#outcomes) erhält eine Anfrage, bei der die Präfixprüfung fehlschlägt, möglicherweise den 400-Fehler oder keinen Fehler. Dieser Test zeigt, welchen Fall eine Anfrage erhält: 1. Nimm eine Konversation, die einen Thinking-Block von einem dieser Modelle enthält. Ändere den System-Prompt (`system`) oder füge ihn hinzu. Bei dem Block schlägt dann die Präfixprüfung fehl, weil sich der System-Prompt geändert hat, nachdem Claude den Block erzeugt hat. 2. Sende sie mit dem Beta-Header `thinking-binding-controls-2026-08-01` an dasselbe Modell und setze `prefix_mismatch_behavior` nicht. Die Antwort ist eine der folgenden: * **Ein [400-Fehler](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#prefix-mismatch-error), der `bound to a different conversation` angibt:** Die Anfrage hat den 400-Fehler erhalten. * **Eine 200-Antwort, deren Array `input_transformations` `thinking_mismatch_allowed`-Einträge enthält:** Die Anfrage hat keinen Fehler erhalten. Jeder Eintrag nennt einen Thinking-Block, bei dem die Präfixprüfung fehlgeschlagen ist und der Claude erreicht hat. * **Eine 200-Antwort, deren Array `input_transformations` leer ist:** Bei keinem Block ist die Präfixprüfung fehlgeschlagen, daher zeigt der Test nichts. Prüfe, ob die Konversation einen Thinking-Block von diesem Modell enthält. Das Ergebnis beschreibt diese eine Anfrage und verspricht nichts über spätere, also schreib deinen Code so, dass er [beide Fälle behandeln](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking/prefix-checks#handle-either-outcome) kann. ## Nächste Schritte Was du statt jeder Änderung senden solltest, die dein Code an einer Konversation vornimmt. Eine Konversation wiederherstellen, bei der die Präfixprüfung fehlschlägt, herausfinden, was dein Code ändert, und testen, dass es behoben ist. Was bewahrtes Nachdenken ist, woran ein Thinking-Block gebunden ist, und der Wechsel von Modellen oder Accounts.