---
title: Corrige un bloque de pensamiento vinculado a una conversación diferente
url: https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation
description: Retoma una conversación después del error 400 que dice que un bloque de pensamiento está vinculado a una conversación diferente, encuentra lo que cambió tu código y comprueba que el cambio ya no está.
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
---
Enviar la misma solicitud de nuevo no puede funcionar, porque tu historial todavía contiene lo que cambió tu código. Envía `"drop_block"` y [detén los errores ahora](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#prefix-mismatch-error). La solución a largo plazo es hacer que tu código sea “append-only” ([de solo anexado](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/prefix-checks#prefix-check)).
## Error: The block is bound to a different conversation
El “thinking block” (bloque de pensamiento) no pasó la “prefix check” ([verificación de prefijo](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/prefix-checks#prefix-check)): algo anterior a él cambió después de que Claude lo produjera (consulta [Qué cuenta como un cambio](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/prefix-checks#what-counts-as-an-edit)), o se omitió o se movió un bloque de pensamiento situado entre otros. El error tiene este aspecto y puede continuar para [nombrar lo que cambió](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#prefix-mismatch-error-details):
```text wrap
messages.1.content.0: Invalid `signature` in `thinking` block. The block is bound to a different conversation. Remove the block, or set `thinking.block_binding.prefix_mismatch_behavior` to "drop_block".
```
“A different conversation” significa contenido diferente antes del bloque: la [verificación de prefijo](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/prefix-checks#prefix-check) no compara sesiones ni usuarios. El mensaje de error dice que elimines el bloque, pero [eliminar solo ese bloque no es suficiente](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#remove-by-hand). [Otros errores](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#similar-errors) pueden parecer similares.
Si la aplicación no es tuya, inicia una conversación nueva e informa a quien la mantiene. Si [eliminaste un secreto, datos personales o texto inyectado](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/change-tools-or-instructions#remove-sensitive-content), o tus solicitudes [desactivan el pensamiento](https://platform.claude.com/docs/es/build-with-claude/thinking#turning-thinking-off), [elimina el pensamiento manualmente](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#remove-by-hand) en lugar del paso 1.
Establece `thinking.block_binding.prefix_mismatch_behavior` en `"drop_block"` y envía el [encabezado beta](https://platform.claude.com/docs/es/api/beta-headers#beta-features-on-other-platforms) `anthropic-beta: thinking-binding-controls-2026-08-01`. Haz esto en cada solicitud posterior de la conversación, porque la API no almacena el ajuste entre solicitudes. Una conversación guardada todavía contiene el cambio, incluso después de que corrijas tu código, así que almacena el ajuste junto con ella. Establece `type` en `"adaptive"`, como se muestra:
```json
{
"thinking": {
"type": "adaptive",
"block_binding": {
"prefix_mismatch_behavior": "drop_block"
}
}
}
```
En el SDK, llama al método beta de Messages y pasa el valor del encabezado, como hace [el programa de prueba](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#how-to-tell-whether-your-integration-is-impacted-details). Si el error [sigue pidiendo el encabezado](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#setting-not-received), el encabezado no llegó.
Eso detiene los errores omitiendo el pensamiento no válido, pero [puede costar más](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#drop-block-cost) y puede afectar la calidad de la salida y la latencia. La siguiente solicitud tiene éxito, y su arreglo `input_transformations` enumera cada bloque que la API omitió.
Si tus solicitudes no establecen el parámetro `thinking`, agregarlo no cambia nada más, porque los [modelos con pensamiento preservado](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/prefix-checks#outcomes) piensan de forma adaptativa por defecto.
Haz que tu integración sea de solo anexado:
1. Encuentra el cambio. El error puede nombrarlo. Para encontrar dónde lo hace tu código, ejecuta `claude update` y luego ejecuta `/claude-api preserved-thinking-migration` en Claude Code en el repositorio de tu código. O [busca manualmente](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#find-the-change-details).
2. Deja de hacer el cambio, o las conversaciones nuevas también pueden recibir el error. [Envía una actualización al final en su lugar](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/change-tools-or-instructions).
3. Sigue enviando a cada conversación en curso el `system` y las `tools` de [su última solicitud exitosa](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/change-tools-or-instructions#saved-sessions).
Si el cambio fue reciente, puedes deshacerlo en su lugar: restaura lo que cambió tu código. El pensamiento de antes del cambio vuelve a ser válido. El pensamiento producido desde entonces no pasa la verificación de prefijo, así que elimínalo o sigue enviando `"drop_block"`.
## Lo que cuesta omitir el pensamiento
Claude puede gastar más tokens de salida elaborando un razonamiento que ya no puede leer. Omitir los bloques también invalida la “prompt cache” (caché de prompts) desde el primer bloque omitido en adelante.
Cuando algo cambia en cada turno, cada turno pierde el pensamiento de los turnos anteriores, así que el aumento se repite. Ejecuta evaluaciones sobre tu propia carga de trabajo antes de depender de `"drop_block"`.
Usa `"drop_block"` para mantener en marcha las conversaciones existentes mientras contienen un cambio que estás corrigiendo, y para una omisión planificada, como [después de tu propio resumen](https://platform.claude.com/docs/es/build-with-claude/compaction-thinking-blocks#own-summary). No lo dejes activado para ocultar un cambio que tu código sigue haciendo. Puedes [dejar de enviarlo](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#drop-block-cost-details) una vez que los bloques no válidos estén fuera del historial.
## Encuentra lo que cambió tu código
El cambio está antes del primer bloque que nombra la API. El error 400 puede decir qué cambió, como `system`, `tools`, un bloque de pensamiento que falta o el primer mensaje que difiere. Si no hay error, o si el error no lo dice, [empieza por lo que tienes](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#find-the-change-details), como una entrada `prefix_binding_mismatch` o más tokens de salida.
## Prueba tu código para detectar fallos de la verificación de prefijo
Puedes confiar en una prueba una vez que la has visto fallar. Primero, a través de tu propio código, ejecuta una sesión que haga pensar a Claude y cambia algo a propósito. Envía `"drop_block"` en este paso, para que la respuesta enumere cada bloque no válido en lugar de detenerse en el primero, como muestran [cinco pasos y un programa](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#how-to-tell-whether-your-integration-is-impacted-details).
Luego quita ese cambio y ejecuta tus sesiones reales. En cada solicitud, envía el encabezado beta `thinking-binding-controls-2026-08-01` y establece [`prefix_mismatch_behavior`](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/prefix-checks#preserved-thinking-controls) en `"error"`, para que un cambio que haga tu código en esas sesiones haga fallar la compilación con el error 400.
Prueba sesiones que compactan, agregan herramientas tarde, cambian instrucciones, [cambian de modelo](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking#switching-models) o se reanudan: los turnos simples no llegan a ese código.
Una ejecución limpia no tiene ninguna entrada `prefix_binding_mismatch` ni ningún error. Solo muestra que los bloques que verificó son válidos, en las sesiones que ejecutaste. No demuestra nada si:
* la sesión no tuvo bloques de pensamiento
* tu código elimina todo el pensamiento, o el modelo no tiene pensamiento preservado
* no enviaste el encabezado beta, y [el modelo podría dejar pasar bloques que no pasan la verificación de prefijo](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/prefix-checks#outcomes) sin un error
## Vigila producción y encuentra razonamiento perdido sin error
Registra cada error 400 y [manéjalo en código](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#handle-the-error-in-code) para que la conversación continúe. Si en cambio no incluyes `prefix_mismatch_behavior` en la solicitud, [vigila el tráfico de producción](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/prefix-checks#watch-production-traffic) para detectar pensamiento que no pasa la verificación de prefijo y que llegó a Claude.
El razonamiento puede perderse sin error a través de `"drop_block"`, un elemento de lote, un cambio de modelo, un paso a [otra cuenta](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking#account-bound-thinking) o un código que no devuelve ningún pensamiento. Con el encabezado beta, cada uno deja una entrada excepto el último. Para ese, comprueba que tus solicitudes contengan bloques `thinking`.
## Detalles técnicos
### Qué más puede decir el mensaje de error
El mensaje de error continúa nombrando lo que cambió, cuando la API puede determinarlo, como `system`, `tools`, el primer mensaje o bloque que difiere, contenido que falta o es nuevo, o un bloque de pensamiento anterior que falta o está fuera de orden. La redacción de esa oración puede cambiar, así que no hagas coincidencias con ella. Si la solicitud no tenía encabezado beta, el mensaje de error agrega esta oración:
```text wrap
That setting requires the `thinking-binding-controls-2026-08-01` value in the `anthropic-beta` header.
```
### El error sigue pidiendo el encabezado, o dice `Extra inputs are not permitted`
Si el error sigue pidiendo el encabezado, el encabezado no llegó a la API: un proxy o una biblioteca podría haberlo eliminado. Un error diferente, que termina en `block_binding: Extra inputs are not permitted`, significa lo mismo, o que el pensamiento está desactivado.
### Elimina manualmente el pensamiento no válido
Usa esto donde no puedas enviar el ajuste, o en uno de estos casos:
* Después de eliminar un secreto, datos personales o texto inyectado, porque `"drop_block"` deja el pensamiento en tu historial almacenado.
* Cuando el pensamiento está desactivado (`"disabled"` o `"between_tools"`), porque `"drop_block"` necesita `"adaptive"`, lo que activaría el pensamiento y agregaría tokens de salida.
1. Elimina el bloque que nombra el error, y cada bloque `thinking` y [`redacted_thinking`](https://platform.claude.com/docs/es/build-with-claude/thinking#redacted-thinking-blocks) posterior a él, o el mismo error nombrará luego el siguiente bloque no válido. Pero si tu historial contiene mensajes `role: "system"`, o dos mensajes del mismo rol seguidos, elimina todos los bloques `thinking` y `redacted_thinking`. El error cuenta ese tipo de mensaje como parte del mensaje anterior, así que la posición que nombra puede ser menor que el índice en tu arreglo. El `path` de una entrada de `input_transformations` cuenta cada mensaje por separado.
2. Conserva todos los demás bloques y envía la solicitud de nuevo. No vuelvas a poner los bloques eliminados.
### Errores que se parecen a este
Estos errores no dicen que el bloque esté vinculado a una conversación diferente, y establecer `prefix_mismatch_behavior` podría no resolverlos:
* Un mensaje que termina después de “Invalid `signature` in `thinking` block”, que dice “cannot be modified” o que trata sobre `budget_tokens`: [Solución de problemas del pensamiento](https://platform.claude.com/docs/es/build-with-claude/thinking-troubleshooting)
* Un mensaje sobre `temperature` o una respuesta prellenada: [Límites y compatibilidad de funciones](https://platform.claude.com/docs/es/build-with-claude/thinking#limits-and-feature-compatibility)
### Cuándo puedes dejar de enviar `"drop_block"`
Para dejar de enviar `"drop_block"`, elimina los bloques que omite y conserva el pensamiento producido desde entonces. Si nada más ha cambiado, la conversación pasa entonces con `"error"`.
### Maneja el error en código
Para manejar el error en código, envía el encabezado beta y `"error"` en cada solicitud, para que un fallo sea un error 400 en todos los modelos. Cuando llegue, cambia solo esa conversación a `"drop_block"` para cada solicitud posterior, almacena esa elección junto con ella, envía de nuevo una vez y registra el error. Si vuelve el mismo error, el ajuste no llegó a la API: consulta [El error sigue pidiendo el encabezado, o dice `Extra inputs are not permitted`](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#setting-not-received).
Tu código tiene que reconocer este error por su campo `message`, la excepción al consejo general de no hacer coincidencias con el texto de un error. Todos los errores 400 tienen el tipo `invalid_request_error`, y este no tiene `error.details.error_code`. Haz coincidencias solo con “The block is bound to a different conversation”, porque el resto del mensaje puede cambiar.
### No tienes ningún error, o tienes uno que no dice qué cambió
* **El error 400, y no nombra ningún cambio:** Compara las solicitudes tú mismo. Una causa es un bloque de compactación enviado sin eliminar los mensajes que resume.
* **Una entrada `prefix_binding_mismatch`:** Compara `system`, `tools` y `messages` hasta el `path` de la primera entrada con la conversación tal como era cuando se produjo ese bloque. Si todos los bloques están enumerados, empieza por `system` y `tools`.
Si nada difiere, busca [una URL de imagen o documento cuyo contenido cambió](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/change-tools-or-instructions#files-by-id), una lista de herramientas de un servidor MCP que cambió (consulta [Fija la lista de herramientas de un servidor MCP](https://platform.claude.com/docs/es/agents-and-tools/mcp-connector#pin-mcp-tool-list)), o un bloque de pensamiento omitido, movido o vuelto a poner. Sin registros de solicitudes, envía la solicitud de nuevo con `"error"` y lee la oración que dice qué difiere, si la hay.
* **Un proxy o una biblioteca que no es tuyo, en medio:** Compara lo que envía con lo que enviaste tú, e indica a quien lo mantiene la sección [Bibliotecas, proxies y gateways](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/change-tools-or-instructions#libraries-proxies-gateways).
* **Solo una sospecha, y sin Claude Code:** Captura los cuerpos de las solicitudes de una conversación, una que tenga una compactación o un cambio de herramientas. Compara cada uno con el anterior, dejando fuera sus turnos nuevos.
### Cinco pasos para una prueba que puede fallar, y un programa que los ejecuta
1. En tu propio código, envía el encabezado beta y `"drop_block"` en cada solicitud de una sesión, a un [modelo con pensamiento preservado](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/prefix-checks#outcomes).
2. Usa prompts que hagan pensar a Claude y comprueba que la primera respuesta tenga un bloque `thinking`. Con el pensamiento adaptativo, Claude puede omitir el pensamiento en un prompt fácil.
3. Falla solo ante una entrada de `input_transformations` cuyo motivo sea `prefix_binding_mismatch`. Una prueba que espera un arreglo vacío también falla después de un cambio de modelo, porque en ese caso se esperan entradas con `model_binding_mismatch` u `organization_binding_mismatch`.
4. Cambia algo a propósito, como agregar un prompt `system` solo en la tercera solicitud.
5. Comprueba que `input_transformations` enumere los bloques de pensamiento que están después del cambio. Si no enumera ninguno, comprueba que el historial contenga un bloque de pensamiento.
Este programa realiza los pasos 1, 2, 4 y 5. Imprime cuántos bloques de pensamiento y entradas de `input_transformations` tiene cada respuesta, y luego cada entrada, que es lo que verifica el paso 3:
Este flujo de trabajo necesita más lógica que un solo comando de shell. Usa el [Anthropic SDK](https://platform.claude.com/docs/es/cli-sdks-libraries/overview) para ejecutarlo.
Este flujo de trabajo necesita más lógica que un solo comando de shell. Usa el [Anthropic SDK](https://platform.claude.com/docs/es/cli-sdks-libraries/overview) para ejecutarlo.
```python Python
client = anthropic.Anthropic()
user_turns = [
"How many positive integers below 500 have exactly 6 positive divisors?",
"How many have exactly 8?",
"How many have exactly 10?",
]
messages = []
for turn, user_turn in enumerate(user_turns, start=1):
messages.append({"role": "user", "content": user_turn})
response = client.beta.messages.create(
model="claude-opus-5-5",
max_tokens=16000,
thinking={
"type": "adaptive",
"block_binding": {"prefix_mismatch_behavior": "drop_block"},
},
# Solo la última solicitud agrega una indicación del sistema, lo que cambia el prefijo a propósito
system="Answer briefly." if turn == len(user_turns) else anthropic.omit,
messages=messages,
betas=["thinking-binding-controls-2026-08-01"],
)
messages.append({"role": "assistant", "content": response.content})
thinking_blocks = sum(block.type == "thinking" for block in response.content)
entries = response.input_transformations or []
print(f"thinking blocks: {thinking_blocks}, entries: {len(entries)}")
for entry in entries:
if entry.type == "thinking_dropped":
print(entry.type, entry.path, entry.reason)
```
```typescript TypeScript
const client = new Anthropic();
const userTurns = [
"How many positive integers below 500 have exactly 6 positive divisors?",
"How many have exactly 8?",
"How many have exactly 10?"
];
const messages: Anthropic.Beta.BetaMessageParam[] = [];
for (const [turnIndex, userTurn] of userTurns.entries()) {
messages.push({ role: "user", content: userTurn });
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" }
},
// Solo la última solicitud agrega una indicación del sistema, lo que cambia el prefijo a propósito
system: turnIndex === userTurns.length - 1 ? "Answer briefly." : undefined,
messages,
betas: ["thinking-binding-controls-2026-08-01"]
});
messages.push({ role: "assistant", content: response.content });
const thinkingBlocks = response.content.filter((block) => block.type === "thinking");
const entries = response.input_transformations ?? [];
console.log(`thinking blocks: ${thinkingBlocks.length}, entries: ${entries.length}`);
for (const entry of entries) {
if (entry.type === "thinking_dropped") {
console.log(entry.type, entry.path, entry.reason);
}
}
}
```
```csharp C#
using Anthropic.Models.Beta;
using Anthropic.Models.Beta.Messages;
using Model = Anthropic.Models.Messages.Model;
AnthropicClient client = new();
string[] userTurns =
[
"How many positive integers below 500 have exactly 6 positive divisors?",
"How many have exactly 8?",
"How many have exactly 10?",
];
List messages = [];
foreach (var (turnIndex, userTurn) in userTurns.Index())
{
messages.Add(new BetaUserMessageParam { Content = userTurn });
var response = await client.Beta.Messages.Create(
new()
{
Model = Model.ClaudeOpus5_5,
MaxTokens = 16000,
Thinking = new BetaThinkingConfigAdaptive
{
BlockBinding = new()
{
PrefixMismatchBehavior = BetaThinkingPrefixMismatchBehavior.DropBlock,
},
},
// Solo la última solicitud agrega una indicación del sistema, lo que cambia el prefijo a propósito
System = turnIndex == userTurns.Length - 1 ? new("Answer briefly.") : null,
Messages = messages,
Betas = [AnthropicBeta.ThinkingBindingControls2026_08_01],
}
);
messages.Add(new BetaAssistantMessageParam
{
Content = response.Content.Select(block => new BetaContentBlockParam(block.Json)).ToList(),
});
var thinkingBlocks = response.Content.Count(block => block.TryPickThinking(out _));
var entries = response.InputTransformations ?? [];
Console.WriteLine($"thinking blocks: {thinkingBlocks}, entries: {entries.Count}");
foreach (var entry in entries)
{
if (entry.TryPickThinkingDropped(out var dropped))
{
Console.WriteLine($"{dropped.Type} {dropped.Path} {dropped.Reason.Raw()}");
}
}
}
```
```go Go
client := anthropic.NewClient()
userTurns := []string{
"How many positive integers below 500 have exactly 6 positive divisors?",
"How many have exactly 8?",
"How many have exactly 10?",
}
messages := []anthropic.BetaMessageParam{}
for turnIndex, userTurn := range userTurns {
messages = append(messages, anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock(userTurn)))
// Solo la última solicitud agrega una indicación del sistema, lo que cambia el prefijo a propósito
var system []anthropic.BetaTextBlockParam
if turnIndex == len(userTurns)-1 {
system = []anthropic.BetaTextBlockParam{{Text: "Answer briefly."}}
}
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,
},
},
},
System: system,
Messages: messages,
Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaThinkingBindingControls2026_08_01},
})
if err != nil {
log.Fatal(err)
}
messages = append(messages, response.ToParam())
thinkingBlocks := 0
for _, block := range response.Content {
if block.Type == "thinking" {
thinkingBlocks++
}
}
fmt.Printf("thinking blocks: %d, entries: %d\n", thinkingBlocks, len(response.InputTransformations))
for _, entry := range response.InputTransformations {
if entry.Type == "thinking_dropped" {
fmt.Println(entry.Type, entry.Path, entry.Reason)
}
}
}
```
```java Java
import com.anthropic.models.beta.AnthropicBeta;
import com.anthropic.models.beta.messages.BetaContentBlock;
import com.anthropic.models.beta.messages.BetaInputTransformation;
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();
List userTurns = List.of(
"How many positive integers below 500 have exactly 6 positive divisors?",
"How many have exactly 8?",
"How many have exactly 10?");
MessageCreateParams.Builder conversation = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(16000L)
.thinking(BetaThinkingConfigAdaptive.builder()
.blockBinding(BetaThinkingBlockBinding.builder()
.prefixMismatchBehavior(BetaThinkingPrefixMismatchBehavior.DROP_BLOCK)
.build())
.build())
.addBeta(AnthropicBeta.THINKING_BINDING_CONTROLS_2026_08_01);
for (int turnIndex = 0; turnIndex < userTurns.size(); turnIndex++) {
if (turnIndex == userTurns.size() - 1) {
// Solo la última solicitud agrega una indicación del sistema, lo que cambia el prefijo a propósito
conversation.system("Answer briefly.");
}
conversation.addUserMessage(userTurns.get(turnIndex));
BetaMessage response = client.beta().messages().create(conversation.build());
conversation.addMessage(response);
long thinkingBlocks = response.content().stream()
.filter(BetaContentBlock::isThinking)
.count();
List entries = response.inputTransformations().orElse(List.of());
IO.println("thinking blocks: " + thinkingBlocks + ", entries: " + entries.size());
for (BetaInputTransformation entry : entries) {
entry.thinkingDropped().ifPresent(dropped ->
IO.println(entry.type() + " " + dropped.path() + " " + dropped.reason()));
}
}
}
```
```php PHP
use Anthropic\Beta\AnthropicBeta;
use Anthropic\Beta\Messages\BetaThinkingBlock;
use Anthropic\Beta\Messages\BetaThinkingBlockBinding;
use Anthropic\Beta\Messages\BetaThinkingConfigAdaptive;
use Anthropic\Beta\Messages\BetaThinkingDroppedInputTransformation;
use Anthropic\Beta\Messages\BetaThinkingPrefixMismatchBehavior;
use Anthropic\Client;
use Anthropic\Messages\Model;
$client = new Client();
$userTurns = [
'How many positive integers below 500 have exactly 6 positive divisors?',
'How many have exactly 8?',
'How many have exactly 10?',
];
$messages = [];
foreach ($userTurns as $turnIndex => $userTurn) {
$messages[] = ['role' => 'user', 'content' => $userTurn];
$response = $client->beta->messages->create(
model: Model::CLAUDE_OPUS_5_5,
maxTokens: 16000,
thinking: BetaThinkingConfigAdaptive::with(
blockBinding: BetaThinkingBlockBinding::with(
prefixMismatchBehavior: BetaThinkingPrefixMismatchBehavior::DROP_BLOCK,
),
),
// Solo la última solicitud agrega una indicación del sistema, lo que cambia el prefijo a propósito
system: $turnIndex === array_key_last($userTurns) ? 'Answer briefly.' : null,
messages: $messages,
betas: [AnthropicBeta::THINKING_BINDING_CONTROLS_2026_08_01],
);
$messages[] = ['role' => 'assistant', 'content' => $response->content];
$thinkingBlocks = array_filter(
$response->content,
fn ($block) => $block instanceof BetaThinkingBlock,
);
$entries = $response->inputTransformations ?? [];
echo 'thinking blocks: ', count($thinkingBlocks), ', entries: ', count($entries), PHP_EOL;
foreach ($entries as $entry) {
if ($entry instanceof BetaThinkingDroppedInputTransformation) {
echo $entry->type, ' ', $entry->path, ' ', $entry->reason, PHP_EOL;
}
}
}
```
```ruby Ruby
client = Anthropic::Client.new
user_turns = [
"How many positive integers below 500 have exactly 6 positive divisors?",
"How many have exactly 8?",
"How many have exactly 10?"
]
messages = []
user_turns.each_with_index do |user_turn, turn_index|
messages << { role: "user", content: user_turn }
# Solo la última solicitud agrega una indicación del sistema, lo que cambia el prefijo a propósito
system_param = (turn_index == user_turns.length - 1) ? { system_: "Answer briefly." } : {}
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: messages,
betas: [Anthropic::AnthropicBeta::THINKING_BINDING_CONTROLS_2026_08_01],
**system_param
)
messages << { role: "assistant", content: response.content }
thinking_blocks = response.content.count { |block| block.is_a?(Anthropic::Beta::BetaThinkingBlock) }
entries = response.input_transformations || []
puts "thinking blocks: #{thinking_blocks}, entries: #{entries.length}"
entries.each do |entry|
if entry.is_a?(Anthropic::Beta::BetaThinkingDroppedInputTransformation)
puts "#{entry.type} #{entry.path} #{entry.reason}"
end
end
end
```
```text Output wrap
thinking blocks: 1, entries: 0
thinking blocks: 1, entries: 0
thinking blocks: 1, entries: 2
thinking_dropped messages.1.content.0 prefix_binding_mismatch
thinking_dropped messages.3.content.0 prefix_binding_mismatch
```
Con `"error"` en lugar de `"drop_block"`, la tercera solicitud recibe [el error 400](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/fix-bound-to-a-different-conversation#prefix-mismatch-error).
### Qué significa cada entrada de `input_transformations`, y cuáles te corresponde corregir
Con el encabezado beta, una respuesta de un modelo que admite el pensamiento tiene el arreglo `input_transformations` junto a `usage`. Está vacío cuando no se omitió nada y no se dejó pasar nada no válido. Cuando usas streaming, está en el `message` del evento `message_start`; después de un fallback a mitad del stream, el evento `message_delta` final contiene el que cuenta. A diferencia de la posición del error, `path` es siempre el lugar del bloque tal como lo enviaste:
```json
{
"input_transformations": [
{
"type": "thinking_dropped",
"path": "messages.1.content.0",
"reason": "prefix_binding_mismatch"
}
]
}
```
El `type` y el `reason` de cada entrada, y lo que significan:
* **`thinking_dropped`, `prefix_binding_mismatch`:** Lo que venía antes de este bloque no es lo que registró. Te corresponde corregirlo: [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).
* **`thinking_mismatch_allowed`, `prefix_binding_mismatch`:** Lo mismo, pero Claude leyó el bloque sin cambios, y se factura. Esta entrada aparece solo cuando la solicitud no incluye el ajuste, en [algunos modelos](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/prefix-checks#outcomes). Te corresponde corregirlo.
* **`thinking_dropped`, `model_binding_mismatch`:** Este modelo no puede leer bloques del modelo que lo produjo. No te corresponde corregirlo: [sigue enviando la conversación completa](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking#switching-models).
* **`thinking_dropped`, `organization_binding_mismatch`:** Otra cuenta produjo el bloque, así que [la API lo omitió](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking#account-bound-thinking). No te corresponde corregirlo.
Ignora cualquier entrada cuyo `type` o `reason` no reconozcas.
### Lotes y conteo de tokens
* **[Lotes de mensajes](https://platform.claude.com/docs/es/build-with-claude/batch-processing):** Un elemento que no incluye `prefix_mismatch_behavior` nunca recibe el error 400. La API omite los bloques no válidos o, en [algunos modelos](https://platform.claude.com/docs/es/build-with-claude/preserved-thinking/prefix-checks#outcomes), puede dejarlos pasar. Un elemento que establece `"error"` se resuelve como `errored` cuando un bloque no pasa la verificación de prefijo. `block_binding` va en el `params.thinking` del elemento.
* **[Conteo de tokens](https://platform.claude.com/docs/es/build-with-claude/token-counting):** En la Claude API, el conteo de tokens puede devolver el mismo error 400 y acepta `prefix_mismatch_behavior` con el mismo encabezado. Deja los bloques omitidos fuera del conteo y no devuelve `input_transformations`.
## Próximos pasos
Qué enviar en lugar de cada cambio que tu código hace en una conversación.
Qué es el pensamiento preservado, a qué está vinculado un bloque de pensamiento y cómo cambiar de modelo o de cuenta.
Soluciones para otros errores de pensamiento, como una firma que no se verifica.