@timo972/cc-router 0.7.0 → 0.9.0-rc.1

package/dist/providers/anthropic/usage-refresher.js

@@ -0,0 +1,195 @@
+import { fetchAnthropicUsage } from "./usage.js";
+const SUCCESS_REFRESH_MS = 5 * 60_000;
+const FAILURE_BACKOFF_MS = [60_000, 2 * 60_000, 5 * 60_000, 15 * 60_000];
+const DEFAULT_STARTUP_STAGGER_MS = 250;
+const MAX_CONCURRENT_REFRESHES = 2;
+const RECONCILE_INTERVAL_MS = 60_000;
+/**
+ * Schedules bounded usage refreshes without becoming a source of routing or
+ * health traffic. Account identity, rather than ID alone, owns both work and
+ * result application so an account replacement cannot receive stale data.
+ */
+export class AnthropicUsageRefresher {
+    pool;
+    fetchUsage;
+    now;
+    startupStaggerMs;
+    maxConcurrent;
+    timers = new Map();
+    inFlight = new Map();
+    resolvers = new Map();
+    queued = new Set();
+    failures = new Map();
+    reconcileTimer;
+    active = 0;
+    started = false;
+    stopped = false;
+    constructor(pool, options = {}) {
+        this.pool = pool;
+        this.fetchUsage = options.fetchUsage ?? fetchAnthropicUsage;
+        this.now = options.now ?? Date.now;
+        this.startupStaggerMs = Math.max(0, options.startupStaggerMs ?? DEFAULT_STARTUP_STAGGER_MS);
+        this.maxConcurrent = Math.max(1, Math.floor(options.maxConcurrent ?? MAX_CONCURRENT_REFRESHES));
+    }
+    /** Begin staggered startup work for the accounts currently in the pool. */
+    start() {
+        if (this.started)
+            return;
+        this.started = true;
+        this.stopped = false;
+        this.reconcile(true);
+        this.reconcileTimer = setInterval(() => this.reconcile(), RECONCILE_INTERVAL_MS);
+    }
+    /** Cancel scheduled work. In-flight calls may settle, but cannot reschedule. */
+    stop() {
+        if (!this.started)
+            return;
+        this.started = false;
+        this.stopped = true;
+        if (this.reconcileTimer)
+            clearInterval(this.reconcileTimer);
+        this.reconcileTimer = undefined;
+        for (const timer of this.timers.values())
+            clearTimeout(timer);
+        this.timers.clear();
+        for (const account of this.queued) {
+            this.resolvers.get(account)?.({ ok: false, reason: "network" });
+            this.resolvers.delete(account);
+            this.inFlight.delete(account);
+        }
+        this.queued.clear();
+    }
+    /** Join or initiate the one usage refresh owned by this exact account object. */
+    refreshNow(account) {
+        const existing = this.inFlight.get(account);
+        if (existing)
+            return existing;
+        if (this.stopped)
+            return Promise.resolve({ ok: false, reason: "network" });
+        const scheduled = this.timers.get(account);
+        if (scheduled) {
+            clearTimeout(scheduled);
+            this.timers.delete(account);
+        }
+        let resolve;
+        const pending = new Promise(done => { resolve = done; });
+        this.inFlight.set(account, pending);
+        this.resolvers.set(account, resolve);
+        this.queued.add(account);
+        this.runQueued();
+        return pending;
+    }
+    /** Start a refresh after any request that was already in flight at call time. */
+    refreshAfterCurrent(account) {
+        const existing = this.inFlight.get(account);
+        return existing
+            ? existing.then(() => this.refreshNow(account))
+            : this.refreshNow(account);
+    }
+    reconcile(startup = false) {
+        if (!this.started)
+            return;
+        const accounts = this.pool.getAll();
+        const current = new Set(accounts);
+        for (const [account, timer] of this.timers) {
+            if (!current.has(account)) {
+                clearTimeout(timer);
+                this.timers.delete(account);
+            }
+        }
+        for (const account of [...this.queued]) {
+            if (!current.has(account)) {
+                this.queued.delete(account);
+                this.resolvers.get(account)?.({ ok: false, reason: "network" });
+                this.resolvers.delete(account);
+                this.inFlight.delete(account);
+            }
+        }
+        for (const account of this.failures.keys()) {
+            if (!current.has(account))
+                this.failures.delete(account);
+        }
+        accounts.forEach((account, index) => {
+            if (!this.timers.has(account) && !this.inFlight.has(account) && !this.queued.has(account)) {
+                if (startup)
+                    this.schedule(account, index * this.startupStaggerMs);
+                else
+                    void this.refreshNow(account);
+            }
+        });
+    }
+    schedule(account, delayMs) {
+        if (!this.started || this.pool.findById(account.id) !== account)
+            return;
+        const timer = setTimeout(() => {
+            this.timers.delete(account);
+            this.reconcile();
+            void this.refreshNow(account);
+        }, delayMs);
+        this.timers.set(account, timer);
+    }
+    runQueued() {
+        while (this.active < this.maxConcurrent) {
+            const account = this.queued.values().next().value;
+            if (!account)
+                return;
+            this.queued.delete(account);
+            if (this.pool.findById(account.id) !== account) {
+                this.resolvers.get(account)?.({ ok: false, reason: "network" });
+                this.resolvers.delete(account);
+                this.inFlight.delete(account);
+                continue;
+            }
+            this.startRequest(account);
+        }
+    }
+    startRequest(account) {
+        this.active++;
+        const operation = this.inFlight.get(account);
+        const resolve = this.resolvers.get(account);
+        if (!operation || !resolve) {
+            this.active--;
+            return;
+        }
+        void (async () => {
+            let result;
+            try {
+                result = await this.fetchUsage(account);
+            }
+            catch {
+                result = { ok: false, reason: "network" };
+            }
+            if (this.pool.findById(account.id) === account) {
+                this.apply(account, result);
+                if (this.started)
+                    this.schedule(account, this.nextDelay(account, result));
+            }
+            if (this.inFlight.get(account) === operation)
+                this.inFlight.delete(account);
+            this.resolvers.delete(account);
+            this.active--;
+            resolve(result);
+            this.reconcile();
+            this.runQueued();
+        })();
+    }
+    apply(account, result) {
+        if (result.ok) {
+            this.failures.delete(account);
+            account.rateLimits = { ...account.rateLimits, usage: result.snapshot };
+            return;
+        }
+        this.failures.set(account, (this.failures.get(account) ?? 0) + 1);
+        const prior = account.rateLimits.usage;
+        const usage = prior
+            ? { ...prior, fetchStatus: "stale" }
+            : { modelLimits: [], fetchedAt: this.now(), fetchStatus: "unavailable" };
+        account.rateLimits = { ...account.rateLimits, usage };
+    }
+    nextDelay(account, result) {
+        if (result.ok)
+            return SUCCESS_REFRESH_MS;
+        const failures = this.failures.get(account) ?? 1;
+        return FAILURE_BACKOFF_MS[Math.min(failures - 1, FAILURE_BACKOFF_MS.length - 1)];
+    }
+}

