fix(provider): preserve assistant message content when reasoning blocks present

normalizeMessages() unconditionally filtered empty text parts from all
message roles, including assistant. When Anthropic adaptive thinking
(Opus 4.6+) emits an empty text part between two reasoning blocks,
removing it shifts thinking block positions and invalidates the
cryptographic signatures, causing the API to reject with:
'thinking blocks in the latest assistant message cannot be modified'

But Anthropic also rejects empty text content blocks with 'text content
blocks must be non-empty', and the AI SDK's convertToLanguageModelPrompt
strips them, so the fix requires two layers:

1. transform.ts: normalizeMessages() skips the empty-text filter for
   assistant messages that contain reasoning blocks. Messages without
   reasoning continue to be filtered normally. This is a defensive
   guard that handles raw ModelMessage[] scenarios.

2. message-v2.ts: when building UIMessage parts, empty text parts in
   assistant messages that contain reasoning blocks are replaced with
   a single space. The space preserves the structural arrangement
   (reasoning block positions) without triggering Anthropic's empty
   content rejection or the SDK's filter. Signatures are on the
   reasoning block content, not the text between them, so a non-empty
   placeholder keeps the arrangement valid.

Closes #16748

Author: edevil

packages/opencode/src/provider/transform.ts

@@ -51,7 +51,10 @@ function normalizeMessages(
   _options: Record<string, unknown>,
 ): ModelMessage[] {
   // Anthropic rejects messages with empty content - filter out empty string messages
-  // and remove empty text/reasoning parts from array content
+  // and remove empty text/reasoning parts from array content.
+  // Assistant messages with reasoning blocks are excluded from filtering because
+  // thinking block signatures encode positional context — removing an empty text
+  // part between reasoning blocks invalidates the signatures.
   if (model.api.npm === "@ai-sdk/anthropic" || model.api.npm === "@ai-sdk/amazon-bedrock") {
     msgs = msgs
       .map((msg) => {
@@ -60,6 +63,7 @@ function normalizeMessages(
           return msg
         }
         if (!Array.isArray(msg.content)) return msg
+        if (msg.role === "assistant" && msg.content.some((part) => part.type === "reasoning")) return msg
         const filtered = msg.content.filter((part) => {
           if (part.type === "text" || part.type === "reasoning") {
             return part.text !== ""

packages/opencode/src/session/message-v2.ts

@@ -825,13 +825,23 @@ export const toModelMessagesEffect = Effect.fnUntraced(function* (
         role: "assistant",
         parts: [],
       }
+      // Empty text parts adjacent to signed reasoning blocks must be preserved
+      // positionally to keep thinking block signatures valid. But Anthropic
+      // rejects text content blocks that are empty, and the AI SDK strips them
+      // too. Substitute a single space — the signatures are on the reasoning
+      // block content, not the text between them, so a non-empty placeholder
+      // keeps the structural arrangement without invalidating signatures.
+      // See transform.ts normalizeMessages for the matching defensive guard.
+      const hasReasoning = msg.parts.some((p) => p.type === "reasoning")
       for (const part of msg.parts) {
-        if (part.type === "text")
+        if (part.type === "text") {
+          const text = part.text === "" && hasReasoning ? " " : part.text
           assistantMessage.parts.push({
             type: "text",
-            text: part.text,
+            text,
             ...(differentModel ? {} : { providerMetadata: part.metadata }),
           })
+        }
         if (part.type === "step-start")
           assistantMessage.parts.push({
             type: "step-start",

packages/opencode/test/provider/transform.test.ts

@@ -1148,7 +1148,7 @@ describe("ProviderTransform.message - anthropic empty content filtering", () =>
     expect(result[0].content[0]).toEqual({ type: "text", text: "Hello" })
   })
 
-  test("filters out empty reasoning parts from array content", () => {
+  test("preserves assistant message verbatim when reasoning blocks present", () => {
     const msgs = [
       {
         role: "assistant",
@@ -1162,12 +1162,16 @@ describe("ProviderTransform.message - anthropic empty content filtering", () =>
 
     const result = ProviderTransform.message(msgs, anthropicModel, {})
 
+    // Assistant messages with reasoning blocks are preserved verbatim
+    // because thinking block signatures encode positional context
     expect(result).toHaveLength(1)
-    expect(result[0].content).toHaveLength(1)
-    expect(result[0].content[0]).toEqual({ type: "text", text: "Answer" })
+    expect(result[0].content).toHaveLength(3)
+    expect(result[0].content[0]).toEqual({ type: "reasoning", text: "" })
+    expect(result[0].content[1]).toEqual({ type: "text", text: "Answer" })
+    expect(result[0].content[2]).toEqual({ type: "reasoning", text: "" })
   })
 
-  test("removes entire message when all parts are empty", () => {
+  test("preserves assistant message with all-empty parts when reasoning present", () => {
     const msgs = [
       { role: "user", content: "Hello" },
       {
@@ -1182,9 +1186,54 @@ describe("ProviderTransform.message - anthropic empty content filtering", () =>
 
     const result = ProviderTransform.message(msgs, anthropicModel, {})
 
-    expect(result).toHaveLength(2)
+    // Preserved because reasoning blocks are present
+    expect(result).toHaveLength(3)
     expect(result[0].content).toBe("Hello")
-    expect(result[1].content).toBe("World")
+    expect(result[1].content).toHaveLength(2)
+    expect(result[2].content).toBe("World")
+  })
+
+  test("preserves empty text between reasoning blocks in assistant messages", () => {
+    // Anthropic adaptive thinking (Opus 4.6+) emits:
+    //   reasoning(sig1) → text("") → reasoning(sig2) → text("answer") → tool_use
+    // The empty text is positionally significant — thinking block signatures
+    // encode block arrangement. Removing it invalidates signatures.
+    const msgs = [
+      {
+        role: "assistant",
+        content: [
+          {
+            type: "reasoning",
+            text: "analyzing...",
+            providerOptions: { anthropic: { signature: "sig1" } },
+          },
+          { type: "text", text: "" },
+          {
+            type: "reasoning",
+            text: "checking auth...",
+            providerOptions: { anthropic: { signature: "sig2" } },
+          },
+          { type: "text", text: "Let me check." },
+          {
+            type: "tool-call",
+            toolCallId: "toolu_01ABC",
+            toolName: "grep",
+            input: { pattern: "endpoint" },
+          },
+        ],
+      },
+    ] as any[]
+
+    const result = ProviderTransform.message(msgs, anthropicModel, {})
+
+    expect(result).toHaveLength(1)
+    const parts = result[0].content as any[]
+    expect(parts).toHaveLength(5)
+    expect(parts[0].type).toBe("reasoning")
+    expect(parts[1]).toEqual({ type: "text", text: "" })
+    expect(parts[2].type).toBe("reasoning")
+    expect(parts[3].text).toBe("Let me check.")
+    expect(parts[4].type).toBe("tool-call")
   })
 
   test("keeps non-text/reasoning parts even if text parts are empty", () => {
@@ -1210,7 +1259,7 @@ describe("ProviderTransform.message - anthropic empty content filtering", () =>
     })
   })
 
-  test("keeps messages with valid text alongside empty parts", () => {
+  test("preserves all parts in assistant message with reasoning alongside empty text", () => {
     const msgs = [
       {
         role: "assistant",
@@ -1224,10 +1273,12 @@ describe("ProviderTransform.message - anthropic empty content filtering", () =>
 
     const result = ProviderTransform.message(msgs, anthropicModel, {})
 
+    // All 3 parts preserved — reasoning present means no filtering
     expect(result).toHaveLength(1)
-    expect(result[0].content).toHaveLength(2)
+    expect(result[0].content).toHaveLength(3)
     expect(result[0].content[0]).toEqual({ type: "reasoning", text: "Thinking..." })
-    expect(result[0].content[1]).toEqual({ type: "text", text: "Result" })
+    expect(result[0].content[1]).toEqual({ type: "text", text: "" })
+    expect(result[0].content[2]).toEqual({ type: "text", text: "Result" })
   })
 
   test("filters empty content for bedrock provider", () => {

packages/opencode/test/session/message-v2.test.ts

@@ -947,6 +947,98 @@ describe("session.message-v2.toModelMessage", () => {
       },
     ])
   })
+
+  test("substitutes space for empty text parts when reasoning blocks present", async () => {
+    // An empty text part between two signed reasoning blocks must retain its
+    // positional slot to keep thinking block signatures valid. But Anthropic
+    // rejects text content blocks with empty text, and the AI SDK's
+    // convertToLanguageModelPrompt also strips them. Substitute a space so the
+    // part survives both filters and Anthropic accepts it. This test reproduces
+    // the exact pattern from the bug: [step-start, reasoning(sig), text(""),
+    // step-start, reasoning(sig), text(full)].
+    const assistantID = "m-assistant"
+    const input: MessageV2.WithParts[] = [
+      {
+        info: assistantInfo(assistantID, "m-parent"),
+        parts: [
+          {
+            ...basePart(assistantID, "p1"),
+            type: "step-start",
+          },
+          {
+            ...basePart(assistantID, "p2"),
+            type: "reasoning",
+            text: "thinking-one",
+            metadata: { anthropic: { signature: "sig1" } },
+          },
+          {
+            ...basePart(assistantID, "p3"),
+            type: "text",
+            text: "",
+          },
+          {
+            ...basePart(assistantID, "p4"),
+            type: "step-start",
+          },
+          {
+            ...basePart(assistantID, "p5"),
+            type: "reasoning",
+            text: "thinking-two",
+            metadata: { anthropic: { signature: "sig2" } },
+          },
+          {
+            ...basePart(assistantID, "p6"),
+            type: "text",
+            text: "the answer",
+          },
+        ] as MessageV2.Part[],
+      },
+    ]
+
+    const result = await MessageV2.toModelMessages(input, model)
+
+    // step-start splits the message into two assistant messages
+    // The SDK's groupIntoBlocks later merges them when sending to Anthropic
+    expect(result).toHaveLength(2)
+
+    // First message: [reasoning(sig1), text(" ")] — space preserves the slot
+    const firstText = (result[0].content as any[]).find((p) => p.type === "text")
+    expect(firstText.text).toBe(" ")
+
+    // Second message: [reasoning(sig2), text("the answer")] — original text unchanged
+    const secondText = (result[1].content as any[]).find((p) => p.type === "text")
+    expect(secondText.text).toBe("the answer")
+  })
+
+  test("does not alter text parts in assistant messages without reasoning", async () => {
+    // The empty-to-space substitution only applies when reasoning is present.
+    // Assistant messages without reasoning should have empty text filtered
+    // later by normalizeMessages, not substituted here.
+    const assistantID = "m-assistant-no-reasoning"
+    const input: MessageV2.WithParts[] = [
+      {
+        info: assistantInfo(assistantID, "m-parent"),
+        parts: [
+          {
+            ...basePart(assistantID, "p1"),
+            type: "text",
+            text: "",
+          },
+          {
+            ...basePart(assistantID, "p2"),
+            type: "text",
+            text: "hello",
+          },
+        ] as MessageV2.Part[],
+      },
+    ]
+
+    const result = await MessageV2.toModelMessages(input, model)
+
+    expect(result).toHaveLength(1)
+    const texts = (result[0].content as any[]).filter((p) => p.type === "text")
+    expect(texts.map((t) => t.text)).toStrictEqual(["", "hello"])
+  })
 })
 
 describe("session.message-v2.fromError", () => {