@timo972/cc-router 0.7.0

package/dist/protocol/model-ref.js

@@ -0,0 +1,36 @@
+const CLAUDE_ALIASES = {
+    "claude/sonnet": "claude-sonnet-4-5",
+    "claude/opus": "claude-opus-4-1",
+};
+function cleanModel(model) {
+    const trimmed = model?.trim();
+    return trimmed ? trimmed : undefined;
+}
+export function parseModelRef(model, config = {}) {
+    const publicModel = cleanModel(model) ?? cleanModel(config.anthropicDefaultModel) ?? "claude/sonnet";
+    if (publicModel.startsWith("openai/")) {
+        const openAIModel = publicModel.slice("openai/".length);
+        const defaultOpenAIModel = cleanModel(config.openAIDefaultModel);
+        return {
+            provider: "openai_subscription",
+            publicModel,
+            upstreamModel: config.openAIAliases?.[openAIModel]
+                ?? (openAIModel === "default" && defaultOpenAIModel ? defaultOpenAIModel : openAIModel),
+        };
+    }
+    if (publicModel.startsWith("anthropic/")) {
+        const anthropicModel = publicModel.slice("anthropic/".length);
+        return {
+            provider: "anthropic_subscription",
+            publicModel,
+            upstreamModel: config.anthropicAliases?.[publicModel]
+                ?? config.anthropicAliases?.[anthropicModel]
+                ?? anthropicModel,
+        };
+    }
+    return {
+        provider: "anthropic_subscription",
+        publicModel,
+        upstreamModel: config.anthropicAliases?.[publicModel] ?? CLAUDE_ALIASES[publicModel] ?? publicModel,
+    };
+}

package/dist/protocol/model-routing-config.js

