fix(provider): substitute space for empty text between reasoning blocks

When Anthropic adaptive thinking (Opus 4.6+) emits an empty text part
between two reasoning blocks, the empty part is filtered out by multiple
layers (normalizeMessages, AI SDK convertToLanguageModelPrompt), and
Anthropic itself rejects empty text blocks. Dropping or preserving the
empty text both lead to failures:

- Dropping it shifts thinking block positions, invalidating signatures:
  'thinking blocks in the latest assistant message cannot be modified'
- Preserving it as '' fails validation:
  'text content blocks must be non-empty'

Substitute a single space when building assistant UIMessages with
reasoning blocks present. The space preserves the structural
arrangement (reasoning block positions) without triggering either
rejection. 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/session/message-v2.ts

@@ -825,13 +825,22 @@ 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.
+      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/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", () => {