F6: derive extended chunkTimeout from model.reasoning

packages/opencode/src/provider/provider.ts

@@ -48,22 +48,23 @@ function shouldUseCopilotResponsesApi(modelID: string): boolean {
 
 const DEFAULT_CHUNK_TIMEOUT_MS = 120_000
 const EXTENDED_THINKING_CHUNK_TIMEOUT_MS = 600_000
-const EXTENDED_THINKING_PROVIDERS: ReadonlySet<string> = new Set([
-  "anthropic",
-  "google-vertex-anthropic",
-  "amazon-bedrock",
-])
 
-export function resolveChunkTimeout(providerID: string, value: unknown): number {
+export function resolveChunkTimeout(
+  model: { readonly providerID: string; readonly reasoning: boolean },
+  value: unknown,
+): number {
   if (value === false) return 0
   if (typeof value === "number") {
     if (!Number.isFinite(value) || value <= 0) return 0
     return value
   }
-  if (value !== undefined) log.warn("unrecognized chunkTimeout value, using provider default", { providerID, value })
-  return EXTENDED_THINKING_PROVIDERS.has(providerID)
-    ? EXTENDED_THINKING_CHUNK_TIMEOUT_MS
-    : DEFAULT_CHUNK_TIMEOUT_MS
+  if (value !== undefined)
+    log.warn("unrecognized chunkTimeout value, using model default", {
+      providerID: model.providerID,
+      reasoning: model.reasoning,
+      value,
+    })
+  return model.reasoning ? EXTENDED_THINKING_CHUNK_TIMEOUT_MS : DEFAULT_CHUNK_TIMEOUT_MS
 }
 
 export function wrapSSE(res: Response, ms: number, ctl: AbortController) {
@@ -1468,7 +1469,10 @@ const layer: Layer.Layer<
         if (existing) return existing
 
         const customFetch = options["fetch"]
-        const resolvedChunkTimeout = resolveChunkTimeout(model.providerID, options["chunkTimeout"])
+        const resolvedChunkTimeout = resolveChunkTimeout(
+          { providerID: model.providerID, reasoning: model.capabilities.reasoning },
+          options["chunkTimeout"],
+        )
         delete options["chunkTimeout"]
 
         options["fetch"] = async (input: any, init?: BunFetchRequestInit) => {

packages/opencode/test/provider/chunk-timeout.test.ts

@@ -2,41 +2,51 @@ import { describe, expect, test } from "bun:test"
 import { resolveChunkTimeout, SSEStallError, wrapSSE } from "../../src/provider/provider"
 
 describe("provider.resolveChunkTimeout", () => {
-  test("returns 120s default when undefined for generic provider", () => {
-    expect(resolveChunkTimeout("github-copilot", undefined)).toBe(120_000)
+  test("returns 120s default when undefined and reasoning=false", () => {
+    expect(resolveChunkTimeout({ providerID: "github-copilot", reasoning: false }, undefined)).toBe(120_000)
   })
 
-  test("returns 600s default for Anthropic", () => {
-    expect(resolveChunkTimeout("anthropic", undefined)).toBe(600_000)
+  test("returns 600s default when reasoning=true on anthropic", () => {
+    expect(resolveChunkTimeout({ providerID: "anthropic", reasoning: true }, undefined)).toBe(600_000)
   })
 
-  test("returns 600s default for google-vertex-anthropic", () => {
-    expect(resolveChunkTimeout("google-vertex-anthropic", undefined)).toBe(600_000)
+  test("returns 600s default for reasoning=true regardless of provider ID (openrouter → anthropic/*)", () => {
+    expect(resolveChunkTimeout({ providerID: "openrouter", reasoning: true }, undefined)).toBe(600_000)
   })
 
-  test("returns 600s default for amazon-bedrock", () => {
-    expect(resolveChunkTimeout("amazon-bedrock", undefined)).toBe(600_000)
+  test("returns 600s default when reasoning=true on google-vertex-anthropic", () => {
+    expect(resolveChunkTimeout({ providerID: "google-vertex-anthropic", reasoning: true }, undefined)).toBe(600_000)
+  })
+
+  test("returns 600s default when reasoning=true on amazon-bedrock", () => {
+    expect(resolveChunkTimeout({ providerID: "amazon-bedrock", reasoning: true }, undefined)).toBe(600_000)
+  })
+
+  test("returns 120s default when reasoning=false on anthropic (non-reasoning Claude)", () => {
+    expect(resolveChunkTimeout({ providerID: "anthropic", reasoning: false }, undefined)).toBe(120_000)
   })
 
   test("returns 0 when explicitly disabled with false", () => {
-    expect(resolveChunkTimeout("github-copilot", false)).toBe(0)
+    expect(resolveChunkTimeout({ providerID: "github-copilot", reasoning: false }, false)).toBe(0)
   })
 
   test("returns the user value when a positive number", () => {
-    expect(resolveChunkTimeout("github-copilot", 60_000)).toBe(60_000)
+    expect(resolveChunkTimeout({ providerID: "github-copilot", reasoning: false }, 60_000)).toBe(60_000)
   })
 
   test("explicit positive number wins over extended-thinking default", () => {
-    expect(resolveChunkTimeout("anthropic", 30_000)).toBe(30_000)
+    expect(resolveChunkTimeout({ providerID: "anthropic", reasoning: true }, 30_000)).toBe(30_000)
   })
 
   test("false wins over extended-thinking default (returns 0)", () => {
-    expect(resolveChunkTimeout("anthropic", false)).toBe(0)
+    expect(resolveChunkTimeout({ providerID: "anthropic", reasoning: true }, false)).toBe(0)
   })
 
-  test("falls back to provider default for non-numeric junk", () => {
+  test("falls back to model default for non-numeric junk", () => {
     // Defensive branch — config schema prevents this, but runtime check guards misconfig.
-    expect(resolveChunkTimeout("github-copilot", "not-a-number" as never)).toBe(120_000)
+    expect(resolveChunkTimeout({ providerID: "github-copilot", reasoning: false }, "not-a-number" as never)).toBe(
+      120_000,
+    )
   })
 })