@@ -0,0 +1,30 @@
+function cleanModel(model) {
+    const trimmed = model?.trim();
+    return trimmed ? trimmed : undefined;
+}
+export function buildModelRoutingUpdate(existing, opts) {
+    const next = {
+        ...existing,
+        anthropicAliases: { ...(existing?.anthropicAliases ?? {}) },
+        openAIAliases: { ...(existing?.openAIAliases ?? {}) },
+    };
+    const claudeModel = cleanModel(opts.claudeModel)?.replace(/^anthropic\//, "");
+    if (claudeModel) {
+        next.anthropicDefaultModel = claudeModel;
+        next.anthropicAliases = {
+            ...next.anthropicAliases,
+            "claude/sonnet": claudeModel,
+            sonnet: claudeModel,
+        };
+    }
+    const openAIModel = cleanModel(opts.openAIModel)?.replace(/^openai\//, "");
+    if (openAIModel) {
+        next.openAIDefaultModel = openAIModel;
+        next.openAIAliases = {
+            ...next.openAIAliases,
+            default: openAIModel,
+            codex: openAIModel,
+        };
+    }
+    return next;
+}

package/dist/protocol/openai-response-to-anthropic.js

@@ -0,0 +1,20 @@
+export function openAIResponseToAnthropicMessage(response) {
+    const content = (response.output ?? [])
+        .filter(item => item.type === "message")
+        .flatMap(item => item.content)
+        .filter(item => item.type === "output_text")
+        .map(item => ({ type: "text", text: item.text }));
+    return {
+        id: response.id,
+        type: "message",
+        role: "assistant",
+        model: response.model ?? "",
+        content,
+        stop_reason: "end_turn",
+        stop_sequence: null,
+        usage: {
+            input_tokens: response.usage?.input_tokens ?? 0,
+            output_tokens: response.usage?.output_tokens ?? 0,
+        },
+    };
+}

package/dist/protocol/openai-responses-types.js

@@ -0,0 +1 @@
+export {};

package/dist/protocol/openai-stream-to-anthropic.js

@@ -0,0 +1,75 @@
+export function createOpenAIStreamToAnthropicNormalizer() {
+    let textBlockStarted = false;
+    const ensureTextBlockStarted = () => {
+        if (textBlockStarted)
+            return [];
+        textBlockStarted = true;
+        return [
+            {
+                type: "content_block_start",
+                index: 0,
+                content_block: { type: "text", text: "" },
+            },
+        ];
+    };
+    const reset = () => {
+        textBlockStarted = false;
+    };
+    return {
+        reset,
+        convert(event) {
+            if (event.type === "response.created") {
+                reset();
+                return [
+                    {
+                        type: "message_start",
+                        message: {
+                            id: event.response?.id ?? "",
+                            type: "message",
+                            role: "assistant",
+                            model: event.response?.model ?? "",
+                            content: [],
+                            stop_reason: null,
+                            stop_sequence: null,
+                            usage: { input_tokens: 0, output_tokens: 0 },
+                        },
+                    },
+                ];
+            }
+            if (event.type === "response.output_text.delta") {
+                return [
+                    ...ensureTextBlockStarted(),
+                    {
+                        type: "content_block_delta",
+                        index: 0,
+                        delta: { type: "text_delta", text: event.delta ?? "" },
+                    },
+                ];
+            }
+            if (event.type === "response.completed") {
+                const usage = event.response?.usage ?? {};
+                const prefix = textBlockStarted
+                    ? [{ type: "content_block_stop", index: 0 }]
+                    : [];
+                reset();
+                return [
+                    ...prefix,
+                    {
+                        type: "message_delta",
+                        delta: { stop_reason: "end_turn", stop_sequence: null },
+                        usage: { output_tokens: usage.output_tokens ?? 0 },
+                    },
+                    { type: "message_stop" },
+                ];
+            }
+            return [];
+        },
+    };
+}
+const defaultNormalizer = createOpenAIStreamToAnthropicNormalizer();
+export function resetOpenAIStreamNormalizer() {
+    defaultNormalizer.reset();
+}
+export function openAIStreamEventToAnthropicEvents(event) {
+    return defaultNormalizer.convert(event);
+}

package/dist/protocol/openai-to-anthropic.js

@@ -0,0 +1,61 @@
+import { parseModelRef } from "./model-ref.js";
+function parseArguments(args) {
+    try {
+        return JSON.parse(args);
+    }
+    catch {
+        return { value: args };
+    }
+}
+function textFromOpenAI(block) {
+    if (block.type === "input_text" || block.type === "output_text")
+        return block.text;
+    return null;
+}
+function messageContentToAnthropic(message) {
+    const blocks = message.content.map((block) => {
+        const text = textFromOpenAI(block);
+        if (text !== null)
+            return { type: "text", text };
+        if (block.type === "function_call") {
+            return {
+                type: "tool_use",
+                id: block.call_id,
+                name: block.name,
+                input: parseArguments(block.arguments),
+            };
+        }
+        if (block.type === "function_call_output") {
+            return {
+                type: "tool_result",
+                tool_use_id: block.call_id,
+                content: block.output,
+            };
+        }
+        return null;
+    }).filter((block) => block !== null);
+    if (blocks.length === 1 && blocks[0].type === "text")
+        return blocks[0].text;
+    return blocks;
+}
+function normalizeRole(role) {
+    return role === "assistant" ? "assistant" : "user";
+}
+export function openAIResponsesToAnthropic(req) {
+    const parsed = parseModelRef(req.model);
+    return {
+        model: parsed.upstreamModel,
+        system: req.instructions,
+        messages: req.input.map(message => ({
+            role: normalizeRole(message.role),
+            content: messageContentToAnthropic(message),
+        })),
+        tools: req.tools?.map(tool => ({
+            name: tool.name,
+            description: tool.description,
+            input_schema: tool.parameters,
+        })),
+        max_tokens: req.max_output_tokens,
+        stream: req.stream,
+    };
+}

package/dist/protocol/sse.js

@@ -0,0 +1,17 @@
+export function parseSseLines(input) {
+    const lines = input.split("\n");
+    const remainder = lines.pop() ?? "";
+    const events = [];
+    for (const line of lines) {
+        if (!line.startsWith("data: "))
+            continue;
+        const payload = line.slice(6).trim();
+        if (!payload || payload === "[DONE]")
+            continue;
+        events.push(JSON.parse(payload));
+    }
+    return { events, remainder };
+}
+export function encodeSseEvent(event) {
+    return `data: ${JSON.stringify(event)}\n\n`;
+}

package/dist/providers/model-discovery.js

@@ -0,0 +1,71 @@
+export const ANTHROPIC_MODELS_ENDPOINT = "https://api.anthropic.com/v1/models";
+export const OPENAI_CODEX_MODELS_ENDPOINT = "https://chatgpt.com/backend-api/codex/models?client_version=1.0.0";
+export const MODEL_DISCOVERY_TIMEOUT_MS = 3_000;
+export function normalizeModelIds(payload) {
+    const values = getModelValues(payload);
+    const ids = new Set();
+    for (const value of values) {
+        const id = getModelId(value);
+        if (id)
+            ids.add(id);
+    }
+    return [...ids];
+}
+export async function fetchAnthropicModels(account, fetchImpl = fetch) {
+    return fetchModels(ANTHROPIC_MODELS_ENDPOINT, {
+        method: "GET",
+        headers: {
+            authorization: `Bearer ${account.tokens.accessToken}`,
+            "anthropic-version": "2023-06-01",
+            "anthropic-beta": "oauth-2025-04-20",
+        },
+        signal: AbortSignal.timeout(MODEL_DISCOVERY_TIMEOUT_MS),
+    }, fetchImpl);
+}
+export async function fetchOpenAICodexModels(account, fetchImpl = fetch) {
+    return fetchModels(OPENAI_CODEX_MODELS_ENDPOINT, {
+        method: "GET",
+        headers: {
+            authorization: `Bearer ${account.accessToken}`,
+            accept: "application/json",
+        },
+        signal: AbortSignal.timeout(MODEL_DISCOVERY_TIMEOUT_MS),
+    }, fetchImpl);
+}
+async function fetchModels(url, init, fetchImpl) {
+    try {
+        const res = await fetchImpl(url, init);
+        if (!res.ok)
+            return [];
+        return normalizeModelIds(await res.json());
+    }
+    catch {
+        return [];
+    }
+}
+function getModelValues(payload) {
+    if (Array.isArray(payload))
+        return payload;
+    if (!payload || typeof payload !== "object")
+        return [];
+    const record = payload;
+    if (Array.isArray(record.data))
+        return record.data;
+    if (Array.isArray(record.models))
+        return record.models;
+    return [];
+}
+function getModelId(value) {
+    if (typeof value === "string")
+        return normalizeId(value);
+    if (!value || typeof value !== "object")
+        return undefined;
+    const record = value;
+    return normalizeId(record.id) ?? normalizeId(record.slug) ?? normalizeId(record.name);
+}
+function normalizeId(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}

package/dist/providers/openai/account-pool.js

@@ -0,0 +1,11 @@
+export function createOpenAIAccountPicker(accounts) {
+    let index = 0;
+    return () => {
+        const enabled = accounts.filter(account => account.enabled);
+        if (enabled.length === 0)
+            return null;
+        const account = enabled[index % enabled.length];
+        index = (index + 1) % enabled.length;
+        return account;
+    };
+}

package/dist/providers/openai/account-record.js

@@ -0,0 +1,33 @@
+function parseExpiresAt(value) {
+    const parsed = typeof value === "number" ? value : Number(value);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        throw new Error("expiresAt must be a positive Unix timestamp in milliseconds");
+    }
+    return parsed;
+}
+function parseScopes(value) {
+    if (Array.isArray(value))
+        return value.filter(Boolean);
+    if (typeof value === "string")
+        return value.split(/\s+/).filter(Boolean);
+    return ["openid", "profile", "email", "offline_access"];
+}
+export function createOpenAIAccountRecord(input) {
+    const id = input.id.trim();
+    if (!/^[a-zA-Z0-9_-]+$/.test(id)) {
+        throw new Error("Only letters, numbers, _ and - allowed in account ID");
+    }
+    if (!input.accessToken.trim())
+        throw new Error("Access token is required");
+    if (!input.refreshToken.trim())
+        throw new Error("Refresh token is required");
+    return {
+        id,
+        provider: "openai_subscription",
+        accessToken: input.accessToken.trim(),
+        refreshToken: input.refreshToken.trim(),
+        expiresAt: parseExpiresAt(input.expiresAt),
+        scopes: parseScopes(input.scopes),
+        enabled: input.enabled ?? true,
+    };
+}

package/dist/providers/openai/codex-transport.js

@@ -0,0 +1,36 @@
+const CODEX_RESPONSES_ENDPOINT = "https://chatgpt.com/backend-api/codex/responses";
+const DEFAULT_CODEX_INSTRUCTIONS = "You are a concise coding assistant.";
+export async function forwardOpenAICodexResponse(opts) {
+    const body = toCodexBackendRequest(opts.body);
+    const upstream = await fetch(CODEX_RESPONSES_ENDPOINT, {
+        method: "POST",
+        headers: {
+            authorization: `Bearer ${opts.account.accessToken}`,
+            "content-type": "application/json",
+            accept: "text/event-stream",
+        },
+        body: JSON.stringify(body),
+    });
+    return ensureEventStreamContentType(upstream);
+}
+export function toCodexBackendRequest(body) {
+    const { max_output_tokens: _maxOutputTokens, ...rest } = body;
+    return {
+        ...rest,
+        instructions: body.instructions?.trim() || DEFAULT_CODEX_INSTRUCTIONS,
+        store: false,
+        stream: true,
+    };
+}
+function ensureEventStreamContentType(upstream) {
+    const contentType = upstream.headers.get("content-type");
+    if (contentType?.includes("text/event-stream"))
+        return upstream;
+    const headers = new Headers(upstream.headers);
+    headers.set("content-type", "text/event-stream");
+    return new Response(upstream.body, {
+        status: upstream.status,
+        statusText: upstream.statusText,
+        headers,
+    });
+}

package/dist/providers/openai/device-oauth.js

@@ -0,0 +1,116 @@
+import { createOpenAIAccountRecord } from "./account-record.js";
+const DEFAULT_ISSUER = "https://auth.openai.com";
+const DEFAULT_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
+const DEFAULT_SCOPE = "openid profile email offline_access";
+const DEFAULT_TIMEOUT_MS = 15 * 60 * 1000;
+function issuerOf(opts) {
+    return (opts.issuer ?? DEFAULT_ISSUER).replace(/\/+$/, "");
+}
+function clientIdOf(opts) {
+    return opts.clientId ?? DEFAULT_CLIENT_ID;
+}
+function fetchOf(opts) {
+    return opts.fetchImpl ?? fetch;
+}
+function parseAccessTokenExpiry(accessToken) {
+    const [, payload] = accessToken.split(".");
+    if (!payload)
+        throw new Error("OpenAI access token is not a JWT");
+    const claims = JSON.parse(Buffer.from(payload, "base64url").toString("utf-8"));
+    if (typeof claims.exp !== "number" || !Number.isFinite(claims.exp)) {
+        throw new Error("OpenAI access token JWT does not contain a numeric exp claim");
+    }
+    return claims.exp * 1000;
+}
+async function readError(res) {
+    try {
+        return await res.text();
+    }
+    catch {
+        return "";
+    }
+}
+export async function requestOpenAIDeviceCode(opts = {}) {
+    const issuer = issuerOf(opts);
+    const res = await fetchOf(opts)(`${issuer}/api/accounts/deviceauth/usercode`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ client_id: clientIdOf(opts) }),
+    });
+    if (!res.ok) {
+        throw new Error(`OpenAI device code request failed (${res.status}): ${await readError(res)}`);
+    }
+    const body = await res.json();
+    const userCode = body.user_code ?? body.usercode;
+    if (!body.device_auth_id || !userCode) {
+        throw new Error("OpenAI device code response is missing device_auth_id or user_code");
+    }
+    return {
+        verificationUrl: `${issuer}/codex/device`,
+        userCode,
+        deviceAuthId: body.device_auth_id,
+        intervalSeconds: Number(body.interval ?? 5),
+    };
+}
+async function pollAuthorizationCode(opts) {
+    const issuer = issuerOf(opts);
+    const sleep = opts.sleep ?? ((ms) => new Promise(resolve => setTimeout(resolve, ms)));
+    const now = opts.now ?? (() => Date.now());
+    const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const started = now();
+    while (now() - started <= timeoutMs) {
+        const res = await fetchOf(opts)(`${issuer}/api/accounts/deviceauth/token`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                device_auth_id: opts.deviceCode.deviceAuthId,
+                user_code: opts.deviceCode.userCode,
+            }),
+        });
+        if (res.ok)
+            return await res.json();
+        if (res.status !== 403 && res.status !== 404) {
+            throw new Error(`OpenAI device authorization failed (${res.status}): ${await readError(res)}`);
+        }
+        await sleep(Math.max(1, opts.deviceCode.intervalSeconds) * 1000);
+    }
+    throw new Error("OpenAI device authorization timed out");
+}
+export async function exchangeOpenAIDeviceCodeForTokens(opts) {
+    const issuer = issuerOf(opts);
+    const code = await pollAuthorizationCode(opts);
+    const form = new URLSearchParams({
+        grant_type: "authorization_code",
+        code: code.authorization_code,
+        redirect_uri: `${issuer}/deviceauth/callback`,
+        client_id: clientIdOf(opts),
+        code_verifier: code.code_verifier,
+    });
+    const res = await fetchOf(opts)(`${issuer}/oauth/token`, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: form.toString(),
+    });
+    if (!res.ok) {
+        throw new Error(`OpenAI token exchange failed (${res.status}): ${await readError(res)}`);
+    }
+    const tokens = await res.json();
+    return {
+        idToken: tokens.id_token,
+        accessToken: tokens.access_token,
+        refreshToken: tokens.refresh_token,
+        expiresAt: parseAccessTokenExpiry(tokens.access_token),
+    };
+}
+export async function loginOpenAIWithDeviceCode(opts) {
+    const deviceCode = await requestOpenAIDeviceCode(opts);
+    opts.onDeviceCode?.(deviceCode);
+    const tokens = await exchangeOpenAIDeviceCodeForTokens({ ...opts, deviceCode });
+    return createOpenAIAccountRecord({
+        id: opts.accountId,
+        accessToken: tokens.accessToken,
+        refreshToken: tokens.refreshToken,
+        expiresAt: tokens.expiresAt,
+        scopes: DEFAULT_SCOPE,
+    });
+}

