@byokit/usage 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,69 +1,153 @@
+import { backoffDelayMs } from "./backoff.js";
 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 } from "./store.js";
+import { claudeWindows, codexWindows, goWindows, record, zaiWindows } from "./windows.js";
+import { 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 { 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();
+    }
+    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 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);
+            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 || !Number.isFinite(stored.at) || clock < stored.at || clock - stored.at > 86_400_000)
+                return undefined;
+            const rows = safeWindows(source.provider, stored.windows);
+            return rows.length ? { provider: source.provider, windows: rows, at: stored.at } : 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);
@@ -71,48 +155,68 @@ export function usage(options) {
         const empty = (code) => ({ provider: source.provider, windows: [], at: clock, code });
         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)
             return previous;
-        if ((backoff.get(identity) ?? 0) > clock)
+        let until = backoffs.get(key) ?? 0;
+        try {
+            if (id.stable)
+                until = Math.max(until, options.backoff?.get(source.provider, id.key) ?? 0);
+        }
+        catch { /* keep internal backoff */ }
+        if (until > clock)
             return previous ? { ...previous, code: 'rate-limited' } : empty('rate-limited');
-        const pending = inFlight.get(identity);
+        const pending = inFlight.get(key);
         if (pending)
             return pending;
-        const attempt = attempts.get(identity);
+        const attempt = attempts.get(key);
         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.code } : empty(attempt.code ?? 'unavailable');
         const task = (async () => {
             let answer;
             try {
-                answer = source.provider === 'codex' ? await codexUsage(source) : await providerGet(source, options.fetch ?? globalThis.fetch, clock);
+                answer = 'read' in source ? await customClaude(source, clock) : 'credentialsFile' in source ? await claudeUsage(source, options.fetch ?? globalThis.fetch, clock)
+                    : 'bin' in source ? await codexUsage(source) : await providerGet(source, options.fetch ?? globalThis.fetch, clock);
             }
             catch {
                 answer = { code: 'unavailable' };
             }
-            if (answer.until !== undefined)
-                backoff.set(identity, answer.until);
-            const rows = windows(source, answer.raw);
+            if (answer.code === 'rate-limited') {
+                let delay = backoffDelayMs(answer.retryAfterMs);
+                try {
+                    const selected = options.backoff?.delayMs?.(answer.retryAfterMs);
+                    if (selected !== undefined && Number.isFinite(selected) && selected >= 0)
+                        delay = selected;
+                }
+                catch { /* default */ }
+                backoffs.set(key, clock + delay);
+                try {
+                    if (id.stable)
+                        options.backoff?.set(source.provider, id.key, clock + delay);
+                }
+                catch { /* internal backoff stands */ }
+            }
+            const rows = safeWindows(source.provider, windows(source, answer.raw, clock));
             if (!answer.code && !rows.length)
                 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 } });
+            attempts.set(key, { at: clock, code: answer.code });
             if (rows.length && !answer.code) {
-                disk.put(source.provider, key, { at: clock, raw: answer.raw });
+                try {
+                    (id.stable ? disk : transient).put(source.provider, id.key, { at: clock, windows: rows });
+                }
+                catch { /* reads survive a store failure */ }
                 return { provider: source.provider, windows: rows, at: clock };
             }
             return previous ? { ...previous, code: answer.code } : empty(answer.code ?? 'unavailable');
         })();
-        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

@@ -2,11 +2,30 @@ import type { Code, Source } from './types.ts';
 export interface Answer {
     raw?: unknown;
     code?: Code;
-    until?: number;
+    retryAfterMs?: number;
 }
-export declare function providerGet(source: Extract<Source, {
+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): 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): 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): Promise<Answer>;
+export {};

package/dist/providers.js

@@ -1,17 +1,21 @@
+import { retryAfterMs } from "./backoff.js";
 import { spawn } from 'node:child_process';
