@lll9p/pi-anyrouter 0.3.2 → 0.4.0

package/src/codex.ts

@@ -0,0 +1,376 @@
+import {
+  type Api,
+  type AssistantMessage,
+  type AssistantMessageEventStream,
+  type Context,
+  calculateCost,
+  type ImageContent,
+  type Model,
+  type SimpleStreamOptions,
+  type TextContent,
+  type Tool,
+  type ToolResultMessage,
+} from "@earendil-works/pi-ai";
+import {
+  delay,
+  fetchWithProxy,
+  getRetryDelayMs,
+  isRetryableStatus,
+  nextSseChunk,
+  parseRetryAfterMs,
+  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";
+
+// ── URL ─────────────────────────────────────────────────────────────────────
+
+export function getCodexResponsesUrl(baseUrl: string) {
+  const normalized = baseUrl.replace(/\/+$/, "");
+  if (normalized.endsWith("/responses")) return normalized;
+  if (normalized.endsWith("/v1")) return `${normalized}/responses`;
+  return `${normalized}/v1/responses`;
+}
+
+// ── Message / tool conversion ───────────────────────────────────────────────
+
+export function convertCodexMessages(context: Context) {
+  const input: any[] = [];
+  if (context.systemPrompt) {
+    input.push({
+      type: "message",
+      role: "developer",
+      content: [{ type: "input_text", text: sanitizeText(context.systemPrompt) }],
+    });
+  }
+
+  for (const msg of context.messages) {
+    if (msg.role === "user") {
+      if (typeof msg.content === "string") {
+        if (msg.content.trim()) {
+          input.push({ type: "message", role: "user", content: [{ type: "input_text", text: sanitizeText(msg.content) }] });
+        }
+      } else {
+        const content = msg.content.map((item) =>
+          item.type === "text"
+            ? { type: "input_text", text: sanitizeText(item.text) }
+            : { type: "input_image", detail: "auto", image_url: `data:${item.mimeType};base64,${item.data}` },
+        );
+        if (content.length) input.push({ type: "message", role: "user", content });
+      }
+      continue;
+    }
+
+    if (msg.role === "assistant") {
+      for (const block of msg.content) {
+        if (block.type === "thinking" && block.thinkingSignature) {
+          const reasoning = tryParseJson(block.thinkingSignature);
+          if (reasoning) input.push(reasoning);
+        } else if (block.type === "text" && block.text.trim()) {
+          input.push({
+            type: "message",
+            role: "assistant",
+            status: "completed",
+            content: [{ type: "output_text", text: sanitizeText(block.text), annotations: [] }],
+          });
+        } else if (block.type === "toolCall") {
+          const [callId, itemId] = block.id.split("|");
+          input.push({
+            type: "function_call",
+            ...(itemId ? { id: itemId } : {}),
+            call_id: callId,
+            name: block.name,
+            arguments: JSON.stringify(block.arguments),
+          });
+        }
+      }
+      continue;
+    }
+
+    if (msg.role === "toolResult") {
+      const toolMsg = msg as ToolResultMessage;
+      const text = toolMsg.content
+        .filter((item) => item.type === "text")
+        .map((item) => (item as TextContent).text)
+        .join("\n");
+      const images = toolMsg.content.filter((item) => item.type === "image") as ImageContent[];
+      const output = images.length
+        ? [
+            ...(text ? [{ type: "input_text", text: sanitizeText(text) }] : []),
+            ...images.map((image) => ({ type: "input_image", detail: "auto", image_url: `data:${image.mimeType};base64,${image.data}` })),
+          ]
+        : sanitizeText(text || (images.length ? "(see attached image)" : "(no tool output)"));
+      input.push({ type: "function_call_output", call_id: toolMsg.toolCallId.split("|")[0], output });
+    }
+  }
+  return input;
+}
+
+function convertCodexTools(tools: Tool[]) {
+  return tools.map((tool) => ({
+    type: "function",
+    name: tool.name,
+    description: tool.description,
+    parameters: tool.parameters,
+    strict: false,
+  }));
+}
+
+// ── Headers / metadata ──────────────────────────────────────────────────────
+
+export function createCodexMetadata(sessionId: string, turnId: string) {
+  const windowId = `${sessionId}:0`;
+  const turnMetadata = JSON.stringify({
+    installation_id: CODEX_INSTALLATION_ID,
+    session_id: sessionId,
+    thread_id: sessionId,
+    turn_id: turnId,
+    window_id: windowId,
+    request_kind: "turn",
+    thread_source: "user",
+    turn_started_at_unix_ms: Date.now(),
+  });
+  return {
+    windowId,
+    turnMetadata,
+    clientMetadata: {
+      session_id: sessionId,
+      thread_id: sessionId,
+      turn_id: turnId,
+      "x-codex-installation-id": CODEX_INSTALLATION_ID,
+      "x-codex-window-id": windowId,
+      "x-codex-turn-metadata": turnMetadata,
+    },
+  };
+}
+
+function createCodexHeaders(apiKey: string, sessionId: string, metadata: ReturnType<typeof createCodexMetadata>) {
+  return {
+    authorization: `Bearer ${apiKey}`,
+    accept: "text/event-stream",
+    "content-type": "application/json",
+    originator: "codex_exec",
+    "user-agent": `codex_exec/${CODEX_VERSION} (Linux; x86_64) (codex_exec; ${CODEX_VERSION})`,
+    "x-openai-internal-codex-responses-lite": "true",
+    "x-codex-beta-features": "remote_compaction_v2",
+    "x-codex-window-id": metadata.windowId,
+    "x-codex-turn-metadata": metadata.turnMetadata,
+    "x-client-request-id": sessionId,
+    "session-id": sessionId,
+    "thread-id": sessionId,
+  };
+}
+
+// ── Request body builder ────────────────────────────────────────────────────
+
+export function buildCodexRequestBody(
+  model: Model<Api>,
+  context: Context,
+  options: SimpleStreamOptions | undefined,
+  sessionId: string,
+  metadata: ReturnType<typeof createCodexMetadata>,
+) {
+  const body: Json = {
+    model: model.id,
+    input: convertCodexMessages(context),
+    tool_choice: "auto",
+    parallel_tool_calls: false,
+    reasoning: {
+      effort: mapReasoningEffort(options?.reasoning),
+      context: "all_turns",
+    },
+    store: false,
+    stream: true,
+    text: { verbosity: "low" },
+    max_output_tokens: options?.maxTokens || model.maxTokens,
+    include: ["reasoning.encrypted_content"],
+    prompt_cache_key: sessionId,
+    client_metadata: metadata.clientMetadata,
+  };
+  if (context.tools?.length) body.tools = convertCodexTools(context.tools);
+  return body;
+}
+
+// ── Usage ───────────────────────────────────────────────────────────────────
+
+function applyCodexUsage(output: AssistantMessage, response: any, model: Model<Api>) {
+  const usage = response?.usage;
+  if (!usage) return;
+  const cached = usage.input_tokens_details?.cached_tokens || 0;
+  const cacheWrite = usage.input_tokens_details?.cache_write_tokens || 0;
+  output.usage.input = Math.max(0, (usage.input_tokens || 0) - cached - cacheWrite);
+  output.usage.output = usage.output_tokens || 0;
+  output.usage.cacheRead = cached;
+  output.usage.cacheWrite = cacheWrite;
+  if (usage.output_tokens_details?.reasoning_tokens != null) output.usage.reasoning = usage.output_tokens_details.reasoning_tokens;
+  output.usage.totalTokens = usage.total_tokens || output.usage.input + output.usage.output + cached + cacheWrite;
+  calculateCost(model, output.usage);
+}
+
+// ── SSE payload processing ──────────────────────────────────────────────────
+
+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 === "response.created") {
+    output.responseId = payload.response?.id || output.responseId;
+    return;
+  }
+
+  if (type === "response.output_item.added") {
+    const item = payload.item;
+    if (item?.type === "message") {
+      const block = { type: "text", text: "" };
+      output.content.push(block as any);
+      const contentIndex = output.content.length - 1;
+      slots.set(payload.output_index, { type: "text", block, contentIndex });
+      stream.push({ type: "text_start", contentIndex, partial: output });
+    } else if (item?.type === "reasoning") {
+      const block = { type: "thinking", thinking: "", thinkingSignature: "" };
+      output.content.push(block as any);
+      const contentIndex = output.content.length - 1;
+      slots.set(payload.output_index, { type: "thinking", block, contentIndex });
+      stream.push({ type: "thinking_start", contentIndex, partial: output });
+    } else if (item?.type === "function_call") {
+      const block = { type: "toolCall", id: `${item.call_id}|${item.id}`, name: item.name, arguments: {}, partialJson: item.arguments || "" };
+      output.content.push(block as any);
+      const contentIndex = output.content.length - 1;
+      slots.set(payload.output_index, { type: "toolCall", block, contentIndex });
+      stream.push({ type: "toolcall_start", contentIndex, partial: output });
+    }
+    return;
+  }
+
+  const slot = slots.get(payload.output_index);
+  if (type === "response.output_text.delta" && slot?.type === "text") {
+    slot.block.text += String(payload.delta || "");
+    stream.push({ type: "text_delta", contentIndex: slot.contentIndex, delta: String(payload.delta || ""), partial: output });
+  } else if ((type === "response.reasoning_summary_text.delta" || type === "response.reasoning_text.delta") && slot?.type === "thinking") {
+    slot.block.thinking += String(payload.delta || "");
+    stream.push({ type: "thinking_delta", contentIndex: slot.contentIndex, delta: String(payload.delta || ""), partial: output });
+  } else if (type === "response.function_call_arguments.delta" && slot?.type === "toolCall") {
+    slot.block.partialJson += String(payload.delta || "");
+    const parsed = tryParseJson(slot.block.partialJson);
+    if (parsed !== undefined) slot.block.arguments = parsed;
+    stream.push({ type: "toolcall_delta", contentIndex: slot.contentIndex, delta: String(payload.delta || ""), partial: output });
+  } else if (type === "response.function_call_arguments.done" && slot?.type === "toolCall") {
+    slot.block.partialJson = String(payload.arguments || slot.block.partialJson);
+    slot.block.arguments = tryParseJson(slot.block.partialJson) || {};
+  } else if (type === "response.output_item.done") {
+    const item = payload.item;
+    if (slot?.type === "text" && item?.type === "message") {
+      slot.block.text = item.content?.map((part: any) => part.text || part.refusal || "").join("") || slot.block.text;
+      stream.push({ type: "text_end", contentIndex: slot.contentIndex, content: slot.block.text, partial: output });
+    } else if (slot?.type === "thinking" && item?.type === "reasoning") {
+      slot.block.thinking =
+        item.summary?.map((part: any) => part.text).join("\n\n") || item.content?.map((part: any) => part.text).join("\n\n") || slot.block.thinking;
+      slot.block.thinkingSignature = JSON.stringify(item);
+      stream.push({ type: "thinking_end", contentIndex: slot.contentIndex, content: slot.block.thinking, partial: output });
+    } else if (slot?.type === "toolCall" && item?.type === "function_call") {
+      slot.block.arguments = tryParseJson(item.arguments || slot.block.partialJson) || {};
+      delete slot.block.partialJson;
+      stream.push({ type: "toolcall_end", contentIndex: slot.contentIndex, toolCall: slot.block, partial: output });
+    }
+    slots.delete(payload.output_index);
+  } else if (type === "response.completed" || type === "response.incomplete") {
+    output.responseId = payload.response?.id || output.responseId;
+    applyCodexUsage(output, payload.response, model);
+    output.stopReason = type === "response.incomplete" ? "length" : output.content.some((block) => block.type === "toolCall") ? "toolUse" : "stop";
+  }
+}
+
+// ── 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}`);
+  }
+
+  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");
+  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",
+  });
+}

