@lll9p/pi-anyrouter 0.4.1 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lll9p/pi-anyrouter",
-  "version": "0.4.1",
+  "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,19 +11,7 @@ import type {
   Tool,
   ToolResultMessage,
 } from "@earendil-works/pi-ai";
-import {
-  delay,
-  fetchWithProxy,
-  getRetryDelayMs,
-  isRetryableErrorType,
-  isRetryableStatus,
-  nextSseChunk,
-  parseRetryAfterMs,
-  parseSseEvent,
-  RetryableStreamError,
-  redactHeaders,
-  writeDebugFile,
-} from "./http.js";
+import { fetchWithProxy, nextSseChunk, parseSseEvent, redactHeaders, writeDebugFile } from "./http.js";
 import {
   ANTHROPIC_BETA,
   CLAUDE_CODE_VERSION,
@@ -211,11 +199,7 @@ function applySsePayloadEvent(
   if (!payload?.type || payload.type === "ping" || payload.type === "message_stop") return;
 
   if (payload.type === "error") {
-    const errorType = payload?.error?.type || payload?.error?.code;
-    const errorText = payload?.error?.message || payload?.error || payload?.message || JSON.stringify(payload);
-    const message = String(errorText);
-    if (isRetryableErrorType(errorType)) throw new RetryableStreamError(message);
-    throw new Error(message);
+    throw new Error(String(payload?.error?.message || payload?.error || payload?.message || JSON.stringify(payload)));
   }
 
   if (payload.type === "message_start") {
@@ -385,176 +369,80 @@ export async function tryStreamAnyRouterCc(
   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);
-
-  for (let attempt = 0; attempt <= maxRetries; attempt++) {
-    const headers = getClaudeCodeHeaders(apiKey, 0, sessionId);
-    if (attempt === 0) {
-      writeDebugFile("request", model.id, undefined, {
-        url,
-        headers: redactHeaders(headers),
-        body: requestBody,
-        transport: "sse",
-      });
-    }
+  const headers = getClaudeCodeHeaders(apiKey, 0, sessionId);
+  writeDebugFile("request", model.id, undefined, { url, headers: redactHeaders(headers), body: requestBody, transport: "sse" });
 
-    let response: Response;
-    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 response = await fetchWithProxy(url, { method: "POST", signal: options?.signal, headers, body: JSON.stringify(requestBody) });
 
-    // HTTP-level error → retry if retryable status
-    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",
-        retryAttempt: attempt,
-        maxRetries,
-      });
-      if (attempt < maxRetries && isRetryableStatus(response.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"))));
-        continue;
-      }
-      throw new Error(raw || `HTTP ${response.status}`);
-    }
-
-    const contentType = response.headers.get("content-type") || "";
-    if (!contentType.includes("text/event-stream")) {
-      if (response.ok) throw new Error(`stream response was not SSE (content-type=${contentType || "<missing>"})`);
-    }
+  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}`);
+  }
 
-    if (options?.onResponse) {
-      await options.onResponse({ status: response.status, headers: Object.fromEntries(response.headers.entries()) }, model);
-    }
+  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>"})`);
+  }
 
