190proof 1.0.107 → 1.0.109

package/README.md

@@ -273,9 +273,11 @@ Main function to make requests to any supported AI provider.
 - `retries`: `number` - Number of retry attempts (default: 5)
 - `chunkTimeoutMs`: `number` - Timeout for streaming chunks in ms (default: 15000)
 
-Two optional per-request knobs live on `payload` (`GenericPayload`):
+Optional per-request knobs live on `payload` (`GenericPayload`):
 
-- `payload.requestTimeoutMs`: `number` - Per-attempt HTTP timeout in ms (default: 120000), honored by every adapter.
+- `payload.requestTimeoutMs`: `number` - Per-attempt HTTP timeout in ms (default: 120000), honored by every adapter — except streaming OpenRouter attempts, which it deliberately does NOT bound (see below). For OpenRouter's non-streaming transport the default is 180000.
+- `payload.streaming`: `boolean` - OpenRouter-only (default: true). Streams the completion over SSE. A streaming attempt is bounded by two independent timers instead of `requestTimeoutMs`: `streamTimeoutMs` (total wall clock, default 600000) and the per-useful-chunk stall timeout (`chunkTimeoutMs` argument, default 15000). A chunk is "useful" only if it advances content, reasoning, tool-call fragments, finish_reason, or usage — SSE comment keep-alives (`: OPENROUTER PROCESSING`) and role-only deltas don't reset the stall timer, so a hung provider dies within one stall window while a healthy long generation can run to the total budget. Set `streaming: false` for the old single-JSON-body transport.
+- `payload.streamTimeoutMs`: `number` - OpenRouter-only: total wall-clock budget per streaming attempt (default: 600000).
 - `payload.signal`: `AbortSignal` - Caller-supplied cancellation. When it aborts, the in-flight provider request is cancelled and `callWithRetries` **rejects immediately — it does not retry or fall back** (both the retry loop and the fallback branch bail on `signal.aborted`). Threaded to the underlying fetch/axios/SDK call of each provider.
 
 #### Returns

package/dist/index.d.mts

