@timo972/cc-router 0.13.0-rc.2 → 0.13.0-rc.3

package/README.md

@@ -109,6 +109,24 @@ it later. Adding more accounts is `cc-router accounts login`, re-signing one in
 Per-platform token extraction, Codex CLI, Docker and everything else lives in
 [the docs](docs/).
 
+## Usage history and savings
+
+Run `cc-router usage` for persistent token history, provider/model stacked bars,
+and a daily activity grid. Switch between day, week, month and year; history
+survives service restarts. Configure your monthly subscription costs to compare
+them with the estimated standard API token value:
+
+```bash
+cc-router usage subscription set personal --monthly-usd 100 --from 2026-09-01
+cc-router usage
+cc-router usage --period month --provider claude --json
+```
+
+Use your actual monthly USD cost and account name in place of the example.
+Missing prices or costs are explicitly marked incomplete. See the
+[usage reference](docs/cli-reference.md#persistent-token-usage-and-savings) for
+configuration, keyboard controls, estimation limits and offline/remote access.
+
 ## Documentation
 
 | Guide | What's in it |

package/dist/cli/cmd-accounts.js

@@ -191,9 +191,9 @@ export function registerAccounts(program) {
             return;
         }
         const record = await flows.loginGrokAccount({ accountId: opts.id });
-        upsertAccountRecord(record);
+        const { mode } = await addAccountRuntimeAware(record);
         console.log(chalk.green(`\n✓ Grok account "${record.id}" saved via device login.\n`));
-        printAddOutcome("stored");
+        printAddOutcome(mode);
     }));
     // ── accounts add ─────────────────────────────────────────────────────────
     accounts
@@ -222,9 +222,9 @@ export function registerAccounts(program) {
             return;
         }
         const record = await flows.importGrokAccount({ accountId: opts.id });
-        upsertAccountRecord(record);
+        const { mode } = await addAccountRuntimeAware(record);
         console.log(chalk.green(`\n✓ Grok account "${record.id}" imported from ~/.grok.\n`));
-        printAddOutcome("stored");
+        printAddOutcome(mode);
     }));
     // ── accounts reauth ──────────────────────────────────────────────────────
     accounts
