@timo972/cc-router 0.7.0

package/dist/proxy/anthropic-routing.js

@@ -0,0 +1,90 @@
+import { acquireRequestRoute } from "./lease-lifecycle.js";
+import { normalizeSessionId } from "./session-router.js";
+import { EmptyPoolError } from "./token-pool.js";
+const SESSION_HEADER = "x-claude-code-session-id";
+/** Extract exactly one native HTTP session header field without joined duplicates. */
+export function extractClaudeSessionId(request) {
+    const distinct = request.headersDistinct;
+    if (distinct !== undefined) {
+        const values = distinct[SESSION_HEADER];
+        if (!values || values.length !== 1)
+            return undefined;
+        return normalizeSessionId(values[0]);
+    }
+    const values = [];
+    for (let index = 0; index < request.rawHeaders.length; index += 2) {
+        if (request.rawHeaders[index]?.toLowerCase() !== SESSION_HEADER)
+            continue;
+        values.push(request.rawHeaders[index + 1] ?? "");
+    }
+    if (values.length !== 1)
+        return undefined;
+    return normalizeSessionId(values[0]);
+}
+/** Acquire the production route and bind its lease to downstream termination. */
+export function createAnthropicRoutingMiddleware(options) {
+    return (request, response, next) => {
+        const routedRequest = request;
+        try {
+            const selected = acquireRequestRoute(extractClaudeSessionId(request), response, options.sessionRouter);
+            routedRequest._ccRoute = selected.route;
+            routedRequest._ccReleaseLease = selected.release;
+            routedRequest._ccAccount = selected.route.account;
+            next();
+        }
+        catch (error) {
+            if (error instanceof EmptyPoolError && options.onEmptyPool) {
+                options.onEmptyPool(error, request, response);
+                return;
+            }
+            next(error);
+        }
+    };
+}
+function requestTerminated(request, response) {
+    return request.aborted || response.destroyed || response.writableEnded;
+}
+/** Prepare the selected account, but never continue after downstream termination. */
+export function createAnthropicRefreshMiddleware(options) {
+    return async (request, response, next) => {
+        const routedRequest = request;
+        const account = routedRequest._ccAccount;
+        const release = routedRequest._ccReleaseLease;
+        if (!account || !release) {
+            next(new Error("Anthropic route missing before refresh"));
+            return;
+        }
+        try {
+            if (options.needsRefresh(account)) {
+                const ok = await options.refresh(account);
+                if (requestTerminated(request, response)) {
+                    release();
+                    return;
+                }
+                if (!ok) {
+                    release();
+                    options.onRefreshFailure(account);
+                    response.status(401).json({
+                        type: "error",
+                        error: {
+                            type: "authentication_error",
+                            message: "Anthropic subscription token refresh failed",
+                        },
+                    });
+                    return;
+                }
+            }
+            if (requestTerminated(request, response)) {
+                release();
+                return;
+            }
+            next();
+        }
+        catch (error) {
+            release();
+            if (requestTerminated(request, response))
+                return;
+            next(error);
+        }
+    };
+}

package/dist/proxy/lease-lifecycle.js

