@timo972/cc-router 0.7.0 → 0.9.0

package/dist/proxy/server.js

@@ -9,7 +9,7 @@ import { checkForUpdate, performUpdate, restartSelf, printUpdateBanner } from ".
 import { trackEvent, startHeartbeat } from "../utils/telemetry.js";
 import { loadTelemetryState } from "../config/telemetry.js";
 import { logRoute, logError, logStartup } from "./logger.js";
-import { stats } from "./stats.js";
+import { createLocalRoutingErrorLog, stats } from "./stats.js";
 import { PROXY_PORT, LITELLM_URL } from "../config/paths.js";
 import { writePid, removePid } from "../daemon/pid.js";
 import { createOpenAIAccountPicker } from "../providers/openai/account-pool.js";
@@ -20,15 +20,19 @@ import { mountModelsRoute } from "./models-server.js";
 import chalk from "chalk";
 import { SessionRouter } from "./session-router.js";
 import { createAnthropicProxy } from "./anthropic-proxy.js";
-import { applyUpstreamFailureRouting, routeFailureDetails, routeReasonDetails, } from "./lease-lifecycle.js";
+import { AnthropicUsageRefresher } from "../providers/anthropic/usage-refresher.js";
+import { canUseExtraUsage } from "../providers/anthropic/usage.js";
+import { applyUpstreamFailureRoutingDetailed, reconcileAmbiguousRateLimitCooldown, routeFailureDetails, routeReasonDetails, } from "./lease-lifecycle.js";
 import { persistProviderEnabledState } from "./provider-routing.js";