package/src/config.ts

@@ -0,0 +1,36 @@
+import { readFileSync } from "node:fs";
+import { CONFIG_PATH, type ProviderConfigFile } from "./types.js";
+
+export function resolveConfigValue(value?: string) {
+  if (!value) return "";
+  if (value.startsWith("!")) {
+    throw new Error("anyrouter does not support shell-command apiKey values. Use a literal key, env var name, or PI_ANYROUTER_CC_API_KEY.");
+  }
+  return process.env[value] || value;
+}
+
+export function loadSourceProvider() {
+  let content = "";
+  try {
+    content = readFileSync(CONFIG_PATH, "utf8");
+  } catch {
+    throw new Error(`Config file not found: ${CONFIG_PATH}. Create ~/.pi/agent/anyrouter.json or set PI_ANYROUTER_CC_CONFIG.`);
+  }
+
+  let parsed: ProviderConfigFile;
+  try {
+    parsed = JSON.parse(content) as ProviderConfigFile;
+  } catch (error) {
+    throw new Error(`Invalid JSON in ${CONFIG_PATH}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+
+  const baseUrl = process.env.PI_ANYROUTER_CC_BASE_URL || parsed.baseUrl;
+  const apiKey = process.env.PI_ANYROUTER_CC_API_KEY || resolveConfigValue(parsed.apiKey);
+  const models = parsed.models || [];
+
+  if (!baseUrl) throw new Error(`Missing baseUrl in ${CONFIG_PATH}. You can also set PI_ANYROUTER_CC_BASE_URL.`);
+  if (!apiKey) throw new Error(`Missing apiKey in ${CONFIG_PATH}. You can also set PI_ANYROUTER_CC_API_KEY.`);
+  if (!models.length) throw new Error(`No models configured in ${CONFIG_PATH}. Add at least one model entry.`);
+
+  return { baseUrl, apiKey, models };
+}

package/src/http.ts

@@ -0,0 +1,113 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { ProxyAgent, fetch as undiciFetch } from "undici";
+import { DEBUG_DIR, DEBUG_ENABLED, type FetchInit, type Json } from "./types.js";
+
+// ── Headers ─────────────────────────────────────────────────────────────────
+
+export function redactHeaders(headers: Record<string, string>) {
+  const redacted = { ...headers };
+  if (redacted.authorization) redacted.authorization = "Bearer ***";
+  if (redacted["x-api-key"]) redacted["x-api-key"] = "***";
+  return redacted;
+}
+
+// ── Proxy ───────────────────────────────────────────────────────────────────
+
+const PROXY_AGENTS = new Map<string, ProxyAgent>();
+
+function hostMatchesNoProxy(hostname: string, pattern: string) {
+  const item = pattern.trim().toLowerCase();
+  if (!item) return false;
+  if (item === "*") return true;
+  const host = hostname.toLowerCase();
+  if (item.startsWith(".")) return host === item.slice(1) || host.endsWith(item);
+  return host === item || host.endsWith(`.${item}`);
+}
+
+function getProxyUrl(url: string) {
+  const parsed = new URL(url);
+  const noProxy = process.env.NO_PROXY || process.env.no_proxy || "";
+  if (noProxy.split(",").some((item) => hostMatchesNoProxy(parsed.hostname, item))) return undefined;
+  if (parsed.protocol === "https:") return process.env.HTTPS_PROXY || process.env.https_proxy || process.env.HTTP_PROXY || process.env.http_proxy;
+  return process.env.HTTP_PROXY || process.env.http_proxy;
+}
+
+function getProxyAgent(proxyUrl: string) {
+  let agent = PROXY_AGENTS.get(proxyUrl);
+  if (!agent) {
+    agent = new ProxyAgent(proxyUrl);
+    PROXY_AGENTS.set(proxyUrl, agent);
+  }
+  return agent;
+}
+
+export function fetchWithProxy(url: string, init: FetchInit) {
+  const proxyUrl = getProxyUrl(url);
+  if (!proxyUrl) return fetch(url, init);
+  return undiciFetch(url, { ...init, dispatcher: getProxyAgent(proxyUrl) } as any) as unknown as Promise<Response>;
+}
+
+// ── Debug ───────────────────────────────────────────────────────────────────
+
+export function writeDebugFile(kind: "request" | "response" | "error", modelId: string, requestId: string | undefined, payload: Json) {
+  if (!DEBUG_ENABLED) return;
+  mkdirSync(DEBUG_DIR, { recursive: true });
+  const safeModel = modelId.replace(/[^a-zA-Z0-9._-]+/g, "_");
+  const safeRequestId = (requestId || "no-request-id").replace(/[^a-zA-Z0-9._-]+/g, "_");
+  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const path = join(DEBUG_DIR, `${timestamp}-${safeModel}-${safeRequestId}-${kind}.json`);
+  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) {
+  let event = "message";
+  const data: string[] = [];
+  for (const line of chunk.split(/\r?\n/)) {
+    if (!line || line.startsWith(":")) continue;
+    if (line.startsWith("event:")) event = line.slice(6).trim();
+    else if (line.startsWith("data:")) data.push(line.slice(5).trimStart());
+  }
+  return { event, data: data.join("\n") };
+}
+
+export function nextSseChunk(buffer: string) {
+  const unix = buffer.indexOf("\n\n");
+  const dos = buffer.indexOf("\r\n\r\n");
+  if (unix === -1 && dos === -1) return undefined;
+  if (dos !== -1 && (unix === -1 || dos < unix)) {
+    return { chunk: buffer.slice(0, dos), rest: buffer.slice(dos + 4) };
+  }
+  return { chunk: buffer.slice(0, unix), rest: buffer.slice(unix + 2) };
+}