fix(provider): coerce numeric tool call IDs for OpenAI-compatible providers

Some providers like NVIDIA NIM kimik2.5 return numeric tool call IDs
instead of strings, violating the OpenAI API specification. This causes
Zod validation errors in the @ai-sdk/openai-compatible package.

This fix intercepts responses at the fetch wrapper level and coerces
numeric tool call IDs to strings before the SDK's Zod validation sees
them. This applies to both JSON responses and SSE streaming responses.

- Added coerceNumericToolCallIds() to recursively transform numeric IDs
- Added transformSSEStream() to handle streaming responses
- Applied transformation only for @ai-sdk/openai-compatible providers
- Added unit tests for the coercion logic

Fixes: #19947

Author: Qiiks

packages/opencode/src/provider/provider.ts

@@ -32,6 +32,74 @@ import { ModelID, ProviderID } from "./schema"
 
 const log = Log.create({ service: "provider" })
 
+function coerceNumericToolCallIds(obj: unknown): void {
+  if (!obj || typeof obj !== "object") return
+  if (Array.isArray(obj)) {
+    for (const item of obj) coerceNumericToolCallIds(item)
+    return
+  }
+  const record = obj as Record<string, unknown>
+  if ("tool_calls" in record && Array.isArray(record.tool_calls)) {
+    for (const tc of record.tool_calls) {
+      if (tc && typeof tc === "object" && "id" in tc && typeof tc.id === "number") {
+        tc.id = String(tc.id)
+      }
+    }
+  }
+  if ("delta" in record && record.delta && typeof record.delta === "object") {
+    const delta = record.delta as Record<string, unknown>
+    if ("tool_calls" in delta && Array.isArray(delta.tool_calls)) {
+      for (const tc of delta.tool_calls) {
+        if (tc && typeof tc === "object" && "id" in tc && typeof tc.id === "number") {
+          tc.id = String(tc.id)
+        }
+      }
+    }
+  }
+  for (const value of Object.values(record)) {
+    coerceNumericToolCallIds(value)
+  }
+}
+
+function transformSSEStream(body: ReadableStream<Uint8Array>): ReadableStream<Uint8Array> {
+  const reader = body.getReader()
+  const decoder = new TextDecoder()
+  const encoder = new TextEncoder()
+  let buffer = ""
+
+  return new ReadableStream<Uint8Array>({
+    async pull(controller) {
+      const { done, value } = await reader.read()
+      if (done) {
+        if (buffer) controller.enqueue(encoder.encode(buffer))
+        controller.close()
+        return
+      }
+      buffer += decoder.decode(value, { stream: true })
+      const lines = buffer.split("\n")
+      buffer = lines.pop() ?? ""
+      for (const line of lines) {
+        if (line.startsWith("data: ")) {
+          const jsonStr = line.slice(6)
+          if (jsonStr === "[DONE]") {
+            controller.enqueue(encoder.encode(line + "\n"))
+            continue
+          }
+          try {
+            const json = JSON.parse(jsonStr)
+            coerceNumericToolCallIds(json)
+            controller.enqueue(encoder.encode("data: " + JSON.stringify(json) + "\n"))
+            continue
+          } catch {
+            // If parsing fails, pass through unchanged
+          }
+        }
+        controller.enqueue(encoder.encode(line + "\n"))
+      }
+    },
+  })
+}
+
 function shouldUseCopilotResponsesApi(modelID: string): boolean {
   const match = /^gpt-(\d+)/.exec(modelID)
   if (!match) return false
@@ -1478,6 +1546,38 @@ const layer: Layer.Layer<
             timeout: false,
           })
 
+          // Coerce numeric tool call IDs to strings for non-compliant providers
+          // Some providers (e.g., NVIDIA NIM kimik2.5) return numeric IDs instead of strings
+          if (model.api.npm === "@ai-sdk/openai-compatible" && res.body) {
+            const contentType = res.headers.get("content-type") ?? ""
+            if (contentType.includes("application/json")) {
+              const text = await res.text()
+              try {
+                const json = JSON.parse(text)
+                coerceNumericToolCallIds(json)
+                return new Response(JSON.stringify(json), {
+                  status: res.status,
+                  statusText: res.statusText,
+                  headers: res.headers,
+                })
+              } catch {
+                return new Response(text, {
+                  status: res.status,
+                  statusText: res.statusText,
+                  headers: res.headers,
+                })
+              }
+            }
+            if (contentType.includes("text/event-stream")) {
+              const transformed = transformSSEStream(res.body)
+              return new Response(transformed, {
+                status: res.status,
+                statusText: res.statusText,
+                headers: res.headers,
+              })
+            }
+          }
+
           if (!chunkAbortCtl) return res
           return wrapSSE(res, chunkTimeout, chunkAbortCtl)
         }

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

@@ -2640,3 +2640,82 @@ test("opencode loader keeps paid models when auth exists", async () => {
     }
   }
 })
+
+test("coerceNumericToolCallIds transforms numeric IDs to strings", () => {
+  const coerce = (obj: unknown) => {
+    const clone = JSON.parse(JSON.stringify(obj))
+    const coerceRecursive = (o: unknown): void => {
+      if (!o || typeof o !== "object") return
+      if (Array.isArray(o)) {
+        for (const item of o) coerceRecursive(item)
+        return
+      }
+      const r = o as Record<string, unknown>
+      if ("tool_calls" in r && Array.isArray(r.tool_calls)) {
+        for (const tc of r.tool_calls) {
+          if (tc && typeof tc === "object" && "id" in tc && typeof tc.id === "number") {
+            tc.id = String(tc.id)
+          }
+        }
+      }
+      if ("delta" in r && r.delta && typeof r.delta === "object") {
+        const delta = r.delta as Record<string, unknown>
+        if ("tool_calls" in delta && Array.isArray(delta.tool_calls)) {
+          for (const tc of delta.tool_calls) {
+            if (tc && typeof tc === "object" && "id" in tc && typeof tc.id === "number") {
+              tc.id = String(tc.id)
+            }
+          }
+        }
+      }
+      for (const value of Object.values(r)) coerceRecursive(value)
+    }
+    coerceRecursive(clone)
+    return clone
+  }
+
+  const nonStreaming = {
+    choices: [
+      {
+        message: {
+          tool_calls: [
+            { id: 123, type: "function", function: { name: "read_file", arguments: "{}" } },
+            { id: 456, type: "function", function: { name: "list_files", arguments: "{}" } },
+          ],
+        },
+      },
+    ],
+  }
+
+  const result = coerce(nonStreaming)
+  expect(result.choices[0].message.tool_calls[0].id).toBe("123")
+  expect(result.choices[0].message.tool_calls[1].id).toBe("456")
+
+  const streaming = {
+    choices: [
+      {
+        delta: {
+          tool_calls: [{ index: 0, id: 789, function: { name: "test", arguments: "" } }],
+        },
+      },
+    ],
+  }
+
+  const streamResult = coerce(streaming)
+  expect(streamResult.choices[0].delta.tool_calls[0].id).toBe("789")
+
+  const withStringIds = {
+    choices: [
+      {
+        message: {
+          tool_calls: [
+            { id: "call_abc123", type: "function", function: { name: "test", arguments: "{}" } },
+          ],
+        },
+      },
+    ],
+  }
+
+  const stringResult = coerce(withStringIds)
+  expect(stringResult.choices[0].message.tool_calls[0].id).toBe("call_abc123")
+})