-import { accountDeletionStatusCode, deleteAnthropicAccountTransaction, } from "./account-deletion.js";
+import { accountDeletionStatusCode, deleteAnthropicAccountTransaction, deleteOpenAIAccountTransaction, } from "./account-deletion.js";
+import { addOpenAIAccountTransaction } from "./account-add.js";
 import { createAnthropicRefreshMiddleware, createAnthropicRoutingMiddleware, } from "./anthropic-routing.js";
 import { createStreamLifecycleTracker } from "./stream-lifecycle.js";
 const zeroRoutingMetrics = () => ({
     inFlightRequests: 0,
     activeSessions: 0,
     coolingDown: false,
+    cooldownUntilMs: 0,
 });
 export function createOperationalStatus(opts) {
     const anthropicAccounts = opts.accounts.filter(a => a.provider === "anthropic_subscription");
@@ -79,6 +83,9 @@ function publicAnthropicAccountView(a, metrics) {
         weeklyLimitPercent: a.weeklyLimitPercent,
         healthy: a.enabled !== false && a.healthy,
         busy: a.busy || metrics.coolingDown,
+        cooldownUntilMs: metrics.cooldownUntilMs ?? 0,
+        globalCooldownUntilMs: metrics.globalCooldownUntilMs ?? 0,
+        modelCooldowns: publicModelCooldowns(metrics.modelCooldowns),
         inFlightRequests: metrics.inFlightRequests,
         activeSessions: metrics.activeSessions,
         requestCount: a.requestCount,
@@ -86,9 +93,95 @@ function publicAnthropicAccountView(a, metrics) {
         expiresInMs: a.tokens.expiresAt - Date.now(),
         lastUsedMs: a.lastUsed,
         lastRefreshMs: a.lastRefresh,
-        rateLimits: a.rateLimits,
+        rateLimits: publicRateLimits(a.rateLimits),
     };
 }
+function publicRateLimits(rateLimits) {
+    return {
+        status: rateLimits.status,
+        fiveHourUtil: publicUtilization(rateLimits.fiveHourUtil),
+        fiveHourReset: publicTimestamp(rateLimits.fiveHourReset),
+        sevenDayUtil: publicUtilization(rateLimits.sevenDayUtil),
+        sevenDayReset: publicTimestamp(rateLimits.sevenDayReset),
+        claim: publicRepresentativeClaim(rateLimits.claim),
+        plan: publicPlan(rateLimits.plan),
+        requestsLimit: publicNonNegativeInteger(rateLimits.requestsLimit),
+        lastUpdated: publicTimestamp(rateLimits.lastUpdated),
+        ...(rateLimits.usage ? { usage: publicUsageSnapshot(rateLimits.usage) } : {}),
+    };
+}
+function publicUsageSnapshot(usage) {
+    return {
+        ...(usage.fiveHour ? { fiveHour: publicWindow(usage.fiveHour) } : {}),
+        ...(usage.sevenDay ? { sevenDay: publicWindow(usage.sevenDay) } : {}),
+        modelLimits: usage.modelLimits.slice(0, 12).map(limit => ({
+            modelFamily: publicModelFamily(limit.modelFamily),
+            displayName: publicDisplayName(limit.displayName),
+            utilization: publicUtilization(limit.utilization),
+            resetAt: publicTimestamp(limit.resetAt),
+            active: limit.active === true,
+            severity: publicSeverity(limit.severity),
+        })),
+        ...(usage.extraUsage ? {
+            extraUsage: {
+                enabled: usage.extraUsage.enabled === true,
+                spendLimitReached: usage.extraUsage.spendLimitReached === true,
+                usable: usage.fetchStatus === "fresh" && canUseExtraUsage(usage.extraUsage),
+            },
+        } : {}),
+        fetchedAt: publicTimestamp(usage.fetchedAt),
+        fetchStatus: usage.fetchStatus,
+    };
+}
+function publicWindow(window) {
+    return { utilization: publicUtilization(window.utilization), resetAt: publicTimestamp(window.resetAt) };
+}
+function publicModelCooldowns(cooldowns) {
+    return (cooldowns ?? []).slice(0, 12).map(cooldown => ({
+        modelFamily: publicModelFamily(cooldown.modelFamily),
+        untilMs: publicTimestamp(cooldown.untilMs),
+    })).filter(cooldown => cooldown.untilMs > 0);
+}
+function publicUtilization(value) {
+    return typeof value === "number" && Number.isFinite(value) ? Math.max(0, Math.min(1, value)) : 0;
+}
+function publicTimestamp(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : 0;
+}
+function publicNonNegativeInteger(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : 0;
+}
+function publicModelFamily(value) {
+    return typeof value === "string" && /^[a-z0-9-]{1,64}$/.test(value) ? value : "unknown";
+}
+function publicDisplayName(value) {
+    if (typeof value !== "string")
+        return "Unknown model";
+    const normalized = value.replace(/[\u0000-\u001f\u007f]/g, "").trim().slice(0, 80);
+    return normalized || "Unknown model";
+}
+function publicSeverity(value) {
+    return value === "warning" || value === "critical" ? value : value ? "unknown" : "";
+}
+function publicPlan(value) {
+    return value === "Pro" || value === "Max 5x" || value === "Max 20x" ? value : "";
+}
+function publicRepresentativeClaim(claim) {
+    if (typeof claim !== "string")
+        return "unknown";
+    const normalized = claim.trim().toLowerCase();
+    if (!normalized)
+        return "";
+    if (normalized === "five_hour" ||
+        normalized === "seven_day" ||
+        normalized === "seven_day_oauth_apps" ||
+        normalized === "seven_day_overage_included")
+        return normalized;
+    if (normalized.startsWith("seven_day_") && normalized.length > "seven_day_".length) {
+        return "seven_day_model";
+    }
+    return "unknown";
+}
 function publicOpenAIAccountView(a) {
     const expiresInMs = a.expiresAt - Date.now();
     return {
@@ -157,6 +250,14 @@ function extractRateLimits(headers) {
         lastUpdated: Date.now(),
     };
 }
+/** Apply upstream rate-limit headers without discarding the usage snapshot. */
+export function applyRateLimitHeaders(account, headers) {
+    const rateLimits = extractRateLimits(headers);
+    if (!rateLimits)
+        return false;
+    account.rateLimits = { ...account.rateLimits, ...rateLimits };
+    return true;
+}
 export async function startServer(opts = {}) {
     const port = opts.port ?? PROXY_PORT;
     // Direct-to-Anthropic (standalone) or via LiteLLM (full mode).
@@ -182,11 +283,17 @@ export async function startServer(opts = {}) {
     const sessionRouter = new SessionRouter(pool);
     const createRoutingMetricsResolver = () => {
         const activeSessionCounts = sessionRouter.getActiveSessionCountsSnapshot();
-        return accountId => ({
-            inFlightRequests: pool.getInFlight(accountId),
-            activeSessions: activeSessionCounts.get(accountId) ?? 0,
-            coolingDown: pool.isCoolingDown(accountId),
-        });
+        return accountId => {
+            const cooldowns = pool.getCooldownSummary(accountId);
+            return {
+                inFlightRequests: pool.getInFlight(accountId),
+                activeSessions: activeSessionCounts.get(accountId) ?? 0,
+                coolingDown: pool.isCoolingDown(accountId),
+                cooldownUntilMs: pool.getEarliestCooldownUntil(accountId),
+                globalCooldownUntilMs: cooldowns.globalUntilMs,
+                modelCooldowns: cooldowns.modelCooldowns,
+            };
+        };
     };
     const pickOpenAIAccount = createOpenAIAccountPicker(openAIAccounts);
     const initialConfig = readConfig();
@@ -206,6 +313,8 @@ export async function startServer(opts = {}) {
     };
     startRefreshLoop(accounts);
     startOpenAIRefreshLoop(openAIAccounts, saveOpenAIAccounts);
+    const usageRefresher = new AnthropicUsageRefresher(pool);
+    usageRefresher.start();
     const app = express();
     const proxyRequestTimeoutMs = getProxyRequestTimeoutMs();
     // ─── Proxy auth middleware ─────────────────────────────────────────────────
@@ -440,10 +549,36 @@ export async function startServer(opts = {}) {
             res.status(400).json({ error: "Invalid field types on account record" });
             return;
         }
-        if (pool.findById(body.id)) {
+        // IDs are unique across providers, so a new account may not collide with an
+        // existing account in either the Claude pool or the OpenAI picker.
+        if (pool.findById(body.id) || openAIAccounts.some(a => a.id === body.id)) {
             res.status(409).json({ error: `Account "${body.id}" already exists` });
             return;
         }
+        if (body.provider === "openai_subscription") {
+            let addedOpenAI;
+            try {
+                addedOpenAI = addOpenAIAccountTransaction({
+                    record: {
+                        id: body.id,
+                        accessToken: body.accessToken,
+                        refreshToken: body.refreshToken,
+                        expiresAt: body.expiresAt,
+                        enabled: body.enabled,
+                    },
+                    accounts: openAIAccounts,
+                    persist: saveOpenAIAccounts,
+                });
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                logError("accounts", 0, `Failed to persist accounts.json: ${message}`);
+                res.status(500).json({ error: `Failed to persist accounts.json: ${message}` });
+                return;
+            }
+            res.status(201).json({ account: publicOpenAIAccountView(addedOpenAI) });
+            return;
+        }
         const record = {
             id: body.id,
             accessToken: body.accessToken,
@@ -475,18 +610,41 @@ export async function startServer(opts = {}) {
     });
     accountsRouter.delete("/:id", async (req, res) => {
         const { id } = req.params;
-        // Refuse to remove the last account — downstream /v1/* would have no
-        // token to route with and the pool would throw EmptyPoolError on the
-        // next request. Users who want an empty pool should `cc-router stop`.
-        if (pool.getAll().length <= 1) {
-            res.status(409).json({ error: "Cannot remove the last account — at least one must remain" });
-            return;
-        }
         const existing = pool.findById(id);
-        if (!existing) {
+        const openAIExisting = openAIAccounts.find(account => account.id === id);
+        if (!existing && !openAIExisting) {
             res.status(404).json({ error: `Account "${id}" not found` });
             return;
         }
+        if (openAIExisting && !existing) {
+            try {
+                deleteOpenAIAccountTransaction({
+                    id,
+                    accounts: openAIAccounts,
+                    otherAccountCount: pool.getAll().length,
+                    persist: saveOpenAIAccounts,
+                });
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                const status = accountDeletionStatusCode(err);
+                if (status === 409) {
+                    res.status(409).json({ error: message });
+                    return;
+                }
+                logError("accounts", 0, `Failed to persist accounts.json: ${message}`);
+                res.status(500).json({ error: `Failed to persist accounts.json: ${message}` });
+                return;
+            }
+            res.json({ ok: true, id });
+            return;
+        }
+        // Preserve the existing Anthropic invariant: a running Anthropic pool
+        // always retains at least one account.
+        if (pool.getAll().length <= 1) {
+            res.status(409).json({ error: "Cannot remove the last account — at least one must remain" });
+            return;
+        }
         try {
             await deleteAnthropicAccountTransaction({
                 id,
@@ -590,9 +748,10 @@ export async function startServer(opts = {}) {
                 pendingLog.statusCode = status;
                 if (durationMs !== undefined)
                     pendingLog.durationMs = durationMs;
-                const cooldownSeconds = route
-                    ? applyUpstreamFailureRouting(status, proxyRes.headers["retry-after"], route, sessionRouter, pool)
+                const failureRouting = route
+                    ? applyUpstreamFailureRoutingDetailed(status, proxyRes.headers, route, sessionRouter, pool)
                     : undefined;
+                const cooldownSeconds = failureRouting?.cooldownSeconds;
                 if (status === 401) {
                     // Token invalid or expired mid-request.
                     // Forward the 401 to the client (Claude Code will retry on 401).
@@ -613,9 +772,19 @@ export async function startServer(opts = {}) {
                     const retryAfter = cooldownSeconds ?? 60;
                     pendingLog.type = "error";
                     pendingLog.details = route
-                        ? routeFailureDetails(route, "rate-limited")
+                        ? routeFailureDetails(route, "rate-limited", failureRouting?.limitingScope)
                         : "rate-limited";
                     logError(account.id, 429, `Rate limited — cooldown ${retryAfter}s`);
+                    // Refresh in the background to narrow only ambiguity-owned global
+                    // state when fresh usage proves a requested-model exhaustion. The
+                    // current upstream response remains on the native proxy stream.
+                    queueMicrotask(() => {
+                        void usageRefresher.refreshAfterCurrent(account).then(result => {
+                            if (result.ok && route) {
+                                reconcileAmbiguousRateLimitCooldown(route, pool, failureRouting?.ambiguousCooldownToken);
+                            }
+                        });
+                    });
                 }
                 else if (status === 529) {
                     // Anthropic service overloaded — short cooldown on this account.
@@ -628,9 +797,7 @@ export async function startServer(opts = {}) {
                     logError(account.id, 529, "Service overloaded — cooldown 30s");
                 }
                 // ── Capture rate limit utilization from response headers ────────────
-                const rl = extractRateLimits(proxyRes.headers);
-                if (rl)
-                    account.rateLimits = rl;
+                applyRateLimitHeaders(account, proxyRes.headers);
                 const entry = pendingLog;
                 stats.addLog(entry);
                 // ── Capture token usage from Anthropic response body ─────────────────
@@ -737,6 +904,12 @@ export async function startServer(opts = {}) {
                 error: { type: "no_accounts", message: err.message },
             });
         },
+        onNoEligibleAccount: (err, req) => {
+            stats.totalErrors++;
+            const entry = createLocalRoutingErrorLog(err.reason, req._ccRouteContext?.modelFamily);
+            stats.addLog(entry);
+            logError(entry.accountId, entry.statusCode ?? 0, entry.details ?? "no-eligible");
+        },
     }), createAnthropicRefreshMiddleware({
         needsRefresh,
         refresh: account => refreshAccountIfCurrent(account, pool),
@@ -775,6 +948,7 @@ export async function startServer(opts = {}) {
     // ─── Graceful shutdown ────────────────────────────────────────────────────
     const shutdown = () => {
         console.log(chalk.yellow("\nShutting down — saving tokens..."));
+        usageRefresher.stop();
         saveAccounts(pool.getAll());
         if (process.env["CC_ROUTER_DAEMON"] === "1") {
             removePid();

package/dist/proxy/session-router.js

@@ -1,3 +1,4 @@
+import { normalizeModelFamily } from "../providers/anthropic/usage.js";
 const DEFAULT_TTL_MS = 60 * 60 * 1000;
 const DEFAULT_MAX_ENTRIES = 10_000;
 const MAX_SESSION_ID_BYTES = 256;
@@ -41,25 +42,26 @@ export class SessionRouter {
             throw new RangeError("session binding capacity must be a positive integer");
         }
     }
-    acquire(sessionHeader) {
+    acquire(sessionHeader, context) {
         const sessionId = normalizeSessionId(sessionHeader);
+        const modelFamily = normalizeModelFamily(context?.modelFamily);
         const now = this.now();
         this.sweepExpiredBindings(now);
         if (!sessionId) {
-            return this.wrapUnscoped(this.pool.acquireBest(this.activeSessionCounts));
+            return this.wrapUnscoped(this.pool.acquireBest(this.activeSessionCounts, context), modelFamily);
         }
         const existing = this.bindings.get(sessionId);
         if (existing) {
-            const stickyLease = this.pool.tryAcquire(existing.accountId);
+            const stickyLease = this.pool.tryAcquire(existing.accountId, context);
             if (stickyLease) {
                 existing.lastSeen = now;
-                return this.wrapScoped(stickyLease, "sticky", sessionId, existing.generation);
+                return this.wrapScoped(stickyLease, "sticky", sessionId, existing.generation, modelFamily);
             }
             this.removeBinding(sessionId);
         }
-        const lease = this.pool.acquireBest(this.activeSessionCounts);
+        const lease = this.pool.acquireBest(this.activeSessionCounts, context);
         const binding = this.insertBinding(sessionId, lease.account.id, now);
-        return this.wrapScoped(lease, existing ? "failover" : "new-session", sessionId, binding.generation);
+        return this.wrapScoped(lease, existing ? "failover" : "new-session", sessionId, binding.generation, modelFamily);
     }
     /**
      * Remove a binding only if it still belongs to the expected account. This
@@ -103,15 +105,16 @@ export class SessionRouter {
         this.sweepExpiredBindings(this.now());
         return new Map(this.activeSessionCounts);
     }
-    wrapUnscoped(lease) {
+    wrapUnscoped(lease, modelFamily) {
         return {
             account: lease.account,
             fallback: lease.fallback,
             release: lease.release,
             reason: "unscoped",
+            ...(modelFamily ? { modelFamily } : {}),
         };
     }
-    wrapScoped(lease, reason, sessionId, bindingGeneration) {
+    wrapScoped(lease, reason, sessionId, bindingGeneration, modelFamily) {
         return {
             account: lease.account,
             fallback: lease.fallback,
@@ -119,6 +122,7 @@ export class SessionRouter {
             reason,
             sessionId,
             bindingGeneration,
+            ...(modelFamily ? { modelFamily } : {}),
         };
     }
     insertBinding(sessionId, accountId, lastSeen) {

package/dist/proxy/stats.js

@@ -1,3 +1,14 @@
+/** Build a bounded diagnostic for a request rejected before account selection. */
+export function createLocalRoutingErrorLog(reason, modelFamily, now = Date.now()) {
+    return {
+        ts: now,
+        accountId: "proxy",
+        model: modelFamily ?? "-",
+        type: "error",
+        details: `no-eligible:${reason.replace("_", "-")}`,
+        statusCode: reason === "rate_limited" ? 429 : 503,
+    };
+}
 const MAX_LOG_ENTRIES = 100;
 class ProxyStats {
     totalRequests = 0;