fix(opencode): filter empty text/reasoning parts when loading from database

Empty text and reasoning parts with blank or whitespace-only text can
be stored in the database during streaming (from text-start events that
receive no deltas, or when streams are interrupted). These empty parts
cause permanent ValidationException errors with providers like AWS
Bedrock, especially when using LiteLLM proxy (@ai-sdk/openai-compatible).

This fix adds defensive filtering at two levels:
1. When hydrating parts from database (filters on load)
2. When converting to model messages (filters during conversion)

Both filters use .trim() to catch whitespace-only content.

Fixes anomalyco#19309
Complements anomalyco#17742 (prevention) with recovery for existing corruption

Author: Eric Lawson

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

@@ -560,6 +560,10 @@ export namespace MessageV2 {
       )
       for (const row of partRows) {
         const next = part(row)
+        // Filter out empty text/reasoning parts (database corruption recovery)
+        if (next.type === "text" || next.type === "reasoning") {
+          if (!next.text || next.text.trim().length === 0) continue
+        }
         const list = partByMessage.get(row.message_id)
         if (list) list.push(next)
         else partByMessage.set(row.message_id, [next])
@@ -644,7 +648,7 @@ export namespace MessageV2 {
         }
         result.push(userMessage)
         for (const part of msg.parts) {
-          if (part.type === "text" && !part.ignored)
+          if (part.type === "text" && !part.ignored && part.text.trim())
             userMessage.parts.push({
               type: "text",
               text: part.text,
@@ -700,7 +704,7 @@ export namespace MessageV2 {
           parts: [],
         }
         for (const part of msg.parts) {
-          if (part.type === "text")
+          if (part.type === "text" && part.text.trim())
             assistantMessage.parts.push({
               type: "text",
               text: part.text,
@@ -763,7 +767,7 @@ export namespace MessageV2 {
                 ...(differentModel ? {} : { callProviderMetadata: part.metadata }),
               })
           }
-          if (part.type === "reasoning") {
+          if (part.type === "reasoning" && part.text.trim()) {
             assistantMessage.parts.push({
               type: "reasoning",
               text: part.text,

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

@@ -955,3 +955,141 @@ describe("session.message-v2.fromError", () => {
     expect(result.name).toBe("MessageAbortedError")
   })
 })
+
+describe("session.message-v2 empty parts filtering", () => {
+  test("filters out empty text parts when converting to model messages", () => {
+    const input: MessageV2.WithParts[] = [
+      {
+        info: userInfo("m-user"),
+        parts: [
+          {
+            ...basePart("m-user", "p1"),
+            type: "text",
+            text: "",
+          },
+          {
+            ...basePart("m-user", "p2"),
+            type: "text",
+            text: "hello",
+          },
+        ] as MessageV2.Part[],
+      },
+    ]
+
+    const result = MessageV2.toModelMessages(input, model)
+
+    expect(result).toStrictEqual([
+      {
+        role: "user",
+        content: [{ type: "text", text: "hello" }],
+      },
+    ])
+  })
+
+  test("filters out whitespace-only text parts", () => {
+    const input: MessageV2.WithParts[] = [
+      {
+        info: assistantInfo("m-assistant", "m-user"),
+        parts: [
+          {
+            ...basePart("m-assistant", "p1"),
+            type: "text",
+            text: "   ",
+          },
+          {
+            ...basePart("m-assistant", "p2"),
+            type: "text",
+            text: "actual content",
+          },
+        ] as MessageV2.Part[],
+      },
+    ]
+
+    const result = MessageV2.toModelMessages(input, model)
+
+    expect(result).toStrictEqual([
+      {
+        role: "assistant",
+        content: [{ type: "text", text: "actual content" }],
+      },
+    ])
+  })
+
+  test("filters out empty reasoning parts", () => {
+    const reasoningModel: Provider.Model = {
+      ...model,
+      capabilities: {
+        ...model.capabilities,
+        reasoning: true,
+      },
+    }
+
+    const input: MessageV2.WithParts[] = [
+      {
+        info: assistantInfo("m-assistant", "m-user"),
+        parts: [
+          {
+            ...basePart("m-assistant", "p1"),
+            type: "reasoning",
+            text: "",
+            time: { start: 0, end: 100 },
+          },
+          {
+            ...basePart("m-assistant", "p2"),
+            type: "text",
+            text: "response",
+          },
+        ] as MessageV2.Part[],
+      },
+    ]
+
+    const result = MessageV2.toModelMessages(input, reasoningModel)
+
+    expect(result).toStrictEqual([
+      {
+        role: "assistant",
+        content: [{ type: "text", text: "response" }],
+      },
+    ])
+  })
+
+  test("preserves non-text parts even when text is empty", () => {
+    const input: MessageV2.WithParts[] = [
+      {
+        info: assistantInfo("m-assistant", "m-user"),
+        parts: [
+          {
+            ...basePart("m-assistant", "p1"),
+            type: "text",
+            text: "",
+          },
+          {
+            ...basePart("m-assistant", "p2"),
+            type: "tool",
+            tool: "test_tool",
+            callID: "call_1",
+            state: {
+              status: "completed",
+              time: { started: 0, completed: 100 },
+              output: "result",
+              input: {},
+            },
+          },
+        ] as MessageV2.Part[],
+      },
+    ]
+
+    const result = MessageV2.toModelMessages(input, model)
+
+    // AI SDK creates 2 messages: assistant with tool-call + tool-result message
+    expect(result.length).toBe(2)
+    expect(result[0].role).toBe("assistant")
+    expect(result[1].role).toBe("tool")
+
+    // First message should have tool-call, no empty text
+    const assistantContent = result[0].content as any[]
+    expect(Array.isArray(assistantContent)).toBe(true)
+    expect(assistantContent.some((c) => c.type === "tool-call")).toBe(true)
+    expect(assistantContent.every((c) => c.type !== "text" || (c.text && c.text.trim() !== ""))).toBe(true)
+  })
+})