fix(opencode): port upstream deepseek reasoning_content fix

Cherry-pick the targeted DeepSeek interleaved-default tweak from upstream
opencode (sst#24630, commit 738b306) and apply a properly scoped
version of the empty-content preserving fix from #1.

provider.ts (custom-provider parser only):
- Default `interleaved` to { field: "reasoning_content" } only for
  brand-new openai-compatible providers whose api id contains
  "deepseek". Existing user/source config still wins via the ?? chain.
  fromModelsDevModel is intentionally left alone — models.dev already
  carries the explicit interleaved config for DeepSeek there.

transform.ts (the existing interleaved branch):
- Switch the providerOptions namespace from hard-coded
  "openaiCompatible" to sdkKey(model.api.npm) ?? "openaiCompatible"
  so providers wired through other AI SDKs land in the right slot.
- Always emit the field (even when reasoningText is empty) so
  DeepSeek's follow-up tool-call requests stop 400-ing, and preserve
  any existing reasoning_content across re-transforms instead of
  overwriting with "".

Deliberately does NOT add a fallback `if (model.capabilities.reasoning)`
branch — that would inject reasoning_content into providerOptions for
OpenAI o1/o3, Claude reasoning, Gemini thinking etc., which is not a
valid key for those SDKs.

tests:
- Share a deepseekModel fixture across the DeepSeek tests.
- Add empty-reasoning preservation regression.
- Add re-transform existing-reasoning preservation regression.
- Add reverse guard: OpenAI o1 (reasoning=true, interleaved=false) must
  NOT pick up reasoning_content in providerOptions.

Supersedes #1 (that PR's broader scope would affect non-DeepSeek
reasoning providers).

Author: panyw5

packages/opencode/src/provider/provider.ts