@@ -0,0 +1,68 @@
+/**
+ * Tie an account lease to every terminal HTTP response path while retaining
+ * one explicit cleanup callback for failures that happen before forwarding.
+ */
+export function attachLeaseLifecycle(response, lease) {
+    let released = false;
+    const release = () => {
+        if (released)
+            return;
+        released = true;
+        lease.release();
+    };
+    response.once("finish", release);
+    response.once("close", release);
+    return release;
+}
+/** Keep route diagnostics useful without ever copying a session ID to logs. */
+export function routeReasonDetails(route) {
+    return route.fallback ? `${route.reason}:fallback` : route.reason;
+}
+/** Retain bounded routing context when a later failure updates the log. */
+export function routeFailureDetails(route, failure) {
+    return `${routeReasonDetails(route)}:${failure}`;
+}
+/** Acquire and immediately bind a routed lease to its response lifecycle. */
+export function acquireRequestRoute(sessionHeader, response, router) {
+    const route = router.acquire(sessionHeader);
+    return {
+        route,
+        release: attachLeaseLifecycle(response, route),
+        details: routeReasonDetails(route),
+    };
+}
+function retryAfterSeconds(value) {
+    if (typeof value !== "string" && typeof value !== "number")
+        return 60;
+    if (typeof value === "string" && value.trim().length === 0)
+        return 60;
+    const candidate = Number(value);
+    const milliseconds = candidate * 1_000;
+    return Number.isFinite(candidate) &&
+        candidate >= 0 &&
+        Number.isFinite(milliseconds)
+        ? candidate
+        : 60;
+}
+/**
+ * Apply only routing state changes implied by an upstream failure. The
+ * current response remains owned by the proxy's native byte stream; callers
+ * use the returned seconds solely for status logging.
+ */
+export function applyUpstreamFailureRouting(status, retryAfterHeader, route, router, pool) {
+    if (status !== 401 && status !== 429 && status !== 529)
+        return undefined;
+    if (route.sessionId !== undefined && route.bindingGeneration !== undefined) {
+        router.invalidate(route.sessionId, route.account.id, route.bindingGeneration);
+    }
+    if (status === 429) {
+        const seconds = retryAfterSeconds(retryAfterHeader);
+        pool.setCooldownForAccount(route.account, seconds * 1_000);
+        return seconds;
+    }
+    if (status === 529) {
+        pool.setCooldownForAccount(route.account, 30_000);
+        return 30;
+    }
+    return undefined;
+}

package/dist/proxy/logger.js

@@ -0,0 +1,39 @@
+import chalk from "chalk";
+function ts() {
+    return new Date().toISOString().slice(11, 19); // HH:MM:SS
+}
+export function logRoute(accountId, requestCount, expiresInMin) {
+    console.log(chalk.gray(`[${ts()}]`) +
+        chalk.green(` → ${accountId}`) +
+        chalk.gray(` req#${requestCount}`) +
+        chalk.yellow(` exp=${expiresInMin}min`));
+}
+export function logRefresh(accountId, ok, expiresInMin) {
+    if (ok) {
+        console.log(chalk.yellow(`[${ts()}] [REFRESH] ${accountId}: OK — expires in ${expiresInMin}min`));
+    }
+    else {
+        console.log(chalk.red(`[${ts()}] [REFRESH] ${accountId}: FAILED`));
+    }
+}
+export function logError(accountId, status, message) {
+    const statusStr = status > 0 ? ` HTTP ${status}` : "";
+    console.log(chalk.red(`[${ts()}] [ERROR] ${accountId}:${statusStr} ${message}`));
+}
+function formatStartupAccountCounts(counts) {
+    const total = counts.anthropic + counts.openai;
+    return `${total} (Claude ${counts.anthropic}, OpenAI ${counts.openai})`;
+}
+export function logStartup(port, host, mode, target, accountCounts) {
+    const listen = host === "127.0.0.1" ? `http://localhost:${port}` : `http://${host}:${port}`;
+    const accounts = formatStartupAccountCounts(accountCounts);
+    console.log(chalk.cyan(`
+╔══════════════════════════════════════════════╗
+║  CC-Router                                   ║
+║  Listening: ${listen.padEnd(33)}║
+║  Mode     : ${mode.padEnd(33)}║
+║  Target   : ${target.slice(0, 33).padEnd(33)}║
+║  Accounts : ${accounts.padEnd(33)}║
+╚══════════════════════════════════════════════╝
+`));
+}

package/dist/proxy/messages-cross-route.js

