fix: preserve thinking block signatures across three independent corruption paths

Author: chan1103

packages/opencode/src/provider/transform.ts

@@ -62,7 +62,10 @@ export namespace ProviderTransform {
           }
           if (!Array.isArray(msg.content)) return msg
           const filtered = msg.content.filter((part) => {
-            if (part.type === "text" || part.type === "reasoning") {
+            if (part.type === "reasoning") {
+              return part.text !== "" || part.providerOptions !== undefined
+            }
+            if (part.type === "text") {
               return part.text !== ""
             }
             return true

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

@@ -792,7 +792,7 @@ export namespace MessageV2 {
             assistantMessage.parts.push({
               type: "reasoning",
               text: part.text,
-              ...(differentModel ? {} : { providerMetadata: part.metadata }),
+              providerMetadata: part.metadata,
             })
           }
         }

packages/opencode/src/session/processor.ts

@@ -245,7 +245,7 @@ export namespace SessionProcessor {
 
             case "reasoning-end":
               if (!(value.id in ctx.reasoningMap)) return
-              ctx.reasoningMap[value.id].text = ctx.reasoningMap[value.id].text.trimEnd()
+              ctx.reasoningMap[value.id].text = ctx.reasoningMap[value.id].text
               ctx.reasoningMap[value.id].time = { ...ctx.reasoningMap[value.id].time, end: Date.now() }
               if (value.providerMetadata) ctx.reasoningMap[value.id].metadata = value.providerMetadata
               yield* session.updatePart(ctx.reasoningMap[value.id])

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

@@ -1099,6 +1099,47 @@ describe("ProviderTransform.message - anthropic empty content filtering", () =>
     expect(result[0].content[0]).toEqual({ type: "text", text: "Answer" })
   })
 
+  test("preserves empty reasoning parts with providerOptions (redacted_thinking)", () => {
+    const msgs = [
+      {
+        role: "assistant",
+        content: [
+          { type: "reasoning", text: "visible thinking", providerOptions: { anthropic: { signature: "sig_abc" } } },
+          { type: "reasoning", text: "", providerOptions: { anthropic: { signature: "sig_xyz", redactedData: "encrypted" } } },
+          { type: "text", text: "Answer" },
+        ],
+      },
+    ] as any[]
+
+    const result = ProviderTransform.message(msgs, anthropicModel, {})
+
+    expect(result).toHaveLength(1)
+    expect(result[0].content).toHaveLength(3)
+    expect(result[0].content[1]).toEqual({
+      type: "reasoning",
+      text: "",
+      providerOptions: { anthropic: { signature: "sig_xyz", redactedData: "encrypted" } },
+    })
+  })
+
+  test("removes empty reasoning parts without providerOptions", () => {
+    const msgs = [
+      {
+        role: "assistant",
+        content: [
+          { type: "reasoning", text: "" },
+          { type: "text", text: "Answer" },
+        ],
+      },
+    ] as any[]
+
+    const result = ProviderTransform.message(msgs, anthropicModel, {})
+
+    expect(result).toHaveLength(1)
+    expect(result[0].content).toHaveLength(1)
+    expect(result[0].content[0]).toEqual({ type: "text", text: "Answer" })
+  })
+
   test("removes entire message when all parts are empty", () => {
     const msgs = [
       { role: "user", content: "Hello" },

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

@@ -1018,6 +1018,54 @@ describe("session.message-v2.fromError", () => {
     expect((result as MessageV2.APIError).data.message).toInclude("decompression")
   })
 
+  test("preserves reasoning providerMetadata when model differs (thinking signatures)", async () => {
+    const userID = "m-user"
+    const assistantID = "m-assistant"
+    const reasoningMeta = { anthropic: { signature: "sig_test_abc123" } }
+
+    const input: MessageV2.WithParts[] = [
+      {
+        info: userInfo(userID),
+        parts: [
+          {
+            ...basePart(userID, "p1"),
+            type: "text",
+            text: "hello",
+          },
+        ] as MessageV2.Part[],
+      },
+      {
+        info: assistantInfo(assistantID, userID, undefined, {
+          providerID: "anthropic",
+          modelID: "claude-opus-4-6",
+        }),
+        parts: [
+          {
+            ...basePart(assistantID, "p2"),
+            type: "reasoning",
+            text: "thinking about the answer",
+            time: { start: 0 },
+            metadata: reasoningMeta,
+          },
+          {
+            ...basePart(assistantID, "p3"),
+            type: "text",
+            text: "the answer",
+          },
+        ] as MessageV2.Part[],
+      },
+    ]
+
+    const result = await MessageV2.toModelMessages(input, model)
+
+    expect(result).toHaveLength(2)
+    const assistantMsg = result[1]
+    expect(assistantMsg.role).toBe("assistant")
+    const reasoningPart = (assistantMsg.content as any[]).find((p: any) => p.type === "reasoning")
+    expect(reasoningPart).toBeDefined()
+    expect(reasoningPart.providerOptions).toEqual(reasoningMeta)
+  })
+
   test("classifies ZlibError as AbortedError when abort context is provided", () => {
     const zlibError = new Error(
       'ZlibError fetching "https://opencode.cloudflare.dev/anthropic/messages". For more information, pass `verbose: true` in the second argument to fetch()',

packages/opencode/test/session/processor-effect.test.ts

@@ -399,6 +399,50 @@ it.live("session.processor effect tests capture reasoning from http mock", () =>
   ),
 )
 
+it.live("session.processor preserves reasoning text with trailing whitespace", () =>
+  provideTmpdirServer(
+    ({ dir, llm }) =>
+      Effect.gen(function* () {
+        const { processors, session, provider } = yield* boot()
+
+        yield* llm.push(reply().reason("thinking with spaces   ").text("done").stop())
+
+        const chat = yield* session.create({})
+        const parent = yield* user(chat.id, "test trailing whitespace")
+        const msg = yield* assistant(chat.id, parent.id, path.resolve(dir))
+        const mdl = yield* provider.getModel(ref.providerID, ref.modelID)
+        const handle = yield* processors.create({
+          assistantMessage: msg,
+          sessionID: chat.id,
+          model: mdl,
+        })
+
+        yield* handle.process({
+          user: {
+            id: parent.id,
+            sessionID: chat.id,
+            role: "user",
+            time: parent.time,
+            agent: parent.agent,
+            model: { providerID: ref.providerID, modelID: ref.modelID },
+          } satisfies MessageV2.User,
+          sessionID: chat.id,
+          model: mdl,
+          agent: agent(),
+          system: [],
+          messages: [{ role: "user", content: "test trailing whitespace" }],
+          tools: {},
+        })
+
+        const parts = MessageV2.parts(msg.id)
+        const reasoning = parts.find((part): part is MessageV2.ReasoningPart => part.type === "reasoning")
+
+        expect(reasoning?.text).toBe("thinking with spaces   ")
+      }),
+    { git: true, config: (url) => providerCfg(url) },
+  ),
+)
+
 it.live("session.processor effect tests reset reasoning state across retries", () =>
   provideTmpdirServer(
     ({ dir, llm }) =>