-    // Consume the SSE stream — retry on RetryableStreamError if no content was emitted
-    const contentLenBefore = output.content.length;
-    try {
-      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,
-          usage: output.usage,
-          contentBlocks: output.content.length,
-        },
-        transport: "sse",
-      });
-      return;
-    } catch (error) {
-      if (error instanceof RetryableStreamError && output.content.length === contentLenBefore && attempt < maxRetries && !options?.signal?.aborted) {
-        writeDebugFile("error", model.id, undefined, { phase: "sse-stream-retry", errorMessage: error.message, retryAttempt: attempt, transport: "sse" });
-        const retryBlockIndex = output.content.length;
-        const retryText = `⏳ SSE error — 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, error.retryAfterMs));
-        continue;
-      }
-      throw error;
-    }
+  if (options?.onResponse) {
+    await options.onResponse({ status: response.status, headers: Object.fromEntries(response.headers.entries()) }, model);
   }
 
-  throw new Error("CC request failed after retries");
+  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,
+      usage: output.usage,
+      contentBlocks: output.content.length,
+    },
+    transport: "sse",
+  });
 }
 
 // ── 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 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;
+  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;
+
+  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,19 +11,7 @@ import {
   type Tool,
   type ToolResultMessage,
 } from "@earendil-works/pi-ai";
-import {
-  delay,
-  fetchWithProxy,
-  getRetryDelayMs,
-  isRetryableErrorType,
-  isRetryableStatus,
-  nextSseChunk,
-  parseRetryAfterMs,
-  parseSseEvent,
-  RetryableStreamError,
-  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";
 
@@ -217,17 +205,10 @@ function applyCodexSsePayload(payload: any, output: AssistantMessage, stream: As
   const type = payload?.type;
   if (!type || type === "response.in_progress" || type === "response.metadata") return;
   if (type === "error") {
-    const errorType = payload.error?.type || payload.error?.code;
-    const message = payload.error?.message || payload.message || JSON.stringify(payload);
-    if (isRetryableErrorType(errorType)) throw new RetryableStreamError(message);
-    throw new Error(message);
+    throw new Error(payload.error?.message || payload.message || JSON.stringify(payload));
   }
   if (type === "response.failed") {
-    const err = payload.response?.error;
-    const message = err?.message || "Codex response failed";
-    const errorType = err?.type || err?.code;
-    if (isRetryableErrorType(errorType)) throw new RetryableStreamError(message);
-    throw new Error(message);
+    throw new Error(payload.response?.error?.message || "Codex response failed");
   }
 
   if (type === "response.created") {
@@ -350,66 +331,33 @@ export async function tryStreamAnyRouterCodex(
   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);
-
-  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" });
+  const headers = createCodexHeaders(apiKey, sessionId, metadata);
+  writeDebugFile("request", model.id, undefined, { url, headers: redactHeaders(headers), body, transport: "codex-sse" });
 
-    let response: Response;
-    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;
-    }
-
-    // HTTP-level error → retry if retryable status
-    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", retryAttempt: attempt });
-      if (attempt < maxRetries && isRetryableStatus(response.status)) {
-        await delay(getRetryDelayMs(attempt, parseRetryAfterMs(response.headers.get("retry-after"))));
-        continue;
-      }
-      throw new Error(raw || `HTTP ${response.status}`);
-    }
+  const response = await fetchWithProxy(url, { method: "POST", signal: options?.signal, headers, body: JSON.stringify(body) });
 
-    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 (!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 (options?.onResponse) {
-      await options.onResponse({ status: response.status, headers: Object.fromEntries(response.headers.entries()) }, model);
-    }
+  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>"})`);
+  }
 
-    // Consume the SSE stream — retry on RetryableStreamError if no content was emitted
-    const contentLenBefore = output.content.length;
-    try {
-      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,
-        transport: "codex-sse",
-      });
-      return;
-    } catch (error) {
-      if (error instanceof RetryableStreamError && output.content.length === contentLenBefore && attempt < maxRetries && !options?.signal?.aborted) {
-        writeDebugFile("error", model.id, undefined, { phase: "sse-stream-retry", errorMessage: error.message, retryAttempt: attempt, transport: "codex-sse" });
-        await delay(getRetryDelayMs(attempt, error.retryAfterMs));
-        continue;
-      }
-      throw error;
-    }
+  if (options?.onResponse) {
+    await options.onResponse({ status: response.status, headers: Object.fromEntries(response.headers.entries()) }, model);
   }
 
-  throw new Error("Codex request failed after retries");
+  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,
+    transport: "codex-sse",
+  });
 }

package/src/http.ts

@@ -60,52 +60,6 @@ export function writeDebugFile(kind: "request" | "response" | "error", modelId:
   writeFileSync(path, JSON.stringify(payload, null, 2), "utf8");
 }
 
-// ── Retry ───────────────────────────────────────────────────────────────────
-
-/** Thrown when an SSE stream delivers a retryable error (e.g. rate_limit) before any content was emitted. */
-export class RetryableStreamError extends Error {
-  constructor(
-    message: string,
-    public readonly retryAfterMs?: number,
-  ) {
-    super(message);
-    this.name = "RetryableStreamError";
-  }
-}
-
-const RETRYABLE_ERROR_TYPES = new Set(["too_many_requests", "rate_limit_exceeded", "server_error", "overloaded_error", "api_error"]);
-
-export function isRetryableErrorType(errorType: string | undefined): boolean {
-  return !!errorType && RETRYABLE_ERROR_TYPES.has(errorType);
-}
-
-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)) {