@byokit/usage 0.1.0 → 0.3.0

package/dist/index.js

@@ -1,118 +1,277 @@
 import { accessSync, constants, statSync } from 'node:fs';
+import { createHash } from 'node:crypto';
 import { isAbsolute, join } from 'node:path';
-import { codexUsage, providerGet } from "./providers.js";
-import { fingerprint, readJson, store } from "./store.js";
-import { codexWindows, goWindows, record, zaiWindows } from "./windows.js";
+import { claudeAuth, claudeUsage, codexUsage, customClaude, providerGet } from "./providers.js";
+import { fingerprint, readJson, store, memoryUsageStore, safeWindows, safePoll } from "./store.js";
+import { claudeWindows, codexWindows, goWindows, record, zaiWindows } from "./windows.js";
+import { codexHardLimit, codexTokenWindows, copilotWindows, grokWindows, minimaxWindows, geminiWindows, kimiWindows } from "./quota.js";
 import { UsageError } from "./types.js";
 export * from "./types.js";
+export { callLedger, normalizeTokens, priceCall } from "./calls.js";
+export { tokenLedger, memoryTokenLedgerStore, TokenLedgerError } from "./ledger.js";
+export { roomOf } from "./room.js";
+export { fingerprint, store as fileUsageStore, memoryUsageStore } from "./store.js";
+export { retryAfterMs, backoffDelayMs, memoryBackoffPolicy } from "./backoff.js";
 export { claudeWindows, codexWindows, goWindows, zaiWindows } from "./windows.js";
+export { codexHardLimit, codexTokenWindows, copilotWindows, grokWindows, minimaxWindows, geminiWindows, kimiWindows } from "./quota.js";
 export { WORDS, words, usageWords } from "./words.js";