@@ -0,0 +1,179 @@
+import express from "express";
+import { selectRoute } from "../providers/route-selector.js";
+import { anthropicToOpenAIResponses } from "../protocol/anthropic-to-openai.js";
+import { openAIResponseToAnthropicMessage } from "../protocol/openai-response-to-anthropic.js";
+import { createOpenAIStreamToAnthropicNormalizer } from "../protocol/openai-stream-to-anthropic.js";
+import { encodeSseEvent, parseSseLines } from "../protocol/sse.js";
+import { forwardOpenAICodexResponse } from "../providers/openai/codex-transport.js";
+function isAnthropicMessagesRequest(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        Array.isArray(value.messages));
+}
+async function sendOpenAIAsAnthropic(upstream, res, requestedStream) {
+    const contentType = upstream.headers.get("content-type") ?? "";
+    if (contentType.includes("text/event-stream")) {
+        if (requestedStream) {
+            await sendOpenAIStreamAsAnthropic(upstream, res);
+            return;
+        }
+        res.status(upstream.status).json(await collectOpenAIStreamAsAnthropicMessage(upstream));
+        return;
+    }
+    if (!contentType.includes("application/json")) {
+        res.status(upstream.status);
+        res.setHeader("content-type", contentType || "text/plain");
+        res.send(await upstream.text());
+        return;
+    }
+    const json = await upstream.json();
+    res.status(upstream.status).json(openAIResponseToAnthropicMessage(json));
+}
+async function collectOpenAIStreamAsAnthropicMessage(upstream) {
+    const reader = upstream.body?.getReader();
+    if (!reader) {
+        return openAIResponseToAnthropicMessage({ id: "", model: "", output: [], usage: {} });
+    }
+    const decoder = new TextDecoder();
+    let remainder = "";
+    let id = "";
+    let model = "";
+    let text = "";
+    let usage = {};
+    const applyEvent = (event) => {
+        if (typeof event !== "object" || event === null)
+            return;
+        const openAIEvent = event;
+        if (openAIEvent.type === "response.created") {
+            id = openAIEvent.response?.id ?? id;
+            model = openAIEvent.response?.model ?? model;
+            return;
+        }
+        if (openAIEvent.type === "response.output_text.delta") {
+            text += openAIEvent.delta ?? "";
+            return;
+        }
+        if (openAIEvent.type === "response.completed") {
+            id = openAIEvent.response?.id ?? id;
+            model = openAIEvent.response?.model ?? model;
+            usage = openAIEvent.response?.usage ?? usage;
+        }
+    };
+    while (true) {
+        const { value, done } = await reader.read();
+        if (done)
+            break;
+        const parsed = parseSseLines(remainder + decoder.decode(value, { stream: true }));
+        remainder = parsed.remainder;
+        parsed.events.forEach(applyEvent);
+    }
+    const tail = decoder.decode();
+    if (tail || remainder) {
+        parseSseLines(remainder + tail + "\n").events.forEach(applyEvent);
+    }
+    return openAIResponseToAnthropicMessage({
+        id,
+        model,
+        output: text ? [{
+                type: "message",
+                role: "assistant",
+                content: [{ type: "output_text", text }],
+            }] : [],
+        usage,
+    });
+}
+async function sendOpenAIStreamAsAnthropic(upstream, res) {
+    res.status(upstream.status);
+    res.setHeader("content-type", "text/event-stream");
+    res.setHeader("cache-control", "no-cache");
+    res.flushHeaders?.();
+    const normalizer = createOpenAIStreamToAnthropicNormalizer();
+    const reader = upstream.body?.getReader();
+    if (!reader) {
+        res.end();
+        return;
+    }
+    const decoder = new TextDecoder();
+    let remainder = "";
+    try {
+        while (true) {
+            const { value, done } = await reader.read();
+            if (done)
+                break;
+            const parsed = parseSseLines(remainder + decoder.decode(value, { stream: true }));
+            remainder = parsed.remainder;
+            for (const event of parsed.events) {
+                for (const mapped of normalizer.convert(event)) {
+                    res.write(encodeSseEvent(mapped));
+                }
+            }
+        }
+        const tail = decoder.decode();
+        if (tail || remainder) {
+            const parsed = parseSseLines(remainder + tail + "\n");
+            for (const event of parsed.events) {
+                for (const mapped of normalizer.convert(event)) {
+                    res.write(encodeSseEvent(mapped));
+                }
+            }
+        }
+    }
+    finally {
+        res.end();
+    }
+}
+export function mountMessagesCrossProviderRoute(app, opts) {
+    const forwardOpenAI = opts.forwardOpenAI ?? forwardOpenAICodexResponse;
+    const prepareOpenAIAccount = opts.prepareOpenAIAccount ?? (async () => true);
+    app.post("/v1/messages", express.json({
+        limit: "10mb",
+        verify: (req, _res, buf) => {
+            req._ccRawBody = Buffer.from(buf);
+        },
+    }), async (req, res, next) => {
+        if (!isAnthropicMessagesRequest(req.body)) {
+            res.status(400).json({
+                type: "error",
+                error: {
+                    type: "invalid_request_error",
+                    message: "Expected Anthropic Messages request with messages array",
+                },
+            });
+            return;
+        }
+        const route = selectRoute(req.body.model, opts.modelRouting);
+        if (route.provider !== "openai_subscription") {
+            next();
+            return;
+        }
+        const account = opts.getOpenAIAccount();
+        if (!account) {
+            res.status(503).json({
+                type: "error",
+                error: {
+                    type: "no_accounts",
+                    message: "No OpenAI subscription accounts are configured",
+                },
+            });
+            return;
+        }
+        const ready = await prepareOpenAIAccount(account);
+        if (!ready) {
+            res.status(401).json({
+                type: "error",
+                error: {
+                    type: "authentication_error",
+                    message: "OpenAI subscription token refresh failed",
+                },
+            });
+            return;
+        }
+        const body = anthropicToOpenAIResponses(req.body, opts.modelRouting);
+        const upstream = await forwardOpenAI({
+            account,
+            body,
+            stream: body.stream === true,
+        });
+        await sendOpenAIAsAnthropic(upstream, res, req.body.stream === true);
+    });
+}

