fix(transform): sync interleaved handling — exclude openrouter + always echo reasoning field (#1819)

* fix(transform): sync interleaved handling — exclude openrouter + always echo reasoning field

Sync two upstream behavioral refinements to the interleaved-thinking
transform (the capability system already existed):

1. Exclude openrouter from the interleaved field injection block —
   openrouter has its own reasoning handling via @openrouter/ai-sdk-provider.

2. Always set the providerOptions.openaiCompatible[field] even when
   reasoningText is empty — some providers (e.g. DeepSeek) return empty
   reasoning_content which still needs to be echoed back in subsequent
   requests; gating on non-empty dropped it.

* fix(schema): add 'reasoning' to ProviderInterleaved Literals

Sync with upstream anomalyco/opencode origin/dev which has THREE values
in the ProviderInterleaved field Literals: ['reasoning',
'reasoning_content', 'reasoning_details']. This repo was missing
'reasoning', which would cause schema validation failures for
providers declaring interleaved.field = 'reasoning'.

Also cast plugin models call to any to bridge SDK ModelV2 type mismatch.

* fix(sdk): regenerate SDK types to include 'reasoning' interleaved field

The interleaved `field` literal was extended to include 'reasoning' in the
provider/config Model schemas, but the checked-in SDK types were not
regenerated. This left `SDK.Model` out of sync, breaking share-next.ts's
discriminated union typecheck (TS2739 at share-next.ts:216). Regenerating the
SDK restores type parity and makes typecheck pass.

---------

Co-authored-by: MI <mi@MIdeMacBook-Pro.local>

Author: wqymi

packages/opencode/src/config/provider.ts

@@ -17,7 +17,7 @@ export const Model = Schema.Struct({
     Schema.Union([
       Schema.Literal(true),
       Schema.Struct({
-        field: Schema.Literals(["reasoning_content", "reasoning_details"]),
+        field: Schema.Literals(["reasoning", "reasoning_content", "reasoning_details"]),
       }),
     ]),
   ),

packages/opencode/src/provider/models.ts

@@ -56,7 +56,7 @@ export const Model = z.object({
       z.literal(true),
       z
         .object({
-          field: z.enum(["reasoning_content", "reasoning_details"]),
+          field: z.enum(["reasoning", "reasoning_content", "reasoning_details"]),
         })
         .strict(),
     ])

packages/opencode/src/provider/provider.ts

@@ -849,7 +849,7 @@ const ProviderModalities = Schema.Struct({
 const ProviderInterleaved = Schema.Union([
   Schema.Boolean,
   Schema.Struct({
-    field: Schema.Literals(["reasoning_content", "reasoning_details"]),
+    field: Schema.Literals(["reasoning", "reasoning_content", "reasoning_details"]),
   }),
 ])
 
@@ -1371,7 +1371,7 @@ const layer: Layer.Layer<
           const pluginAuth = yield* auth.get(providerID).pipe(Effect.orDie)
 
           provider.models = yield* Effect.promise(async () => {
-            const next = await models(provider, { auth: pluginAuth })
+            const next = await models(provider as any, { auth: pluginAuth })
             return Object.fromEntries(
               Object.entries(next).map(([id, model]) => [
                 id,

packages/opencode/src/provider/transform.ts

@@ -177,7 +177,11 @@ function normalizeMessages(
     return result
   }
 
-  if (typeof model.capabilities.interleaved === "object" && model.capabilities.interleaved.field) {
+  if (
+    typeof model.capabilities.interleaved === "object" &&
+    model.capabilities.interleaved.field &&
+    model.api.npm !== "@openrouter/ai-sdk-provider"
+  ) {
     const field = model.capabilities.interleaved.field
     return msgs.map((msg) => {
       if (msg.role === "assistant" && Array.isArray(msg.content)) {
@@ -187,24 +191,18 @@ 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?.openaiCompatible,
-                [field]: reasoningText,
-              },
-            },
-          }
-        }
-
+        // Always set the field even when empty — some providers (e.g. DeepSeek) may return empty
+        // reasoning_content which still needs to be sent back in subsequent requests.
         return {
           ...msg,
           content: filteredContent,
+          providerOptions: {
+            ...msg.providerOptions,
+            openaiCompatible: {
+              ...msg.providerOptions?.openaiCompatible,
+              [field]: reasoningText,
+            },
+          },
         }
       }
 

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

@@ -424,6 +424,10 @@ test("custom DeepSeek openai-compatible model defaults interleaved reasoning fie
                   name: "DeepSeek Details",
                   interleaved: { field: "reasoning_details" },
                 },
+                "deepseek-reasoning": {
+                  name: "DeepSeek Reasoning",
+                  interleaved: { field: "reasoning" },
+                },
                 "custom-model": {
                   name: "Custom Model",
                 },
@@ -457,6 +461,7 @@ test("custom DeepSeek openai-compatible model defaults interleaved reasoning fie
       const provider = providers[ProviderID.make("custom-provider")]
       expect(provider.models["deepseek-r1"].capabilities.interleaved).toEqual({ field: "reasoning_content" })
       expect(provider.models["deepseek-details"].capabilities.interleaved).toEqual({ field: "reasoning_details" })
+      expect(provider.models["deepseek-reasoning"].capabilities.interleaved).toEqual({ field: "reasoning" })
       expect(provider.models["custom-model"].capabilities.interleaved).toBe(false)
       expect(
         providers[ProviderID.make("custom-anthropic-provider")].models["deepseek-r1"].capabilities.interleaved,

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

@@ -4410,3 +4410,101 @@ describe("ProviderTransform.message - non-array content guard (j.map is not a fu
     expect(() => ProviderTransform.message(msgs, genericModel, {})).not.toThrow()
   })
 })
+
+describe("ProviderTransform.message - interleaved field: openrouter exclusion", () => {
+  const openrouterModel = {
+    id: "openrouter/anthropic/claude-sonnet-4",
+    providerID: "openrouter",
+    api: {
+      id: "anthropic/claude-sonnet-4",
+      url: "https://openrouter.ai/api",
+      npm: "@openrouter/ai-sdk-provider",
+    },
+    name: "Claude Sonnet 4",
+    capabilities: {
+      temperature: true,
+      reasoning: true,
+      attachment: true,
+      toolcall: true,
+      input: { text: true, audio: false, image: true, 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: 200000, output: 8192 },
+    status: "active",
+    options: {},
+    headers: {},
+  } as any
+
+  test("openrouter is excluded from interleaved field injection", () => {
+    const msgs = [
+      {
+        role: "assistant",
+        content: [
+          { type: "reasoning", text: "Thinking..." },
+          { type: "text", text: "Answer" },
+        ],
+      },
+      { role: "user", content: [{ type: "text", text: "next" }] },
+    ] as any[]
+
+    const result = ProviderTransform.message(msgs, openrouterModel, {})
+
+    // Reasoning parts should be LEFT IN content (not extracted to providerOptions.openaiCompatible)
+    const assistantContent = result[0].content as any[]
+    expect(assistantContent).toHaveLength(2)
+    expect(assistantContent[0].type).toBe("reasoning")
+    expect(assistantContent[0].text).toBe("Thinking...")
+    expect(assistantContent[1].type).toBe("text")
+    expect(assistantContent[1].text).toBe("Answer")
+    // The interleaved field must NOT be set on the message (openrouter excluded)
+    expect(result[0].providerOptions?.openaiCompatible?.reasoning_content).toBeUndefined()
+  })
+})
+
+describe("ProviderTransform.message - interleaved field: empty reasoning still sets the field", () => {
+  test("empty reasoning_content is echoed back (DeepSeek-style)", () => {
+    const deepseekModel = {
+      id: "deepseek/deepseek-chat",
+      providerID: "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: {},
+    } as any
+
+    const msgs = [
+      {
+        role: "assistant",
+        content: [
+          { type: "reasoning", text: "" },
+          { type: "text", text: "Hello" },
+        ],
+      },
+      { role: "user", content: [{ type: "text", text: "next" }] },
+    ] as any[]
+
+    const result = ProviderTransform.message(msgs, deepseekModel, {})
+
+    expect(result[0].content).toEqual([{ type: "text", text: "Hello" }])
+    // The field MUST be set even when reasoningText is empty
+    expect(result[0].providerOptions?.openaiCompatible?.reasoning_content).toBe("")
+  })
+})

packages/sdk/js/src/v2/gen/types.gen.ts

@@ -1820,7 +1820,7 @@ export type ProviderConfig = {
       interleaved?:
         | true
         | {
-            field: "reasoning_content" | "reasoning_details"
+            field: "reasoning" | "reasoning_content" | "reasoning_details"
           }
       cost?: {
         input: number
@@ -2487,7 +2487,7 @@ export type Model = {
     interleaved:
       | boolean
       | {
-          field: "reasoning_content" | "reasoning_details"
+          field: "reasoning" | "reasoning_content" | "reasoning_details"
         }
   }
   cost: {
@@ -6778,6 +6778,7 @@ export type AppSkillsResponses = {
   200: Array<{
     name: string
     description: string
+    aliases?: Array<string>
     location: string
     content: string
     hidden?: boolean