fix(anthropic): strip thinking blocks from history when thinking is disabled

liuhao1024 · liuhao1024 · commit 5e8dc95ba43d · 2026-06-12T15:08:42.000+08:00
When a persistent session accumulates thinking blocks from previous runs (thinking enabled) but the current request has thinking disabled, Anthropic rejects the request with a 400 because the history contains thinking content blocks without a matching thinking configuration. This commonly affects cron jobs running in named sessions where the thinking configuration changes between runs. Fix: in convertMessages, when thinkingEnabled is explicitly false, convert thinking blocks to plain text (preserving context) and drop redacted thinking blocks (opaque, no readable content). When thinkingEnabled is undefined (not set), existing behavior is preserved. Fixes #92360
diff --git a/src/llm/providers/anthropic.test.ts b/src/llm/providers/anthropic.test.ts
@@ -242,6 +242,100 @@ describe("Anthropic provider", () => {
     expect(result.responseModel).toBe("claude-fable-5");
   });
 
+  it("strips thinking blocks from history when thinking is explicitly disabled", async () => {
+    let capturedPayload: unknown;
+    const client = {
+      messages: {
+        create: vi.fn(() => ({
+          asResponse: () =>
+            Promise.resolve(
+              createSseResponse([
+                {
+                  type: "message_start",
+                  message: {
+                    id: "msg_1",
+                    model: "claude-sonnet-4-6",
+                    usage: { input_tokens: 1, output_tokens: 0 },
+                  },
+                },
+                {
+                  type: "message_delta",
+                  delta: { stop_reason: "end_turn" },
+                  usage: { input_tokens: 1, output_tokens: 1 },
+                },
+                { type: "message_stop" },
+              ]),
+            ),
+        })),
+      },
+    };
+
+    const stream = streamAnthropic(
+      makeAnthropicModel(),
+      {
+        messages: [
+          { role: "user", content: "hello", timestamp: 0 },
+          {
+            role: "assistant",
+            provider: "anthropic",
+            api: "anthropic-messages",
+            model: "claude-sonnet-4-6",
+            stopReason: "stop",
+            timestamp: 0,
+            usage: {
+              input: 0,
+              output: 0,
+              cacheRead: 0,
+              cacheWrite: 0,
+              totalTokens: 0,
+              cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+            },
+            content: [
+              {
+                type: "thinking",
+                thinking: "deep reasoning about the answer",
+                thinkingSignature: "sig_1",
+              },
+              {
+                type: "text",
+                text: "Here is the answer.",
+              },
+            ],
+          },
+          { role: "user", content: "again", timestamp: 0 },
+        ],
+      },
+      {
+        apiKey: "***",
+        client: client as never,
+        thinkingEnabled: false,
+        onPayload: (payload) => {
+          capturedPayload = payload;
+        },
+      },
+    );
+
+    await stream.result();
+
+    const payload = capturedPayload as { messages: Array<{ role: string; content: unknown[] }> };
+    const assistantMessage = payload.messages.find((message) => message.role === "assistant");
+    // Thinking block with signature should be converted to plain text, not sent as thinking type
+    expect(assistantMessage?.content).toEqual([
+      {
+        type: "text",
+        text: "deep reasoning about the answer",
+      },
+      {
+        type: "text",
+        text: "Here is the answer.",
+      },
+    ]);
+    // No thinking or redacted_thinking blocks should be present
+    const contentStr = JSON.stringify(assistantMessage?.content);
+    expect(contentStr).not.toContain('"type":"thinking"');
+    expect(contentStr).not.toContain('"type":"redacted_thinking"');
+  });
+
   it.each([
     ["anthropic", "sk-ant-provider"],
     ["anthropic-vertex", "vertex-token"],
diff --git a/src/llm/providers/anthropic.ts b/src/llm/providers/anthropic.ts
@@ -1080,6 +1080,7 @@ function buildParams(
       isOAuthTokenResult,
       cacheControl,
       messageCacheControlLimit,
+      options?.thinkingEnabled,
     ),
     max_tokens: options?.maxTokens ?? model.maxTokens,
     stream: true,
@@ -1166,6 +1167,7 @@ function convertMessages(
   isOAuthTokenValue: boolean,
   cacheControl?: CacheControlEphemeral,
   messageCacheControlLimit = 4,
+  thinkingEnabled?: boolean,
 ): MessageParam[] {
   const params: MessageParam[] = [];
 
@@ -1227,6 +1229,18 @@ function convertMessages(
             text: sanitizeSurrogates(block.text),
           });
         } else if (block.type === "thinking") {
+          // When thinking is explicitly disabled for the current request, Anthropic
+          // rejects history containing thinking/redacted_thinking blocks. Strip them
+          // and convert to plain text where possible to preserve context.
+          if (thinkingEnabled === false) {
+            if (!block.redacted && block.thinking?.trim()) {
+              blocks.push({
+                type: "text",
+                text: sanitizeSurrogates(block.thinking),
+              });
+            }
+            continue;
+          }
           // Redacted thinking: pass the opaque payload back as redacted_thinking
           if (block.redacted) {
             blocks.push({
