fix(minimax): raise undici headers/body timeout past the 300s cliff

Node's built-in fetch (undici 6) caps the headers and body response
timeouts at 300_000 ms. The clawpatch AbortController above the fetch
never sees a long-running minimax response finish — undici rejects it
with a low-level HeadersTimeoutError first, which the user sees as
'minimax provider network error: fetch failed' at ~301s even when
CLAWPATCH_MINIMAX_TIMEOUT_MS is set much higher.

Install a custom undici Agent whose headersTimeout and bodyTimeout
track minimaxTimeoutMs(), and raise the default timeout to 30 minutes
so the AbortController is the dominant timeout for typical large code
reviews.

Author: ferminquant

CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## 0.5.1 - Unreleased
 
+- Fixed `minimax` provider review timeouts at ~301s for large prompts. Node's built-in fetch uses undici with a hard-coded 300_000 ms headers/body timeout, which silently rejected long minimax responses as `fetch failed` even when the user set `CLAWPATCH_MINIMAX_TIMEOUT_MS` higher. The provider now installs a custom undici `Agent` whose `headersTimeout`/`bodyTimeout` track `minimaxTimeoutMs()`, and the default timeout was raised to 30 minutes so the AbortController is the dominant timeout for typical large reviews.
+
 ## 0.5.0 - 2026-05-31
 
 - Added CUDA support to the C/C++ mapper, mapping `.cu` and `.cuh` sources as standalone `main()` files, CMake and autotools targets, legacy `FindCUDA` `cuda_add_executable` / `cuda_add_library` calls, and bounded loose source groups.

package.json

@@ -30,6 +30,7 @@
     "crabbox:warmup": "crabbox warmup"
   },
   "dependencies": {
+    "undici": "^6.21.0",
     "zod": "^4.4.3"
   },
   "devDependencies": {

pnpm-lock.yaml

@@ -36,6 +36,7 @@ const {
   formatZodIssue,
   minimaxBaseUrl,
   minimaxDefaultModel,
+  minimaxDispatcher,
   minimaxExitCode,
   minimaxFailureMessage,
   minimaxTimeoutMs,
@@ -86,6 +87,25 @@ function withEnv(name: string, value: string | undefined, fn: () => void): void
   }
 }
 