-import { record } from "./windows.js";
-export async function providerGet(source, fetcher, nowMs) {
+import { readJson, readJsonSnapshot } from "./store.js";
+import { claudeWindows, record } from "./windows.js";
+import { grokWindows } from "./quota.js";
+const USER_AGENT = 'byokit/usage/0.2.0';
+/** One bounded request; credentials and response bodies never become errors. */
+async function request(url, key, fetcher, nowMs, extra = {}) {
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), 10_000);
     try {
-        const url = source.provider === 'opencode' ? 'https://opencode.ai/zen/go/v1/usage' : 'https://api.z.ai/api/monitor/usage/quota/limit';
-        const response = await fetcher(url, { headers: { accept: 'application/json', authorization: `Bearer ${source.key}` }, redirect: 'error', signal: controller.signal });
+        const response = await fetcher(url, { headers: { accept: 'application/json', authorization: `Bearer ${key}`, 'User-Agent': USER_AGENT,
+                ...(extra.body !== undefined ? { 'content-type': 'application/json' } : {}), ...extra.headers },
+            ...(extra.body !== undefined ? { method: 'POST', body: JSON.stringify(extra.body) } : {}), redirect: 'error', signal: controller.signal });
         if (response.status === 429) {
-            const retry = response.headers.get('retry-after');
-            const seconds = Number(retry);
-            const delay = retry !== null && Number.isFinite(seconds) ? seconds * 1000 : Date.parse(retry ?? '') - nowMs;
+            const delay = retryAfterMs(response.headers.get('retry-after'), nowMs);
             controller.abort();
-            return { code: 'rate-limited', until: nowMs + Math.max(300_000, Number.isFinite(delay) ? delay : 0) };
+            return { code: 'rate-limited', retryAfterMs: delay };
         }
         if (response.status !== 200) {
             controller.abort();
@@ -40,11 +44,60 @@ export async function providerGet(source, fetcher, nowMs) {
         catch {
             return { code: 'incomplete' };
         }
-        if (!record(raw))
-            return { code: 'incomplete' };
-        if (source.provider === 'zai' && raw.success === false)
-            return { code: 'no-plan' };
-        return { raw: source.provider === 'opencode' ? raw.usage : record(raw.data) ? raw.data.limits : undefined };
+        return record(raw) ? { raw } : { code: 'incomplete' };
+    }
+    catch {
+        return { code: 'unavailable' };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export async function providerGet(source, fetcher, nowMs) {
+    const key = 'access' in source ? source.access : source.key;
+    const get = (url, extra) => request(url, key, fetcher, nowMs, extra);
+    switch (source.provider) {
+        case 'claude': return get('https://api.anthropic.com/api/oauth/usage', { headers: { 'anthropic-beta': 'oauth-2025-04-20' } });
+        case 'codex': return get('https://chatgpt.com/backend-api/wham/usage', { headers: { 'ChatGPT-Account-Id': source.accountId } });
+        case 'copilot': return get('https://api.github.com/copilot_internal/user');
+        case 'minimax': {
+            const answer = await get('https://api.minimax.io/v1/token_plan/remains');
+            return !answer.code && record(answer.raw) && record(answer.raw.base_resp) && answer.raw.base_resp.status_code !== 0 ? { code: 'no-plan' } : answer;
+        }
+        case 'kimi': return get('https://api.kimi.com/coding/v1/usages');
+        case 'grok': {
+            const answer = await get('https://cli-chat-proxy.grok.com/v1/billing?format=credits');
+            if (answer.code)
+                return answer;
+            const config = record(answer.raw) && record(answer.raw.config) ? answer.raw.config : undefined;
+            return config?.isUnifiedBillingUser === true || !grokWindows(answer.raw).length ? get('https://cli-chat-proxy.grok.com/v1/billing') : answer;
+        }
+        case 'gemini': {
+            let project = source.project;
+            if (!project) {
+                const loaded = await get('https://cloudcode-pa.googleapis.com/v1internal:loadCodeAssist', { body: { metadata: { ideType: 'IDE_UNSPECIFIED', platform: 'PLATFORM_UNSPECIFIED', pluginType: 'GEMINI' } } });
+                if (loaded.code)
+                    return loaded;
+                const value = record(loaded.raw) ? loaded.raw.cloudaicompanionProject : undefined;
+                project = typeof value === 'string' ? value : record(value) && typeof value.id === 'string' ? value.id : undefined;
+            }
+            return get('https://cloudcode-pa.googleapis.com/v1internal:retrieveUserQuota', { body: project ? { project } : {} });
+        }
+        case 'opencode': return get('https://opencode.ai/zen/go/v1/usage');
+        case 'zai': {
+            const answer = await get('https://api.z.ai/api/monitor/usage/quota/limit');
+            return !answer.code && record(answer.raw) && answer.raw.success === false ? { code: 'no-plan' } : answer;
+        }
+    }
+}
+/** A host hook gets the same deadline and failure envelope as built-in sources. */
+export async function customClaude(source, nowMs) {
+    const controller = new AbortController();
+    let timer;
+    try {
+        return await Promise.race([source.read({ nowMs, signal: controller.signal }), new Promise((resolve) => {
+                timer = setTimeout(() => { controller.abort(); resolve({ code: 'unavailable' }); }, 10_000);
+            })]);
     }
     catch {
         return { code: 'unavailable' };
@@ -107,3 +160,28 @@ export function codexUsage(source) {
         child.stdin.write(`${JSON.stringify({ id: 1, method: 'initialize', params: { clientInfo: { name: 'byokit', version: '1' } } })}\n`);
     });
 }
+/** Re-read the tool's credentials so its own renewal is picked up; never renew or write them. */
+export function claudeAuth(source) {
+    const stored = readJson(source.credentialsFile, 64 * 1024);
+    const credentials = record(stored) && record(stored.claudeAiOauth) ? stored.claudeAiOauth : undefined;
+    const token = credentials?.accessToken;
+    if (!credentials || typeof token !== 'string' || !token.trim() || token.length > 16384 || token.includes('\0'))
+        return undefined;
+    const config = source.configFile ? readJson(source.configFile, 4 * 1024 * 1024) : undefined;
+    const oauthAccount = record(config) && record(config.oauthAccount) ? config.oauthAccount : undefined;
+    const identity = typeof credentials.accountUuid === 'string' ? credentials.accountUuid : typeof oauthAccount?.accountUuid === 'string' ? oauthAccount.accountUuid : `claude-file\0${source.credentialsFile}`;
+    if (typeof identity !== 'string' || !identity || identity.length > 16384)
+        return undefined;
+    return { token, account: identity, ...(typeof credentials.expiresAt === 'number' && Number.isFinite(credentials.expiresAt) ? { expiresAt: credentials.expiresAt } : {}) };
+}
+export async function claudeUsage(source, fetcher, nowMs) {
+    const snapshot = source.statuslineFile ? readJsonSnapshot(source.statuslineFile, 64 * 1024) : undefined;
+    if (snapshot && nowMs >= snapshot.modified && nowMs - snapshot.modified < 300_000 && claudeWindows(snapshot.value).length)
+        return { raw: snapshot.value };
+    const auth = claudeAuth(source);
+    if (!auth)
+        return { code: 'not-connected' };
+    if (auth.expiresAt !== undefined && auth.expiresAt <= nowMs)
+        return { code: 'expired' };
+    return providerGet({ provider: 'claude', access: auth.token }, fetcher, nowMs);
+}

package/dist/quota.d.ts

@@ -0,0 +1,7 @@
+import type { Window } from './types.ts';
+export declare function codexTokenWindows(raw: unknown): Window[];
+export declare function copilotWindows(raw: unknown): Window[];
+export declare function grokWindows(raw: unknown): Window[];
+export declare function minimaxWindows(raw: unknown): Window[];
+export declare function geminiWindows(raw: unknown): Window[];
+export declare function kimiWindows(raw: unknown, nowMs: number): Window[];