--- title: Vérifications du préfixe sur les blocs de réflexion url: https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking/prefix-checks description: Ce que compare la vérification du préfixe, quels modèles l'exécutent, ce qui se passe lorsqu'une requête y échoue, et comment gérer l'erreur 400 et le cas sans erreur. 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 --- Chaque requête qui renvoie des « thinking blocks » (blocs de réflexion) à un [modèle avec « preserved thinking » (réflexion préservée)](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking/prefix-checks#outcomes) fait l’objet d’un « prefix check » (vérification du préfixe). Une vérification du préfixe échoue si `system`, `tools` ou un message antérieur a été modifié après que Claude a produit un bloc. Elle échoue également si un bloc de réflexion situé entre d’autres a été omis ou déplacé. L’échec de la vérification du préfixe peut entraîner ou non une erreur 400, [selon le modèle](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking/prefix-checks#outcomes) : [gérez donc les deux cas](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking/prefix-checks#handle-either-outcome). ## Qui est concerné par la vérification du préfixe Vous n’avez rien à modifier si l’une de ces conditions est remplie : * Claude Code, claude.ai ou Claude Managed Agents gère l’historique de votre conversation. * Le Claude Agent SDK gère l’historique, et l’invite système que vous fournissez au SDK reste identique. * Votre code suit [les trois habitudes d’une intégration en ajout seul](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking/prefix-checks#prefix-check), et rien ne réécrit ses requêtes en chemin. * Vous n’appelez aucun [modèle avec réflexion préservée](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking/prefix-checks#outcomes). Si vos requêtes transitent par une bibliothèque, un proxy ou une passerelle, [comparez ce qu’il envoie avec ce que vous avez envoyé](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#find-the-change-details). Si vous en exploitez un, consultez [Bibliothèques, proxys et passerelles](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking/change-tools-or-instructions#libraries-proxies-gateways) pour savoir ce qu’il faut transmettre. ## Ce qui doit rester identique, et pourquoi Faites de votre intégration une intégration en ajout seul. Trois habitudes y parviennent : 1. Renvoyez chaque tour de l’assistant exactement tel que l’API l’a renvoyé, y compris les blocs de réflexion dont le texte est vide. 2. Construisez `system` et `tools` une seule fois pour chaque conversation, et envoyez cette copie à chaque fois. 3. Placez chaque mise à jour dans un nouveau message à la fin, et laissez-la là. Le raisonnement de chaque bloc de réflexion porte exactement sur ce qui le précède : `system`, `tools` et chaque message antérieur. Ce contenu est le *préfixe* du bloc, et c’est ce que compare la [vérification du préfixe](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking/prefix-checks#prefix-check-details). La vérification du préfixe est similaire à la mise en cache des prompts, sauf qu’une modification rend invalide la réflexion qui la suit au lieu de simplement manquer le cache. Prenons une application qui place la date du jour dans son invite système. À minuit, la date change, tout comme le préfixe de la réflexion déjà présente dans la conversation. Cette réflexion devient invalide, et la requête suivante peut échouer. Une application en ajout seul conserve l’invite système telle qu’elle était, et indique la nouvelle date dans [un message à la fin](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking/change-tools-or-instructions#changing-context). ![Une mise à jour à la fin garde toute la réflexion valide ; une modification du tour 2, ou de system, invalide la réflexion qui la suit](https://platform.claude.com/docs/fr/images/preserved-thinking-add-or-change.svg) Une modification rend invalide uniquement la réflexion qui la suit déjà. La réflexion qui la précède et la réflexion que Claude produit ensuite restent valides. ## Si votre code modifie l’invite système, les outils ou l’historique | Si votre code… | Que faire | | ----------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Reconstruit l’invite système avec la date, un mode ou des fichiers d’instructions | Cessez de modifier `system`. [Ajoutez vos propres instructions sous forme de message système](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking/change-tools-or-instructions#new-instructions), une entrée `role: "system"` dans `messages`, et [indiquez les nouvelles valeurs dans le tour le plus récent](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking/change-tools-or-instructions#changing-context). Pour un texte que d’autres personnes peuvent modifier, consultez plutôt [Texte que d’autres personnes peuvent modifier](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking/change-tools-or-instructions#untrusted-text). | | Ajoute, supprime ou reformule un outil, ou obtient des outils lorsqu’un serveur MCP se connecte | Cessez de modifier `tools`, et [ajoutez ou supprimez des outils dans un message système](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking/change-tools-or-instructions#tool-changes). | | Tronque, condense ou résume les tours plus anciens, et conserve les plus récents inchangés | [Laissez l’API rédiger le résumé, ou supprimez la réflexion des tours conservés](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking/change-tools-or-instructions#server-side-trimming). | D’autres causes, comme le fait d’ignorer les blocs de réflexion dont le texte est vide ou de reconstruire une conversation enregistrée, ont leurs propres correctifs : consultez [Modifier les outils ou les instructions sans échouer à la vérification du préfixe](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking/change-tools-or-instructions). Pour trouver la vôtre, [demandez à un agent d’examiner votre code](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking#hand-to-an-agent). ## Ce que fait chaque modèle lorsque la vérification du préfixe échoue Sur la Claude API et [certaines plateformes cloud](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking#feature-availability), le résultat d’un échec de la vérification du préfixe lorsque [`prefix_mismatch_behavior`](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking/prefix-checks#preserved-thinking-controls) est omis dépend du modèle : | Modèle avec réflexion préservée | Résultat | | ------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- | | Claude Fable 5.2 | Erreur 400 | | Claude Mythos 5.2 | Erreur 400 | | Claude Mythos 5.1 | Erreur 400 | | Claude Fable 5.1 | [Erreur 400 possible](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking/prefix-checks#possible-400-error) | | Claude Opus 5.5 | [Erreur 400 possible](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking/prefix-checks#possible-400-error) | | Claude Sonnet 5.5 | [Erreur 400 possible](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking/prefix-checks#possible-400-error) | | Claude Haiku 5.5 | [Erreur 400 possible](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking/prefix-checks#possible-400-error) | Lorsque le tableau indique « Erreur 400 possible », il existe deux cas : une requête qui échoue à la vérification du préfixe peut obtenir une erreur 400 ou aucune erreur. Lorsqu’aucune erreur n’est renvoyée, les blocs qui échouent à la vérification du préfixe parviennent au modèle. Claude les lit comme n’importe quelle autre entrée, ils vous sont facturés, et Claude travaille à partir d’un raisonnement portant sur un contenu qui a changé depuis. Sur ces modèles, vous pouvez [déterminer quel cas une requête obtient](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking/prefix-checks#check-which-case), mais [gérez les deux cas](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking/prefix-checks#handle-either-outcome). Le code qui suit [les trois habitudes d’une intégration en ajout seul](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking/prefix-checks#prefix-check) ne provoque pas d’échecs de la vérification du préfixe. Les [éléments de Message Batches](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#batches) qui omettent `prefix_mismatch_behavior` n’obtiennent aucune erreur, et l’API peut écarter les blocs qui échouent à la vérification du préfixe. ## Gérer les deux cas Pour obtenir un seul résultat sur chaque requête, faites de votre intégration une intégration en ajout seul ou définissez `prefix_mismatch_behavior`. Sinon, votre code doit gérer les deux comportements. * **En ajout seul :** avec [les trois habitudes](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking/prefix-checks#prefix-check), votre code ne fait pas échouer une requête à la vérification du préfixe. * **Le réglage :** avec `"error"` sur chaque requête, chaque échec est une erreur 400, et vous [l’interceptez dans le code](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#handle-the-error-in-code). * **Les deux comportements :** si vous omettez le réglage, interceptez l’erreur 400, et [surveillez la réflexion ayant échoué à la vérification du préfixe qui a atteint Claude](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking/prefix-checks#watch-production-traffic). Après une erreur 400, envoyez `"drop_block"` sur les requêtes ultérieures de cette conversation pour la rétablir. Cela a un coût : consultez [Ce que coûte le fait d’écarter la réflexion](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#drop-block-cost). Ne l’envoyez pas sur toutes vos conversations pour masquer les erreurs. ## Détails techniques ### Fonctionnement de la vérification du préfixe Les modèles avec réflexion préservée enregistrent une empreinte du préfixe de chaque bloc de réflexion dans sa `signature`. La référence de l’API appelle la vérification du préfixe la vérification de la conversation, et l’erreur 400 indique qu’un bloc ayant échoué à la vérification du préfixe `is bound to a different conversation`. ### Quels modèles exécutent la vérification du préfixe La vérification du préfixe s’exécute sur la Claude API et sur [certaines plateformes cloud](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking#feature-availability). Elle vérifie les blocs de réflexion qu’un [modèle avec réflexion préservée](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking/prefix-checks#outcomes) a produits, sur les requêtes adressées à l’un de ces modèles. Sur la Claude API, les autres modèles, comme Claude Opus 5, ne l’exécutent pas, et elle ne couvre pas leurs blocs. ### Ce qui compte comme une modification * **Chaque bloc est comparé à son propre enregistrement.** L’API compare ce qui précède un bloc dans cette requête avec ce que sa signature a enregistré lorsque Claude l’a produit. Votre dernière requête ne joue aucun rôle. La vérification du préfixe ne porte que sur le contenu, et non sur les sessions, les identifiants ou les utilisateurs. Le même contenu dans une nouvelle requête ou une bifurcation la passe. * **La vérification du préfixe compare ce que vous avez envoyé, et non ce que Claude a lu.** La [compaction à un seuil de tokens](https://platform.claude.com/docs/fr/build-with-claude/compaction-threshold) et l’édition du contexte ne modifient que ce que Claude lit : elles ne comptent donc jamais. Après un bloc de compaction à seuil, l’API ne compare que les messages à partir de ce bloc, plus `system` et `tools`. La compaction à la demande a ses propres conditions : consultez [Conditions pour que la réflexion conservée reste valide](https://platform.claude.com/docs/fr/build-with-claude/compaction-thinking-blocks#conditions-for-kept-thinking-to-stay-valid). Pour un fichier envoyé par URL et, sur la Claude API, [une liste d’outils MCP](https://platform.claude.com/docs/fr/agents-and-tools/mcp-connector#pin-mcp-tool-list), l’API compare plutôt ce qu’elle a récupéré. * **La réflexion que vous envoyez doit former une suite ininterrompue.** Les blocs de réflexion ne sont pas comparés en tant que contenu. Mais chacun de ceux que vous envoyez, à l’exception du premier, doit avoir le même bloc de réflexion précédent que lorsque Claude l’a produit. Vous pouvez donc [omettre le plus ancien, le plus récent ou tous](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking/change-tools-or-instructions#leave-out-thinking), mais pas un bloc situé entre d’autres. Une modification peut être aussi minime qu’un seul mot dans la description d’un outil. Modifier, insérer, déplacer ou supprimer un message antérieur compte, quel que soit son rôle. Il en va de même pour la modification du texte qui précède un bloc de réflexion dans son propre message. ### Ce qui ne compte pas | Ceci ne compte pas | Parce que | | ------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------- | | `model`, `effort`, `max_tokens`, `tool_choice`, `metadata`, `thinking.display` et les autres paramètres | Seuls `system`, `tools` et les messages sont comparés | | La mise en forme JSON ou l’ordre des clés | L’API compare le JSON analysé, et non son texte | | Les marqueurs `cache_control` | Ils indiquent où mettre en cache, et ne sont pas du contenu que Claude lit | | Un outil avec `defer_loading: true` auquel rien n’a fait référence | Il n’est pas dans le contexte de Claude tant que quelque chose n’y fait pas référence | ### Définir `prefix_mismatch_behavior` L’[en-tête bêta](https://platform.claude.com/docs/fr/api/beta-headers#beta-features-on-other-platforms) `thinking-binding-controls-2026-08-01` ajoute le réglage `thinking.block_binding.prefix_mismatch_behavior` et le tableau `input_transformations` de la réponse. | Valeur | Si un bloc échoue à la vérification du préfixe | | --------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `"error"` | L’API rejette la requête avec une erreur 400 qui nomme le premier bloc invalide | | `"drop_block"` | L’API écarte les blocs invalides, et la requête réussit. Ces blocs ne vous sont pas facturés, mais [les écarter peut coûter davantage](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#drop-block-cost) | | Omis, ou `null` | [Dépend du modèle](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking/prefix-checks#outcomes) | Les blocs qui échouent à la vérification du préfixe restent invalides sur chaque requête ultérieure qui les envoie, tant que la modification est en place. Le réglage agit sur la seule requête qui le contient. Avec la réflexion désactivée (`"disabled"` ou `"between_tools"`), l’envoyer produit une erreur 400 sur tous les modèles. La requête suivante définit `prefix_mismatch_behavior` sur `"drop_block"`. Lors d’un premier tour, il n’y a aucune réflexion à renvoyer, donc `input_transformations` revient vide : ```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}" ``` ### Surveiller le trafic de production Lorsque `prefix_mismatch_behavior` est omis, une requête qui échoue à la vérification du préfixe peut n’obtenir aucune erreur sur [certains modèles](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking/prefix-checks#outcomes). Les blocs de réflexion qui y ont échoué parviennent alors au modèle. Pour trouver ces blocs dans le trafic de production, envoyez l’en-tête bêta `thinking-binding-controls-2026-08-01`, omettez le réglage et journalisez le tableau `input_transformations` de chaque réponse. L’en-tête ajoute ce tableau et ne modifie pas ce que reçoit le modèle. Chacun de ces blocs obtient sa propre entrée `thinking_mismatch_allowed` dans ce tableau. Une entrée se présente ainsi : ```json { "input_transformations": [ { "type": "thinking_mismatch_allowed", "path": "messages.1.content.0", "reason": "prefix_binding_mismatch" } ] } ``` Pour trouver la modification, consultez [Trouver ce que votre code a modifié](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#find-the-change). ### Déterminer quel cas vous obtenez Sur [certains modèles](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking/prefix-checks#outcomes), une requête qui échoue à la vérification du préfixe peut obtenir l’erreur 400 ou aucune erreur. Ce test montre lequel des deux une requête obtient : 1. Prenez une conversation qui contient un bloc de réflexion provenant de l’un de ces modèles. Modifiez ou ajoutez l’invite système (`system`). Le bloc échoue alors à la vérification du préfixe, car l’invite système a changé après que Claude a produit le bloc. 2. Envoyez-la au même modèle avec l’en-tête bêta `thinking-binding-controls-2026-08-01`, et omettez `prefix_mismatch_behavior`. La réponse est l’une des suivantes : * **Une [erreur 400](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#prefix-mismatch-error) qui indique `bound to a different conversation` :** la requête a obtenu l’erreur 400. * **Une réponse 200 dont le tableau `input_transformations` contient des entrées `thinking_mismatch_allowed` :** la requête n’a obtenu aucune erreur. Chaque entrée nomme un bloc de réflexion qui a échoué à la vérification du préfixe et a atteint Claude. * **Une réponse 200 dont le tableau `input_transformations` est vide :** aucun bloc n’a échoué à la vérification du préfixe, donc le test ne montre rien. Assurez-vous que la conversation contient un bloc de réflexion provenant de ce modèle. Le résultat décrit cette seule requête et ne garantit rien pour les suivantes : écrivez donc votre code de manière à [gérer les deux cas](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking/prefix-checks#handle-either-outcome). ## Étapes suivantes Ce qu’il faut envoyer à la place de chaque modification que votre code apporte à une conversation. Rétablir une conversation en échec, trouver ce que votre code modifie et vérifier par un test que le problème a disparu. Ce qu’est la réflexion préservée, ce à quoi un bloc de réflexion est lié, et le changement de modèle ou de compte.