@@ -279,6 +279,24 @@ interface GenericPayload {
      * valid response isn't cut short.
      */
     requestTimeoutMs?: number;
+    /**
+     * OpenRouter-only: stream the completion over SSE instead of waiting for a
+     * single JSON body. Defaults to true. Streaming attempts are bounded by
+     * `streamTimeoutMs` (total) plus a per-useful-chunk stall timeout — NOT by
+     * `requestTimeoutMs`, which only governs non-streaming attempts (default
+     * 180s for OpenRouter). Set to false to force the old non-streaming path.
+     */
+    streaming?: boolean;
+    /**
+     * OpenRouter-only: total wall-clock budget in ms for one streaming attempt
+     * (connect + full generation). Defaults to 600s. Independent of
+     * `requestTimeoutMs` by design: a healthy long generation keeps streaming
+     * useful chunks and may run far past any sane non-streaming deadline, while
+     * a hung one is killed much earlier by the per-useful-chunk stall timeout
+     * (`chunkTimeoutMs` argument of `callWithRetries`, default 15s — reset only
+     * by chunks that advance the output, never by keep-alive bytes/comments).
+     */
+    streamTimeoutMs?: number;
     /**
      * Optional caller-supplied cancellation signal. When it aborts, the in-flight
      * provider request is cancelled and `callWithRetries` rejects immediately —
@@ -289,10 +307,12 @@ interface GenericPayload {
     signal?: AbortSignal;
 }
 
+declare const OPENROUTER_STREAM_TIMEOUT_MS = 600000;
+declare const OPENROUTER_NONSTREAM_TIMEOUT_MS = 180000;
 declare function parseModelString(model: string): {
     provider: Provider;
     modelId: string;
 };
 declare function callWithRetries(id: string | string[], aiPayload: GenericPayload, aiConfig?: OpenAIConfig | AnthropicAIConfig, retries?: number, chunkTimeoutMs?: number): Promise<ParsedResponseMessage>;
 
-export { type AnyModel, ClaudeModel, type FunctionCall, type FunctionDefinition, GPTModel, GeminiModel, type GenericMessage, type GenericPayload, GroqModel, type OpenAIConfig, OpenRouterModel, type OpenRouterProviderPreferences, type ParsedResponseMessage, type Provider, type ToolResult, callWithRetries, parseModelString };
+export { type AnyModel, ClaudeModel, type FunctionCall, type FunctionDefinition, GPTModel, GeminiModel, type GenericMessage, type GenericPayload, GroqModel, OPENROUTER_NONSTREAM_TIMEOUT_MS, OPENROUTER_STREAM_TIMEOUT_MS, type OpenAIConfig, OpenRouterModel, type OpenRouterProviderPreferences, type ParsedResponseMessage, type Provider, type ToolResult, callWithRetries, parseModelString };

package/dist/index.d.ts

@@ -279,6 +279,24 @@ interface GenericPayload {
      * valid response isn't cut short.
      */
     requestTimeoutMs?: number;
+    /**
+     * OpenRouter-only: stream the completion over SSE instead of waiting for a
+     * single JSON body. Defaults to true. Streaming attempts are bounded by
+     * `streamTimeoutMs` (total) plus a per-useful-chunk stall timeout — NOT by
+     * `requestTimeoutMs`, which only governs non-streaming attempts (default
+     * 180s for OpenRouter). Set to false to force the old non-streaming path.
+     */
+    streaming?: boolean;
+    /**
+     * OpenRouter-only: total wall-clock budget in ms for one streaming attempt
+     * (connect + full generation). Defaults to 600s. Independent of
+     * `requestTimeoutMs` by design: a healthy long generation keeps streaming
+     * useful chunks and may run far past any sane non-streaming deadline, while
+     * a hung one is killed much earlier by the per-useful-chunk stall timeout
+     * (`chunkTimeoutMs` argument of `callWithRetries`, default 15s — reset only
+     * by chunks that advance the output, never by keep-alive bytes/comments).
+     */
+    streamTimeoutMs?: number;
     /**
      * Optional caller-supplied cancellation signal. When it aborts, the in-flight
      * provider request is cancelled and `callWithRetries` rejects immediately —
@@ -289,10 +307,12 @@ interface GenericPayload {
     signal?: AbortSignal;
 }
 
+declare const OPENROUTER_STREAM_TIMEOUT_MS = 600000;
+declare const OPENROUTER_NONSTREAM_TIMEOUT_MS = 180000;
 declare function parseModelString(model: string): {
     provider: Provider;
     modelId: string;
 };
 declare function callWithRetries(id: string | string[], aiPayload: GenericPayload, aiConfig?: OpenAIConfig | AnthropicAIConfig, retries?: number, chunkTimeoutMs?: number): Promise<ParsedResponseMessage>;
 
-export { type AnyModel, ClaudeModel, type FunctionCall, type FunctionDefinition, GPTModel, GeminiModel, type GenericMessage, type GenericPayload, GroqModel, type OpenAIConfig, OpenRouterModel, type OpenRouterProviderPreferences, type ParsedResponseMessage, type Provider, type ToolResult, callWithRetries, parseModelString };
+export { type AnyModel, ClaudeModel, type FunctionCall, type FunctionDefinition, GPTModel, GeminiModel, type GenericMessage, type GenericPayload, GroqModel, OPENROUTER_NONSTREAM_TIMEOUT_MS, OPENROUTER_STREAM_TIMEOUT_MS, type OpenAIConfig, OpenRouterModel, type OpenRouterProviderPreferences, type ParsedResponseMessage, type Provider, type ToolResult, callWithRetries, parseModelString };

package/dist/index.js

@@ -34,6 +34,8 @@ __export(index_exports, {
   GPTModel: () => GPTModel,
   GeminiModel: () => GeminiModel,
   GroqModel: () => GroqModel,
+  OPENROUTER_NONSTREAM_TIMEOUT_MS: () => OPENROUTER_NONSTREAM_TIMEOUT_MS,
+  OPENROUTER_STREAM_TIMEOUT_MS: () => OPENROUTER_STREAM_TIMEOUT_MS,
   OpenRouterModel: () => OpenRouterModel,
   callWithRetries: () => callWithRetries,
   parseModelString: () => parseModelString
@@ -1409,47 +1411,25 @@ function parseDsmlToolCalls(content) {
   const remaining = first === -1 ? content : (content.slice(0, first) + content.slice(last)).trim();
   return { calls, remainingContent: remaining.length ? remaining : null };
 }
-async function callOpenRouter(id, payload, requestTimeoutMs = 12e4, signal) {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
-  const response = await withRequestDeadline(
-    "OpenRouter",
-    requestTimeoutMs,
-    signal,
-    (mergedSignal) => import_axios.default.post(
-      // Override point for tests (deadline behavior needs a local server).
-      `${process.env.OPENROUTER_BASE_URL || "https://openrouter.ai"}/api/v1/chat/completions`,
-      payload,
-      {
-        headers: {
-          "content-type": "application/json",
-          Authorization: `Bearer ${process.env.OPENROUTER_API_KEY}`
-        },
-        timeout: requestTimeoutMs,
-        signal: mergedSignal
-      }
-    )
-  );
-  if (response.data.error) {
-    logger_default.error(id, "OpenRouter error:", response.data.error);
-    throw new Error(`OpenRouter error: ${response.data.error.message}`);
-  }
-  const answer = (_b = (_a = response.data.choices) == null ? void 0 : _a[0]) == null ? void 0 : _b.message;
-  if (!answer) {
-    logger_default.error(id, "Missing answer in OpenRouter API response:", response.data);
-    throw new Error("Missing answer in OpenRouter API");
-  }
+var OPENROUTER_STREAM_TIMEOUT_MS = 6e5;
+var OPENROUTER_NONSTREAM_TIMEOUT_MS = 18e4;
+function openRouterEndpoint() {
+  return `${process.env.OPENROUTER_BASE_URL || "https://openrouter.ai"}/api/v1/chat/completions`;
+}
+function finalizeOpenRouterMessage(id, raw) {
+  var _a, _b, _c, _d, _e;
   const functionCalls = [];
-  if ((_c = answer.tool_calls) == null ? void 0 : _c.length) {
-    for (let i = 0; i < answer.tool_calls.length; i++) {
-      const tc = answer.tool_calls[i];
-      functionCalls.push({
-        id: (_d = tc.id) != null ? _d : `call_${i}`,
-        name: tc.function.name,
-        arguments: JSON.parse(tc.function.arguments)
-      });
-    }
+  for (let i = 0; i < raw.toolCalls.length; i++) {
+    const tc = raw.toolCalls[i];
+    if (!tc.name) continue;
+    functionCalls.push({
+      id: (_a = tc.id) != null ? _a : `call_${i}`,
+      name: tc.name,
+      // Streamed no-arg calls can close with an empty fragment; treat as {}.
+      arguments: tc.argumentsJson.trim() ? JSON.parse(tc.argumentsJson) : {}
+    });
   }
-  let content = (_e = answer.content) != null ? _e : null;
+  let content = raw.content;
   if (!functionCalls.length && content && DSML_ENVELOPE_RE.test(content)) {
     const { calls, remainingContent } = parseDsmlToolCalls(content);
     if (calls.length) {
@@ -1459,11 +1439,7 @@ async function callOpenRouter(id, payload, requestTimeoutMs = 12e4, signal) {
   }
   const hasUnparsedDsml = !!content && DSML_DELIMITER_RE.test(content);
   if (!functionCalls.length && (!content || hasUnparsedDsml)) {
-    logger_default.error(
-      id,
-      "OpenRouter: empty or unparseable completion:",
-      JSON.stringify(response.data)
-    );
+    logger_default.error(id, "OpenRouter: empty or unparseable completion:", raw.forLog());
     throw new Error(
       "OpenRouter: received message without usable content or function_call"
     );
@@ -1474,24 +1450,267 @@ async function callOpenRouter(id, payload, requestTimeoutMs = 12e4, signal) {
     function_call: functionCalls[0] || null,
     function_calls: functionCalls,
     files: [],
-    reasoning: (_f = answer.reasoning) != null ? _f : void 0,
-    reasoningDetails: (_g = answer.reasoning_details) != null ? _g : void 0,
+    reasoning: raw.reasoning || void 0,
+    reasoningDetails: (_b = raw.reasoningDetails) != null ? _b : void 0,
     // The upstream provider OpenRouter routed to (e.g. "Baidu") — finer-grained
     // than the "openrouter" stamp callWithRetries would apply.
-    provider: (_h = response.data.provider) != null ? _h : void 0,
-    usage: response.data.usage ? {
-      prompt_tokens: response.data.usage.prompt_tokens,
-      completion_tokens: response.data.usage.completion_tokens,
-      total_tokens: response.data.usage.total_tokens,
-      cached_tokens: (_j = (_i = response.data.usage.prompt_tokens_details) == null ? void 0 : _i.cached_tokens) != null ? _j : 0
+    provider: (_c = raw.provider) != null ? _c : void 0,
+    usage: raw.usage ? {
+      prompt_tokens: raw.usage.prompt_tokens,
+      completion_tokens: raw.usage.completion_tokens,
+      total_tokens: raw.usage.total_tokens,
+      cached_tokens: (_e = (_d = raw.usage.prompt_tokens_details) == null ? void 0 : _d.cached_tokens) != null ? _e : 0
     } : null
   };
 }
-async function callOpenRouterWithRetries(id, payload, retries = 5, requestTimeoutMs = 12e4, signal) {
+async function callOpenRouterStream(id, payload, streamTimeoutMs = OPENROUTER_STREAM_TIMEOUT_MS, chunkTimeoutMs = 15e3, signal) {
+  var _a, _b, _c, _d, _e, _f, _g;
+  const controller = new AbortController();
+  let abortReason = null;
+  const abortWith = (reason) => {
+    abortReason = reason;
+    controller.abort();
+  };
+  const unref = (t) => {
+    if (typeof t === "object" && "unref" in t) t.unref();
+    return t;
+  };
+  const totalTimer = unref(
+    setTimeout(
+      () => abortWith(
+        `OpenRouter stream exceeded total deadline of ${streamTimeoutMs}ms`
+      ),
+      streamTimeoutMs
+    )
+  );
+  let stallTimer;
+  const armStallTimer = () => {
+    clearTimeout(stallTimer);
+    stallTimer = unref(
+      setTimeout(
+        () => abortWith(
+          `OpenRouter stream stalled: no useful chunk for ${chunkTimeoutMs}ms`
+        ),
+        chunkTimeoutMs
+      )
+    );
+  };
+  let paragraph = "";
+  let reasoning = "";
+  const reasoningDetails = [];
+  const toolCalls = [];
+  let provider;
+  let usage = null;
+  let finishReason = null;
+  let sawDone = false;
+  let dataChunks = 0;
+  try {
+    armStallTimer();
+    const response = await fetch(openRouterEndpoint(), {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        Authorization: `Bearer ${process.env.OPENROUTER_API_KEY}`
+      },
+      body: JSON.stringify({ ...payload, stream: true, usage: { include: true } }),
+      signal: signal ? anySignal([controller.signal, signal]) : controller.signal
+    });
+    if (!response.ok) {
+      let data;
+      try {
+        data = await response.json();
+      } catch (e) {
+        data = void 0;
+      }
+      logger_default.error(id, `OpenRouter stream HTTP ${response.status}:`, data);
+      const error2 = new Error(
+        `OpenRouter error: ${((_a = data == null ? void 0 : data.error) == null ? void 0 : _a.message) || `HTTP ${response.status}`}`
+      );
+      error2.response = { status: response.status, data };
+      throw error2;
+    }
+    if ((_b = response.headers.get("content-type")) == null ? void 0 : _b.includes("application/json")) {
+      return parseOpenRouterBody(id, await response.json());
+    }
+    if (!response.body) {
+      throw new Error("OpenRouter stream error: no response body");
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let lineBuffer = "";
+    outer: while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      lineBuffer += decoder.decode(value, { stream: true });
+      let newlineIdx;
+      while ((newlineIdx = lineBuffer.indexOf("\n")) !== -1) {
+        let line = lineBuffer.slice(0, newlineIdx);
+        lineBuffer = lineBuffer.slice(newlineIdx + 1);
+        if (line.endsWith("\r")) line = line.slice(0, -1);
+        if (!line) continue;
+        if (line.startsWith(":")) continue;
+        if (!line.startsWith("data:")) continue;
+        const dataStr = line.slice(5).trimStart();
+        if (dataStr === "[DONE]") {
+          sawDone = true;
+          break outer;
+        }
+        let json;
+        try {
+          json = JSON.parse(dataStr);
+        } catch (e) {
+          logger_default.error(
+            id,
+            "OpenRouter stream: unparseable data line:",
+            dataStr.slice(0, 200)
+          );
+          continue;
+        }
+        dataChunks++;
+        if (json.error) {
+          logger_default.error(id, "OpenRouter stream error event:", json.error);
+          const error2 = new Error(
+            `OpenRouter error: ${json.error.message}`
+          );
+          error2.data = json.error;
+          throw error2;
+        }
+        if (json.provider) provider = json.provider;
+        let useful = false;
+        if (json.usage) {
+          usage = json.usage;
+          useful = true;
+        }
+        const choice = (_c = json.choices) == null ? void 0 : _c[0];
+        if (choice) {
+          const delta = (_d = choice.delta) != null ? _d : {};
+          if (delta.content) {
+            paragraph += delta.content;
+            useful = true;
+          }
+          if (delta.reasoning) {
+            reasoning += delta.reasoning;
+            useful = true;
+          }
+          if (Array.isArray(delta.reasoning_details) && delta.reasoning_details.length) {
+            reasoningDetails.push(...delta.reasoning_details);
+            useful = true;
+          }
+          if (Array.isArray(delta.tool_calls)) {
+            for (const toolCall of delta.tool_calls) {
+              const idx = (_e = toolCall.index) != null ? _e : 0;
+              while (toolCalls.length <= idx) {
+                toolCalls.push({ name: "", argumentsJson: "" });
+              }
+              if (toolCall.id) toolCalls[idx].id = toolCall.id;
+              if ((_f = toolCall.function) == null ? void 0 : _f.name)
+                toolCalls[idx].name += toolCall.function.name;
+              if ((_g = toolCall.function) == null ? void 0 : _g.arguments)
+                toolCalls[idx].argumentsJson += toolCall.function.arguments;
+              useful = true;
+            }
+          }
+          if (choice.finish_reason) {
+            finishReason = choice.finish_reason;
+            useful = true;
+          }
+        }
+        if (useful) armStallTimer();
+      }
+    }
+    if (sawDone) reader.cancel().catch(() => {
+    });
+    if (!sawDone && !finishReason) {
+      logger_default.error(
+        id,
+        `OpenRouter stream ended prematurely after ${dataChunks} data chunks`
+      );
+      throw new Error("OpenRouter stream error: ended prematurely");
+    }
+    return finalizeOpenRouterMessage(id, {
+      content: paragraph || null,
+      toolCalls,
+      reasoning,
+      reasoningDetails: reasoningDetails.length ? reasoningDetails : void 0,
+      provider,
+      usage,
+      forLog: () => JSON.stringify({
+        finishReason,
+        provider,
+        usage,
+        paragraph: paragraph.slice(0, 500),
+        reasoningChars: reasoning.length,
+        toolCalls
+      })
+    });
+  } catch (error2) {
+    if (abortReason && !(signal == null ? void 0 : signal.aborted)) {
+      logger_default.error(id, abortReason);
+      throw new Error(abortReason);
+    }
+    throw error2;
+  } finally {
+    clearTimeout(totalTimer);
+    clearTimeout(stallTimer);
+  }
+}
+function parseOpenRouterBody(id, data) {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  if (data.error) {
+    logger_default.error(id, "OpenRouter error:", data.error);
+    throw new Error(`OpenRouter error: ${data.error.message}`);
+  }
+  const answer = (_b = (_a = data.choices) == null ? void 0 : _a[0]) == null ? void 0 : _b.message;
+  if (!answer) {
+    logger_default.error(id, "Missing answer in OpenRouter API response:", data);
+    throw new Error("Missing answer in OpenRouter API");
+  }
+  return finalizeOpenRouterMessage(id, {
+    content: (_c = answer.content) != null ? _c : null,
+    toolCalls: ((_d = answer.tool_calls) != null ? _d : []).map((tc) => ({
+      id: tc.id,
+      name: tc.function.name,
+      argumentsJson: tc.function.arguments
+    })),
+    reasoning: (_e = answer.reasoning) != null ? _e : void 0,
+    reasoningDetails: (_f = answer.reasoning_details) != null ? _f : void 0,
+    provider: (_g = data.provider) != null ? _g : void 0,
+    usage: (_h = data.usage) != null ? _h : null,
+    forLog: () => JSON.stringify(data)
+  });
+}
+async function callOpenRouterNonStreaming(id, payload, requestTimeoutMs = OPENROUTER_NONSTREAM_TIMEOUT_MS, signal) {
+  const response = await withRequestDeadline(
+    "OpenRouter",
+    requestTimeoutMs,
+    signal,
+    (mergedSignal) => import_axios.default.post(openRouterEndpoint(), payload, {
+      headers: {
+        "content-type": "application/json",
+        Authorization: `Bearer ${process.env.OPENROUTER_API_KEY}`
+      },
+      timeout: requestTimeoutMs,
+      signal: mergedSignal
+    })
+  );
+  return parseOpenRouterBody(id, response.data);
+}
+async function callOpenRouterWithRetries(id, payload, retries = 5, options, signal) {
   return withRetries(
     id,
     "OpenRouter",
-    () => callOpenRouter(id, payload, requestTimeoutMs, signal),
+    () => options.streaming ? callOpenRouterStream(
+      id,
+      payload,
+      options.streamTimeoutMs,
+      options.chunkTimeoutMs,
+      signal
+    ) : callOpenRouterNonStreaming(
+      id,
+      payload,
+      options.requestTimeoutMs,
+      signal
+    ),
     { retries, signal }
   );
 }
@@ -1533,7 +1752,7 @@ function parseModelString(model) {
   );
 }
 async function callWithRetries(id, aiPayload, aiConfig, retries = 5, chunkTimeoutMs = 15e3) {
-  var _a, _b, _c;
+  var _a, _b, _c, _d, _e, _f;
   try {
     const { provider, modelId } = parseModelString(aiPayload.model);
     const routingPayload = { ...aiPayload, model: modelId };
@@ -1585,15 +1804,20 @@ async function callWithRetries(id, aiPayload, aiConfig, retries = 5, chunkTimeou
           id,
           prepareOpenRouterPayload(routingPayload),
           retries,
-          requestTimeoutMs,
+          {
+            streaming: (_b = aiPayload.streaming) != null ? _b : true,
+            streamTimeoutMs: (_c = aiPayload.streamTimeoutMs) != null ? _c : OPENROUTER_STREAM_TIMEOUT_MS,
+            requestTimeoutMs: (_d = aiPayload.requestTimeoutMs) != null ? _d : OPENROUTER_NONSTREAM_TIMEOUT_MS,
+            chunkTimeoutMs
+          },
           signal
         );
         break;
     }
-    (_b = result.provider) != null ? _b : result.provider = provider;
+    (_e = result.provider) != null ? _e : result.provider = provider;
     return result;
   } catch (error2) {
-    if ((_c = aiPayload.signal) == null ? void 0 : _c.aborted) throw error2;
+    if ((_f = aiPayload.signal) == null ? void 0 : _f.aborted) throw error2;
     if (aiPayload.fallbackModel) {
       logger_default.error(
         id,
@@ -1624,6 +1848,8 @@ async function callWithRetries(id, aiPayload, aiConfig, retries = 5, chunkTimeou
   GPTModel,
   GeminiModel,
   GroqModel,
+  OPENROUTER_NONSTREAM_TIMEOUT_MS,
+  OPENROUTER_STREAM_TIMEOUT_MS,
   OpenRouterModel,
   callWithRetries,
   parseModelString