@lll9p/pi-anyrouter 0.4.0 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lll9p/pi-anyrouter",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "private": false,
   "type": "module",
   "description": "Unofficial pi provider extension for AnyRouter Claude Code and Codex Responses Lite routes",

package/src/claude-code.ts

@@ -11,17 +11,7 @@ import type {
   Tool,
   ToolResultMessage,
 } from "@earendil-works/pi-ai";
-import {
-  delay,
-  fetchWithProxy,
-  getRetryDelayMs,
-  isRetryableStatus,
-  nextSseChunk,
-  parseRetryAfterMs,
-  parseSseEvent,
-  redactHeaders,
-  writeDebugFile,
-} from "./http.js";
+import { fetchWithProxy, nextSseChunk, parseSseEvent, redactHeaders, writeDebugFile } from "./http.js";
 import {
   ANTHROPIC_BETA,
   CLAUDE_CODE_VERSION,
@@ -209,8 +199,7 @@ function applySsePayloadEvent(
   if (!payload?.type || payload.type === "ping" || payload.type === "message_stop") return;
 
   if (payload.type === "error") {
-    const errorText = payload?.error?.message || payload?.error || payload?.message || JSON.stringify(payload);
-    throw new Error(String(errorText));
+    throw new Error(String(payload?.error?.message || payload?.error || payload?.message || JSON.stringify(payload)));
   }
 
   if (payload.type === "message_start") {
@@ -327,91 +316,10 @@ function applySsePayloadEvent(
   }
 }
 
-// ── Streaming request ───────────────────────────────────────────────────────
-
-export async function tryStreamAnyRouterCc(
-  url: string,
-  body: Json,
-  apiKey: string,
-  model: Model<Api>,
-  output: AssistantMessage,
-  stream: AssistantMessageEventStream,
-  sessionId: string,
-  options?: SimpleStreamOptions,
-) {
-  const requestBody = { ...body, stream: true };
-  const bodyText = JSON.stringify(requestBody);
-  const maxRetries = Math.max(0, Number(process.env.PI_ANYROUTER_CC_MAX_RETRIES || options?.maxRetries || "10") || 0);
-  let response: Response | undefined;
-
-  for (let attempt = 0; attempt <= maxRetries; attempt++) {
-    // Real Claude Code keeps this at zero across its application-level retries.
-    const headers = getClaudeCodeHeaders(apiKey, 0, sessionId);
-    if (attempt === 0) {
-      writeDebugFile("request", model.id, undefined, {
-        url,
-        headers: redactHeaders(headers),
-        body: requestBody,
-        transport: "sse",
-      });
-    }
-
-    try {
-      response = await fetchWithProxy(url, {
-        method: "POST",
-        signal: options?.signal,
-        headers,
-        body: bodyText,
-      });
-    } catch (error) {
-      if (attempt < maxRetries && !options?.signal?.aborted) {
-        await delay(getRetryDelayMs(attempt));
-        continue;
-      }
-      throw error;
-    }
-
-    const contentType = response.headers.get("content-type") || "";
-    if (response.ok && contentType.includes("text/event-stream")) {
-      if (options?.onResponse) {
-        await options.onResponse({ status: response.status, headers: Object.fromEntries(response.headers.entries()) }, model);
-      }
-      break;
-    }
-
-    const raw = await response.text();
-    const parsed = tryParseJson(raw) || { raw };
-    const requestId = extractRequestId(parsed, response.headers);
-    writeDebugFile(response.ok ? "response" : "error", model.id, requestId, {
-      status: response.status,
-      statusText: response.statusText,
-      requestId,
-      headers: Object.fromEntries(response.headers.entries()),
-      body: parsed,
-      raw,
-      transport: "sse",
-      retryAttempt: attempt,
-      maxRetries,
-    });
-
-    if (!response.ok && attempt < maxRetries && isRetryableStatus(response.status)) {
-      // Push visible retry feedback so pi's UI shows activity instead of a frozen "working" status.
-      const retryBlockIndex = output.content.length;
-      const retryText = `⏳ ${response.status} — retrying (${attempt + 1}/${maxRetries})…`;
-      output.content.push({ type: "text", text: retryText } as any);
-      stream.push({ type: "text_start", contentIndex: retryBlockIndex, partial: output });
-      stream.push({ type: "text_delta", contentIndex: retryBlockIndex, delta: retryText, partial: output });
-      stream.push({ type: "text_end", contentIndex: retryBlockIndex, content: retryText, partial: output });
-      await delay(getRetryDelayMs(attempt, parseRetryAfterMs(response.headers.get("retry-after"))));
-      response = undefined;
-      continue;
-    }
-    if (response.ok) throw new Error(`stream response was not SSE (content-type=${contentType || "<missing>"})`);
-    throw new Error(raw || `HTTP ${response.status}`);
-  }
-
-  if (!response?.body) throw new Error("stream response body missing");
+// ── Stream consumption ──────────────────────────────────────────────────────
 
+async function consumeCcStream(response: Response, output: AssistantMessage, stream: AssistantMessageEventStream, model: Model<Api>) {
+  if (!response.body) throw new Error("stream response body missing");
   const blockIndexByEventIndex = new Map<number, number>();
   const reader = response.body.getReader();
   const decoder = new TextDecoder();
@@ -445,11 +353,57 @@ export async function tryStreamAnyRouterCc(
       applySsePayloadEvent(payload, output, stream, model, blockIndexByEventIndex);
     }
   }
+  return response;
+}
 
-  writeDebugFile("response", model.id, response.headers.get("x-oneapi-request-id") || undefined, {
-    status: response.status,
-    statusText: response.statusText,
-    headers: Object.fromEntries(response.headers.entries()),
+// ── Streaming request ───────────────────────────────────────────────────────
+
+export async function tryStreamAnyRouterCc(
+  url: string,
+  body: Json,
+  apiKey: string,
+  model: Model<Api>,
+  output: AssistantMessage,
+  stream: AssistantMessageEventStream,
+  sessionId: string,
+  options?: SimpleStreamOptions,
+) {
+  const requestBody = { ...body, stream: true };
+  const headers = getClaudeCodeHeaders(apiKey, 0, sessionId);
+  writeDebugFile("request", model.id, undefined, { url, headers: redactHeaders(headers), body: requestBody, transport: "sse" });
+
+  const response = await fetchWithProxy(url, { method: "POST", signal: options?.signal, headers, body: JSON.stringify(requestBody) });
+
+  if (!response.ok) {
+    const raw = await response.text();
+    const parsed = tryParseJson(raw) || { raw };
+    const requestId = extractRequestId(parsed, response.headers);
+    writeDebugFile("error", model.id, requestId, {
+      status: response.status,
+      statusText: response.statusText,
+      requestId,
+      headers: Object.fromEntries(response.headers.entries()),
+      body: parsed,
+      raw,
+      transport: "sse",
+    });
+    throw new Error(raw || `HTTP ${response.status}`);
+  }
+
+  const contentType = response.headers.get("content-type") || "";
+  if (!contentType.includes("text/event-stream")) {
+    throw new Error(`stream response was not SSE (content-type=${contentType || "<missing>"})`);
+  }
+
+  if (options?.onResponse) {
+    await options.onResponse({ status: response.status, headers: Object.fromEntries(response.headers.entries()) }, model);
+  }
+
+  const resp = await consumeCcStream(response, output, stream, model);
+  writeDebugFile("response", model.id, resp.headers.get("x-oneapi-request-id") || undefined, {
+    status: resp.status,
+    statusText: resp.statusText,
+    headers: Object.fromEntries(resp.headers.entries()),
     body: {
       responseId: output.responseId,
       stopReason: output.stopReason,
@@ -463,69 +417,32 @@ export async function tryStreamAnyRouterCc(
 // ── JSON request ────────────────────────────────────────────────────────────
 
 export async function postJson(url: string, body: Json, apiKey: string, modelId: string, sessionId: string, model: Model<Api>, options?: SimpleStreamOptions) {
-  const maxRetries = Math.max(0, Number(process.env.PI_ANYROUTER_CC_MAX_RETRIES || options?.maxRetries || "10") || 0);
-  const bodyText = JSON.stringify(body);
-  let lastErrorText = "";
-
-  for (let attempt = 0; attempt <= maxRetries; attempt++) {
-    const headers = getClaudeCodeHeaders(apiKey, attempt, sessionId);
-    if (attempt === 0) {
-      writeDebugFile("request", modelId, undefined, {
-        url,
-        headers: redactHeaders(headers),
-        body,
-      });
-    }
-
-    let response: Response;
-    try {
-      response = await fetchWithProxy(url, {
-        method: "POST",
-        signal: options?.signal,
-        headers,
-        body: bodyText,
-      });
-    } catch (error) {
-      if (attempt < maxRetries) {
-        await delay(getRetryDelayMs(attempt));
-        continue;
-      }
-      throw error;
-    }
+  const headers = getClaudeCodeHeaders(apiKey, 0, sessionId);
+  writeDebugFile("request", modelId, undefined, { url, headers: redactHeaders(headers), body });
+
+  const response = await fetchWithProxy(url, { method: "POST", signal: options?.signal, headers, body: JSON.stringify(body) });
+  const text = await response.text();
+  let parsed: any = {};
+  try {
+    parsed = text ? JSON.parse(text) : {};
+  } catch {
+    parsed = { raw: text };
+  }
+  const requestId = parsed?.error?.message?.match(/request id:\s*([^)]+)/i)?.[1] || response.headers.get("x-oneapi-request-id") || undefined;
 
-    const text = await response.text();
-    lastErrorText = text;
-    let parsed: any = {};
-    try {
-      parsed = text ? JSON.parse(text) : {};
-    } catch {
-      parsed = { raw: text };
-    }
-    const requestId = parsed?.error?.message?.match(/request id:\s*([^)]+)/i)?.[1] || response.headers.get("x-oneapi-request-id") || undefined;
+  writeDebugFile(response.ok ? "response" : "error", modelId, requestId, {
+    status: response.status,
+    statusText: response.statusText,
+    requestId,
+    headers: Object.fromEntries(response.headers.entries()),
+    body: parsed,
+    raw: text,
+  });
 
-    writeDebugFile(response.ok ? "response" : "error", modelId, requestId, {
-      status: response.status,
-      statusText: response.statusText,
-      requestId,
-      headers: Object.fromEntries(response.headers.entries()),
-      body: parsed,
-      raw: text,
-      retryAttempt: attempt,
-      maxRetries,
-    });
+  if (!response.ok) throw new Error(text || `HTTP ${response.status}`);
 
-    if (response.ok) {
-      if (options?.onResponse) {
-        await options.onResponse({ status: response.status, headers: Object.fromEntries(response.headers.entries()) }, model);
-      }
-      return parsed;
-    }
-    if (attempt < maxRetries && isRetryableStatus(response.status)) {
-      await delay(getRetryDelayMs(attempt, parseRetryAfterMs(response.headers.get("retry-after"))));
-      continue;
-    }
-    throw new Error(text || `HTTP ${response.status}`);
+  if (options?.onResponse) {
+    await options.onResponse({ status: response.status, headers: Object.fromEntries(response.headers.entries()) }, model);
   }
-
-  throw new Error(lastErrorText || "HTTP request failed after retries");
+  return parsed;
 }

package/src/codex.ts

@@ -11,17 +11,7 @@ import {
   type Tool,
   type ToolResultMessage,
 } from "@earendil-works/pi-ai";
-import {
-  delay,
-  fetchWithProxy,
-  getRetryDelayMs,
-  isRetryableStatus,
-  nextSseChunk,
-  parseRetryAfterMs,
-  parseSseEvent,
-  redactHeaders,
-  writeDebugFile,
-} from "./http.js";
+import { fetchWithProxy, nextSseChunk, parseSseEvent, redactHeaders, writeDebugFile } from "./http.js";
 import { CODEX_INSTALLATION_ID, CODEX_VERSION, type Json } from "./types.js";
 import { extractRequestId, mapReasoningEffort, sanitizeText, tryParseJson } from "./utils.js";
 
@@ -214,8 +204,12 @@ function applyCodexUsage(output: AssistantMessage, response: any, model: Model<A
 function applyCodexSsePayload(payload: any, output: AssistantMessage, stream: AssistantMessageEventStream, model: Model<Api>, slots: Map<number, any>) {
   const type = payload?.type;
   if (!type || type === "response.in_progress" || type === "response.metadata") return;
-  if (type === "error") throw new Error(payload.message || JSON.stringify(payload));
-  if (type === "response.failed") throw new Error(payload.response?.error?.message || "Codex response failed");
+  if (type === "error") {
+    throw new Error(payload.error?.message || payload.message || JSON.stringify(payload));
+  }
+  if (type === "response.failed") {
+    throw new Error(payload.response?.error?.message || "Codex response failed");
+  }
 
   if (type === "response.created") {
     output.responseId = payload.response?.id || output.responseId;
@@ -284,55 +278,10 @@ function applyCodexSsePayload(payload: any, output: AssistantMessage, stream: As
   }
 }
 
-// ── Streaming request ───────────────────────────────────────────────────────
-
-export async function tryStreamAnyRouterCodex(
-  url: string,
-  body: Json,
-  apiKey: string,
-  model: Model<Api>,
-  output: AssistantMessage,
-  stream: AssistantMessageEventStream,
-  sessionId: string,
-  metadata: ReturnType<typeof createCodexMetadata>,
-  options?: SimpleStreamOptions,
-) {
-  const bodyText = JSON.stringify(body);
-  const maxRetries = Math.max(0, Number(process.env.PI_ANYROUTER_CC_MAX_RETRIES || options?.maxRetries || "10") || 0);
-  let response: Response | undefined;
-
-  for (let attempt = 0; attempt <= maxRetries; attempt++) {
-    const headers = createCodexHeaders(apiKey, sessionId, metadata);
-    if (attempt === 0) writeDebugFile("request", model.id, undefined, { url, headers: redactHeaders(headers), body, transport: "codex-sse" });
-    try {
-      response = await fetchWithProxy(url, { method: "POST", signal: options?.signal, headers, body: bodyText });
-    } catch (error) {
-      if (attempt < maxRetries && !options?.signal?.aborted) {
-        await delay(getRetryDelayMs(attempt));
-        continue;
-      }
-      throw error;
-    }
-
-    if (response.ok && (response.headers.get("content-type") || "").includes("text/event-stream")) {
-      if (options?.onResponse) {
-        await options.onResponse({ status: response.status, headers: Object.fromEntries(response.headers.entries()) }, model);
-      }
-      break;
-    }
-    const raw = await response.text();
-    const parsed = tryParseJson(raw) || { raw };
-    const requestId = extractRequestId(parsed, response.headers);
-    writeDebugFile("error", model.id, requestId, { status: response.status, requestId, body: parsed, raw, transport: "codex-sse", retryAttempt: attempt });
-    if (!response.ok && attempt < maxRetries && isRetryableStatus(response.status)) {
-      await delay(getRetryDelayMs(attempt, parseRetryAfterMs(response.headers.get("retry-after"))));
-      response = undefined;
-      continue;
-    }
-    throw new Error(raw || `HTTP ${response.status}`);
-  }
+// ── Stream consumption ──────────────────────────────────────────────────────
 
-  if (!response?.body) throw new Error("Codex stream response body missing");
+async function consumeCodexStream(response: Response, output: AssistantMessage, stream: AssistantMessageEventStream, model: Model<Api>) {
+  if (!response.body) throw new Error("Codex stream response body missing");
   const slots = new Map<number, any>();
   const reader = response.body.getReader();
   const decoder = new TextDecoder();
@@ -366,8 +315,46 @@ export async function tryStreamAnyRouterCodex(
     }
   }
   if (!terminal) throw new Error("Codex stream ended before a terminal response event");
-  writeDebugFile("response", model.id, response.headers.get("x-oneapi-request-id") || undefined, {
-    status: response.status,
+  return response;
+}
+
+// ── Streaming request ───────────────────────────────────────────────────────
+
+export async function tryStreamAnyRouterCodex(
+  url: string,
+  body: Json,
+  apiKey: string,
+  model: Model<Api>,
+  output: AssistantMessage,
+  stream: AssistantMessageEventStream,
+  sessionId: string,
+  metadata: ReturnType<typeof createCodexMetadata>,
+  options?: SimpleStreamOptions,
+) {
+  const headers = createCodexHeaders(apiKey, sessionId, metadata);
+  writeDebugFile("request", model.id, undefined, { url, headers: redactHeaders(headers), body, transport: "codex-sse" });
+
+  const response = await fetchWithProxy(url, { method: "POST", signal: options?.signal, headers, body: JSON.stringify(body) });
+
+  if (!response.ok) {
+    const raw = await response.text();
+    const parsed = tryParseJson(raw) || { raw };
+    const requestId = extractRequestId(parsed, response.headers);
+    writeDebugFile("error", model.id, requestId, { status: response.status, requestId, body: parsed, raw, transport: "codex-sse" });
+    throw new Error(raw || `HTTP ${response.status}`);
+  }
+
+  if (!(response.headers.get("content-type") || "").includes("text/event-stream")) {
+    throw new Error(`stream response was not SSE (content-type=${response.headers.get("content-type") || "<missing>"})`);
+  }
+
+  if (options?.onResponse) {
+    await options.onResponse({ status: response.status, headers: Object.fromEntries(response.headers.entries()) }, model);
+  }
+
+  const resp = await consumeCodexStream(response, output, stream, model);
+  writeDebugFile("response", model.id, resp.headers.get("x-oneapi-request-id") || undefined, {
+    status: resp.status,
     responseId: output.responseId,
     stopReason: output.stopReason,
     usage: output.usage,

package/src/http.ts

@@ -60,35 +60,6 @@ export function writeDebugFile(kind: "request" | "response" | "error", modelId:
   writeFileSync(path, JSON.stringify(payload, null, 2), "utf8");
 }
 
-// ── Retry ───────────────────────────────────────────────────────────────────
-
-export function delay(ms: number) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-export function isRetryableStatus(status: number) {
-  return [408, 409, 429, 500, 502, 503, 504, 520, 522, 524].includes(status);
-}
-
-export function parseRetryAfterMs(value: string | null) {
-  if (!value) return undefined;
-  const seconds = Number(value);
-  if (Number.isFinite(seconds) && seconds >= 0) return seconds * 1000;
-  const at = Date.parse(value);
-  if (Number.isFinite(at)) {
-    const delta = at - Date.now();
-    return delta > 0 ? delta : 0;
-  }
-  return undefined;
-}
-
-export function getRetryDelayMs(attempt: number, retryAfterMs?: number) {
-  if (typeof retryAfterMs === "number") return Math.max(0, Math.min(retryAfterMs, 30_000));
-  const base = Math.min(1000 * 2 ** attempt, 15_000);
-  const jitter = Math.floor(Math.random() * 250);
-  return base + jitter;
-}
-
 // ── SSE parsing ─────────────────────────────────────────────────────────────
 
 export function parseSseEvent(chunk: string) {

package/src/index.ts

@@ -41,7 +41,7 @@ function streamAnyRouterCc(model: Model<Api>, context: Context, options?: Simple
     try {
       const source = loadSourceProvider();
       const apiKey = options?.apiKey || source.apiKey;
-      const sessionId = randomUUID();
+      const sessionId = options?.sessionId || randomUUID();
 
       const configuredModel = source.models.find((item) => item.id === model.id);
       if (isCodexModel(model.id, configuredModel?.api)) {