package/dist/providers/openai/token-refresher.js

@@ -0,0 +1,56 @@
+const TOKEN_ENDPOINT = "https://auth.openai.com/oauth/token";
+const REFRESH_BUFFER_MS = 10 * 60 * 1000;
+const CHECK_INTERVAL_MS = 5 * 60 * 1000;
+const refreshLocks = new Map();
+export function needsOpenAIRefresh(account) {
+    return account.expiresAt - Date.now() < REFRESH_BUFFER_MS;
+}
+export async function refreshOpenAISubscriptionToken(account) {
+    const existing = refreshLocks.get(account.id);
+    if (existing)
+        return existing;
+    const promise = doRefresh(account);
+    refreshLocks.set(account.id, promise);
+    try {
+        return await promise;
+    }
+    finally {
+        refreshLocks.delete(account.id);
+    }
+}
+export async function prepareOpenAIAccountForRequest(account, allAccounts, saveAccounts) {
+    if (!needsOpenAIRefresh(account))
+        return true;
+    const ok = await refreshOpenAISubscriptionToken(account);
+    if (ok)
+        saveAccounts(allAccounts);
+    return ok;
+}
+export function startOpenAIRefreshLoop(accounts, saveAccounts) {
+    const check = async () => {
+        for (const account of accounts) {
+            await prepareOpenAIAccountForRequest(account, accounts, saveAccounts);
+        }
+    };
+    const timer = setInterval(() => { check().catch(console.error); }, CHECK_INTERVAL_MS);
+    queueMicrotask(() => { check().catch(console.error); });
+    return () => clearInterval(timer);
+}
+async function doRefresh(account) {
+    const body = new URLSearchParams({
+        grant_type: "refresh_token",
+        refresh_token: account.refreshToken,
+    });
+    const res = await fetch(TOKEN_ENDPOINT, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: body.toString(),
+    });
+    if (!res.ok)
+        return false;
+    const data = await res.json();
+    account.accessToken = data.access_token;
+    account.refreshToken = data.refresh_token ?? account.refreshToken;
+    account.expiresAt = Date.now() + data.expires_in * 1000;
+    return true;
+}