package/dist/providers/anthropic/usage.js

@@ -0,0 +1,217 @@
+const ANTHROPIC_USAGE_ENDPOINT = "https://api.anthropic.com/api/oauth/usage";
+const OAUTH_BETA_HEADER = "oauth-2025-04-20";
+const DEFAULT_USAGE_TIMEOUT_MS = 5_000;
+const USAGE_FIELDS = new Set([
+    "five_hour",
+    "seven_day",
+    "seven_day_sonnet",
+    "seven_day_opus",
+    "limits",
+    "extra_usage",
+]);
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringValue(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function numberValue(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function utilization(value) {
+    const number = numberValue(value);
+    if (number === undefined)
+        return 0;
+    return Math.max(0, Math.min(1, number / 100));
+}
+function resetAt(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return Math.max(0, Math.floor(value > 10_000_000_000 ? value / 1_000 : value));
+    }
+    if (typeof value !== "string")
+        return 0;
+    const timestamp = Date.parse(value);
+    return Number.isFinite(timestamp) ? Math.floor(timestamp / 1_000) : 0;
+}
+function getFirst(record, keys) {
+    for (const key of keys) {
+        if (key in record)
+            return record[key];
+    }
+    return undefined;
+}
+function parseWindow(value) {
+    if (!isRecord(value))
+        return undefined;
+    return {
+        utilization: utilization(getFirst(value, ["utilization", "percentage", "percent"])),
+        resetAt: resetAt(getFirst(value, ["resets_at", "reset_at", "resetAt"])),
+    };
+}
+/** Normalize an upstream model id or display name into a stable routing family. */
+export function normalizeModelFamily(modelIdOrName) {
+    const input = modelIdOrName?.trim().toLowerCase();
+    if (!input)
+        return undefined;
+    for (const family of ["fable", "sonnet", "opus", "haiku"]) {
+        if (input.includes(family))
+            return family;
+    }
+    const slug = input
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 64)
+        .replace(/-+$/g, "");
+    return slug || undefined;
+}
+function modelDetails(limit) {
+    const model = isRecord(limit.model) ? limit.model : undefined;
+    const scope = isRecord(limit.scope) ? limit.scope : undefined;
+    const scopedModel = scope && isRecord(scope.model) ? scope.model : undefined;
+    const modelId = stringValue(getFirst(limit, ["model_id", "modelId"]))
+        ?? (model ? stringValue(getFirst(model, ["id", "model_id"])) : undefined)
+        ?? (scopedModel ? stringValue(getFirst(scopedModel, ["id", "model_id"])) : undefined);
+    const displayName = stringValue(getFirst(limit, ["model_name", "display_name", "displayName"]))
+        ?? (typeof limit.model === "string" ? stringValue(limit.model) : undefined)
+        ?? (model ? stringValue(getFirst(model, ["display_name", "displayName", "name"])) : undefined)
+        ?? (scopedModel ? stringValue(getFirst(scopedModel, ["display_name", "displayName", "name"])) : undefined)
+        ?? modelId;
+    const modelFamily = normalizeModelFamily(modelId ?? displayName);
+    if (!displayName || !modelFamily)
+        return undefined;
+    return { ...(modelId ? { modelId } : {}), displayName, modelFamily };
+}
+function parseModelLimit(value) {
+    if (!isRecord(value) || stringValue(value.kind) !== "weekly_scoped")
+        return undefined;
+    const model = modelDetails(value);
+    if (!model)
+        return undefined;
+    const active = getFirst(value, ["active", "is_active"]);
+    return {
+        kind: "weekly_scoped",
+        group: stringValue(value.group) ?? "weekly",
+        ...model,
+        utilization: utilization(getFirst(value, ["utilization", "percentage", "percent"])),
+        resetAt: resetAt(getFirst(value, ["resets_at", "reset_at", "resetAt"])),
+        active: typeof active === "boolean" ? active : true,
+        severity: stringValue(value.severity) ?? "",
+    };
+}
+function parseExtraUsage(value) {
+    if (!isRecord(value))
+        return undefined;
+    const enabled = getFirst(value, ["is_enabled", "enabled"]) === true;
+    const disabledReason = stringValue(getFirst(value, ["disabled_reason", "disabledReason", "reason"]));
+    const usedMinor = numberValue(getFirst(value, ["used_minor", "used_credits", "used"]));
+    const limitMinor = numberValue(getFirst(value, ["limit_minor", "monthly_limit", "spend_limit", "limit"]));
+    const explicitReached = getFirst(value, ["spend_limit_reached", "is_spend_limit_reached"]);
+    const spendLimitReached = explicitReached === true
+        || (usedMinor !== undefined && limitMinor !== undefined && limitMinor >= 0 && usedMinor >= limitMinor);
+    const parsed = { enabled, spendLimitReached };
+    if (disabledReason)
+        parsed.disabledReason = disabledReason;
+    const rawUtilization = getFirst(value, ["utilization", "percentage", "percent"]);
+    if (rawUtilization !== undefined)
+        parsed.utilization = utilization(rawUtilization);
+    const currency = stringValue(value.currency);
+    if (currency)
+        parsed.currency = currency;
+    if (usedMinor !== undefined)
+        parsed.usedMinor = usedMinor;
+    if (limitMinor !== undefined)
+        parsed.limitMinor = limitMinor;
+    return parsed;
+}
+function legacyModelLimit(family, value) {
+    const window = parseWindow(value);
+    if (!window)
+        return undefined;
+    return {
+        kind: "weekly_scoped",
+        group: "weekly",
+        modelFamily: family,
+        displayName: family,
+        ...window,
+        active: true,
+        severity: "",
+    };
+}
+/** Parse the OAuth usage endpoint without retaining its provider-specific payload. */
+export function parseAnthropicUsage(value, fetchedAt) {
+    if (!isRecord(value) || !Object.keys(value).some((key) => USAGE_FIELDS.has(key)))
+        return null;
+    const limits = Array.isArray(value.limits) ? value.limits : undefined;
+    const modelLimits = limits
+        ? limits.map(parseModelLimit).filter((limit) => limit !== undefined)
+        : [
+            legacyModelLimit("sonnet", value.seven_day_sonnet),
+            legacyModelLimit("opus", value.seven_day_opus),
+        ].filter((limit) => limit !== undefined);
+    const snapshot = {
+        modelLimits,
+        fetchedAt,
+        fetchStatus: "fresh",
+    };
+    const fiveHour = parseWindow(value.five_hour);
+    const sevenDay = parseWindow(value.seven_day);
+    const extraUsage = parseExtraUsage(value.extra_usage);
+    if (fiveHour)
+        snapshot.fiveHour = fiveHour;
+    if (sevenDay)
+        snapshot.sevenDay = sevenDay;
+    if (extraUsage)
+        snapshot.extraUsage = extraUsage;
+    return snapshot;
+}
+export function canUseExtraUsage(state) {
+    return state?.enabled === true
+        && state.spendLimitReached === false
+        && !state.disabledReason;
+}
+/**
+ * Fetch and normalize the OAuth usage snapshot for one account.
+ *
+ * All expected provider failures are deliberately represented as compact
+ * results. In particular, this function neither reads nor exposes an error
+ * response body, which prevents tokens or provider diagnostics from leaking
+ * through refresh logs.
+ */
+export async function fetchAnthropicUsage(account, options = {}) {
+    const request = options.fetch ?? globalThis.fetch;
+    const now = options.now ?? Date.now;
+    const timeoutMs = Math.max(0, options.timeoutMs ?? DEFAULT_USAGE_TIMEOUT_MS);
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const response = await request(ANTHROPIC_USAGE_ENDPOINT, {
+            method: "GET",
+            headers: {
+                Authorization: `Bearer ${account.tokens.accessToken}`,
+                "anthropic-beta": OAUTH_BETA_HEADER,
+            },
+            signal: controller.signal,
+        });
+        if (!response.ok)
+            return { ok: false, reason: "http", status: response.status };
+        let body;
+        try {
+            body = await response.json();
+        }
+        catch {
+            return { ok: false, reason: "invalid_json" };
+        }
+        const snapshot = parseAnthropicUsage(body, now());
+        return snapshot
+            ? { ok: true, snapshot }
+            : { ok: false, reason: "invalid_schema" };
+    }
+    catch {
+        return controller.signal.aborted
+            ? { ok: false, reason: "timeout" }
+            : { ok: false, reason: "network" };
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}

