@lll9p/pi-anyrouter 0.4.0 → 0.4.1

package/package.json

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

package/src/claude-code.ts

@@ -15,10 +15,12 @@ import {
   delay,
   fetchWithProxy,
   getRetryDelayMs,
+  isRetryableErrorType,
   isRetryableStatus,
   nextSseChunk,
   parseRetryAfterMs,
   parseSseEvent,
+  RetryableStreamError,
   redactHeaders,
   writeDebugFile,
 } from "./http.js";
@@ -209,8 +211,11 @@ 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);
-    throw new Error(String(errorText));
+    const message = String(errorText);
+    if (isRetryableErrorType(errorType)) throw new RetryableStreamError(message);
+    throw new Error(message);
   }
 
   if (payload.type === "message_start") {
@@ -327,6 +332,46 @@ function applySsePayloadEvent(
   }
 }
 
+// ── 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();
+  let buffer = "";
+
+  while (true) {
+    const { value, done } = await reader.read();
+    buffer += decoder.decode(value || new Uint8Array(), { stream: !done });
+
+    let parsedChunk = nextSseChunk(buffer);
+    while (parsedChunk) {
+      buffer = parsedChunk.rest;
+      const event = parseSseEvent(parsedChunk.chunk);
+      if (event.data) {
+        const payload = tryParseJson(event.data);
+        if (!payload && event.data !== "[DONE]") throw new Error(`invalid SSE payload: ${event.data.slice(0, 200)}`);
+        if (payload) applySsePayloadEvent(payload, output, stream, model, blockIndexByEventIndex);
+      }
+      parsedChunk = nextSseChunk(buffer);
+    }
+
+    if (done) break;
+  }
+
+  const tail = buffer.trim();
+  if (tail) {
+    const event = parseSseEvent(tail);
+    if (event.data && event.data !== "[DONE]") {
+      const payload = tryParseJson(event.data);
+      if (!payload) throw new Error(`invalid SSE payload: ${event.data.slice(0, 200)}`);
+      applySsePayloadEvent(payload, output, stream, model, blockIndexByEventIndex);
+    }
+  }
+  return response;
+}
+
 // ── Streaming request ───────────────────────────────────────────────────────
 
 export async function tryStreamAnyRouterCc(
@@ -342,10 +387,8 @@ export async function tryStreamAnyRouterCc(
   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, {
@@ -356,6 +399,7 @@ export async function tryStreamAnyRouterCc(
       });
     }
 
+    let response: Response;
     try {
       response = await fetchWithProxy(url, {
         method: "POST",
@@ -371,93 +415,78 @@ export async function tryStreamAnyRouterCc(
       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);
+    // 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;
       }
-      break;
+      throw new Error(raw || `HTTP ${response.status}`);
     }
 
-    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;
+    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) 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");
-
-  const blockIndexByEventIndex = new Map<number, number>();
-  const reader = response.body.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-
-  while (true) {
-    const { value, done } = await reader.read();
-    buffer += decoder.decode(value || new Uint8Array(), { stream: !done });
 
-    let parsedChunk = nextSseChunk(buffer);
-    while (parsedChunk) {
-      buffer = parsedChunk.rest;
-      const event = parseSseEvent(parsedChunk.chunk);
-      if (event.data) {
-        const payload = tryParseJson(event.data);
-        if (!payload && event.data !== "[DONE]") throw new Error(`invalid SSE payload: ${event.data.slice(0, 200)}`);
-        if (payload) applySsePayloadEvent(payload, output, stream, model, blockIndexByEventIndex);
-      }
-      parsedChunk = nextSseChunk(buffer);
+    if (options?.onResponse) {
+      await options.onResponse({ status: response.status, headers: Object.fromEntries(response.headers.entries()) }, model);
     }
 
-    if (done) break;
-  }
-
-  const tail = buffer.trim();
-  if (tail) {
-    const event = parseSseEvent(tail);
-    if (event.data && event.data !== "[DONE]") {
-      const payload = tryParseJson(event.data);
-      if (!payload) throw new Error(`invalid SSE payload: ${event.data.slice(0, 200)}`);
-      applySsePayloadEvent(payload, output, stream, model, blockIndexByEventIndex);
+    // 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;
     }
   }
 
-  writeDebugFile("response", model.id, response.headers.get("x-oneapi-request-id") || undefined, {
-    status: response.status,
-    statusText: response.statusText,
-    headers: Object.fromEntries(response.headers.entries()),
-    body: {
-      responseId: output.responseId,
-      stopReason: output.stopReason,
-      usage: output.usage,
-      contentBlocks: output.content.length,
-    },
-    transport: "sse",
-  });
+  throw new Error("CC request failed after retries");
 }
 
 // ── JSON request ────────────────────────────────────────────────────────────

package/src/codex.ts

@@ -15,10 +15,12 @@ import {
   delay,
   fetchWithProxy,
   getRetryDelayMs,
+  isRetryableErrorType,
   isRetryableStatus,
   nextSseChunk,
   parseRetryAfterMs,
   parseSseEvent,
+  RetryableStreamError,
   redactHeaders,
   writeDebugFile,
 } from "./http.js";
@@ -214,8 +216,19 @@ 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") {
+    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);
+  }
+  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);
+  }
 
   if (type === "response.created") {
     output.responseId = payload.response?.id || output.responseId;
@@ -284,6 +297,46 @@ function applyCodexSsePayload(payload: any, output: AssistantMessage, stream: As
   }
 }
 