@@ -623,6 +623,25 @@ export async function removeAccountRuntimeAware(id, dependencies = {
         throw new Error(`Account "${id}" disappeared before it could be removed`);
     return { mode: "stored", removed };
 }
+/** Read-only probe for commands that cannot be represented as a live mutation. */
+export async function isAccountApiReachable(options = {}) {
+    const fetchImpl = options.fetch ?? globalThis.fetch;
+    const baseUrl = (options.baseUrl ?? `http://localhost:${PROXY_PORT}`).replace(/\/+$/, "");
+    const authToken = options.authToken ?? readConfig().proxySecret;
+    let response;
+    try {
+        response = await fetchImpl(`${baseUrl}/cc-router/accounts`, {
+            headers: authToken ? { authorization: `Bearer ${authToken}` } : {},
+            signal: AbortSignal.timeout(3_000),
+        });
+    }
+    catch {
+        return false;
+    }
+    if (!response.ok)
+        throw new Error(`HTTP ${response.status} while checking the running proxy`);
+    return true;
+}
 /**
  * Add an account to a running proxy so it becomes routable without a restart.
  * Returns false only when no running proxy can be reached (the caller then

package/dist/cli/cmd-setup.js

@@ -9,6 +9,8 @@ import { existsSync } from "fs";
 import { checkMitmproxyInstalled, isCaCertInstalled, generateCaCert, installCaCert, writeAddonScript, getNetworkExtensionStatus, openNetworkExtensionSettings, } from "../interceptor/mitmproxy-manager.js";
 import { printDesktopSupportExplainer, printNetworkExtensionInstructions } from "./cmd-client.js";
 import { collectClaudeAccount } from "./account-flows.js";
+import { accountToRecord } from "./account-flows.js";
+import { addAccountRuntimeAware, isAccountApiReachable, tryAddAccountToRunningProxy } from "./cmd-accounts.js";
 import { withSetupTelemetryFlush, } from "../telemetry/setup-diagnostics.js";
 // ─── Public registration ──────────────────────────────────────────────────────
 export function registerSetup(program) {
@@ -56,6 +58,8 @@ export async function runSetupWizard({ addMode }) {
             return;
         }
     }
+    let replaceExisting = false;
+    let includeExisting = addMode;
     if (hasExisting && !addMode) {
         const existing = loadAccounts();
         console.log(chalk.yellow(`  Found ${existing.length} existing account(s).\n`));
@@ -80,6 +84,10 @@ export async function runSetupWizard({ addMode }) {
                 console.log(chalk.gray("\nCancelled.\n"));
                 return;
             }
+            replaceExisting = true;
+        }
+        else {
+            includeExisting = true;
         }
     }
     let numAccounts = 1;
@@ -114,14 +122,19 @@ export async function runSetupWizard({ addMode }) {
         return;
     }
     // Merge: existing accounts minus any overwritten by ID, plus new ones
-    const existingAccounts = (hasExisting && !addMode) ? [] : (hasExisting ? loadAccounts() : []);
+    const existingAccounts = hasExisting && includeExisting ? loadAccounts() : [];
     const merged = [
         ...existingAccounts.filter(a => !newAccounts.some(n => n.id === a.id)),
         ...newAccounts,
     ];
     console.log(chalk.bold(`\n${"━".repeat(40)}\n  Saving\n${"━".repeat(40)}\n`));
+    let persistenceMode;
     try {
-        saveAccounts(merged);
+        persistenceMode = await persistSetupAccountsRuntimeAware({
+            newAccounts,
+            merged,
+            replaceExisting,
+        });
     }
     catch (error) {
         const outcomes = savedAttempts.map(attempt => attempt.failed(error, "persistence"));
@@ -130,6 +143,9 @@ export async function runSetupWizard({ addMode }) {
         throw error;
     }
     console.log(chalk.green(`  ✓ ${merged.length} account(s) saved to ~/.cc-router/accounts.json`));
+    if (persistenceMode === "live") {
+        console.log(chalk.gray("  Loaded into the running proxy — available now, no restart needed."));
+    }
     for (const attempt of savedAttempts) {
         attempt.stageCompleted("persistence");
         attempt.succeeded();
@@ -137,6 +153,31 @@ export async function runSetupWizard({ addMode }) {
     // ─── Post-setup interactive flow ─────────────────────────────────────────
     await runPostSetupFlow(merged.length);
 }
+export async function persistSetupAccountsRuntimeAware(input, dependencies = {
+    isLive: isAccountApiReachable,
+    // The wizard merges by id, so a re-collected account must upsert live the
+    // way `saveAccounts(merged)` upserts on disk; without `replace` the daemon
+    // answers 409 and discards the login the operator just completed.
+    tryAddLive: live => tryAddAccountToRunningProxy(live, { replace: true }),
+    saveStored: saveAccounts,
+}) {
+    if (input.replaceExisting) {
+        if (await dependencies.isLive()) {
+            throw new Error("Cannot replace all accounts while the proxy is running. Stop it first: cc-router stop --keep-config");
+        }
+        dependencies.saveStored(input.merged);
+        return "stored";
+    }
+    for (const account of input.newAccounts) {
+        const { mode } = await addAccountRuntimeAware(accountToRecord(account), {
+            tryAddLive: dependencies.tryAddLive,
+            addStored: () => dependencies.saveStored(input.merged),
+        });
+        if (mode === "stored")
+            return "stored";
+    }
+    return "live";
+}
 // ─── Post-setup interactive flow ─────────────────────────────────────────────
 async function runPostSetupFlow(accountCount) {
     console.log(chalk.bold(`\n${"━".repeat(40)}\n  Configure this machine\n${"━".repeat(40)}\n`));

package/dist/cli/cmd-usage.js

@@ -0,0 +1,124 @@
+import { InvalidArgumentError } from "commander";
+import { USAGE_DIR, PROXY_PORT } from "../config/paths.js";
+import { readAccountsRaw, readConfig } from "../config/manager.js";
+import { resolveStatusTarget } from "./cmd-status.js";
+import { createUsageClient } from "../usage/client.js";
+import { recoverAccountTransition, reconcileUsageAccounts } from "../usage/account-lifecycle.js";
+import { totalTokens, utcTimestamp, usageProvider } from "../usage/types.js";
+const aliases = { claude: "anthropic_subscription", anthropic: "anthropic_subscription", openai: "openai_subscription", grok: "xai_subscription", xai: "xai_subscription" };
+export function parseUsageOptions(options) {
+    const period = options.period ?? "month";
+    if (!["day", "week", "month", "year"].includes(period))
+        throw new InvalidArgumentError("Period must be day, week, month or year");
+    if (options.date) {
+        if (!/^\d{4}-\d\d-\d\d$/.test(options.date))
+            throw new InvalidArgumentError("Date must be YYYY-MM-DD (UTC)");
+        utcTimestamp(options.date);
+    }
+    const providers = options.provider?.map(p => usageProvider(aliases[p] ?? p));
+    return { period: period, ...(options.date ? { date: options.date } : {}), ...(providers ? { providers: [...new Set(providers)] } : {}) };
+}
+function client(portText) {
+    const port = Number(portText ?? PROXY_PORT);
+    if (!Number.isInteger(port) || port < 1 || port > 65535)
+        throw new InvalidArgumentError("Port must be 1..65535");
+    const target = resolveStatusTarget(port);
+    return createUsageClient({ baseUrl: target.baseUrl, headers: target.headers, remote: Boolean(readConfig().client), directory: USAGE_DIR,
+        initializeOffline: store => {
+            const aliases = [];
+            for (const raw of readAccountsRaw()) {
+                if (!raw || typeof raw !== "object")
+                    continue;
+                const record = raw;
+                if (typeof record.id !== "string")
+                    continue;
+                const provider = record.provider ?? "anthropic_subscription";
+                if (typeof provider === "string" && ["anthropic_subscription", "openai_subscription", "xai_subscription"].includes(provider))
+                    aliases.push({ id: record.id, provider: provider });
+            }
+            recoverAccountTransition(store, USAGE_DIR, aliases);
+            reconcileUsageAccounts(store, aliases);
+        },
+    });
+}
+export function formatUsageText(report) {
+    const { totals: t, costs: c } = report;
+    const money = (n) => n === null ? "unavailable" : `${n < 0 ? "-" : ""}$${Math.abs(n).toFixed(2)}`;
+    return [
+        `Usage ${report.period}: ${report.start.slice(0, 10)} — ${report.end.slice(0, 10)} (UTC, end exclusive)`,
+        `Tokens: ${totalTokens(t).toLocaleString("en-US")} | input ${t.input} | output ${t.output} | cache read ${t.cacheRead} | cache write ${t.cacheWrite}`,
+        `API equivalent: ${money(c.pricedApiUsd)}${c.coverage.pricingComplete ? "" : " (partial; unpriced tokens excluded)"}`,
+        `Subscription: ${money(c.subscriptionUsd)}${c.coverage.subscriptionComplete ? "" : " (partial; configure missing costs)"}`,
+        `Net savings: ${money(c.savingsUsd)}${c.savingsPercent === null ? "" : ` (${c.savingsPercent.toFixed(1)}%)`}`,
+        ...report.warnings.map(w => `Warning: ${w}`),
+    ].join("\n");
+}
+export function registerUsage(program) {
+    const usage = program.command("usage").description("Persistent token usage and API-equivalent subscription savings")
+        .option("--period <period>", "day, week, month or year", "month")
+        .option("--date <date>", "Date within the selected period (YYYY-MM-DD, UTC)")
+        .option("--provider <provider>", "Filter Claude, OpenAI or Grok (repeatable)", (value, previous = []) => [...previous, value])
+        .option("--port <port>", "Proxy port", String(PROXY_PORT))
+        .option("--json", "Output JSON without initializing the terminal UI")
+        .action(async (options) => {
+        try {
+            const query = parseUsageOptions(options);
+            const api = client(options.port);
+            if (options.json || !process.stdout.isTTY || !process.stdin.isTTY) {
+                const report = await api.query(query);
+                console.log(options.json ? JSON.stringify(report, null, 2) : formatUsageText(report));
+                return;
+            }
+            const [{ render }, { createElement }, { UsageDashboard }] = await Promise.all([import("ink"), import("react"), import("../ui/UsageDashboard.js")]);
+            const instance = render(createElement(UsageDashboard, { load: api.query, initialQuery: query }), { exitOnCtrlC: true });
+            try {
+                await instance.waitUntilExit();
+            }
+            finally {
+                if (process.stdin.isTTY)
+                    process.stdin.setRawMode(false);
+            }
+        }
+        catch (error) {
+            program.error(error instanceof Error ? error.message : "Usage query failed");
+        }
+    });
+    const subscriptions = usage.command("subscription").description("Configure effective-dated monthly USD subscription costs");
+    const guarded = (command, action) => command.action(async (...args) => {
+        try {
+            await action(...args);
+        }
+        catch (error) {
+            program.error(error instanceof Error ? error.message : "Subscription update failed");
+        }
+    });
+    const set = subscriptions.command("set <account>").description("Start a monthly USD rate; closes the previous open interval")
+        .requiredOption("--monthly-usd <amount>", "Monthly subscription cost in USD")
+        .requiredOption("--from <date>", "Effective date, YYYY-MM-DD (UTC)");
+    guarded(set, async (account, opts) => {
+        if (!/^\d+(?:\.\d+)?$/.test(opts.monthlyUsd) || !Number.isFinite(Number(opts.monthlyUsd)))
+            throw new InvalidArgumentError("Monthly USD must be a finite nonnegative amount");
+        parseUsageOptions({ date: opts.from });
+        await client(usage.opts().port).setSubscription(account, Number(opts.monthlyUsd), opts.from);
+        console.log(`Subscription cost saved for ${account}.`);
+    });
+    const end = subscriptions.command("end <account>").description("End a subscription cost interval")
+        .requiredOption("--on <date>", "Exclusive end date, YYYY-MM-DD (UTC)");
+    guarded(end, async (account, opts) => { parseUsageOptions({ date: opts.on }); await client(usage.opts().port).endSubscription(account, opts.on); console.log(`Subscription interval ended for ${account}.`); });
+    const list = subscriptions.command("list").description("List historical subscription costs").option("--json", "Output JSON");
+    guarded(list, async (opts) => {
+        const result = await client(usage.opts().port).subscriptions();
+        if (opts.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        if (!result.subscriptions.length) {
+            console.log("No subscription costs configured. Use: cc-router usage subscription set <account> --monthly-usd <amount> --from YYYY-MM-DD");
+            return;
+        }
+        for (const sub of result.subscriptions) {
+            const account = result.accounts.find(a => a.key === sub.accountKey);
+            console.log(`${account?.alias ?? sub.accountKey}${account?.retired ? " (retired)" : ""} | $${sub.monthlyUsd.toFixed(2)}/month | ${sub.from.slice(0, 10)} → ${sub.to?.slice(0, 10) ?? "ongoing"} | ${sub.accountKey}`);
+        }
+    });
+}

package/dist/cli/index.js

@@ -3,6 +3,7 @@ import { Command } from "commander";
 import { registerSetup } from "./cmd-setup.js";
 import { registerStart } from "./cmd-start.js";
 import { registerStop, registerRevert } from "./cmd-stop.js";
+import { registerUsage } from "./cmd-usage.js";
 import { registerStatus } from "./cmd-status.js";
 import { registerAccounts } from "./cmd-accounts.js";
 import { registerConfigure } from "./cmd-configure.js";
@@ -30,6 +31,7 @@ Examples:
   $ cc-router start --reconfigure# Re-ask run preferences
   $ cc-router stop               # Stop proxy (offers to remove auto-start / config)
   $ cc-router status             # Live dashboard with account stats
+  $ cc-router usage              # Persistent token usage and subscription savings
   $ cc-router models list        # List dynamically discovered provider models
   $ cc-router logs               # View proxy logs (background mode)
   $ cc-router accounts list      # Show Claude, ChatGPT, and Grok accounts
@@ -48,6 +50,7 @@ registerStart(program);
 registerStop(program);
 registerRevert(program);
 registerStatus(program);
+registerUsage(program);
 registerModels(program);
 registerAccounts(program);
 registerConfigure(program);

package/dist/config/manager.js

@@ -1,4 +1,6 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync, copyFileSync, chmodSync } from "fs";
+import { coordinateAccountWrite, withUsageRename } from "../usage/account-lifecycle.js";
+import { dirname } from "node:path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync, copyFileSync, chmodSync, openSync, fsyncSync, closeSync } from "fs";
 import { randomBytes } from "crypto";
 import { CONFIG_DIR, ACCOUNTS_PATH, CONFIG_PATH } from "./paths.js";
 import { DEFAULT_RATE_LIMITS, ACCOUNT_USER_DEFAULTS, clampPercent, withInheritedSettings } from "../proxy/types.js";
@@ -31,12 +33,30 @@ function writeFileSecureSync(path, data) {
         chmodSync(tmp, SECRET_FILE_MODE);
     }
     catch { /* best effort */ }
