feat(opencode): native deepseek reasoning support and 400 recovery hint

Author: See U

packages/opencode/src/provider/error.ts

@@ -41,6 +41,16 @@ function message(providerID: ProviderV2.ID, e: APICallError) {
       return "Unknown error"
     }
 
+    // DeepSeek rejects requests that drop a prior turn's
+    // `reasoning_content` (e.g. after history edits or a model switch);
+    // the reliable recovery is a fresh session.
+    if (e.statusCode === 400 && providerID.includes("deepseek")) {
+      const body = json(e.responseBody)
+      const errMsg = body?.error?.message ?? body?.message ?? msg
+      if (typeof errMsg === "string" && errMsg.includes("reasoning_content"))
+        return `${msg}${msg === errMsg ? "" : `: ${errMsg}`} — DeepSeek requires previous reasoning to be resent verbatim; start a new session if this error persists.`
+    }
+
     if (!e.responseBody || (e.statusCode && msg !== STATUS_CODES[e.statusCode])) {
       return msg
     }

packages/opencode/src/session/llm/native-request.ts

@@ -110,13 +110,24 @@ const messages = (input: readonly ModelMessage[]) => {
       Message.make({
         role: message.role,
         content: content(message.content),
-        native: isRecord(message.providerOptions) ? { providerOptions: message.providerOptions } : undefined,
+        native: messageNative(message),
       }),
     ]
   })
   return { system, messages }
 }
 
+// The openai-chat protocol reads continuation metadata from
+// `message.native.openaiCompatible` (e.g. DeepSeek's mandatory
+// `reasoning_content` echo on assistant turns). The AI SDK stores the same
+// data on `providerOptions.openaiCompatible`; project it so the echo
+// survives native request lowering and tool-turn requests stay valid.
+const messageNative = (message: ModelMessage): Message["native"] | undefined => {
+  const options = isRecord(message.providerOptions) ? message.providerOptions : undefined
+  if (!isRecord(options?.openaiCompatible)) return undefined
+  return { openaiCompatible: options.openaiCompatible }
+}
+
 const schema = (value: unknown): JsonSchema => {
   if (!isRecord(value)) return { type: "object", properties: {} }
   if (isRecord(value.jsonSchema)) return value.jsonSchema
@@ -189,8 +200,23 @@ export const request = (input: RequestInput) => {
     tools: tools(input.tools),
     toolChoice: input.toolChoice,
     generation: generation(input),
-    providerOptions: input.providerOptions,
+    providerOptions: providerOptions(input),
   })
 }
 
+// opencode-managed OpenAI-compatible providers key model options under the
+// dot-split providerID prefix (e.g. "opencode" for "opencode.deepseek"); the
+// openai-chat protocol reads the "openai" key. Translate so reasoning
+// variants (effort, thinking toggle) reach the native request body.
+function providerOptions(input: RequestInput): LLMRequest["providerOptions"] {
+  const options = input.providerOptions
+  if (!isRecord(options) || input.model.api.npm !== "@ai-sdk/openai-compatible") return options
+  const key = input.model.providerID.split(".")[0]
+  if (key === "openai") return options
+  const value = options[key]
+  if (!isRecord(value)) return options
+  const openai = isRecord(options.openai) ? { ...value, ...options.openai } : value
+  return { ...options, openai }
+}
+
 export * as LLMNative from "./native-request"

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