package/dist/proxy/models-server.js

@@ -0,0 +1,150 @@
+import express from "express";
+import { fetchAnthropicModels, fetchOpenAICodexModels, } from "../providers/model-discovery.js";
+import { buildModelRoutingUpdate } from "../protocol/model-routing-config.js";
+export function mountModelsRoute(app, opts) {
+    const fetchAnthropic = opts.fetchAnthropicModels ?? fetchAnthropicModels;
+    const fetchOpenAI = opts.fetchOpenAIModels ?? fetchOpenAICodexModels;
+    const prepareOpenAIAccount = opts.prepareOpenAIAccount ?? (async () => true);
+    app.get("/v1/models", async (_req, res) => {
+        const models = await discoverModelList(opts, prepareOpenAIAccount, fetchAnthropic, fetchOpenAI);
+        const body = {
+            object: "list",
+            data: models,
+            models: models.map(toCodexCliModel),
+        };
+        res.json(body);
+    });
+    app.get("/cc-router/models", async (_req, res) => {
+        res.json({
+            routing: currentModelRouting(opts),
+            models: await discoverModelList(opts, prepareOpenAIAccount, fetchAnthropic, fetchOpenAI),
+        });
+    });
+    app.patch("/cc-router/models", express.json({ limit: "16kb" }), async (req, res) => {
+        if (!opts.setModelRouting) {
+            res.status(501).json({ error: "Model routing updates are not available" });
+            return;
+        }
+        const body = (req.body ?? {});
+        if (body.claudeModel !== undefined && typeof body.claudeModel !== "string") {
+            res.status(400).json({ error: "claudeModel must be a string" });
+            return;
+        }
+        if (body.openAIModel !== undefined && typeof body.openAIModel !== "string") {
+            res.status(400).json({ error: "openAIModel must be a string" });
+            return;
+        }
+        const next = buildModelRoutingUpdate(currentModelRouting(opts), {
+            claudeModel: body.claudeModel,
+            openAIModel: body.openAIModel,
+        });
+        await opts.setModelRouting(next);
+        res.json({ routing: next });
+    });
+}
+async function discoverModelList(opts, prepareOpenAIAccount, fetchAnthropic, fetchOpenAI) {
+    const discovered = await Promise.all([
+        discoverAnthropicModels(opts.getAnthropicAccounts(), fetchAnthropic),
+        discoverOpenAIModels(opts.getOpenAIAccounts(), prepareOpenAIAccount, fetchOpenAI),
+    ]);
+    const models = new Map();
+    for (const model of discovered.flat()) {
+        models.set(model.id, model);
+    }
+    addConfiguredAliases(models, currentModelRouting(opts));
+    return [...models.values()].sort((a, b) => a.id.localeCompare(b.id));
+}
+function currentModelRouting(opts) {
+    return opts.getModelRouting?.() ?? opts.modelRouting ?? {};
+}
+async function discoverAnthropicModels(accounts, fetchAnthropic) {
+    const enabledAccounts = accounts.filter(account => account.enabled !== false);
+    const results = await Promise.allSettled(enabledAccounts.map(account => fetchAnthropic(account)));
+    return results.flatMap(result => {
+        if (result.status !== "fulfilled")
+            return [];
+        return result.value.map(id => modelEntry(`anthropic/${id}`, "anthropic_subscription"));
+    });
+}
+async function discoverOpenAIModels(accounts, prepareOpenAIAccount, fetchOpenAI) {
+    const enabledAccounts = accounts.filter(account => account.enabled !== false);
+    const results = await Promise.allSettled(enabledAccounts.map(async (account) => {
+        const ready = await prepareOpenAIAccount(account);
+        if (!ready)
+            return [];
+        return fetchOpenAI(account);
+    }));
+    return results.flatMap(result => {
+        if (result.status !== "fulfilled")
+            return [];
+        return result.value.map(id => modelEntry(`openai/${id}`, "openai_subscription"));
+    });
+}
+function addConfiguredAliases(models, config) {
+    for (const [alias, upstream] of Object.entries(config?.openAIAliases ?? {})) {
+        if (models.has(`openai/${upstream}`)) {
+            models.set(`openai/${alias}`, modelEntry(`openai/${alias}`, "openai_subscription"));
+        }
+    }
+    for (const [alias, upstream] of Object.entries(config?.anthropicAliases ?? {})) {
+        if (models.has(`anthropic/${upstream}`)) {
+            models.set(alias, modelEntry(alias, "anthropic_subscription"));
+        }
+    }
+    if (config?.anthropicDefaultModel && models.has(`anthropic/${config.anthropicDefaultModel}`)) {
+        models.set("claude/default", modelEntry("claude/default", "anthropic_subscription"));
+    }
+    if (config?.openAIDefaultModel && models.has(`openai/${config.openAIDefaultModel}`)) {
+        models.set("openai/default", modelEntry("openai/default", "openai_subscription"));
+    }
+}
+function modelEntry(id, ownedBy) {
+    return { id, object: "model", owned_by: ownedBy };
+}
+function toCodexCliModel(model) {
+    return {
+        prefer_websockets: true,
+        support_verbosity: true,
+        default_verbosity: "medium",
+        apply_patch_tool_type: "freeform",
+        web_search_tool_type: "text_and_image",
+        input_modalities: ["text"],
+        supports_image_detail_original: false,
+        truncation_policy: { mode: "tokens", limit: 10_000 },
+        supports_parallel_tool_calls: true,
+        tool_mode: null,
+        multi_agent_version: null,
+        use_responses_lite: false,
+        auto_review_model_override: null,
+        context_window: 128_000,
+        max_context_window: 128_000,
+        auto_compact_token_limit: null,
+        reasoning_summary_format: "experimental",
+        default_reasoning_summary: "none",
+        slug: model.id,
+        display_name: model.id,
+        description: `${model.owned_by} model routed by CC-Router`,
+        default_reasoning_level: "medium",
+        supported_reasoning_levels: [
+            { effort: "low", description: "Fast responses with lighter reasoning" },
+            { effort: "medium", description: "Balanced reasoning for everyday tasks" },
+            { effort: "high", description: "Deeper reasoning for complex tasks" },
+        ],
+        shell_type: "shell_command",
+        visibility: "list",
+        minimal_client_version: "0.98.0",
+        supported_in_api: true,
+        availability_nux: null,
+        upgrade: null,
+        priority: model.owned_by === "openai_subscription" ? 20 : 10,
+        base_instructions: "",
+        model_messages: {},
+        experimental_supported_tools: [],
+        available_in_plans: [],
+        supports_search_tool: false,
+        default_service_tier: null,
+        service_tiers: [],
+        additional_speed_tiers: [],
+        supports_reasoning_summaries: true,
+    };
+}

