feat: cherry-pick 4 upstream fixes (PRs anomalyco#13502, anomalyco#12585, anomalyco#15183, anomalyco#14783)

- anomalyco#13502: Retry on timeout errors instead of failing — DOMException
  TimeoutError now marked as retryable
- anomalyco#12585: Generate fallback tool call IDs for providers (NVIDIA NIM,
  GLM, Bedrock, Chutes) that omit the id field in streaming responses
- anomalyco#15183: Prevent literal NUL file creation on POSIX — redirects to
  /dev/null instead of writing "nul" files
- anomalyco#14783: Block reasoningSummary injection for GPT-5 through
  openai-compatible adapter (keeps reasoningEffort, strips summary)

Co-Authored-By: Claude Opus 4.6 <[email protected]>

Author: EBrown

packages/opencode/src/provider/sdk/copilot/chat/openai-compatible-chat-language-model.ts

@@ -30,6 +30,8 @@ import { defaultOpenAICompatibleErrorStructure, type ProviderErrorStructure } fr
 import type { MetadataExtractor } from "./openai-compatible-metadata-extractor"
 import { prepareTools } from "./openai-compatible-prepare-tools"
 
+const UNSUPPORTED_CHAT_COMPLETIONS_OPTIONS = new Set(["reasoningSummary"])
+
 export type OpenAICompatibleChatConfig = {
   provider: string
   headers: () => Record<string, string | undefined>
@@ -168,7 +170,9 @@ export class OpenAICompatibleChatLanguageModel implements LanguageModelV2 {
         seed,
         ...Object.fromEntries(
           Object.entries(providerOptions?.[this.providerOptionsName] ?? {}).filter(
-            ([key]) => !Object.keys(openaiCompatibleProviderOptions.shape).includes(key),
+            ([key]) =>
+              !Object.keys(openaiCompatibleProviderOptions.shape).includes(key) &&
+              !UNSUPPORTED_CHAT_COMPLETIONS_OPTIONS.has(key),
           ),
         ),
 
@@ -517,13 +521,21 @@ export class OpenAICompatibleChatLanguageModel implements LanguageModelV2 {
                 const index = toolCallDelta.index
 
                 if (toolCalls[index] == null) {
-                  if (toolCallDelta.id == null) {
+                  // Providers known to not send tool call IDs (see https://github.com/anomalyco/opencode/issues/6290)
+                  const providersMissingToolCallId = ["nvidia", "glm", "bedrock", "chutes"]
+                  const shouldGenerateFallbackId = providersMissingToolCallId.some((p) =>
+                    providerOptionsName.toLowerCase().includes(p),
+                  )
+
+                  if (toolCallDelta.id == null && !shouldGenerateFallbackId) {
                     throw new InvalidResponseDataError({
                       data: toolCallDelta,
                       message: `Expected 'id' to be a string.`,
                     })
                   }
 
+                  const toolCallId = toolCallDelta.id ?? generateId()
+
                   if (toolCallDelta.function?.name == null) {
                     throw new InvalidResponseDataError({
                       data: toolCallDelta,
@@ -533,12 +545,12 @@ export class OpenAICompatibleChatLanguageModel implements LanguageModelV2 {
 
                   controller.enqueue({
                     type: "tool-input-start",
-                    id: toolCallDelta.id,
+                    id: toolCallId,
                     toolName: toolCallDelta.function.name,
                   })
 
                   toolCalls[index] = {
-                    id: toolCallDelta.id,
+                    id: toolCallId,
                     type: "function",
                     function: {
                       name: toolCallDelta.function.name,

packages/opencode/src/provider/transform.ts

@@ -759,7 +759,9 @@ export namespace ProviderTransform {
     if (input.model.api.id.includes("gpt-5") && !input.model.api.id.includes("gpt-5-chat")) {
       if (!input.model.api.id.includes("gpt-5-pro")) {
         result["reasoningEffort"] = "medium"
-        result["reasoningSummary"] = "auto"
+        if (input.model.api.npm !== "@ai-sdk/openai-compatible") {
+          result["reasoningSummary"] = "auto"
+        }
       }
 
       // Only set textVerbosity for non-chat gpt-5.x models

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

@@ -840,6 +840,14 @@ export namespace MessageV2 {
             cause: e,
           },
         ).toObject()
+      case e instanceof DOMException && e.name === "TimeoutError":
+        return new MessageV2.APIError(
+          {
+            message: e.message || "Operation timed out",
+            isRetryable: true,
+          },
+          { cause: e },
+        ).toObject()
       case MessageV2.OutputLengthError.isInstance(e):
         return e
       case LoadAPIKeyError.isInstance(e):

packages/opencode/src/session/prompt.ts

@@ -51,6 +51,7 @@ import { InjectionBudget } from "../util/injection-budget"
 import { iife } from "@/util/iife"
 import { Shell } from "@/shell/shell"
 import { Truncate } from "@/tool/truncation"
+import { normalizeNul } from "@/util/redirection"
 
 // @ts-ignore
 globalThis.AI_SDK_LOG_WARNINGS = false
@@ -1581,6 +1582,7 @@ NOTE: At any point in time through this workflow you should feel free to ask the
   })
   export type ShellInput = z.infer<typeof ShellInput>
   export async function shell(input: ShellInput) {
+    const command = normalizeNul(input.command, process.platform)
     const abort = start(input.sessionID)
     if (!abort) {
       throw new Session.BusyError(input.sessionID)
@@ -1667,7 +1669,7 @@ NOTE: At any point in time through this workflow you should feel free to ask the
           start: Date.now(),
         },
         input: {
-          command: input.command,
+          command,
         },
       },
     }
@@ -1679,10 +1681,10 @@ NOTE: At any point in time through this workflow you should feel free to ask the
 
     const invocations: Record<string, { args: string[] }> = {
       nu: {
-        args: ["-c", input.command],
+        args: ["-c", command],
       },
       fish: {
-        args: ["-c", input.command],
+        args: ["-c", command],
       },
       zsh: {
         args: [
@@ -1691,7 +1693,7 @@ NOTE: At any point in time through this workflow you should feel free to ask the
           `
             [[ -f ~/.zshenv ]] && source ~/.zshenv >/dev/null 2>&1 || true
             [[ -f "\${ZDOTDIR:-$HOME}/.zshrc" ]] && source "\${ZDOTDIR:-$HOME}/.zshrc" >/dev/null 2>&1 || true
-            eval ${JSON.stringify(input.command)}
+            eval ${JSON.stringify(command)}
           `,
         ],
       },
@@ -1702,25 +1704,25 @@ NOTE: At any point in time through this workflow you should feel free to ask the
           `
             shopt -s expand_aliases
             [[ -f ~/.bashrc ]] && source ~/.bashrc >/dev/null 2>&1 || true
-            eval ${JSON.stringify(input.command)}
+            eval ${JSON.stringify(command)}
           `,
         ],
       },
       // Windows cmd
       cmd: {
-        args: ["/c", input.command],
+        args: ["/c", command],
       },
       // Windows PowerShell
       powershell: {
-        args: ["-NoProfile", "-Command", input.command],
+        args: ["-NoProfile", "-Command", command],
       },
       pwsh: {
-        args: ["-NoProfile", "-Command", input.command],
+        args: ["-NoProfile", "-Command", command],
       },
       // Fallback: any shell that doesn't match those above
       //  - No -l, for max compatibility
       "": {
-        args: ["-c", `${input.command}`],
+        args: ["-c", `${command}`],
       },
     }
 
@@ -1736,13 +1738,14 @@ NOTE: At any point in time through this workflow you should feel free to ask the
     const proc = spawn(shell, args, {
       cwd,
       detached: process.platform !== "win32",
-      stdio: ["ignore", "pipe", "pipe"],
+      stdio: ["pipe", "pipe", "pipe"],
       env: {
         ...process.env,
         ...shellEnv.env,
         TERM: "dumb",
       },
     })
+    proc.stdin?.end()
 
     let output = ""
 

packages/opencode/src/tool/bash.ts

@@ -17,6 +17,7 @@ import { Shell } from "@/shell/shell"
 import { BashArity } from "@/permission/arity"
 import { Truncate } from "./truncation"
 import { Plugin } from "@/plugin"
+import { normalizeNul } from "@/util/redirection"
 
 const MAX_METADATA_LENGTH = 30_000
 const DEFAULT_TIMEOUT = Flag.OPENCODE_EXPERIMENTAL_BASH_DEFAULT_TIMEOUT_MS || 2 * 60 * 1000
@@ -76,12 +77,13 @@ export const BashTool = Tool.define("bash", async () => {
         ),
     }),
     async execute(params, ctx) {
+      const command = normalizeNul(params.command, process.platform)
       const cwd = params.workdir || Instance.directory
       if (params.timeout !== undefined && params.timeout < 0) {
         throw new Error(`Invalid timeout value: ${params.timeout}. Timeout must be a positive number.`)
       }
       const timeout = params.timeout ?? DEFAULT_TIMEOUT
-      const tree = await parser().then((p) => p.parse(params.command))
+      const tree = await parser().then((p) => p.parse(command))
       if (!tree) {
         throw new Error("Failed to parse command")
       }
@@ -169,16 +171,17 @@ export const BashTool = Tool.define("bash", async () => {
         { cwd, sessionID: ctx.sessionID, callID: ctx.callID },
         { env: {} },
       )
-      const proc = spawn(params.command, {
+      const proc = spawn(command, {
         shell,
         cwd,
         env: {
           ...process.env,
           ...shellEnv.env,
         },
-        stdio: ["ignore", "pipe", "pipe"],
+        stdio: ["pipe", "pipe", "pipe"],
         detached: process.platform !== "win32",
       })
+      proc.stdin?.end()
 
       let output = ""
 

packages/opencode/src/util/redirection.ts

@@ -0,0 +1,9 @@
+const OPS = "(?:\\d+>>?|>>|>|&>|>&)"
+
+export function normalizeNul(command: string, platform: string) {
+  if (platform === "win32") return command
+
+  return command
+    .replace(new RegExp(`(^|[\\s;|&(])(${OPS}\\s*)["']nul["'](?=($|[\\s;|&)]))`, "gi"), "$1$2/dev/null")
+    .replace(new RegExp(`(^|[\\s;|&(])(${OPS}\\s*)nul(?=($|[\\s;|&)]))`, "gi"), "$1$2/dev/null")
+}

packages/opencode/test/provider/copilot/copilot-chat-model.test.ts

@@ -589,4 +589,38 @@ describe("request body", () => {
       },
     ])
   })
+
+  test("should strip reasoningSummary but keep reasoning effort and custom options", async () => {
+    let capturedBody: any
+    const mockFetch = mock(async (_url: string, init?: RequestInit) => {
+      capturedBody = JSON.parse(init?.body as string)
+      return new Response(
+        new ReadableStream({
+          start(controller) {
+            controller.enqueue(new TextEncoder().encode(`data: [DONE]\n\n`))
+            controller.close()
+          },
+        }),
+        { status: 200, headers: { "Content-Type": "text/event-stream" } },
+      )
+    })
+
+    const model = createModel(mockFetch)
+
+    await model.doStream({
+      prompt: TEST_PROMPT,
+      providerOptions: {
+        copilot: {
+          reasoningEffort: "high",
+          reasoningSummary: "auto",
+          custom_field: true,
+        },
+      },
+      includeRawChunks: false,
+    })
+
+    expect(capturedBody.reasoning_effort).toBe("high")
+    expect(capturedBody.reasoningSummary).toBeUndefined()
+    expect(capturedBody.custom_field).toBe(true)
+  })
 })

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

@@ -132,6 +132,32 @@ describe("ProviderTransform.options - gpt-5 textVerbosity", () => {
       headers: {},
     }) as any
 
+  const createOpenAICompatibleGpt5Model = (apiId: string) =>
+    ({
+      id: `myprovider/${apiId}`,
+      providerID: "myprovider",
+      api: {
+        id: apiId,
+        url: "https://inference.do-ai.run/v1",
+        npm: "@ai-sdk/openai-compatible",
+      },
+      name: apiId,
+      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: false,
+      },
+      cost: { input: 0.03, output: 0.06, cache: { read: 0.001, write: 0.002 } },
+      limit: { context: 128000, output: 4096 },
+      status: "active",
+      options: {},
+      headers: {},
+    }) as any
+
   test("gpt-5.2 should have textVerbosity set to low", () => {
     const model = createGpt5Model("gpt-5.2")
     const result = ProviderTransform.options({ model, sessionID, providerOptions: {} })
@@ -173,6 +199,19 @@ describe("ProviderTransform.options - gpt-5 textVerbosity", () => {
     const result = ProviderTransform.options({ model, sessionID, providerOptions: {} })
     expect(result.textVerbosity).toBeUndefined()
   })
+
+  test("openai gpt-5 should include reasoningSummary by default", () => {
+    const model = createGpt5Model("gpt-5")
+    const result = ProviderTransform.options({ model, sessionID, providerOptions: {} })
+    expect(result.reasoningSummary).toBe("auto")
+  })
+
+  test("openai-compatible gpt-5 should not include reasoningSummary by default", () => {
+    const model = createOpenAICompatibleGpt5Model("openai-gpt-5")
+    const result = ProviderTransform.options({ model, sessionID, providerOptions: {} })
+    expect(result.reasoningEffort).toBe("medium")
+    expect(result.reasoningSummary).toBeUndefined()
+  })
 })
 
 describe("ProviderTransform.options - gateway", () => {

packages/opencode/test/util/redirection.test.ts

@@ -0,0 +1,16 @@
+import { describe, expect, test } from "bun:test"
+import { normalizeNul } from "../../src/util/redirection"
+
+describe("util.redirection", () => {
+  test("rewrites nul redirect targets on non-windows", () => {
+    expect(normalizeNul("dir /s *.dll >nul 2>&1", "linux")).toBe("dir /s *.dll >/dev/null 2>&1")
+    expect(normalizeNul("echo hi 2> NUL", "linux")).toBe("echo hi 2> /dev/null")
+    expect(normalizeNul("echo hi >> 'nul'", "linux")).toBe("echo hi >> /dev/null")
+    expect(normalizeNul("dir /s *.dll >nul 2>&1", "win32")).toBe("dir /s *.dll >nul 2>&1")
+  })
+
+  test("does not touch ordinary file paths", () => {
+    expect(normalizeNul("cat ./nul.txt", "linux")).toBe("cat ./nul.txt")
+    expect(normalizeNul("echo hi > ./nul", "linux")).toBe("echo hi > ./nul")
+  })
+})