package/dist/providers/route-selector.js

@@ -0,0 +1,8 @@
+import { parseModelRef } from "../protocol/model-ref.js";
+export function selectRoute(model, config = {}) {
+    const parsed = parseModelRef(model, config);
+    return {
+        ...parsed,
+        ingressProtocol: parsed.provider === "openai_subscription" ? "responses" : "anthropic_messages",
+    };
+}

package/dist/providers/types.js

@@ -0,0 +1 @@
+export {};

package/dist/proxy/account-deletion.js

@@ -0,0 +1,44 @@
+import { reserveAccountForDeletion } from "./token-refresher.js";
+export class AccountDeletionConflictError extends Error {
+    constructor(id) {
+        super(`Account "${id}" changed during deletion`);
+        this.name = "AccountDeletionConflictError";
+    }
+}
+export class LastAccountDeletionError extends Error {
+    constructor() {
+        super("Cannot remove the last account — at least one must remain");
+        this.name = "LastAccountDeletionError";
+    }
+}
+export function accountDeletionStatusCode(error) {
+    return error instanceof AccountDeletionConflictError ||
+        error instanceof LastAccountDeletionError
+        ? 409
+        : 500;
+}
+/** Persist prospective state before irreversibly removing runtime routing state. */
+export async function deleteAnthropicAccountTransaction(options) {
+    const account = options.pool.findById(options.id);
+    if (!account)
+        throw new Error(`Account "${options.id}" not found`);
+    const releaseReservation = await reserveAccountForDeletion(account);
+    try {
+        if (options.pool.findById(options.id) !== account) {
+            throw new AccountDeletionConflictError(options.id);
+        }
+        if (options.pool.getAll().length <= 1) {
+            throw new LastAccountDeletionError();
+        }
+        const prospective = options.pool.getAll().filter(candidate => candidate !== account);
+        options.persist(prospective);
+        if (!options.pool.removeAccount(options.id)) {
+            throw new AccountDeletionConflictError(options.id);
+        }
+        options.sessionRouter.invalidateAccount(options.id);
+        return account;
+    }
+    finally {
+        releaseReservation();
+    }
+}

package/dist/proxy/anthropic-proxy.js

@@ -0,0 +1,26 @@
+import { createProxyMiddleware } from "http-proxy-middleware";
+/**
+ * Construct the Anthropic transport with http-proxy-middleware's native
+ * response piping. In particular, this deliberately does not self-handle,
+ * buffer, transform, or synthesize any response bytes.
+ */
+export function createAnthropicProxy(options) {
+    const configuredProxyRequest = options.on.proxyReq;
+    return createProxyMiddleware({
+        target: options.target,
+        changeOrigin: true,
+        pathRewrite: path => `/v1${path}`,
+        proxyTimeout: options.timeoutMs,
+        timeout: options.timeoutMs,
+        on: {
+            ...options.on,
+            proxyReq: (proxyRequest, request, response, proxyOptions) => {
+                proxyRequest.once("response", () => {
+                    proxyRequest.setTimeout(0);
+                    request.socket.setTimeout(0);
+                });
+                configuredProxyRequest?.(proxyRequest, request, response, proxyOptions);
+            },
+        },
+    });
+}