+// ── Stream consumption ──────────────────────────────────────────────────────
+
+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();
+  let buffer = "";
+  let terminal = false;
+  while (true) {
+    const { value, done } = await reader.read();
+    buffer += decoder.decode(value || new Uint8Array(), { stream: !done });
+    let parsedChunk = nextSseChunk(buffer);
+    while (parsedChunk) {
+      buffer = parsedChunk.rest;
+      const event = parseSseEvent(parsedChunk.chunk);
+      if (event.data && event.data !== "[DONE]") {
+        const payload = tryParseJson(event.data);
+        if (!payload) throw new Error(`invalid Codex SSE payload: ${event.data.slice(0, 200)}`);
+        applyCodexSsePayload(payload, output, stream, model, slots);
+        if (payload.type === "response.completed" || payload.type === "response.incomplete") terminal = true;
+      }
+      parsedChunk = nextSseChunk(buffer);
+    }
+    if (done) break;
+  }
+  const tail = buffer.trim();
+  if (tail) {
+    const event = parseSseEvent(tail);
+    if (event.data && event.data !== "[DONE]") {
+      const payload = tryParseJson(event.data);
+      if (!payload) throw new Error(`invalid Codex SSE payload: ${event.data.slice(0, 200)}`);
+      applyCodexSsePayload(payload, output, stream, model, slots);
+      if (payload.type === "response.completed" || payload.type === "response.incomplete") terminal = true;
+    }
+  }
+  if (!terminal) throw new Error("Codex stream ended before a terminal response event");
+  return response;
+}
+
 // ── Streaming request ───────────────────────────────────────────────────────
 
 export async function tryStreamAnyRouterCodex(
@@ -299,11 +352,12 @@ export async function tryStreamAnyRouterCodex(
 ) {
   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" });
+
+    let response: Response;
     try {
       response = await fetchWithProxy(url, { method: "POST", signal: options?.signal, headers, body: bodyText });
     } catch (error) {
@@ -314,63 +368,48 @@ export async function tryStreamAnyRouterCodex(
       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);
+    // 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;
       }
-      break;
+      throw new Error(raw || `HTTP ${response.status}`);
     }
-    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;
+
+    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>"})`);
     }
-    throw new Error(raw || `HTTP ${response.status}`);
-  }
 
-  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();
-  let buffer = "";
-  let terminal = false;
-  while (true) {
-    const { value, done } = await reader.read();
-    buffer += decoder.decode(value || new Uint8Array(), { stream: !done });
-    let parsedChunk = nextSseChunk(buffer);
-    while (parsedChunk) {
-      buffer = parsedChunk.rest;
-      const event = parseSseEvent(parsedChunk.chunk);
-      if (event.data && event.data !== "[DONE]") {
-        const payload = tryParseJson(event.data);
-        if (!payload) throw new Error(`invalid Codex SSE payload: ${event.data.slice(0, 200)}`);
-        applyCodexSsePayload(payload, output, stream, model, slots);
-        if (payload.type === "response.completed" || payload.type === "response.incomplete") terminal = true;
-      }
-      parsedChunk = nextSseChunk(buffer);
+    if (options?.onResponse) {
+      await options.onResponse({ status: response.status, headers: Object.fromEntries(response.headers.entries()) }, model);
     }
-    if (done) break;
-  }
-  const tail = buffer.trim();
-  if (tail) {
-    const event = parseSseEvent(tail);
-    if (event.data && event.data !== "[DONE]") {
-      const payload = tryParseJson(event.data);
-      if (!payload) throw new Error(`invalid Codex SSE payload: ${event.data.slice(0, 200)}`);
-      applyCodexSsePayload(payload, output, stream, model, slots);
-      if (payload.type === "response.completed" || payload.type === "response.incomplete") terminal = true;
+
+    // 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 (!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,
-    responseId: output.responseId,
-    stopReason: output.stopReason,
-    usage: output.usage,
-    transport: "codex-sse",
-  });
+
+  throw new Error("Codex request failed after retries");
 }

package/src/http.ts

@@ -62,6 +62,23 @@ export function writeDebugFile(kind: "request" | "response" | "error", modelId:
 
 // ── 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));
 }