package/dist/proxy/provider-routing.js

@@ -0,0 +1,14 @@
+/**
+ * Persist a provider toggle before discarding any Anthropic affinity. If
+ * persistence throws, the caller can roll back runtime enablement without
+ * losing bindings that still point at valid accounts.
+ */
+export function persistProviderEnabledState(options) {
+    const result = options.persist();
+    if (options.provider === "anthropic_subscription" && !options.enabled) {
+        for (const accountId of options.accountIds) {
+            options.invalidateAccount(accountId);
+        }
+    }
+    return result;
+}

package/dist/proxy/responses-server.js

@@ -0,0 +1,91 @@
+import express from "express";
+import { selectRoute } from "../providers/route-selector.js";
+import { forwardOpenAICodexResponse } from "../providers/openai/codex-transport.js";
+function isResponsesRequest(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        typeof value.model === "string" &&
+        Array.isArray(value.input));
+}
+async function sendUpstreamResponse(upstream, res) {
+    const contentType = upstream.headers.get("content-type");
+    if (contentType)
+        res.setHeader("content-type", contentType);
+    res.status(upstream.status);
+    if (!upstream.body) {
+        res.end();
+        return;
+    }
+    if (contentType?.includes("text/event-stream")) {
+        res.setHeader("cache-control", "no-cache");
+        res.flushHeaders?.();
+    }
+    const reader = upstream.body.getReader();
+    try {
+        while (true) {
+            const { value, done } = await reader.read();
+            if (done)
+                break;
+            if (value)
+                res.write(Buffer.from(value));
+        }
+    }
+    finally {
+        res.end();
+    }
+}
+export function mountResponsesRoutes(app, opts) {
+    const forwardOpenAI = opts.forwardOpenAI ?? forwardOpenAICodexResponse;
+    const prepareOpenAIAccount = opts.prepareOpenAIAccount ?? (async () => true);
+    app.post("/v1/responses", express.json({ limit: "10mb" }), async (req, res) => {
+        if (!isResponsesRequest(req.body)) {
+            res.status(400).json({
+                error: {
+                    type: "invalid_request_error",
+                    message: "Expected Responses request with string model and input array",
+                },
+            });
+            return;
+        }
+        const route = selectRoute(req.body.model, opts.modelRouting);
+        if (route.provider !== "openai_subscription") {
+            res.status(501).json({
+                error: {
+                    type: "unsupported_provider",
+                    message: `Responses ingress for ${route.provider} is not implemented yet`,
+                },
+            });
+            return;
+        }
+        const account = opts.getOpenAIAccount();
+        if (!account) {
+            res.status(503).json({
+                error: {
+                    type: "no_accounts",
+                    message: "No OpenAI subscription accounts are configured",
+                },
+            });
+            return;
+        }
+        const ready = await prepareOpenAIAccount(account);
+        if (!ready) {
+            res.status(401).json({
+                error: {
+                    type: "authentication_error",
+                    message: "OpenAI subscription token refresh failed",
+                },
+            });
+            return;
+        }
+        const body = {
+            ...req.body,
+            model: route.upstreamModel,
+        };
+        const upstream = await forwardOpenAI({
+            account,
+            body,
+            stream: body.stream === true,
+        });
+        await sendUpstreamResponse(upstream, res);
+    });
+}