@@ -1049,6 +1049,13 @@ export namespace Provider {
 
       for (const [modelID, model] of Object.entries(provider.models ?? {})) {
         const existingModel = parsed.models[model.id ?? modelID]
+        const apiID = model.id ?? existingModel?.api.id ?? modelID
+        const apiNpm =
+          model.provider?.npm ??
+          provider.npm ??
+          existingModel?.api.npm ??
+          modelsDev[providerID]?.npm ??
+          "@ai-sdk/openai-compatible"
         const name = iife(() => {
           if (model.name) return model.name
           if (model.id && model.id !== modelID) return modelID
@@ -1057,13 +1064,8 @@ export namespace Provider {
         const parsedModel: Model = {
           id: ModelID.make(modelID),
           api: {
-            id: model.id ?? existingModel?.api.id ?? modelID,
-            npm:
-              model.provider?.npm ??
-              provider.npm ??
-              existingModel?.api.npm ??
-              modelsDev[providerID]?.npm ??
-              "@ai-sdk/openai-compatible",
+            id: apiID,
+            npm: apiNpm,
             url: model.provider?.api ?? provider?.api ?? existingModel?.api.url ?? modelsDev[providerID]?.api,
           },
           status: model.status ?? existingModel?.status ?? "active",
@@ -1088,7 +1090,12 @@ export namespace Provider {
               video: model.modalities?.output?.includes("video") ?? existingModel?.capabilities.output.video ?? false,
               pdf: model.modalities?.output?.includes("pdf") ?? existingModel?.capabilities.output.pdf ?? false,
             },
-            interleaved: model.interleaved ?? false,
+            interleaved:
+              model.interleaved ??
+              existingModel?.capabilities.interleaved ??
+              (!existingModel && apiNpm === "@ai-sdk/openai-compatible" && apiID.toLowerCase().includes("deepseek")
+                ? { field: "reasoning_content" }
+                : false),
           },
           cost: {
             input: model?.cost?.input ?? existingModel?.cost?.input ?? 0,

packages/opencode/src/provider/transform.ts

@@ -154,6 +154,7 @@ export namespace ProviderTransform {
 
     if (typeof model.capabilities.interleaved === "object" && model.capabilities.interleaved.field) {
       const field = model.capabilities.interleaved.field
+      const sdk = sdkKey(model.api.npm) ?? "openaiCompatible"
       return msgs.map((msg) => {
         if (msg.role === "assistant" && Array.isArray(msg.content)) {
           const reasoningParts = msg.content.filter((part: any) => part.type === "reasoning")
@@ -162,24 +163,26 @@ export namespace ProviderTransform {
           // Filter out reasoning parts from content
           const filteredContent = msg.content.filter((part: any) => part.type !== "reasoning")
 
-          // Include reasoning_content | reasoning_details directly on the message for all assistant messages
-          if (reasoningText) {
-            return {
-              ...msg,
-              content: filteredContent,
-              providerOptions: {
-                ...msg.providerOptions,
-                openaiCompatible: {
-                  ...(msg.providerOptions as any)?.openaiCompatible,
-                  [field]: reasoningText,
-                },
-              },
-            }
-          }
+          // DeepSeek-style openai-compatible providers require the reasoning field
+          // to be echoed back on every assistant message — even an empty string —
+          // so follow-up tool-call requests don't 400. The DeepSeek normalize block
+          // above also synthesizes an empty reasoning part on every assistant
+          // message, so on a re-transform `reasoningText` is "" and we have to fall
+          // back to whatever a previous pass already attached to providerOptions.
+          const existing = (msg.providerOptions as any)?.[sdk]?.[field]
+          const existingText = typeof existing === "string" ? existing : ""
+          const resolvedText = reasoningText || existingText
 
           return {
             ...msg,
             content: filteredContent,
+            providerOptions: {
+              ...msg.providerOptions,
+              [sdk]: {
+                ...(msg.providerOptions as any)?.[sdk],
+                [field]: resolvedText,
+              },
+            },
           }
         }
 

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

@@ -788,6 +788,41 @@ describe("ProviderTransform.schema - gemini non-object properties removal", () =
 })
 
 describe("ProviderTransform.message - DeepSeek reasoning content", () => {
+  const deepseekModel = {
+    id: ModelID.make("deepseek/deepseek-chat"),
+    providerID: ProviderID.make("deepseek"),
+    api: {
+      id: "deepseek-chat",
+      url: "https://api.deepseek.com",
+      npm: "@ai-sdk/openai-compatible",
+    },
+    name: "DeepSeek Chat",
+    capabilities: {
+      temperature: true,
+      reasoning: true,
+      attachment: false,
+      toolcall: true,
+      input: { text: true, audio: false, image: false, video: false, pdf: false },
+      output: { text: true, audio: false, image: false, video: false, pdf: false },
+      interleaved: {
+        field: "reasoning_content",
+      },
+    },
+    cost: {
+      input: 0.001,
+      output: 0.002,
+      cache: { read: 0.0001, write: 0.0002 },
+    },
+    limit: {
+      context: 128000,
+      output: 8192,
+    },
+    status: "active",
+    options: {},
+    headers: {},
+    release_date: "2023-04-01",
+  } as any
+
   test("DeepSeek with tool calls includes reasoning_content in providerOptions", () => {
     const msgs = [
       {
@@ -804,44 +839,7 @@ describe("ProviderTransform.message - DeepSeek reasoning content", () => {
       },
     ] as any[]
 
-    const result = ProviderTransform.message(
-      msgs,
-      {
-        id: ModelID.make("deepseek/deepseek-chat"),
-        providerID: ProviderID.make("deepseek"),
-        api: {
-          id: "deepseek-chat",
-          url: "https://api.deepseek.com",
-          npm: "@ai-sdk/openai-compatible",
-        },
-        name: "DeepSeek Chat",
-        capabilities: {
-          temperature: true,
-          reasoning: true,
-          attachment: false,
-          toolcall: true,
-          input: { text: true, audio: false, image: false, video: false, pdf: false },
-          output: { text: true, audio: false, image: false, video: false, pdf: false },
-          interleaved: {
-            field: "reasoning_content",
-          },
-        },
-        cost: {
-          input: 0.001,
-          output: 0.002,
-          cache: { read: 0.0001, write: 0.0002 },
-        },
-        limit: {
-          context: 128000,
-          output: 8192,
-        },
-        status: "active",
-        options: {},
-        headers: {},
-        release_date: "2023-04-01",
-      },
-      {},
-    )
+    const result = ProviderTransform.message(msgs, deepseekModel, {})
 
     expect(result).toHaveLength(1)
     expect(result[0].content).toEqual([
@@ -855,6 +853,102 @@ describe("ProviderTransform.message - DeepSeek reasoning content", () => {
     expect(result[0].providerOptions?.openaiCompatible?.reasoning_content).toBe("Let me think about this...")
   })
 
+  test("DeepSeek emits empty reasoning_content when the assistant produced no reasoning", () => {
+    // Follow-up tool calls regress with HTTP 400 unless the field is echoed back,
+    // even as an empty string.
+    const result = ProviderTransform.message(
+      [
+        {
+          role: "assistant",
+          content: [
+            { type: "reasoning", text: "" },
+            {
+              type: "tool-call",
+              toolCallId: "test",
+              toolName: "bash",
+              input: { command: "echo hello" },
+            },
+          ],
+        },
+      ] as any[],
+      deepseekModel,
+      {},
+    )
+
+    expect(result[0].providerOptions?.openaiCompatible?.reasoning_content).toBe("")
+  })
+
+  test("DeepSeek preserves an existing reasoning_content across repeated transforms", () => {
+    // After the first pass the reasoning lives in providerOptions, not in
+    // content. Re-running the transform must not blow that field away.
+    const result = ProviderTransform.message(
+      [
+        {
+          role: "assistant",
+          content: [{ type: "text", text: "Done" }],
+          providerOptions: {
+            openaiCompatible: {
+              reasoning_content: "Stored thinking",
+            },
+          },
+        },
+      ] as any[],
+      deepseekModel,
+      {},
+    )
+
+    expect(result[0].providerOptions?.openaiCompatible?.reasoning_content).toBe("Stored thinking")
+  })
+
+  test("Reasoning models without an interleaved.field config do not get reasoning_content injected", () => {
+    // Guard rail: only providers that explicitly configure `interleaved.field`
+    // (DeepSeek-style openai-compatible) should pick up the reasoning_content
+    // echo. OpenAI o1/o3, Claude reasoning, Gemini thinking — all reasoning=true
+    // — must stay untouched so we don't pollute their providerOptions.
+    const openaiReasoningModel = {
+      id: ModelID.make("openai/o1-mini"),
+      providerID: ProviderID.make("openai"),
+      api: {
+        id: "o1-mini",
+        url: "https://api.openai.com",
+        npm: "@ai-sdk/openai",
+      },
+      name: "OpenAI o1-mini",
+      capabilities: {
+        temperature: false,
+        reasoning: true,
+        attachment: false,
+        toolcall: true,
+        input: { text: true, audio: false, image: false, video: false, pdf: false },
+        output: { text: true, audio: false, image: false, video: false, pdf: false },
+        interleaved: false,
+      },
+      cost: { input: 0, output: 0, cache: { read: 0, write: 0 } },
+      limit: { context: 128000, output: 65536 },
+      status: "active",
+      options: {},
+      headers: {},
+      release_date: "2024-09-12",
+    } as any
+
+    const result = ProviderTransform.message(
+      [
+        {
+          role: "assistant",
+          content: [
+            { type: "reasoning", text: "internal thought" },
+            { type: "text", text: "Answer" },
+          ],
+        },
+      ] as any[],
+      openaiReasoningModel,
+      {},
+    )
+
+    expect((result[0].providerOptions as any)?.openai?.reasoning_content).toBeUndefined()
+    expect((result[0].providerOptions as any)?.openaiCompatible?.reasoning_content).toBeUndefined()
+  })
+
   test("Non-DeepSeek providers leave reasoning content unchanged", () => {
     const msgs = [
       {