+    const fd = openSync(tmp, "r");
+    try {
+        fsyncFileBestEffort(fd);
+    }
+    finally {
+        closeSync(fd);
+    }
     renameSync(tmp, path);
     try {
         chmodSync(path, SECRET_FILE_MODE);
     }
     catch { /* best effort */ }
 }
+export function fsyncFileBestEffort(fd, sync = fsyncSync) {
+    try {
+        sync(fd);
+    }
+    catch (error) {
+        const code = error.code;
+        if (process.platform === "win32" && (code === "EPERM" || code === "EINVAL"))
+            return;
+        throw error;
+    }
+}
 export function accountsFileExists(path) {
     return existsSync(path ?? ACCOUNTS_PATH);
 }
@@ -63,8 +83,7 @@ export function writeAccountsAtomic(data) {
     writeAccountsAtomicToPath(ACCOUNTS_PATH, data);
 }
 function writeAccountsAtomicToPath(path, data) {
-    // accounts.json holds plaintext OAuth access + refresh tokens — owner-only.
-    writeFileSecureSync(path, JSON.stringify(data, null, 2));
+    coordinateAccountWrite(path, readRawFromPath(path), data, () => writeFileSecureSync(path, JSON.stringify(data, null, 2)));
 }
 /**
  * Replace the Anthropic records in an accounts file, leaving every other
@@ -77,16 +96,16 @@ function writeAccountsAtomicToPath(path, data) {
  * `saveOpenAIAccountsToPath`, which has always taken the path.
  */
 export function writeAnthropicAccountsPreservingOtherProviders(data, path = ACCOUNTS_PATH) {
-    ensureConfigDir();
+    mkdirSync(dirname(path), { recursive: true, mode: SECRET_DIR_MODE });
     // Read from the same file being written, or the merge would carry another
     // file's non-Anthropic records into this one.
     const existing = readRawFromPath(path);
     const nonAnthropic = existing.filter(a => a.provider !== undefined && a.provider !== "anthropic_subscription");
     writeAccountsAtomicToPath(path, [...data, ...nonAnthropic]);
 }