package/dist/proxy/account-add.js

@@ -0,0 +1,30 @@
+/**
+ * Append an OpenAI subscription account to the running pool and persist it.
+ *
+ * The account is pushed IN PLACE so the picker (`createOpenAIAccountPicker`) and
+ * the refresh loop — both of which close over the same array reference — pick it
+ * up immediately without a restart, mirroring `TokenPool.addAccount` for Claude.
+ * If persistence throws, the in-place append is rolled back so the live routing
+ * state never diverges from disk.
+ */
+export function addOpenAIAccountTransaction(options) {
+    const account = {
+        id: options.record.id,
+        provider: "openai_subscription",
+        accessToken: options.record.accessToken,
+        refreshToken: options.record.refreshToken,
+        expiresAt: options.record.expiresAt,
+        enabled: options.record.enabled !== false,
+    };
+    options.accounts.push(account);
+    try {
+        options.persist(options.accounts);
+    }
+    catch (err) {
+        const index = options.accounts.indexOf(account);
+        if (index >= 0)
+            options.accounts.splice(index, 1);
+        throw err;
+    }
+    return account;
+}

package/dist/proxy/account-deletion.js

@@ -42,3 +42,19 @@ export async function deleteAnthropicAccountTransaction(options) {
         releaseReservation();
     }
 }
