@lll9p/pi-anyrouter 0.3.3 → 0.4.0

package/src/index.ts

@@ -0,0 +1,166 @@
+import { randomUUID } from "node:crypto";
+import {
+  type Api,
+  type AssistantMessage,
+  type AssistantMessageEventStream,
+  type Context,
+  createAssistantMessageEventStream,
+  type Model,
+  type SimpleStreamOptions,
+} from "@earendil-works/pi-ai";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import {
+  applyJsonResponseToOutput,
+  convertMessages,
+  convertTools,
+  createClaudeCodeMetadata,
+  createClaudeCodeSystem,
+  postJson,
+  tryStreamAnyRouterCc,
+} from "./claude-code.js";
+import { buildCodexRequestBody, createCodexMetadata, getCodexResponsesUrl, tryStreamAnyRouterCodex } from "./codex.js";
+import { loadSourceProvider } from "./config.js";
+import { writeDebugFile } from "./http.js";
+import { API_ID, CONFIG_PATH, type Json, PROVIDER_NAME } from "./types.js";
+import { createEmptyUsage, getStreamMode, isCodexModel, mapReasoningEffort, resetOutputState } from "./utils.js";
+
+function streamAnyRouterCc(model: Model<Api>, context: Context, options?: SimpleStreamOptions): AssistantMessageEventStream {
+  const stream = createAssistantMessageEventStream();
+  (async () => {
+    const output: AssistantMessage = {
+      role: "assistant",
+      content: [],
+      api: model.api,
+      provider: model.provider,
+      model: model.id,
+      usage: createEmptyUsage(),
+      stopReason: "pending",
+      timestamp: Date.now(),
+    };
+
+    try {
+      const source = loadSourceProvider();
+      const apiKey = options?.apiKey || source.apiKey;
+      const sessionId = randomUUID();
+
+      const configuredModel = source.models.find((item) => item.id === model.id);
+      if (isCodexModel(model.id, configuredModel?.api)) {
+        const turnId = randomUUID();
+        const metadata = createCodexMetadata(sessionId, turnId);
+        let codexBody: Json = buildCodexRequestBody(model, context, options, sessionId, metadata);
+        if (options?.onPayload) {
+          const replaced = await options.onPayload(codexBody, model);
+          if (replaced !== undefined) codexBody = replaced as Json;
+        }
+        stream.push({ type: "start", partial: output });
+        await tryStreamAnyRouterCodex(getCodexResponsesUrl(source.baseUrl), codexBody, apiKey, model, output, stream, sessionId, metadata, options);
+        if (options?.signal?.aborted) throw new Error("Request was aborted");
+        stream.push({ type: "done", reason: output.stopReason as "stop" | "length" | "toolUse" | "deferred", message: output });
+        stream.end();
+        return;
+      }
+
+      const url = `${source.baseUrl.replace(/\/$/, "")}/v1/messages?beta=true`;
+      let requestBody: Json = {
+        model: model.id,
+        messages: convertMessages(context.messages),
+        max_tokens: options?.maxTokens || model.maxTokens || 32000,
+        stream: false,
+        metadata: createClaudeCodeMetadata(sessionId),
+        system: createClaudeCodeSystem(context.systemPrompt || "You are an expert coding assistant operating inside pi."),
+        context_management: {
+          edits: [{ type: "clear_thinking_20251015", keep: "all" }],
+        },
+      };
+      if (context.tools?.length) requestBody.tools = convertTools(context.tools);
+      if (options?.reasoning && model.reasoning) {
+        requestBody.thinking = { type: "adaptive", display: "omitted" };
+        requestBody.output_config = { effort: mapReasoningEffort(options.reasoning) };
+      }
+      if (options?.onPayload) {
+        const replaced = await options.onPayload(requestBody, model);
+        if (replaced !== undefined) requestBody = replaced as Json;
+      }
+
+      stream.push({ type: "start", partial: output });
+
+      const streamMode = getStreamMode();
+      if (streamMode !== "off") {
+        try {
+          await tryStreamAnyRouterCc(url, requestBody, apiKey, model, output, stream, sessionId, options);
+          if (options?.signal?.aborted) throw new Error("Request was aborted");
+          stream.push({ type: "done", reason: output.stopReason as "stop" | "length" | "toolUse" | "deferred", message: output });
+          stream.end();
+          return;
+        } catch (streamError) {
+          if (streamMode === "force" || output.content.length > 0) {
+            const errText = `[anyrouter] ${streamError instanceof Error ? streamError.message : String(streamError)}`;
+            const contentIndex = output.content.length;
+            output.content.push({ type: "text", text: errText } as any);
+            output.stopReason = "stop";
+            output.errorMessage = errText;
+            stream.push({ type: "text_start", contentIndex, partial: output });
+            stream.push({ type: "text_delta", contentIndex, delta: errText, partial: output });
+            stream.push({ type: "text_end", contentIndex, content: errText, partial: output });
+            stream.push({ type: "done", reason: "stop", message: output });
+            stream.end();
+            return;
+          }
+          writeDebugFile("error", model.id, undefined, {
+            phase: "stream-fallback",
+            errorMessage: streamError instanceof Error ? streamError.message : String(streamError),
+          });
+          resetOutputState(output);
+        }
+      }
+
+      const response = await postJson(url, requestBody, apiKey, model.id, sessionId, model, options);
+      applyJsonResponseToOutput(response, output, stream, model);
+      stream.push({ type: "done", reason: output.stopReason as "stop" | "length" | "toolUse" | "deferred", message: output });
+      stream.end();
+    } catch (error) {
+      output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+      output.errorMessage = error instanceof Error ? `[anyrouter] ${error.message}` : String(error);
+      writeDebugFile("error", model.id, undefined, {
+        stopReason: output.stopReason,
+        errorMessage: output.errorMessage,
+      });
+      stream.push({ type: "error", reason: output.stopReason, error: output });
+      stream.end();
+    }
+  })();
+  return stream;
+}
+
+export default function (pi: ExtensionAPI) {
+  try {
+    const source = loadSourceProvider();
+    pi.registerProvider(PROVIDER_NAME, {
+      baseUrl: source.baseUrl,
+      apiKey: source.apiKey,
+      api: API_ID,
+      models: source.models.map((model) => ({
+        id: model.id,
+        name: model.name ? `${model.name} (AnyRouter)` : `${model.id} (AnyRouter)`,
+        api: API_ID,
+        reasoning: model.reasoning ?? true,
+        thinkingLevelMap:
+          (model.reasoning ?? true) ? { off: "off", minimal: "minimal", low: "low", medium: "medium", high: "high", xhigh: "xhigh", max: "max" } : undefined,
+        input: model.input ?? ["text"],
+        cost: {
+          input: model.cost?.input ?? 0,
+          output: model.cost?.output ?? 0,
+          cacheRead: model.cost?.cacheRead ?? 0,
+          cacheWrite: model.cost?.cacheWrite ?? 0,
+        },
+        contextWindow: model.contextWindow ?? 200000,
+        maxTokens: model.maxTokens ?? 32000,
+      })),
+      streamSimple: streamAnyRouterCc,
+    });
+  } catch (error) {
+    console.error(`[anyrouter] Failed to register provider: ${error instanceof Error ? error.message : String(error)}`);
+    console.error(`[anyrouter] Config path: ${CONFIG_PATH}`);
+    console.error(`[anyrouter] You can override with PI_ANYROUTER_CC_CONFIG, PI_ANYROUTER_CC_BASE_URL, PI_ANYROUTER_CC_API_KEY`);
+  }
+}