@@ -0,0 +1,80 @@
+import { describe, expect, test } from "bun:test"
+import { APICallError } from "ai"
+import { ProviderV2 } from "@opencode-ai/core/provider"
+import { ProviderError } from "@/provider/error"
+
+const deepseekReasoningContent = (statusCode: number) =>
+  new APICallError({
+    message: `${statusCode} Bad Request`,
+    url: "https://api.deepseek.com/v1/chat/completions",
+    statusCode,
+    responseBody: JSON.stringify({
+      error: {
+        message:
+          "This model version does not support reasoning_content, please resend all assistant messages that contain reasoning_content",
+      },
+    }),
+  })
+
+const parsedApiError = (parsed: ProviderError.ParsedAPICallError) => {
+  if (parsed.type !== "api_error") throw new Error("expected api_error")
+  return parsed
+}
+
+describe("ProviderError.parseAPICallError", () => {
+  test("adds a DeepSeek reasoning_content recovery hint on 400", () => {
+    const parsed = parsedApiError(
+      ProviderError.parseAPICallError({
+        providerID: ProviderV2.ID.make("deepseek"),
+        error: deepseekReasoningContent(400),
+      }),
+    )
+
+    expect(parsed.message).toContain("DeepSeek requires previous reasoning to be resent verbatim")
+  })
+
+  test("does not hint when the DeepSeek error does not mention reasoning_content", () => {
+    const error = new APICallError({
+      message: "400 Bad Request",
+      url: "https://api.deepseek.com/v1/chat/completions",
+      statusCode: 400,
+      responseBody: JSON.stringify({ error: { message: "Invalid model" } }),
+    })
+    const parsed = parsedApiError(
+      ProviderError.parseAPICallError({
+        providerID: ProviderV2.ID.make("deepseek"),
+        error,
+      }),
+    )
+
+    expect(parsed.message).not.toContain("resent verbatim")
+  })
+
+  test("does not hint for non-DeepSeek providers", () => {
+    const parsed = parsedApiError(
+      ProviderError.parseAPICallError({
+        providerID: ProviderV2.ID.make("openai"),
+        error: deepseekReasoningContent(400),
+      }),
+    )
+
+    expect(parsed.message).not.toContain("resent verbatim")
+  })
+
+  test("does not crash when the error body message is not a string", () => {
+    const error = new APICallError({
+      message: "400 Bad Request",
+      url: "https://api.deepseek.com/v1/chat/completions",
+      statusCode: 400,
+      responseBody: JSON.stringify({ error: { message: { code: "x" } } }),
+    })
+    const parsed = parsedApiError(
+      ProviderError.parseAPICallError({
+        providerID: ProviderV2.ID.make("deepseek"),
+        error,
+      }),
+    )
+
+    expect(parsed.message).toBe("400 Bad Request")
+  })
+})

packages/opencode/test/session/llm-native.test.ts

@@ -332,6 +332,56 @@ describe("session.llm-native.request", () => {
     ])
   })
 
+  test("projects AI SDK openaiCompatible continuation metadata into native message metadata", () => {
+    const request = LLMNative.request({
+      model: {
+        ...baseModel,
+        providerID: ProviderV2.ID.make("opencode"),
+        api: { ...baseModel.api, url: "https://ai.example.test/v1", npm: "@ai-sdk/openai-compatible" },
+      },
+      messages: [
+        {
+          role: "assistant",
+          content: [{ type: "text", text: "Hello" }],
+          providerOptions: { openaiCompatible: { reasoning_content: "thinking" } },
+        },
+      ],
+    })
+
+    expect(request.messages).toMatchObject([
+      {
+        role: "assistant",
+        native: { openaiCompatible: { reasoning_content: "thinking" } },
+      },
+    ])
+  })
+
+  test("remaps opencode-keyed provider options to the openai key for native openai-compatible routes", () => {
+    const request = LLMNative.request({
+      model: {
+        ...baseModel,
+        providerID: ProviderV2.ID.make("opencode.deepseek"),
+        api: { ...baseModel.api, url: "https://ai.example.test/v1", npm: "@ai-sdk/openai-compatible" },
+      },
+      messages: [{ role: "user", content: "hi" }],
+      providerOptions: { opencode: { reasoningEffort: "max", thinking: { type: "disabled" } } },
+    })
+
+    expect(request.providerOptions).toMatchObject({
+      openai: { reasoningEffort: "max", thinking: { type: "disabled" } },
+    })
+  })
+
+  test("leaves openai-keyed provider options untouched for native openai routes", () => {
+    const request = LLMNative.request({
+      model: baseModel,
+      messages: [{ role: "user", content: "hi" }],
+      providerOptions: { openai: { store: false } },
+    })
+
+    expect(request.providerOptions).toEqual({ openai: { store: false } })
+  })
+
   test("selects native request routes for provider packages", () => {
     const openai = LLMNative.model({
       model: { ...baseModel, api: { ...baseModel.api, url: "", npm: "@ai-sdk/openai" } },