+/** Persist prospective OpenAI state before removing it from the live picker array. */
+export function deleteOpenAIAccountTransaction(options) {
+    const account = options.accounts.find(candidate => candidate.id === options.id);
+    if (!account)
+        throw new Error(`Account "${options.id}" not found`);
+    if (options.accounts.length + options.otherAccountCount <= 1) {
+        throw new LastAccountDeletionError();
+    }
+    const prospective = options.accounts.filter(candidate => candidate !== account);
+    options.persist(prospective);
+    const index = options.accounts.indexOf(account);
+    if (index < 0)
+        throw new AccountDeletionConflictError(options.id);
+    options.accounts.splice(index, 1);
+    return account;
+}

package/dist/proxy/anthropic-routing.js

@@ -1,6 +1,6 @@
 import { acquireRequestRoute } from "./lease-lifecycle.js";
 import { normalizeSessionId } from "./session-router.js";
-import { EmptyPoolError } from "./token-pool.js";
+import { EmptyPoolError, NoEligibleAccountError } 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) {
@@ -21,12 +21,36 @@ export function extractClaudeSessionId(request) {
         return undefined;
     return normalizeSessionId(values[0]);
 }
+const NO_ELIGIBLE_ACCOUNT_MESSAGE = "All configured accounts are unavailable for the requested model";
+function sendNoEligibleAccountResponse(error, response, now) {
+    if (error.reason === "rate_limited") {
+        if (error.retryAtMs !== undefined) {
+            const retryAfterSeconds = Math.max(0, Math.ceil((error.retryAtMs - now) / 1_000));
+            response.setHeader("Retry-After", String(retryAfterSeconds));
+        }
+        response.status(429).json({
+            type: "error",
+            error: {
+                type: "rate_limit_error",
+                message: NO_ELIGIBLE_ACCOUNT_MESSAGE,
+            },
+        });
+        return;
+    }
+    response.status(503).json({
+        type: "error",
+        error: {
+            type: "service_unavailable",
+            message: NO_ELIGIBLE_ACCOUNT_MESSAGE,
+        },
+    });
+}
 /** 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);
+            const selected = acquireRequestRoute(extractClaudeSessionId(request), response, options.sessionRouter, request._ccRouteContext);
             routedRequest._ccRoute = selected.route;
             routedRequest._ccReleaseLease = selected.release;
             routedRequest._ccAccount = selected.route.account;
@@ -37,6 +61,11 @@ export function createAnthropicRoutingMiddleware(options) {
                 options.onEmptyPool(error, request, response);
                 return;
             }
+            if (error instanceof NoEligibleAccountError) {
+                options.onNoEligibleAccount?.(error, request, response);
+                sendNoEligibleAccountResponse(error, response, (options.now ?? Date.now)());
+                return;
+            }
             next(error);
         }
     };