--- title: Verificaciones de prefijo en bloques de pensamiento url: https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/prefix-checks description: Qué compara la verificación de prefijo, qué modelos la ejecutan, qué sucede cuando una solicitud no la supera y cómo manejar el error 400 y el caso sin error. 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 solicitud que devuelve “thinking blocks” (bloques de pensamiento) a un [modelo con “preserved thinking” (pensamiento preservado)](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/prefix-checks#outcomes) pasa por una “prefix check” (verificación de prefijo). Una verificación de prefijo falla si `system`, `tools` o un mensaje anterior cambiaron después de que Claude produjera un bloque. También falla si un bloque de pensamiento situado entre otros se omitió o se movió. No superar la verificación de prefijo puede o no dar como resultado un error 400, [según el modelo](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/prefix-checks#outcomes), así que [maneja ambos casos](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/prefix-checks#handle-either-outcome). ## A quién afecta la verificación de prefijo No tienes nada que cambiar si se cumple una de estas condiciones: * Claude Code, claude.ai o Claude Managed Agents gestiona tu historial de conversación. * El Claude Agent SDK gestiona el historial, y la indicación del sistema que le das al SDK se mantiene igual. * Tu código sigue [los tres hábitos de una integración “append-only” (de solo anexar)](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/prefix-checks#prefix-check), y nada reescribe sus solicitudes por el camino. * No llamas a ningún [modelo con pensamiento preservado](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/prefix-checks#outcomes). Si tus solicitudes pasan por una biblioteca, un proxy o un gateway, [compara lo que envía con lo que enviaste tú](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#find-the-change-details). Si ejecutas uno, consulta [Bibliotecas, proxies y gateways](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/change-tools-or-instructions#libraries-proxies-gateways) para saber qué debe dejar pasar. ## Qué debe mantenerse igual y por qué Haz que tu integración sea de solo anexar. Tres hábitos lo logran: 1. Devuelve cada turno del asistente exactamente como lo devolvió la API, incluidos los bloques de pensamiento cuyo texto está vacío. 2. Construye `system` y `tools` una vez por cada conversación, y envía esa copia cada vez. 3. Coloca cada actualización en un mensaje nuevo al final, y déjala ahí. El razonamiento de cada bloque de pensamiento trata exactamente sobre lo que vino antes de él: `system`, `tools` y cada mensaje anterior. Ese contenido es el *prefijo* del bloque, y es lo que compara la [verificación de prefijo](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/prefix-checks#prefix-check-details). La verificación de prefijo es similar al “prompt caching” (almacenamiento en caché de prompts), excepto que un cambio invalida el pensamiento posterior a él en lugar de solo perder la caché. Toma como ejemplo una aplicación que pone la fecha de hoy en su indicación del sistema. A medianoche la fecha cambia, y también el prefijo del pensamiento que ya está en la conversación. Ese pensamiento se vuelve inválido, y la siguiente solicitud puede fallar. Una aplicación de solo anexar mantiene la indicación del sistema tal como estaba, e indica la nueva fecha en [un mensaje al final](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/change-tools-or-instructions#changing-context). ![Una actualización al final mantiene válido todo el pensamiento; un cambio en el turno 2, o en system, invalida el pensamiento posterior a él](https://platform.claude.com/docs/es/images/preserved-thinking-add-or-change.svg) Un cambio invalida solo el pensamiento que ya le sigue. El pensamiento anterior a él y el pensamiento que Claude produce después siguen siendo válidos. ## Si tu código cambia la indicación del sistema, las herramientas o el historial | Si tu código… | Qué hacer | | -------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | Reconstruye la indicación del sistema con la fecha, un modo o archivos de instrucciones | Deja de cambiar `system`. [Anexa tus propias instrucciones como un mensaje del sistema](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/change-tools-or-instructions#new-instructions), una entrada `role: "system"` en `messages`, e [indica los nuevos valores en el turno más reciente](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/change-tools-or-instructions#changing-context). Para texto que otras personas pueden editar, consulta en su lugar [Texto que otras personas pueden editar](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/change-tools-or-instructions#untrusted-text). | | Agrega, elimina o reformula una herramienta, o gana herramientas cuando se conecta un servidor MCP | Deja de cambiar `tools`, y [agrega o elimina herramientas en un mensaje del sistema](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/change-tools-or-instructions#tool-changes). | | Recorta, contrae o resume turnos antiguos, y mantiene sin cambios los más recientes | [Deja que la API escriba el resumen, o elimina el pensamiento de los turnos conservados](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/change-tools-or-instructions#server-side-trimming). | Otras causas, como omitir bloques de pensamiento cuyo texto está vacío o reconstruir una conversación guardada, tienen sus propias soluciones: consulta [Cambia herramientas o instrucciones sin fallar la verificación de prefijo](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/change-tools-or-instructions). Para encontrar la tuya, [haz que un agente revise tu código](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking#hand-to-an-agent). ## Qué hace cada modelo cuando la verificación de prefijo falla En la Claude API y en [algunas plataformas en la nube](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking#feature-availability), el resultado de no superar la verificación de prefijo con [`prefix_mismatch_behavior`](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/prefix-checks#preserved-thinking-controls) sin establecer depende del modelo: | Modelo con pensamiento preservado | Resultado | | --------------------------------- | ------------------------------------------------------------------------------------------------------------------------------ | | Claude Fable 5.2 | Error 400 | | Claude Mythos 5.2 | Error 400 | | Claude Mythos 5.1 | Error 400 | | Claude Fable 5.1 | [Posible error 400](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/prefix-checks#possible-400-error) | | Claude Opus 5.5 | [Posible error 400](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/prefix-checks#possible-400-error) | | Claude Sonnet 5.5 | [Posible error 400](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/prefix-checks#possible-400-error) | | Claude Haiku 5.5 | [Posible error 400](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/prefix-checks#possible-400-error) | Donde la tabla dice “Posible error 400”, hay dos casos: una solicitud que no supera la verificación de prefijo podría recibir un error 400 o ningún error. Cuando no se devuelve ningún error, los bloques que no superan la verificación de prefijo llegan al modelo. Claude los lee como cualquier otra entrada, se te factura por ellos, y Claude trabaja a partir de un razonamiento sobre contenido que ha cambiado desde entonces. En esos modelos, puedes [comprobar qué caso obtiene una solicitud](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/prefix-checks#check-which-case), pero [maneja ambos casos](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/prefix-checks#handle-either-outcome). El código que sigue [los tres hábitos de una integración de solo anexar](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/prefix-checks#prefix-check) no provoca fallos de la verificación de prefijo. Los [elementos de Message Batches](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#batches) que dejan `prefix_mismatch_behavior` sin establecer no reciben ningún error, y la API puede omitir los bloques que no superan la verificación de prefijo. ## Maneja ambos casos Para obtener un único resultado en cada solicitud, haz que tu integración sea de solo anexar o establece `prefix_mismatch_behavior`. De lo contrario, tu código debe manejar ambos comportamientos. * **De solo anexar:** con [los tres hábitos](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/prefix-checks#prefix-check), tu código no hace que una solicitud falle la verificación de prefijo. * **La configuración:** con `"error"` en cada solicitud, cada fallo es un error 400, y lo [capturas en el código](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#handle-the-error-in-code). * **Ambos comportamientos:** si dejas la configuración sin establecer, captura el error 400 y [vigila el pensamiento que no superó la verificación de prefijo y llegó a Claude](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/prefix-checks#watch-production-traffic). Después de un error 400, envía `"drop_block"` en las solicitudes posteriores de esa conversación para recuperarte. Tiene un costo: consulta [Lo que cuesta omitir el pensamiento](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#drop-block-cost). No lo envíes en todas tus conversaciones para ocultar errores. ## Detalles técnicos ### Cómo funciona la verificación de prefijo Los modelos con pensamiento preservado registran una huella del prefijo de cada bloque de pensamiento en su `signature`. La referencia de la API llama a la verificación de prefijo la verificación de conversación, y el error 400 indica que un bloque que no supera la verificación de prefijo `is bound to a different conversation`. ### Qué modelos ejecutan la verificación de prefijo La verificación de prefijo se ejecuta en la Claude API y en [algunas plataformas en la nube](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking#feature-availability). Verifica los bloques de pensamiento que produjo un [modelo con pensamiento preservado](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/prefix-checks#outcomes), en solicitudes a uno de esos modelos. En la Claude API, otros modelos, como Claude Opus 5, no la ejecutan, y no cubre sus bloques. ### Qué cuenta como un cambio * **Cada bloque se verifica contra su propio registro.** La API compara lo que hay antes de un bloque en esta solicitud con lo que su firma registró cuando Claude lo produjo. Tu última solicitud no interviene. La verificación de prefijo solo observa el contenido, no las sesiones, los ID ni los usuarios. El mismo contenido en una nueva solicitud o en una bifurcación supera la verificación de prefijo. * **La verificación de prefijo compara lo que enviaste, no lo que leyó Claude.** La [compactación en un umbral de tokens](https://platform.claude.com/docs/es/build-with-claude/compaction-threshold) y la edición de contexto solo cambian lo que lee Claude, así que nunca cuentan. Después de un bloque de compactación por umbral, la API compara solo los mensajes a partir de ese bloque, además de `system` y `tools`. La compactación bajo demanda tiene sus propias condiciones: consulta [Condiciones para que el pensamiento conservado siga siendo válido](https://platform.claude.com/docs/es/build-with-claude/compaction-thinking-blocks#conditions-for-kept-thinking-to-stay-valid). Para un archivo enviado por URL y, en la Claude API, [una lista de herramientas MCP](https://platform.claude.com/docs/es/agents-and-tools/mcp-connector#pin-mcp-tool-list), la API compara en su lugar lo que obtuvo. * **El pensamiento que envías debe ser una secuencia ininterrumpida.** Los bloques de pensamiento no se comparan como contenido. Pero cada uno que envías, aparte del primero, debe tener el mismo bloque de pensamiento anterior que cuando Claude lo produjo. Así que puedes [omitir el más antiguo, el más reciente o todos ellos](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/change-tools-or-instructions#leave-out-thinking), pero no uno intermedio. Un cambio puede ser tan pequeño como una palabra de la descripción de una herramienta. Cambiar, insertar, mover o eliminar un mensaje anterior cuenta, sea cual sea su rol. También cuenta cambiar el texto que precede a un bloque de pensamiento en su propio mensaje. ### Qué no cuenta | Esto no cuenta | Porque | | ------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------- | | `model`, `effort`, `max_tokens`, `tool_choice`, `metadata`, `thinking.display` y otros parámetros | Solo se comparan `system`, `tools` y los mensajes | | El formato JSON o el orden de las claves | La API compara el JSON analizado, no su texto | | Los marcadores `cache_control` | Indican dónde almacenar en caché, y no son contenido que lea Claude | | Una herramienta con `defer_loading: true` a la que nada ha hecho referencia | No está en el contexto de Claude hasta que algo hace referencia a ella | ### Establece `prefix_mismatch_behavior` El [encabezado beta](https://platform.claude.com/docs/es/api/beta-headers#beta-features-on-other-platforms) `thinking-binding-controls-2026-08-01` agrega la configuración `thinking.block_binding.prefix_mismatch_behavior` y el array `input_transformations` de la respuesta. | Valor | Si un bloque no supera la verificación de prefijo | | ------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `"error"` | La API rechaza la solicitud con un error 400 que nombra el primer bloque inválido | | `"drop_block"` | La API omite los bloques inválidos, y la solicitud tiene éxito. No se te factura por esos bloques, pero [omitirlos puede costar más](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#drop-block-cost) | | Sin establecer, o `null` | [Depende del modelo](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/prefix-checks#outcomes) | Los bloques que no superan la verificación de prefijo siguen siendo inválidos en cada solicitud posterior que los envíe, mientras el cambio siga vigente. La configuración actúa solo sobre la solicitud que la lleva. Con el pensamiento desactivado (`"disabled"` o `"between_tools"`), enviarla produce un error 400 en todos los modelos. La siguiente solicitud establece `prefix_mismatch_behavior` en `"drop_block"`. En un primer turno no hay pensamiento que devolver, así que `input_transformations` se devuelve vacío: ```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}" ``` ### Vigila el tráfico de producción Con `prefix_mismatch_behavior` sin establecer, una solicitud que no supera la verificación de prefijo podría no recibir ningún error en [algunos modelos](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/prefix-checks#outcomes). Los bloques de pensamiento que no la superaron llegan entonces al modelo. Para encontrar esos bloques en el tráfico de producción, envía el encabezado beta `thinking-binding-controls-2026-08-01`, deja la configuración sin establecer y registra el array `input_transformations` de cada respuesta. El encabezado agrega ese array y no cambia lo que recibe el modelo. Cada uno de esos bloques obtiene su propia entrada `thinking_mismatch_allowed` en ese array. Una entrada tiene este aspecto: ```json { "input_transformations": [ { "type": "thinking_mismatch_allowed", "path": "messages.1.content.0", "reason": "prefix_binding_mismatch" } ] } ``` Para encontrar el cambio, consulta [Encuentra lo que cambió tu código](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#find-the-change). ### Comprueba qué caso obtienes En [algunos modelos](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/prefix-checks#outcomes), una solicitud que no supera la verificación de prefijo podría recibir el error 400 o ningún error. Esta prueba muestra cuál recibe una solicitud: 1. Toma una conversación que contenga un bloque de pensamiento de uno de esos modelos. Cambia o agrega la indicación del sistema (`system`). El bloque entonces no supera la verificación de prefijo, porque la indicación del sistema cambió después de que Claude produjera el bloque. 2. Envíala al mismo modelo con el encabezado beta `thinking-binding-controls-2026-08-01`, y deja `prefix_mismatch_behavior` sin establecer. La respuesta es una de estas: * **Un [error 400](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#prefix-mismatch-error) que dice `bound to a different conversation`:** La solicitud recibió el error 400. * **Una respuesta 200 cuyo array `input_transformations` tiene entradas `thinking_mismatch_allowed`:** La solicitud no recibió ningún error. Cada entrada nombra un bloque de pensamiento que no superó la verificación de prefijo y llegó a Claude. * **Una respuesta 200 cuyo array `input_transformations` está vacío:** Ningún bloque falló la verificación de prefijo, así que la prueba no muestra nada. Comprueba que la conversación contenga un bloque de pensamiento de ese modelo. El resultado describe esa única solicitud y no garantiza nada sobre las siguientes, así que escribe tu código para [manejar ambos casos](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/prefix-checks#handle-either-outcome). ## Próximos pasos Qué enviar en lugar de cada cambio que tu código hace en una conversación. Recupera una conversación que falla, encuentra lo que cambia tu código y comprueba que ya no ocurre. Qué es el pensamiento preservado, a qué está vinculado un bloque de pensamiento y cómo cambiar de modelo o de cuenta.