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).

(cherry picked from commit f5d2963)

Author: panyw5

packages/opencode/src/provider/provider.ts

@@ -1352,60 +1352,25 @@ export const layer = Layer.effect(
         })),
       }
 
-        function isProviderAllowed(providerID: ProviderID): boolean {
-          if (enabled && !enabled.has(providerID)) return false
-          if (disabled.has(providerID)) return false
-          return true
-        }
-
-        for (const hook of plugins) {
-          const p = hook.provider
-          const models = p?.models
-          if (!p || !models) continue
-
-          const providerID = ProviderID.make(p.id)
-          if (disabled.has(providerID)) continue
-
-          const provider = database[providerID]
-          if (!provider) continue
-          const pluginAuth = yield* auth.get(providerID).pipe(Effect.orDie)
-
-          provider.models = yield* Effect.promise(async () => {
-            const next = await models(toPublicInfo(provider), { auth: pluginAuth })
-            return Object.fromEntries(
-              Object.entries(next).map(([id, model]) => [
-                id,
-                {
-                  ...model,
-                  id: ModelID.make(id),
-                  providerID,
-                },
-              ]),
-            )
-          })
-        }
-
-        // extend database from config
-        for (const [providerID, provider] of configProviders) {
-          const existing = database[providerID]
-          const parsed: Info = {
-            id: ProviderID.make(providerID),
-            name: provider.name ?? existing?.name ?? providerID,
-            env: provider.env ?? existing?.env ?? [],
-            options: mergeDeep(existing?.options ?? {}, provider.options ?? {}),
-            source: "config",
-            models: existing?.models ?? {},
-          }
-
-          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",
+      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
+          return existingModel?.name ?? modelID
+        })
+        const parsedModel: Model = {
+          id: ModelID.make(modelID),
+          api: {
+            id: apiID,
+            npm: apiNpm,
             url: model.provider?.api ?? provider?.api ?? existingModel?.api.url ?? modelsDev[providerID]?.api,
           },
           status: model.status ?? existingModel?.status ?? "active",
@@ -1430,7 +1395,12 @@ export const layer = Layer.effect(
               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

@@ -159,6 +159,7 @@ function normalizeMessages(
 
     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")
@@ -167,24 +168,26 @@ function normalizeMessages(
           // 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

@@ -1069,6 +1069,41 @@ describe("ProviderTransform.schema - moonshot $ref siblings", () => {
 })
 
 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 = [
       {
@@ -1085,44 +1120,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([
@@ -1136,6 +1134,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 = [
       {