package/src/types.ts

@@ -0,0 +1,65 @@
+import { randomBytes, randomUUID } from "node:crypto";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+// ── Local type aliases ──────────────────────────────────────────────────────
+
+export type Json = Record<string, any>;
+export type StreamMode = "off" | "auto" | "force";
+export type FetchInit = Parameters<typeof fetch>[1];
+
+export type ProviderModelConfig = {
+  id: string;
+  name?: string;
+  api?: string;
+  reasoning?: boolean;
+  input?: ("text" | "image")[];
+  cost?: { input?: number; output?: number; cacheRead?: number; cacheWrite?: number };
+  contextWindow?: number;
+  maxTokens?: number;
+};
+
+export type ProviderConfigFile = {
+  baseUrl?: string;
+  apiKey?: string;
+  models?: ProviderModelConfig[];
+};
+
+// ── Constants ───────────────────────────────────────────────────────────────
+
+export const DEFAULT_CONFIG_PATH = join(homedir(), ".pi", "agent", "anyrouter.json");
+export const CONFIG_PATH = process.env.PI_ANYROUTER_CC_CONFIG || DEFAULT_CONFIG_PATH;
+export const PROVIDER_NAME = "anyrouter";
+// Keep this API id unique so pi uses this extension's streamSimple handler
+// without touching the built-in anthropic-messages implementation.
+export const API_ID = "anyrouter-messages" as import("@earendil-works/pi-ai").Api;
+export const DEBUG_ENABLED = process.env.PI_ANYROUTER_CC_DEBUG === "1";
+export const DEBUG_DIR = process.env.PI_ANYROUTER_CC_DEBUG_DIR || join(process.cwd(), ".pi", "anyrouter-cc-debug");
+// Captured from the locally installed Claude Code on 2026-07-11.
+export const CLAUDE_CODE_VERSION = "2.1.206";
+export const CLAUDE_CODE_VERSION_BUILD = "2.1.206.3ee";
+export const STAINLESS_PACKAGE_VERSION = "0.94.0";
+export const STAINLESS_OS = "Linux";
+export const STAINLESS_ARCH = "x64";
+export const STAINLESS_RUNTIME = "node";
+export const STAINLESS_RUNTIME_VERSION = "v26.3.0";
+export const ANTHROPIC_BETA =
+  "claude-code-20250219,context-1m-2025-08-07,interleaved-thinking-2025-05-14,thinking-token-count-2026-05-13,context-management-2025-06-27,prompt-caching-scope-2026-01-05,mid-conversation-system-2026-04-07,effort-2025-11-24";
+export const CLAUDE_DEVICE_ID = randomBytes(32).toString("hex");
+export const CODEX_VERSION = "0.153.4";
+export const CODEX_INSTALLATION_ID = randomUUID();
+
+export const NAME_MAP: Record<string, string> = {
+  read: "Read",
+  write: "Write",
+  edit: "Edit",
+  bash: "Bash",
+  grep: "Grep",
+  find: "Glob",
+  glob: "Glob",
+  ls: "LS",
+  todowrite: "TodoWrite",
+  webfetch: "WebFetch",
+  websearch: "WebSearch",
+  google_search: "Google_Search",
+};