-export function upsertAccountRecord(record) {
-    ensureConfigDir();
-    const existing = readAccountsRaw();
+export function upsertAccountRecord(record, path = ACCOUNTS_PATH) {
+    mkdirSync(dirname(path), { recursive: true, mode: SECRET_DIR_MODE });
+    const existing = readRawFromPath(path);
     // Compare normalised providers: a Claude record written before provider
     // tags existed has none, and a strict comparison appended a tagged
     // duplicate next to it instead of replacing it.
@@ -97,15 +116,15 @@ export function upsertAccountRecord(record) {
         // A re-authentication replaces credentials, not the operator's settings.
         previous ? withInheritedSettings(record, previous) : record,
     ];
-    writeAccountsAtomicToPath(ACCOUNTS_PATH, next);
+    writeAccountsAtomicToPath(path, next);
 }
-export function removeAccountRecordById(id) {
-    ensureConfigDir();
-    const existing = readAccountsRaw();
+export function removeAccountRecordById(id, path = ACCOUNTS_PATH) {
+    mkdirSync(dirname(path), { recursive: true, mode: SECRET_DIR_MODE });
+    const existing = readRawFromPath(path);
     const removed = existing.find(a => a.id === id) ?? null;
     if (!removed)
         return null;
-    writeAccountsAtomicToPath(ACCOUNTS_PATH, existing.filter(a => a.id !== id));
+    writeAccountsAtomicToPath(path, existing.filter(a => a.id !== id));
     return removed;
 }
 /**
@@ -124,7 +143,7 @@ export function renameAccountRecordById(oldId, newId) {
         throw new Error(`An account named "${newId}" already exists`);
     }
     target.id = newId;
-    writeAccountsAtomicToPath(ACCOUNTS_PATH, existing);
+    withUsageRename(ACCOUNTS_PATH, oldId, newId, () => writeAccountsAtomicToPath(ACCOUNTS_PATH, existing));
     return target;
 }
 function normalizeAccountProvider(record) {

package/dist/config/paths.js

@@ -20,3 +20,5 @@ export const TELEMETRY_PATH = process.env["TELEMETRY_PATH"] ??
 export const PID_PATH = path.join(CONFIG_DIR, "cc-router.pid");
 // Log file — daemon stdout/stderr redirect here
 export const LOG_PATH = path.join(CONFIG_DIR, "cc-router.log");
+/** Durable usage history follows an explicit accounts file unless overridden. */
+export const USAGE_DIR = process.env["USAGE_DIR"] ?? path.join(path.dirname(ACCOUNTS_PATH), "usage");

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

@@ -74,7 +74,7 @@ export async function collectCodexResponseStream(upstream,
  *  verdict even when the read is later cut short — the catch below turns any
  *  such interruption into a generic "malformed stream" and would otherwise
  *  bury it. */
-onUpstreamFailure) {
+onUpstreamFailure, onResponse) {
     if (!upstream.ok) {
         onUpstreamFailure?.();
         const contentType = upstream.headers.get("content-type") ?? undefined;
@@ -83,7 +83,9 @@ onUpstreamFailure) {
     const contentType = upstream.headers.get("content-type") ?? "";
     if (contentType.includes("application/json")) {
         try {
-            return { kind: "json", status: upstream.status, body: await upstream.json() };
+            const body = await upstream.json();
+            onResponse?.(body);
+            return { kind: "json", status: upstream.status, body };
         }
         catch {
             return upstreamError("Malformed upstream JSON body");
@@ -97,6 +99,8 @@ onUpstreamFailure) {
     let terminalResponse;
     let failure;
     const applyEvent = (event) => {
+        if (event && typeof event === "object")
+            onResponse?.(event.response);
         const payload = terminalResponsePayload(event);
         if (payload !== undefined) {
             terminalResponse = payload;
@@ -182,13 +186,18 @@ export function usageFromTerminalEvent(event) {
  * ended in failure can still be reported (for stats/activity only) as the
  * failure it was, without altering a single byte written to the client.
  */
-export function createCodexUsageObserver() {
+export function createCodexUsageObserver(onResponse, contentType = "text/event-stream") {
     const decoder = new TextDecoder();
     let remainder = "";
+    const isJSON = contentType.includes("application/json");
+    let json = "";
+    let jsonOversized = false;
     let totals;
     let failure;
     let completed = false;
     const applyEvent = (event) => {
+        if (event && typeof event === "object")
+            onResponse?.(event.response);
         totals = usageFromTerminalEvent(event) ?? totals;
         if (typeof event !== "object" || event === null)
             return;
@@ -212,6 +221,15 @@ export function createCodexUsageObserver() {
             // frame goes uncaptured, never that the response breaks. Tolerant
             // parsing keeps the rest of the chunk's valid events.
             try {
+                if (isJSON) {
+                    if (json.length + chunk.byteLength > 20 * 1024 * 1024) {
+                        jsonOversized = true;
+                        json = "";
+                    }
+                    if (!jsonOversized)
+                        json += decoder.decode(chunk, { stream: true });
+                    return;
+                }
                 const parsed = parseSseLines(remainder + decoder.decode(chunk, { stream: true }), { tolerant: true });
                 remainder = parsed.remainder;
                 parsed.events.forEach(applyEvent);
@@ -222,6 +240,16 @@ export function createCodexUsageObserver() {
         },
         finish() {
             try {
+                if (isJSON) {
+                    if (!jsonOversized) {
+                        const body = JSON.parse(json + decoder.decode());
+                        onResponse?.(body);
+                        totals = usageFromResponseBody(body);
+                    }
+                    json = "";
+                    jsonOversized = true;
+                    return totals;
+                }
                 const tail = decoder.decode();
                 if (tail || remainder) {
                     parseSseLines(remainder + tail + "\n", { tolerant: true }).events.forEach(applyEvent);

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

@@ -1,3 +1,4 @@
+import { finishUsageAttempt, discardUsageAttempt } from "./stats.js";
 import { request as httpRequest } from "node:http";
 import { request as httpsRequest } from "node:https";
 import { createAnthropicRefreshMiddleware, createAnthropicRoutingMiddleware, extractClaudeSessionId, } from "./anthropic-routing.js";
@@ -210,7 +211,20 @@ export function mountAnthropicMessagesRoute(app, opts) {
         // the first upstream response headers arrive, then cleared for good so a
         // long-lived stream is never cut (see anthropic-proxy.ts).
         req.socket.setTimeout(opts.timeoutMs);
+        const attemptEntries = new WeakMap();
+        if (req._ccUsageEntry)
+            attemptEntries.set(route, req._ccUsageEntry);
+        const entryFor = (lease) => {
+            let entry = attemptEntries.get(lease);
+            if (!entry) {
+                entry = { ts: now(), accountId: lease.account.id, model, type: "route" };
+                opts.usageRuntime?.bind(entry, "anthropic_subscription");
+                attemptEntries.set(lease, entry);
+            }
+            return entry;
+        };
         for (let attempt = 1;; attempt++) {
+            const entry = entryFor(route);
             const account = route.account;
             const attemptStartedAt = now();
             const attemptSpan = startTelemetrySpan("provider.inference", {
@@ -222,6 +236,7 @@ export function mountAnthropicMessagesRoute(app, opts) {
             });
             /** Close this attempt's span exactly once, on the outcome it ended with. */
             const endAttempt = (outcome, extra = {}) => {
+                finishUsageAttempt(entry, false);
                 attemptSpan.annotate({
                     ...extra,
                     outcome,
@@ -246,6 +261,7 @@ export function mountAnthropicMessagesRoute(app, opts) {
                 upstream = await forwarded.response;
             }
             catch (error) {
+                finishUsageAttempt(entry, false);
                 release();
                 // A hung-up client rejects this await through the abort above. That
                 // is a cancellation, not an upstream failure — there is no client
@@ -302,7 +318,7 @@ export function mountAnthropicMessagesRoute(app, opts) {
             // binding invalidation — run before any retry decision, so the
             // re-acquisition below already sees the failed account excluded.
             const failureRouting = applyUpstreamFailureRoutingDetailed(status, upstream.headers, route, opts.sessionRouter, opts.pool, now);
-            const entry = {
+            Object.assign(entry, {
                 ts: attemptStartedAt,
                 accountId: account.id,
                 model,
@@ -313,7 +329,7 @@ export function mountAnthropicMessagesRoute(app, opts) {
                 source,
                 details: routeReasonDetails(route),
                 durationMs: now() - attemptStartedAt,
-            };
+            });
             if (status === 401) {
                 // Token invalid or expired mid-request. Forward the 401 to the client
                 // (Claude Code will retry on 401) and schedule a background refresh
@@ -365,6 +381,7 @@ export function mountAnthropicMessagesRoute(app, opts) {
                 let next;
                 try {
                     next = acquireRequestRoute(sessionHeader, res, opts.sessionRouter, context);
+                    entryFor(next.route);
                 }
                 catch (error) {
                     // Nothing eligible to fail over to — pass the failure through.
@@ -380,6 +397,7 @@ export function mountAnthropicMessagesRoute(app, opts) {
                     // Re-sending a 429 to the account that produced it would only
                     // reproduce the rate limit. The cooldown normally guarantees a
                     // different account here; if it ever does not, pass through.
+                    discardUsageAttempt(entryFor(next.route));
                     next.release();
                     next = undefined;
                 }
@@ -410,11 +428,14 @@ export function mountAnthropicMessagesRoute(app, opts) {
                         logError(failoverAccount.id, 0, `failover token refresh still pending after ${retryRefreshTimeoutMs}ms — relaying held upstream failure`);
                     }
                     if (outcome !== "refreshed") {
+                        discardUsageAttempt(entryFor(next.route));
                         next.release();
                         next = undefined;
                     }
                 }
                 if (clientGone.signal.aborted || res.writableEnded) {
+                    if (next)
+                        discardUsageAttempt(entryFor(next.route));
                     next?.release();
                     release();
                     upstream.destroy();
@@ -429,6 +450,7 @@ export function mountAnthropicMessagesRoute(app, opts) {
                         streamOutcome: "upstream_error",
                     });
                     entry.details = `${entry.details}:will-retry`;
+                    finishUsageAttempt(entry, false);
                     recordActivity(entry);
                     upstream.destroy();
                     release();
@@ -443,6 +465,7 @@ export function mountAnthropicMessagesRoute(app, opts) {
                     if (sameAccount) {
                         await retryDelay(sameAccountDelayMs, clientGone.signal);
                         if (clientGone.signal.aborted || res.writableEnded) {
+                            discardUsageAttempt(entryFor(route));
                             release();
                             return;
                         }
@@ -487,6 +510,7 @@ export function mountAnthropicMessagesRoute(app, opts) {
                 entry.type = "error";
                 entry.statusCode = 502;
                 entry.details = `${entry.details}:held-response-lost`;
+                finishUsageAttempt(entry, false);
                 recordActivity(entry);
                 release();
                 endAttempt("upstream_error", { httpStatusCode: 502, streamOutcome: "upstream_error" });
@@ -582,6 +606,7 @@ export function mountAnthropicMessagesRoute(app, opts) {
     };
     app.post("/v1/messages", requireBufferedBody, createAnthropicRoutingMiddleware({
         sessionRouter: opts.sessionRouter,
+        usageRuntime: opts.usageRuntime,
         ...(opts.onEmptyPool ? { onEmptyPool: opts.onEmptyPool } : {}),
         ...(opts.onNoEligibleAccount ? { onNoEligibleAccount: opts.onNoEligibleAccount } : {}),
         ...(opts.now ? { now: opts.now } : {}),
@@ -590,6 +615,7 @@ export function mountAnthropicMessagesRoute(app, opts) {
         refresh: opts.refresh,
         onRefreshFailure: opts.onRefreshFailure,
     }), (req, res, next) => {
-        void handler(req, res).catch(next);
+        void handler(req, res).catch(error => { if (req._ccUsageEntry)
+            finishUsageAttempt(req._ccUsageEntry, false); next(error); });
     });
 }