-const validText = (v) => typeof v === 'string' && !v.includes('\0');
+const providers = ['claude', 'codex', 'opencode', 'zai', 'copilot', 'grok', 'minimax', 'gemini', 'kimi'];
+const validText = (v) => typeof v === 'string' && !v.includes('\0') && !/[\r\n]/.test(v) && v.length <= 16384;
 function validate(source) {
-    if (!record(source))
+    if (!record(source) || !providers.includes(source.provider))
         throw new UsageError();
-    if (source.provider === 'codex') {
-        if (!validText(source.bin) || !isAbsolute(source.bin) || !validText(source.home) || !isAbsolute(source.home))
+    if ('credentialsFile' in source) {
+        if (source.provider !== 'claude' || ![source.credentialsFile, ...[source.configFile, source.statuslineFile].filter((v) => v !== undefined)].every((v) => validText(v) && isAbsolute(v)))
+            throw new UsageError();
+    }
+    else if ('read' in source) {
+        if (source.provider !== 'claude' || typeof source.read !== 'function' || !validText(source.accountUuid) || !source.accountUuid || source.connected !== undefined && typeof source.connected !== 'function')
+            throw new UsageError();
+    }
+    else if ('bin' in source) {
+        if (source.provider !== 'codex' || !validText(source.bin) || !isAbsolute(source.bin) || !validText(source.home) || !isAbsolute(source.home))
             throw new UsageError();
         if (source.env !== undefined && (!record(source.env) || Object.entries(source.env).some(([k, v]) => !k || k.includes('=') || !validText(k) || !validText(v))))
             throw new UsageError();
     }
-    else if (!['opencode', 'zai'].includes(source.provider) || !validText(source.key) || source.key.length > 16384)
-        throw new UsageError();
+    else {
+        if ('key' in source && !['opencode', 'zai'].includes(source.provider) || 'access' in source && ['opencode', 'zai'].includes(source.provider))
+            throw new UsageError();
+        const credential = 'access' in source ? source.access : 'key' in source ? source.key : undefined;
+        if (!validText(credential))
+            throw new UsageError();
+        if ('access' in source && source.provider === 'codex' && (!validText(source.accountId) || !source.accountId))
+            throw new UsageError();
+    }
+    if ('origin' in source && source.origin !== undefined) {
+        try {
+            const url = new URL(source.origin);
+            if (!['https:', 'http:'].includes(url.protocol) || url.origin !== source.origin)
+                throw new Error();
+        }
+        catch {
+            throw new UsageError();
+        }
+    }
+    const fields = source;
+    for (const field of ['accountId', 'accountUuid', 'project'])
+        if (fields[field] !== undefined && (!validText(fields[field]) || !fields[field]))
+            throw new UsageError();
+}
+/** Claims provide a cache identity only; this does not authenticate or trust a token. */
+function subject(access) {
+    try {
+        const encoded = access.split('.')[1];
+        if (!encoded)
+            return undefined;
+        const claims = JSON.parse(Buffer.from(encoded, 'base64url').toString('utf8'));
+        return record(claims) && validText(claims.sub) && claims.sub ? claims.sub : undefined;
+    }
+    catch {
+        return undefined;
+    }
 }
 /** One reader owns per-account backoff and concurrent-read deduplication. */
 export function usage(options) {
-    if (!validText(options.stateDir) || !isAbsolute(options.stateDir))
+    if (options.stateDir !== undefined && (!validText(options.stateDir) || !isAbsolute(options.stateDir)))
         throw new UsageError();
-    const disk = store(options.stateDir);
+    const disk = options.store ?? (options.stateDir ? store(options.stateDir) : memoryUsageStore());
+    const transient = memoryUsageStore();
     const fp = fingerprint(options.salt ?? 'byokit/usage/account');
-    const backoff = new Map();
+    const backoffs = new Map();
     const inFlight = new Map();
     const attempts = new Map();
+    const failures = new Map();
     const now = (opts) => opts?.nowMs ?? (options.now ?? Date.now)();
     function connected(source) {
         validate(source);
-        if (source.provider !== 'codex')
-            return source.key.trim() !== '';
-        try {
-            accessSync(source.bin, constants.X_OK);
-            return statSync(source.bin).isFile();
+        if ('credentialsFile' in source)
+            return claudeAuth(source) !== undefined;
+        if ('read' in source) {
+            try {
+                return source.connected?.() ?? true;
+            }
+            catch {
+                return false;
+            }
         }
-        catch {
-            return false;
+        if ('bin' in source) {
+            try {
+                accessSync(source.bin, constants.X_OK);
+                return statSync(source.bin).isFile();
+            }
+            catch {
+                return false;
+            }
         }
+        return ('access' in source ? source.access : source.key).trim() !== '';
     }
     function account(source) {
         validate(source);
-        if (source.provider !== 'codex')
-            return source.key.trim() ? fp(source.provider, source.key) : undefined;
-        const raw = readJson(join(source.home, 'auth.json'), 64 * 1024);
-        const tokens = record(raw) && record(raw.tokens) ? raw.tokens : undefined;
-        const value = typeof tokens?.account_id === 'string' ? tokens.account_id : `codex-home\0${source.home}`;
-        return value !== '' && value.length <= 16384 ? fp('codex', value) : undefined;
+        let id;
+        if ('credentialsFile' in source)
+            id = claudeAuth(source)?.account;
+        else if ('read' in source)
+            id = source.accountUuid;
+        else if ('bin' in source) {
+            const raw = readJson(join(source.home, 'auth.json'), 64 * 1024);
+            const tokens = record(raw) && record(raw.tokens) ? raw.tokens : undefined;
+            id = typeof tokens?.account_id === 'string' ? tokens.account_id : `codex-home\0${source.home}`;
+        }
+        else
+            id = source.accountId ?? (source.provider === 'claude' ? source.accountUuid : undefined) ?? ('access' in source ? subject(source.access) : undefined);
+        return id && id.length <= 16384 ? fp(source.provider, id) : undefined;
+    }
+    function identity(source) {
+        const stable = account(source);
+        if (stable)
+            return { key: stable, stable: true };
+        // Opaque credentials without an identity can be read, but never reach an app/disk store.
+        const credential = 'access' in source ? source.access : 'key' in source ? source.key : '';
+        return { key: createHash('sha256').update(`${source.provider}\0${credential}`).digest('hex'), stable: false };
+    }
+    function windows(source, raw, clock) {
+        switch (source.provider) {
+            case 'claude': return claudeWindows(raw);
+            case 'codex': return 'bin' in source ? codexWindows(raw) : codexTokenWindows(raw, clock);
+            case 'opencode': return goWindows(record(raw) ? raw.usage : undefined);
+            case 'zai': return zaiWindows(record(raw) && record(raw.data) ? raw.data.limits : undefined);
+            case 'copilot': return copilotWindows(raw);
+            case 'grok': return grokWindows(raw);
+            case 'minimax': return minimaxWindows(raw);
+            case 'gemini': return geminiWindows(raw);
+            case 'kimi': return kimiWindows(raw, clock);
+        }
     }
-    const windows = (source, raw) => source.provider === 'codex' ? codexWindows(raw) : source.provider === 'opencode' ? goWindows(raw) : zaiWindows(raw);
     function lastKnown(source, opts) {
         if (!connected(source))
             return undefined;
-        const key = account(source);
-        if (!key)
-            return undefined;
-        const stored = disk.get(source.provider, key);
+        const id = identity(source);
         const clock = now(opts);
-        if (!stored || clock < stored.at || clock - stored.at > 86_400_000)
+        try {
+            const stored = (id.stable ? disk : transient).get(source.provider, id.key);
+            if (!stored)
+                return undefined;
+            if (!stored.limited && !stored.windows.some((w) => w.limited) && stored.at !== undefined && (clock < stored.at || clock - stored.at > 86_400_000))
+                return undefined;
+            const rows = safeWindows(source.provider, stored.windows);
+            const poll = attempts.get(`${source.provider}\0${id.key}`) ?? safePoll(stored.poll);
+            return rows.length || stored.limited ? { provider: source.provider, windows: rows, ...(stored.at !== undefined ? { at: stored.at } : {}),
+                ...(stored.limited ? { limited: true } : {}), ...(poll ? { poll, ...(poll.outcome !== 'ok' ? { code: poll.outcome } : {}) } : {}) } : undefined;
+        }
+        catch {
             return undefined;
-        const rows = windows(source, stored.raw);
-        return rows.length ? { provider: source.provider, windows: rows, at: stored.at } : undefined;
+        }
     }
     async function read(source, opts) {
         validate(source);
         const clock = now(opts);
-        const empty = (code) => ({ provider: source.provider, windows: [], at: clock, code });
+        const empty = (code) => ({ provider: source.provider, windows: [], code, poll: { at: clock, outcome: code ?? 'unavailable' } });
         if (!connected(source))
             return empty('not-connected');
-        const key = account(source);
-        if (!key)
-            return empty('not-connected');
-        const identity = `${source.provider}\0${key}`;
+        const id = identity(source);
+        const key = `${source.provider}\0${id.key}`;
         const previous = lastKnown(source, { nowMs: clock });
-        if (previous && clock - previous.at < 60_000)
+        if (previous && !previous.code && previous.at !== undefined && clock >= previous.at && clock - previous.at < 60_000)
             return previous;
-        if ((backoff.get(identity) ?? 0) > clock)
-            return previous ? { ...previous, code: 'rate-limited' } : empty('rate-limited');
-        const pending = inFlight.get(identity);
+        let until = backoffs.get(key) ?? 0;
+        try {
+            const saved = id.stable ? options.backoff?.get(source.provider, id.key) : undefined;
+            if (typeof saved === 'number' && Number.isFinite(saved))
+                until = Math.max(until, saved);
+            else if (saved && typeof saved !== 'number' && Number.isFinite(saved.untilMs) && Number.isFinite(saved.at) && ['rate-limited', 'refresh-failed', 'unavailable', 'incomplete'].includes(saved.outcome)) {
+                until = Math.max(until, saved.untilMs);
+                if (!attempts.has(key))
+                    attempts.set(key, { at: saved.at, outcome: saved.outcome, retryAt: saved.untilMs });
+                if (!failures.has(`${key}\0${saved.outcome}`) && Number.isSafeInteger(saved.failures) && saved.failures > 0)
+                    failures.set(`${key}\0${saved.outcome}`, saved.failures);
+            }
+        }
+        catch { /* keep internal backoff */ }
+        if (until > clock) {
+            const poll = attempts.get(key) ?? previous?.poll ?? { at: clock, outcome: 'unavailable', retryAt: until };
+            return { ...(previous ?? empty(poll.outcome === 'ok' ? 'unavailable' : poll.outcome)), code: poll.outcome === 'ok' ? undefined : poll.outcome, poll };
+        }
+        const pending = inFlight.get(key);
         if (pending)
             return pending;
-        const attempt = attempts.get(identity);
+        const attempt = attempts.get(key) ?? previous?.poll;
         if (attempt && clock >= attempt.at && clock - attempt.at < 60_000)
-            return previous ? { ...previous, code: attempt.answer.code } : empty(attempt.answer.code ?? 'unavailable');
+            return previous ? { ...previous, code: attempt.outcome === 'ok' ? undefined : attempt.outcome, poll: attempt } : empty(attempt.outcome === 'ok' ? 'unavailable' : attempt.outcome);
         const task = (async () => {
             let answer;
+            const pacing = { hook: options.pace, provider: source.provider, account: id.key, signal: opts?.signal };
             try {
-                answer = source.provider === 'codex' ? await codexUsage(source) : await providerGet(source, options.fetch ?? globalThis.fetch, clock);
+                answer = 'read' in source ? await customClaude(source, clock, pacing) : 'credentialsFile' in source ? await claudeUsage(source, options.fetch ?? globalThis.fetch, clock, pacing)
+                    : 'bin' in source ? await codexUsage(source) : await providerGet(source, options.fetch ?? globalThis.fetch, clock, pacing);
             }
             catch {
                 answer = { code: 'unavailable' };
             }
-            if (answer.until !== undefined)
-                backoff.set(identity, answer.until);
-            const rows = windows(source, answer.raw);
-            if (!answer.code && !rows.length)
+            const rows = safeWindows(source.provider, windows(source, answer.raw, clock));
+            const limited = !answer.code && (answer.limited === true || source.provider === 'codex' && codexHardLimit(answer.raw));
+            if (!answer.code && !rows.length && !limited)
                 answer = { code: 'incomplete' };
-            // Do not keep a source key or a raw payload in a retry map.
-            attempts.set(identity, { at: clock, answer: { code: answer.code } });
-            if (rows.length && !answer.code) {
-                disk.put(source.provider, key, { at: clock, raw: answer.raw });
-                return { provider: source.provider, windows: rows, at: clock };
+            const poll = { at: clock, outcome: answer.code ?? 'ok' };
+            if (answer.code) {
+                const failureKey = `${key}\0${answer.code}`;
+                const count = (failures.get(failureKey) ?? 0) + 1;
+                failures.set(failureKey, count);
+                if (['rate-limited', 'refresh-failed', 'unavailable', 'incomplete'].includes(answer.code)) {
+                    const retry = Number.isFinite(answer.retryAfterMs) && answer.retryAfterMs >= 0 ? answer.retryAfterMs : undefined;
+                    let delay = answer.code === 'rate-limited' ? 300_000 : Math.min(3_600_000, 60_000 * 2 ** Math.min(count - 1, 6));
+                    try {
+                        const selected = options.backoff?.delayMs?.(retry, { outcome: answer.code, failures: count });
+                        if (selected !== undefined && Number.isFinite(selected) && selected >= 0)
+                            delay = selected;
+                    }
+                    catch { /* internal policy stands */ }
+                    delay = Math.max(60_000, delay, retry ?? 0);
+                    poll.retryAt = clock + delay;
+                    backoffs.set(key, poll.retryAt);
+                    try {
+                        if (id.stable)
+                            options.backoff?.set(source.provider, id.key, poll.retryAt, { untilMs: poll.retryAt, at: clock, outcome: answer.code, failures: count });
+                    }
+                    catch { /* internal backoff stands */ }
+                }
+            }
+            else {
+                for (const outcome of ['rate-limited', 'refresh-failed', 'unavailable', 'incomplete'])
+                    failures.delete(`${key}\0${outcome}`);
+                backoffs.delete(key);
+                try {
+                    if (id.stable)
+                        options.backoff?.set(source.provider, id.key, 0);
+                }
+                catch { /* expired host policy remains bounded */ }
+            }
+            attempts.set(key, poll);
+            if ((rows.length || limited) && !answer.code) {
+                // Explicit host/snapshot time is authoritative, including unknown or future time.
+                const observed = 'at' in answer ? answer.at : clock;
+                const at = typeof observed === 'number' && Number.isFinite(observed) ? observed : undefined;
+                const reading = { provider: source.provider, windows: rows, ...(at !== undefined ? { at } : {}), ...(limited ? { limited: true } : {}), poll };
+                try {
+                    (id.stable ? disk : transient).put(source.provider, id.key, { at: reading.at, windows: rows, ...(limited ? { limited: true } : {}), poll });
+                }
+                catch { /* reads survive a store failure */ }
+                return reading;
+            }
+            if (previous) {
+                try {
+                    (id.stable ? disk : transient).put(source.provider, id.key, { at: previous.at, windows: previous.windows, ...(previous.limited ? { limited: true } : {}), poll });
+                }
+                catch { /* last-good remains in memory */ }
             }
-            return previous ? { ...previous, code: answer.code } : empty(answer.code ?? 'unavailable');
+            return { ...(previous ?? empty(answer.code ?? 'unavailable')), code: answer.code, poll };
         })();
-        inFlight.set(identity, task);
+        inFlight.set(key, task);
         try {
             return await task;
         }
         finally {
-            inFlight.delete(identity);
+            inFlight.delete(key);
         }
     }
     return { read, lastKnown, connected, account };

package/dist/ledger.d.ts

@@ -0,0 +1,49 @@
+import type { CallRecord } from './calls.ts';
+/** Counts measured tokens for a host's member; no credential, account or network access. */
+export interface TokenEntry {
+    tokens: number;
+    time: number;
+    call?: CallRecord;
+}
+export interface TokenLedgerStore {
+    record(member: string, entry: TokenEntry): void;
+    /** Entries in [from, to); the ledger checks bounds again before counting. */
+    query(member: string, from: number, to: number): readonly TokenEntry[];
+}
+export interface TokenLedgerOptions {
+    store?: TokenLedgerStore;
+    /** Seven-day token allowance. Missing means uncapped; zero means no allowance. */
+    cap?: number | ((member: string) => number | undefined);
+}
+export interface TokenQuery {
+    from: number;
+    to: number;
+    tokens: number;
+    /** Present when call records lack reported total tokens; tokens is the known subtotal. */
+    unknownCalls?: number;
+    days: {
+        date: string;
+        tokens: number;
+        unknownCalls?: number;
+    }[];
+    week: {
+        from: number;
+        to: number;
+        tokens: number;
+        cap?: number;
+        remaining?: number;
+        unknownCalls?: number;
+    };
+}
+export interface TokenLedger {
+    record(member: string, tokens: number, time: number): void;
+    query(member: string, from: number, to: number): TokenQuery;
+}
+export declare class TokenLedgerError extends Error {
+    readonly code: 'invalid' | 'store';
+    name: string;
+    constructor(code: 'invalid' | 'store');
+}
+export declare function memoryTokenLedgerStore(): TokenLedgerStore;
+/** Local calendar days, including DST changes; all API timestamps are epoch milliseconds. */
+export declare function tokenLedger(options?: TokenLedgerOptions): TokenLedger;

package/dist/ledger.js

@@ -0,0 +1,87 @@
+export class TokenLedgerError extends Error {
+    code;
+    name = 'TokenLedgerError';
+    constructor(code) { super(code === 'invalid' ? 'The app supplied an invalid token ledger value.' : 'The token ledger store did not answer.'); this.code = code; }
+}
+const validMember = (member) => typeof member === 'string' && !!member && member.length <= 1024 && !member.includes('\0');
+const validTime = (time) => typeof time === 'number' && Number.isFinite(time) && !Number.isNaN(new Date(time).getTime());
+const validCount = (tokens) => Number.isSafeInteger(tokens) && tokens >= 0;
+const dateOf = (time) => {
+    const date = new Date(time);
+    return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(date.getDate()).padStart(2, '0')}`;
+};
+export function memoryTokenLedgerStore() {
+    const entries = new Map();
+    return {
+        record: (member, entry) => { const rows = entries.get(member) ?? []; rows.push(copyEntry(entry)); entries.set(member, rows); },
+        query: (member, from, to) => (entries.get(member) ?? []).filter((entry) => entry.time >= from && entry.time < to).map(copyEntry),
+    };
+}
+/** Local calendar days, including DST changes; all API timestamps are epoch milliseconds. */
+export function tokenLedger(options = {}) {
+    const store = options.store ?? memoryTokenLedgerStore();
+    if (options.cap !== undefined && typeof options.cap !== 'function' && !validCount(options.cap))
+        throw new TokenLedgerError('invalid');
+    return {
+        record(member, tokens, time) {
+            if (!validMember(member) || !validCount(tokens) || !validTime(time))
+                throw new TokenLedgerError('invalid');
+            try {
+                store.record(member, { tokens, time });
+            }
+            catch {
+                throw new TokenLedgerError('store');
+            }
+        },
+        query(member, from, to) {
+            if (!validMember(member) || !validTime(from) || !validTime(to) || to < from)
+                throw new TokenLedgerError('invalid');
+            const start = new Date(to);
+            start.setDate(start.getDate() - 7);
+            const weekFrom = start.getTime();
+            if (!validTime(weekFrom))
+                throw new TokenLedgerError('invalid');
+            let entries;
+            let cap;
+            try {
+                entries = store.query(member, Math.min(from, weekFrom), to);
+                cap = typeof options.cap === 'function' ? options.cap(member) : options.cap;
+            }
+            catch {
+                throw new TokenLedgerError('store');
+            }
+            if (!Array.isArray(entries) || cap !== undefined && !validCount(cap))
+                throw new TokenLedgerError('invalid');
+            let tokens = 0;
+            let weekTokens = 0;
+            let unknownCalls = 0;
+            let weekUnknown = 0;
+            const days = new Map();
+            for (const entry of entries) {
+                if (!entry || !validCount(entry.tokens) || !validTime(entry.time) || entry.time >= to)
+                    continue;
+                const unknown = entry.call !== undefined && entry.call.tokens.total === undefined ? 1 : 0;
+                if (entry.time >= weekFrom) {
+                    weekTokens += entry.tokens;
+                    weekUnknown += unknown;
+                }
+                if (entry.time < from)
+                    continue;
+                tokens += entry.tokens;
+                unknownCalls += unknown;
+                const date = dateOf(entry.time);
+                const previous = days.get(date) ?? { tokens: 0, unknownCalls: 0 };
+                days.set(date, { tokens: previous.tokens + entry.tokens, unknownCalls: previous.unknownCalls + unknown });
+            }
+            if (!Number.isSafeInteger(tokens) || !Number.isSafeInteger(weekTokens))
+                throw new TokenLedgerError('invalid');
+            return { from, to, tokens, ...(unknownCalls ? { unknownCalls } : {}), days: [...days].sort(([a], [b]) => a.localeCompare(b)).map(([date, counts]) => ({ date, tokens: counts.tokens, ...(counts.unknownCalls ? { unknownCalls: counts.unknownCalls } : {}) })),
+                week: { from: weekFrom, to, tokens: weekTokens, ...(weekUnknown ? { unknownCalls: weekUnknown } : {}), ...(cap === undefined ? {} : { cap, ...(weekUnknown ? {} : { remaining: Math.max(0, cap - weekTokens) }) }) } };
+        },
+    };
+}
+function copyEntry(entry) {
+    const call = entry.call;
+    return { tokens: entry.tokens, time: entry.time, ...(call ? { call: { ...call, tokens: { ...call.tokens },
+                ...(call.cost ? { cost: { ...call.cost } } : {}), ...(call.limits ? { limits: call.limits.map((window) => ({ ...window })) } : {}) } } : {}) };
+}

package/dist/providers.d.ts

@@ -1,12 +1,41 @@
-import type { Code, Source } from './types.ts';
-export interface Answer {
-    raw?: unknown;
-    code?: Code;
-    until?: number;
-}
-export declare function providerGet(source: Extract<Source, {
+import type { Source, SourceAnswer, PacingHook } from './types.ts';
+export type Answer = SourceAnswer;
+type TokenSource = Extract<Source, {
+    access: string;
+} | {
     key: string;
-}>, fetcher: typeof fetch, nowMs: number): Promise<Answer>;
+}>;
+export declare function providerGet(source: TokenSource, fetcher: typeof fetch, nowMs: number, pacing?: {
+    hook?: PacingHook;
+    provider: Source['provider'];
+    account: string;
+    signal?: AbortSignal;
+}): Promise<Answer>;
+/** A host hook gets the same deadline and failure envelope as built-in sources. */
+export declare function customClaude(source: Extract<Source, {
+    read: unknown;
+}>, nowMs: number, pacing?: {
+    hook?: PacingHook;
+    account: string;
+    signal?: AbortSignal;
+}): Promise<Answer>;
 export declare function codexUsage(source: Extract<Source, {
-    provider: 'codex';
+    bin: string;
 }>): Promise<Answer>;
+/** Re-read the tool's credentials so its own renewal is picked up; never renew or write them. */
+export declare function claudeAuth(source: Extract<Source, {
+    credentialsFile: string;
+}>): {
+    token: string;
+    expiresAt?: number;
+    account: string;
+} | undefined;
+export declare function claudeUsage(source: Extract<Source, {
+    credentialsFile: string;
+}>, fetcher: typeof fetch, nowMs: number, pacing?: {
+    hook?: PacingHook;
+    provider: Source['provider'];
+    account: string;
+    signal?: AbortSignal;
+}): Promise<Answer>;
+export {};