+// undici stores Agent construction options on an internal Symbol-keyed slot
+// (`Symbol(options)`), not as enumerable properties. Helper for tests that
+// need to assert which timeouts were configured on a dispatcher.
+function readAgentOptions(agent: unknown): { headersTimeout: number; bodyTimeout: number } {
+  const sym = Object.getOwnPropertySymbols(agent as object).find(
+    (s) => s.toString() === "Symbol(options)",
+  );
+  if (sym === undefined) {
+    throw new Error("undici Agent options symbol not found");
+  }
+  const options = (agent as Record<symbol, { headersTimeout: number; bodyTimeout: number } | undefined>)[
+    sym
+  ];
+  if (options === undefined) {
+    throw new Error("undici Agent options slot is empty");
+  }
+  return options;
+}
+
 function updateEnvelope(update: object): string {
   return JSON.stringify({
     jsonrpc: "2.0",
@@ -1989,7 +2009,50 @@ describe("minimax provider", () => {
 
   it("minimaxTimeoutMs falls back to default for invalid values", () => {
     withEnv("CLAWPATCH_MINIMAX_TIMEOUT_MS", "not-a-number", () => {
-      expect(minimaxTimeoutMs()).toBe(300_000);
+      expect(minimaxTimeoutMs()).toBe(1_800_000);
+    });
+  });
+
+  it("minimaxTimeoutMs default is large enough to clear the undici 300s cliff", () => {
+    withEnv("CLAWPATCH_MINIMAX_TIMEOUT_MS", undefined, () => {
+      withEnv("CLAWPATCH_PROVIDER_TIMEOUT_MS", undefined, () => {
+        // Node's built-in fetch has a 300_000 ms headers/body timeout. The
+        // AbortController is the user-visible timeout, so it must be larger
+        // than 300_000 to ever fire before undici rejects the response.
+        expect(minimaxTimeoutMs()).toBeGreaterThan(300_000);
+      });
+    });
+  });
+
+  it("minimaxDispatcher returns an undici Agent sized to the configured timeout", () => {
+    withEnv("CLAWPATCH_MINIMAX_TIMEOUT_MS", "120000", () => {
+      // undici stores Agent options on an internal Symbol-keyed slot
+      // (`Symbol(options)`), not as enumerable properties. Reach in to verify
+      // the timeouts we passed at construction time made it through.
+      const dispatcher = minimaxDispatcher();
+      const options = readAgentOptions(dispatcher);
+      expect(options.headersTimeout).toBe(120000);
+      expect(options.bodyTimeout).toBe(120000);
+    });
+  });
+
+  it("minimaxDispatcher caches the agent when timeout is unchanged", () => {
+    withEnv("CLAWPATCH_MINIMAX_TIMEOUT_MS", "180000", () => {
+      const a = minimaxDispatcher();
+      const b = minimaxDispatcher();
+      expect(a).toBe(b);
+    });
+  });
+
+  it("minimaxDispatcher rebuilds the agent when the timeout changes", () => {
+    withEnv("CLAWPATCH_MINIMAX_TIMEOUT_MS", "180000", () => {
+      const a = minimaxDispatcher();
+      withEnv("CLAWPATCH_MINIMAX_TIMEOUT_MS", "240000", () => {
+        const b = minimaxDispatcher();
+        expect(a).not.toBe(b);
+        const options = readAgentOptions(b);
+        expect(options.headersTimeout).toBe(240000);
+      });
     });
   });
 

src/provider.test.ts

@@ -1,6 +1,7 @@
 import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { Agent } from "undici";
 import { z, type ZodError, type ZodIssue, type ZodType } from "zod";
 import { runCommandArgs } from "./exec.js";
 import { ClawpatchError } from "./errors.js";
@@ -456,7 +457,15 @@ const grokProvider: Provider = {
 const MINIMAX_PROVIDER_NAME = "minimax";
 const MINIMAX_DEFAULT_BASE_URL = "https://api.minimax.io/v1";
 const MINIMAX_DEFAULT_MODEL = "MiniMax-M3";
-const MINIMAX_DEFAULT_TIMEOUT_MS = 300_000;
+// Node's built-in fetch (undici) caps the headers/body response timeout at
+// 300_000 ms by default. The clawpatch `setTimeout`/AbortController above the
+// fetch never sees that — undici rejects with a low-level HeadersTimeoutError
+// first, which surfaces to the user as "minimax provider network error: fetch
+// failed" after exactly ~301s. Raising the AbortController value alone is not
+// enough; we also have to install a custom undici dispatcher whose
+// headers/body timeouts match the AbortController. Bump the default to 30 min
+// so the AbortController is the dominant timeout for typical large reviews.
+const MINIMAX_DEFAULT_TIMEOUT_MS = 1_800_000;
 const MINIMAX_CHECK_TIMEOUT_MS = 30_000;
 
 function minimaxTimeoutMs(): number {
@@ -469,6 +478,33 @@ function minimaxTimeoutMs(): number {
   return Number.isFinite(parsed) && parsed > 0 ? parsed : MINIMAX_DEFAULT_TIMEOUT_MS;
 }
 
+// Cached undici dispatcher sized to the current `minimaxTimeoutMs()` value.
+// The dispatcher controls the underlying socket-level timeouts (headers and
+// body) that the global `fetch` does not expose. We rebuild the agent when
+// the configured timeout changes so behaviour stays in sync with env-var
+// overrides (typically set once at process start, but a test may flip them).
+// The Agent return type is structurally compatible with the Dispatcher type
+// expected by the global `fetch` `dispatcher` option, even when the type
+// packages between undici 6 and @types/node differ.
+let minimaxDispatcherCache: { timeoutMs: number; dispatcher: InstanceType<typeof Agent> } | null =
+  null;
+function minimaxDispatcher(): InstanceType<typeof Agent> {
+  const timeoutMs = minimaxTimeoutMs();
+  if (minimaxDispatcherCache !== null && minimaxDispatcherCache.timeoutMs === timeoutMs) {
+    return minimaxDispatcherCache.dispatcher;
+  }
+  if (minimaxDispatcherCache !== null) {
+    void minimaxDispatcherCache.dispatcher.close();
+  }
+  const dispatcher = new Agent({
+    headersTimeout: timeoutMs,
+    bodyTimeout: timeoutMs,
+    connectTimeout: 10_000,
+  });
+  minimaxDispatcherCache = { timeoutMs, dispatcher };
+  return dispatcher;
+}
+
 function minimaxBaseUrl(): string {
   const raw = process.env["MINIMAX_BASE_URL"];
   return raw !== undefined && raw.length > 0 ? raw : MINIMAX_DEFAULT_BASE_URL;
@@ -560,6 +596,13 @@ async function runMinimaxJson(
       },
       body: JSON.stringify(body),
       signal: controller.signal,
+      // undici dispatcher with headers/body timeouts matching the
+      // AbortController. Without this, Node's global fetch uses a 300s
+      // hard-coded headers/body timeout and the AbortController never fires.
+      // The undici 6 Agent type is structurally compatible with the global
+      // fetch Dispatcher type, but the two type packages disagree, so we
+      // cast through `unknown` at the call site.
+      dispatcher: minimaxDispatcher() as unknown as NonNullable<RequestInit["dispatcher"]>,
     });
   } catch (err) {
     clearTimeout(timer);
@@ -2572,6 +2615,7 @@ export const __testing = {
   parseOrThrow,
   minimaxBaseUrl,
   minimaxDefaultModel,
+  minimaxDispatcher,
   minimaxExitCode,
   minimaxFailureMessage,
   minimaxTimeoutMs,