@timo972/cc-router 0.7.0 → 0.9.0

package/dist/proxy/lease-lifecycle.js

@@ -1,3 +1,4 @@
+import { canUseExtraUsage, normalizeModelFamily } from "../providers/anthropic/usage.js";
 /**
  * Tie an account lease to every terminal HTTP response path while retaining
  * one explicit cleanup callback for failures that happen before forwarding.
@@ -19,50 +20,209 @@ 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}`;
+export function routeFailureDetails(route, failure, limitingScope) {
+    return `${routeReasonDetails(route)}:${failure}${limitingScope ? `:${limitingScope}` : ""}`;
 }
 /** Acquire and immediately bind a routed lease to its response lifecycle. */
-export function acquireRequestRoute(sessionHeader, response, router) {
-    const route = router.acquire(sessionHeader);
+export function acquireRequestRoute(sessionHeader, response, router, context) {
+    const route = context === undefined ? router.acquire(sessionHeader) : router.acquire(sessionHeader, context);
     return {
         route,
         release: attachLeaseLifecycle(response, route),
         details: routeReasonDetails(route),
     };
 }
-function retryAfterSeconds(value) {
+const DEFAULT_RATE_LIMIT_COOLDOWN_MS = 60_000;
+const OVERLOAD_COOLDOWN_MS = 30_000;
+const MAX_RATE_LIMIT_COOLDOWN_MS = 8 * 24 * 60 * 60 * 1_000;
+function asHeaders(value) {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+        return value;
+    }
+    return { "retry-after": value };
+}
+function header(headers, name) {
+    for (const [key, value] of Object.entries(headers)) {
+        if (key.toLowerCase() !== name)
+            continue;
+        return typeof value === "string" || typeof value === "number" ? value : undefined;
+    }
+    return undefined;
+}
+function futureExpiry(expiryMs, nowMs) {
+    if (!Number.isFinite(expiryMs) || expiryMs <= nowMs)
+        return undefined;
+    return expiryMs - nowMs <= MAX_RATE_LIMIT_COOLDOWN_MS ? expiryMs : undefined;
+}
+function retryAfterExpiry(value, nowMs) {
+    if (typeof value !== "string" && typeof value !== "number")
+        return undefined;
+    if (typeof value === "string" && value.trim().length === 0)
+        return undefined;
+    const numeric = Number(value);
+    if (Number.isFinite(numeric)) {
+        if (numeric <= 0)
+            return undefined;
+        return futureExpiry(nowMs + numeric * 1_000, nowMs);
+    }
+    if (typeof value !== "string")
+        return undefined;
+    return futureExpiry(Date.parse(value), nowMs);
+}
+function resetHeaderExpiry(value, nowMs) {
     if (typeof value !== "string" && typeof value !== "number")
-        return 60;
+        return undefined;
     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;
+        return undefined;
+    const numeric = Number(value);
+    if (Number.isFinite(numeric)) {
+        const milliseconds = numeric < 10_000_000_000 ? numeric * 1_000 : numeric;
+        return futureExpiry(milliseconds, nowMs);
+    }
+    if (typeof value !== "string")
+        return undefined;
+    return futureExpiry(Date.parse(value), nowMs);
+}
+function matchingModelLimit(account, modelFamily) {
+    if (!modelFamily)
+        return undefined;
+    const usage = account.rateLimits?.usage;
+    if (!usage || usage.fetchStatus === "unavailable")
+        return undefined;
+    return usage.modelLimits.find(limit => normalizeModelFamily(limit.modelFamily) === modelFamily);
+}
+function classifyCooldown(claimValue, route) {
+    const claim = typeof claimValue === "string" ? claimValue.trim().toLowerCase() : "";
+    const requestedFamily = normalizeModelFamily(route.modelFamily);
+    const usage = route.account.rateLimits?.usage;
+    if (claim === "five_hour" || claim === "seven_day" || claim === "seven_day_oauth_apps") {
+        const usageWindow = claim === "five_hour" ? usage?.fiveHour : claim === "seven_day" ? usage?.sevenDay : undefined;
+        return {
+            kind: "global",
+            ambiguous: false,
+            ...(usageWindow ? { usageResetAtMs: usageWindow.resetAt * 1_000 } : {}),
+        };
+    }
+    if (claim === "seven_day_overage_included") {
+        const matching = matchingModelLimit(route.account, requestedFamily);
+        if (requestedFamily && matching?.active === true && matching.utilization >= 1) {
+            return {
+                kind: "model",
+                ambiguous: false,
+                modelFamily: requestedFamily,
+                usageResetAtMs: matching.resetAt * 1_000,
+            };
+        }
+        return { kind: "global", ambiguous: true };
+    }
+    if (claim.startsWith("seven_day_")) {
+        const family = normalizeModelFamily(claim.slice("seven_day_".length));
+        if (family) {
+            const matching = matchingModelLimit(route.account, family);
+            return {
+                kind: "model",
+                ambiguous: false,
+                modelFamily: family,
+                ...(matching ? { usageResetAtMs: matching.resetAt * 1_000 } : {}),
+            };
+        }
+    }
+    return { kind: "global", ambiguous: true };
+}
+function cooldownDurationMs(headers, classification, nowMs) {
+    const expiries = [
+        retryAfterExpiry(header(headers, "retry-after"), nowMs),
+        resetHeaderExpiry(header(headers, "anthropic-ratelimit-unified-reset"), nowMs),
+        classification.usageResetAtMs === undefined
+            ? undefined
+            : futureExpiry(classification.usageResetAtMs, nowMs),
+    ].filter((expiry) => expiry !== undefined);
+    return expiries.length > 0
+        ? Math.max(...expiries) - nowMs
+        : DEFAULT_RATE_LIMIT_COOLDOWN_MS;
+}
+function setGlobalCooldown(pool, account, durationMs, ambiguous, modelFamily) {
+    if (ambiguous && pool.setAmbiguousGlobalCooldownForAccount) {
+        return pool.setAmbiguousGlobalCooldownForAccount(account, durationMs, modelFamily);
+    }
+    else if (pool.setGlobalCooldownForAccount) {
+        pool.setGlobalCooldownForAccount(account, durationMs);
+    }
+    else {
+        pool.setCooldownForAccount(account, durationMs);
+    }
+    return undefined;
+}
+/** Narrow an ambiguity-created 429 cooldown only from a fresh, conclusive snapshot. */
+export function reconcileAmbiguousRateLimitCooldown(route, pool, token, now = Date.now) {
+    const family = normalizeModelFamily(route.modelFamily);
+    const usage = route.account.rateLimits?.usage;
+    if (token === undefined || !family || !usage || usage.fetchStatus !== "fresh")
+        return false;
+    if (!usage.fiveHour || !usage.sevenDay)
+        return false;
+    if (!Number.isFinite(usage.fiveHour.utilization) ||
+        !Number.isFinite(usage.sevenDay.utilization) ||
+        usage.fiveHour.utilization < 0 ||
+        usage.sevenDay.utilization < 0 ||
+        usage.fiveHour.utilization >= 1 ||
+        usage.sevenDay.utilization >= 1)
+        return false;
+    if (canUseExtraUsage(usage.extraUsage))
+        return false;
+    const matching = matchingModelLimit(route.account, family);
+    if (!matching || !matching.active || !Number.isFinite(matching.utilization) || matching.utilization < 1) {
+        return false;
+    }
+    if (!pool.reconcileAmbiguousGlobalCooldownForAccount)
+        return false;
+    const nowMs = now();
+    const resetExpiry = futureExpiry(matching.resetAt * 1_000, nowMs);
+    return pool.reconcileAmbiguousGlobalCooldownForAccount(route.account, token, family, resetExpiry === undefined ? 0 : resetExpiry - nowMs);
 }
 /**
  * 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) {
+export function applyUpstreamFailureRoutingDetailed(status, failureHeaders, route, router, pool, now = Date.now) {
     if (status !== 401 && status !== 429 && status !== 529)
-        return undefined;
+        return {};
     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;
+        const headers = asHeaders(failureHeaders);
+        const classification = classifyCooldown(header(headers, "anthropic-ratelimit-unified-representative-claim"), route);
+        const durationMs = cooldownDurationMs(headers, classification, now());
+        let ambiguousCooldownToken;
+        if (classification.kind === "model" && classification.modelFamily) {
+            if (pool.setModelCooldownForAccount) {
+                pool.setModelCooldownForAccount(route.account, classification.modelFamily, durationMs);
+            }
+            else {
+                pool.setCooldownForAccount(route.account, durationMs);
+            }
+        }
+        else {
+            ambiguousCooldownToken = setGlobalCooldown(pool, route.account, durationMs, classification.ambiguous, route.modelFamily);
+        }
+        return {
+            cooldownSeconds: durationMs / 1_000,
+            ...(ambiguousCooldownToken === undefined ? {} : { ambiguousCooldownToken }),
+            ...(classification.ambiguous
+                ? {}
+                : { limitingScope: classification.kind === "model" && classification.modelFamily
+                        ? `model:${classification.modelFamily}`
+                        : "global" }),
+        };
     }
     if (status === 529) {
-        pool.setCooldownForAccount(route.account, 30_000);
-        return 30;
+        setGlobalCooldown(pool, route.account, OVERLOAD_COOLDOWN_MS, false);
+        return { cooldownSeconds: OVERLOAD_COOLDOWN_MS / 1_000 };
     }
-    return undefined;
+    return {};
+}
+export function applyUpstreamFailureRouting(status, failureHeaders, route, router, pool, now = Date.now) {
+    return applyUpstreamFailureRoutingDetailed(status, failureHeaders, route, router, pool, now).cooldownSeconds;
 }

package/dist/proxy/logger.js

@@ -20,6 +20,9 @@ export function logError(accountId, status, message) {
     const statusStr = status > 0 ? ` HTTP ${status}` : "";
     console.log(chalk.red(`[${ts()}] [ERROR] ${accountId}:${statusStr} ${message}`));
 }
+export function logWarn(context, message) {
+    console.log(chalk.yellow(`[${ts()}] [WARN] ${context}: ${message}`));
+}
 function formatStartupAccountCounts(counts) {
     const total = counts.anthropic + counts.openai;
     return `${total} (Claude ${counts.anthropic}, OpenAI ${counts.openai})`;

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

@@ -5,6 +5,7 @@ import { openAIResponseToAnthropicMessage } from "../protocol/openai-response-to
 import { createOpenAIStreamToAnthropicNormalizer } from "../protocol/openai-stream-to-anthropic.js";
 import { encodeSseEvent, parseSseLines } from "../protocol/sse.js";
 import { forwardOpenAICodexResponse } from "../providers/openai/codex-transport.js";
+import { extractAnthropicRouteContext } from "./request-model.js";
 function isAnthropicMessagesRequest(value) {
     return (typeof value === "object" &&
         value !== null &&
@@ -141,8 +142,10 @@ export function mountMessagesCrossProviderRoute(app, opts) {
             });
             return;
         }
-        const route = selectRoute(req.body.model, opts.modelRouting);
+        const requestedModel = typeof req.body.model === "string" ? req.body.model : undefined;
+        const route = selectRoute(requestedModel, opts.modelRouting);
         if (route.provider !== "openai_subscription") {
+            req._ccRouteContext = extractAnthropicRouteContext(requestedModel, opts.modelRouting);
             next();
             return;
         }

package/dist/proxy/request-model.js

@@ -0,0 +1,17 @@
+import { normalizeModelFamily } from "../providers/anthropic/usage.js";
+import { parseModelRef } from "../protocol/model-ref.js";
+/**
+ * Extract bounded Anthropic routing context from an incoming Messages model.
+ * OpenAI-routed requests deliberately return no context because they never
+ * enter the Anthropic account-selection middleware.
+ */
+export function extractAnthropicRouteContext(model, config = {}) {
+    const parsed = parseModelRef(typeof model === "string" ? model : undefined, config);
+    if (parsed.provider !== "anthropic_subscription")
+        return undefined;
+    const modelFamily = normalizeModelFamily(parsed.upstreamModel);
+    return {
+        requestedModel: parsed.upstreamModel,
+        ...(modelFamily ? { modelFamily } : {}),
+    };
+}

package/dist/proxy/responses-server.js

@@ -1,6 +1,9 @@
 import express from "express";
 import { selectRoute } from "../providers/route-selector.js";
 import { forwardOpenAICodexResponse } from "../providers/openai/codex-transport.js";
+import { collectCodexResponseStream } from "../protocol/openai-responses-collect.js";
+import { stats } from "./stats.js";
+import { logWarn } from "./logger.js";
 function isResponsesRequest(value) {
     return (typeof value === "object" &&
         value !== null &&
@@ -37,6 +40,7 @@ async function sendUpstreamResponse(upstream, res) {
 export function mountResponsesRoutes(app, opts) {
     const forwardOpenAI = opts.forwardOpenAI ?? forwardOpenAICodexResponse;
     const prepareOpenAIAccount = opts.prepareOpenAIAccount ?? (async () => true);
+    const recordActivity = opts.recordActivity ?? ((entry) => stats.addLog(entry));
     app.post("/v1/responses", express.json({ limit: "10mb" }), async (req, res) => {
         if (!isResponsesRequest(req.body)) {
             res.status(400).json({
@@ -47,6 +51,34 @@ export function mountResponsesRoutes(app, opts) {
             });
             return;
         }
+        if (req.body.store === true) {
+            recordActivity({
+                ts: Date.now(),
+                accountId: "-",
+                model: req.body.model,
+                type: "warn",
+                statusCode: 400,
+                details: "store:true rejected — Codex backend is stateless (store:false only)",
+            });
+            logWarn("responses", "store:true is not supported by the Codex backend; rejecting request");
+            res.status(400).json({
+                error: {
+                    type: "invalid_request_error",
+                    message: "store:true is not supported: the Codex subscription backend operates only in stateless (store:false) mode.",
+                },
+            });
+            return;
+        }
+        if (req.body.max_output_tokens !== undefined) {
+            recordActivity({
+                ts: Date.now(),
+                accountId: "-",
+                model: req.body.model,
+                type: "warn",
+                details: "max_output_tokens ignored — unsupported by the Codex backend",
+            });
+            logWarn("responses", "max_output_tokens is unsupported by the Codex backend and was dropped");
+        }
         const route = selectRoute(req.body.model, opts.modelRouting);
         if (route.provider !== "openai_subscription") {
             res.status(501).json({
@@ -86,6 +118,16 @@ export function mountResponsesRoutes(app, opts) {
             body,
             stream: body.stream === true,
         });
-        await sendUpstreamResponse(upstream, res);
+        if (body.stream === true) {
+            await sendUpstreamResponse(upstream, res);
+            return;
+        }
+        const collected = await collectCodexResponseStream(upstream);
+        if (collected.kind === "json") {
+            res.status(collected.status).json(collected.body);
+        }
+        else {
+            res.status(collected.status).type(collected.contentType ?? "text/plain").send(collected.body);
+        }
     });
 }