package/src/utils.ts

@@ -0,0 +1,114 @@
+import { type Api, type AssistantMessage, calculateCost, type Model, type SimpleStreamOptions, type StopReason } from "@earendil-works/pi-ai";
+import { NAME_MAP, type StreamMode } from "./types.js";
+
+export function toClaudeCodeName(name?: string | null) {
+  if (!name || typeof name !== "string") return name;
+  return NAME_MAP[name.toLowerCase()] ?? name.charAt(0).toUpperCase() + name.slice(1);
+}
+
+export function fromClaudeCodeName(name?: string | null): string {
+  if (!name || typeof name !== "string") return name ?? "";
+  const lower = name.toLowerCase();
+  for (const [from, to] of Object.entries(NAME_MAP)) {
+    if (to.toLowerCase() === lower) return from;
+  }
+  return name.charAt(0).toLowerCase() + name.slice(1);
+}
+
+export function sanitizeText(text: string) {
+  return text.replace(/[\uD800-\uDFFF]/g, "\uFFFD");
+}
+
+export function mapReasoningEffort(level?: SimpleStreamOptions["reasoning"]) {
+  switch (level) {
+    case "minimal":
+    case "low":
+      return "low";
+    case "medium":
+      return "medium";
+    case "high":
+      return "high";
+    case "xhigh":
+      return "xhigh";
+    case "max":
+      return "max";
+    default:
+      return "medium";
+  }
+}
+
+export function mapStopReason(reason: string): StopReason {
+  switch (reason) {
+    case "end_turn":
+    case "pause_turn":
+    case "stop_sequence":
+      return "stop";
+    case "max_tokens":
+      return "length";
+    case "tool_use":
+      return "toolUse";
+    default:
+      return "error";
+  }
+}
+
+export function createEmptyUsage() {
+  return {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    reasoning: undefined as number | undefined,
+    totalTokens: 0,
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+  };
+}
+
+export function tryParseJson(text: string) {
+  try {
+    return text ? JSON.parse(text) : {};
+  } catch {
+    return undefined;
+  }
+}
+
+export function extractRequestId(parsed: any, headers: Headers) {
+  return parsed?.error?.message?.match(/request id:\s*([^)]+)/i)?.[1] || headers.get("x-oneapi-request-id") || undefined;
+}
+
+export function updateUsageFromAnthropic(output: AssistantMessage, usage: any, model: Model<Api>) {
+  if (usage?.input_tokens != null) output.usage.input = usage.input_tokens;
+  if (usage?.output_tokens != null) output.usage.output = usage.output_tokens;
+  if (usage?.cache_read_input_tokens != null) output.usage.cacheRead = usage.cache_read_input_tokens;
+  if (usage?.cache_creation_input_tokens != null) output.usage.cacheWrite = usage.cache_creation_input_tokens;
+  // Anthropic reports thinking tokens under cache_read_input_tokens in some responses,
+  // but the explicit thinking_tokens field (when present) is the authoritative source.
+  if (usage?.thinking_tokens != null) output.usage.reasoning = usage.thinking_tokens;
+  output.usage.totalTokens = output.usage.input + output.usage.output + output.usage.cacheRead + output.usage.cacheWrite;
+  calculateCost(model, output.usage);
+}
+
+export function resetOutputState(output: AssistantMessage) {
+  output.content = [];
+  output.usage = createEmptyUsage();
+  output.stopReason = "pending";
+  output.timestamp = Date.now();
+  output.errorMessage = undefined;
+  output.responseId = undefined;
+}
+
+export function isCodexModel(modelId: string, configuredApi?: string) {
+  if (configuredApi) return configuredApi === "openai-codex-responses";
+  return /(?:^|[-_.])(gpt|codex)(?:[-_.]|$)/i.test(modelId) || /^o\d(?:[-_.]|$)/i.test(modelId);
+}
+
+export function getStreamMode(): StreamMode {
+  // AnyRouter's Claude Code subscription route is SSE-first. Keep the exact
+  // transport by default instead of falling back to a generic JSON request.
+  const value = String(process.env.PI_ANYROUTER_CC_STREAM_MODE || "force")
+    .trim()
+    .toLowerCase();
+  if (["1", "true", "on", "auto"].includes(value)) return "auto";
+  if (["force", "only"].includes(value)) return "force";
+  return "off";
+}