@cortexkit/anthropic-auth-core 1.4.1 → 1.6.0

package/dist/killswitch.js

@@ -0,0 +1,127 @@
+import { DEFAULT_KILLSWITCH_THRESHOLDS as DEFAULT_THRESHOLDS } from "./accounts.js";
+export const KILLSWITCH_COMMAND_NAME = 'claude-killswitch';
+export function parseKillswitchCommandAction(argumentsText) {
+    const parts = argumentsText.trim().split(/\s+/).filter(Boolean);
+    if (parts.length === 0)
+        return { type: 'status' };
+    if (parts.length === 1 && parts[0] === 'on')
+        return { type: 'on' };
+    if (parts.length === 1 && parts[0] === 'off')
+        return { type: 'off' };
+    if (parts[0] === 'set') {
+        const entries = [];
+        for (let i = 1; i < parts.length; i++) {
+            const match = parts[i]?.match(/^([^:]+):(\d+),(\d+)$/);
+            if (!match)
+                return { type: 'usage' };
+            const [, account, fhStr, sdStr] = match;
+            entries.push({
+                account,
+                fh: Number.parseInt(fhStr, 10),
+                sd: Number.parseInt(sdStr, 10),
+            });
+        }
+        if (entries.length === 0)
+            return { type: 'usage' };
+        return { type: 'set', entries };
+    }
+    return { type: 'usage' };
+}
+function buildStatusTable(config, accountIds) {
+    const enabled = config.enabled === true;
+    const lines = [
+        '## Killswitch',
+        '',
+        `Status: **${enabled ? 'ON' : 'OFF'}**`,
+    ];
+    if (enabled) {
+        lines.push('');
+        lines.push('| Account | 5h threshold | 1w threshold |');
+        lines.push('| ------- | ------------ | ------------ |');
+        const mainT = config.main ?? {};
+        const fh = mainT.five_hour ?? mainT['5h'] ?? DEFAULT_THRESHOLDS.five_hour;
+        const sd = mainT.seven_day ?? mainT['1w'] ?? DEFAULT_THRESHOLDS.seven_day;
+        lines.push(`| main | \u2265 ${fh}% | \u2265 ${sd}% |`);
+        for (const id of accountIds) {
+            const t = config.accounts?.[id] ?? config.main ?? {};
+            const afh = t.five_hour ?? t['5h'] ?? DEFAULT_THRESHOLDS.five_hour;
+            const asd = t.seven_day ?? t['1w'] ?? DEFAULT_THRESHOLDS.seven_day;
+            lines.push(`| ${id} | \u2265 ${afh}% | \u2265 ${asd}% |`);
+        }
+    }
+    return lines.join('\n');
+}
+const USAGE_TEXT = [
+    '## Killswitch Commands',
+    '',
+    '```',
+    `/${KILLSWITCH_COMMAND_NAME}              — show status`,
+    `/${KILLSWITCH_COMMAND_NAME} on           — enable with current or default thresholds`,
+    `/${KILLSWITCH_COMMAND_NAME} off          — disable`,
+    `/${KILLSWITCH_COMMAND_NAME} set all:5,10 — set all accounts to 5h≥5%, 1w≥10%`,
+    `/${KILLSWITCH_COMMAND_NAME} set main:3,8 work-alt:5,10 — per-account`,
+    '```',
+].join('\n');
+export function executeKillswitchCommand(input) {
+    const action = parseKillswitchCommandAction(input.argumentsText);
+    if (action.type === 'status') {
+        const status = buildStatusTable(input.config, input.accountIds);
+        return { text: `${status}\n\n${USAGE_TEXT}` };
+    }
+    if (action.type === 'on') {
+        const updated = {
+            ...input.config,
+            enabled: true,
+            main: input.config.main ?? {
+                five_hour: DEFAULT_THRESHOLDS.five_hour,
+                seven_day: DEFAULT_THRESHOLDS.seven_day,
+            },
+        };
+        const status = buildStatusTable(updated, input.accountIds);
+        return {
+            text: `## Killswitch Enabled\n\n${status}`,
+            updatedConfig: updated,
+        };
+    }
+    if (action.type === 'off') {
+        const updated = { ...input.config, enabled: false };
+        return {
+            text: '## Killswitch Disabled',
+            updatedConfig: updated,
+        };
+    }
+    if (action.type === 'set') {
+        const accounts = { ...(input.config.accounts ?? {}) };
+        const updated = {
+            ...input.config,
+            enabled: true,
+            accounts,
+        };
+        for (const entry of action.entries) {
+            const thresholds = {
+                five_hour: entry.fh,
+                seven_day: entry.sd,
+            };
+            if (entry.account === 'main') {
+                updated.main = thresholds;
+            }
+            else if (entry.account === 'all') {
+                updated.main = thresholds;
+                for (const id of input.accountIds) {
+                    accounts[id] = thresholds;
+                }
+            }
+            else {
+                accounts[entry.account] = thresholds;
+            }
+        }
+        const status = buildStatusTable(updated, input.accountIds);
+        return {
+            text: `## Killswitch Updated\n\n${status}`,
+            updatedConfig: updated,
+        };
+    }
+    // usage
+    const status = buildStatusTable(input.config, input.accountIds);
+    return { text: `${status}\n\n${USAGE_TEXT}` };
+}

package/dist/quota-manager.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Unified quota cache and API gateway.
+ *
+ * Single source of truth for main + fallback quota state. All consumers
+ * share one QuotaManager instance so they see the same in-memory cache.
+ * Handles deduplication, rate-limiting (429 backoff), and staleness.
+ */
+import type { AccountOperationError, AccountStorage, OAuthAccount, OAuthQuotaSnapshot } from './accounts.ts';
+/**
+ * Stable, non-reversible fingerprint of an access token. Used to detect a
+ * main-account switch so a different account's persisted/cached quota is never
+ * reused. Not a secret — a truncated SHA-256, safe to persist alongside quota.
+ */
+export declare function tokenFingerprint(token: string): string;
+export type QuotaEntry = {
+    quota: OAuthQuotaSnapshot;
+    refreshAfter: number;
+    checkedAt: number;
+};
+export type QuotaManagerOptions = {
+    storage: AccountStorage | null;
+    fetchImpl?: typeof fetch;
+    now?: () => number;
+    onMainQuotaFetched?: (quota: OAuthQuotaSnapshot, checkedAt: number, tokenFingerprint: string) => void;
+    onApiError?: (error: AccountOperationError) => void;
+};
+export declare class QuotaManager {
+    private main;
+    private mainTokenFp;
+    private fallbacks;
+    private fallbackTokenFps;
+    private inflightMain;
+    private inflightFallbacks;
+    private mainLastApiError;
+    private fallbackApiErrors;
+    private fallbackErrorTokenFps;
+    private apiGate;
+    private lastApiCallAt;
+    private storage;
+    private readonly fetchImpl;
+    private readonly now;
+    private readonly onMainQuotaFetched;
+    private readonly onApiError;
+    constructor(opts: QuotaManagerOptions);
+    /**
+     * Cached main quota entry. Pass the live access token to enforce token
+     * binding: if the cached entry was produced by a different token (main
+     * account switched), it is dropped and null is returned so the caller
+     * refetches for the current account. Called without a token (e.g. for
+     * display) it returns whatever is cached.
+     */
+    getMain(accessToken?: string): QuotaEntry | null;
+    /**
+     * Cached fallback quota entry. Pass the live access token to enforce token
+     * binding: if the entry was produced by a different token (account re-login),
+     * it is dropped and null is returned so the caller refetches.
+     */
+    getFallback(accountId: string, accessToken?: string): QuotaEntry | null;
+    getAllFallbacks(): Map<string, QuotaEntry>;
+    setMain(accessToken: string, entry: QuotaEntry): void;
+    setFallback(accountId: string, entry: QuotaEntry, accessToken?: string): void;
+    refreshMain(accessToken: string): Promise<OAuthQuotaSnapshot>;
+    refreshFallback(accountId: string, accessToken: string): Promise<OAuthQuotaSnapshot>;
+    refreshAllFallbacks(accounts: OAuthAccount[]): Promise<void>;
+    /**
+     * Fire-and-forget refresh. Does not await, swallows errors.
+     */
+    refreshMainInBackground(accessToken: string): void;
+    isMainStale(): boolean;
+    isFallbackStale(accountId: string, accessToken?: string): boolean;
+    shouldRefreshOnRequestCount(requestCount: number): boolean;
+    /**
+     * Combined check: should a refresh happen right now?
+     * True if main is stale by time OR triggered by request count.
+     */
+    needsRefresh(requestCount: number): boolean;
+    updateStorage(storage: AccountStorage | null): void;
+    /**
+     * Seed fallback cache entries from persisted account.quota data.
+     * Only seeds accounts that don't already have a cache entry.
+     * Prevents unnecessary API calls when persisted quota is still fresh.
+     */
+    seedFallbacksFromAccounts(accounts: OAuthAccount[]): void;
+    /**
+     * Whether the MAIN quota API is currently in backoff. Scoped to the main
+     * account — a fallback account's 429 never reports here.
+     */
+    isBackedOff(): boolean;
+    /**
+     * Whether a specific fallback account's quota API is in backoff.
+     */
+    isFallbackBackedOff(accountId: string, accessToken?: string): boolean;
+    getLastApiError(): AccountOperationError | undefined;
+    /** Minimum gap between consecutive quota API calls (ms). */
+    private static readonly API_CALL_GAP_MS;
+    private static fallbackInflightKey;
+    /**
+     * Serialize API calls through a shared gate so only one
+     * quota API request runs at a time, with a minimum gap
+     * between calls. Prevents concurrent and rapid-fire calls
+     * from triggering Anthropic's rate limits.
+     */
+    private _enqueueApiFetch;
+    private _fetchMain;
+    private _fetchFallback;
+    private static isAuthError;
+    /** Main quota failure: arms main-only backoff and persists via onApiError. */
+    private _handleMainFetchError;
+    /**
+     * Fallback quota failure: arms backoff for THIS account only. Never touches
+     * main backoff state and never calls onApiError (which persists the main
+     * quota error) — the per-account error is recorded by the caller via the
+     * account's lastQuotaRefreshError.
+     */
+    private _handleFallbackFetchError;
+}

package/dist/quota-manager.js

@@ -0,0 +1,432 @@
+/**
+ * Unified quota cache and API gateway.
+ *
+ * Single source of truth for main + fallback quota state. All consumers
+ * share one QuotaManager instance so they see the same in-memory cache.
+ * Handles deduplication, rate-limiting (429 backoff), and staleness.
+ */
+import { createHash } from 'node:crypto';
+import { acquireRefreshFileLock, buildQuotaOperationError, fetchOAuthQuotaSnapshot, getPersistedMainQuota, getQuotaCheckIntervalMs, getQuotaNextRefreshAt, getQuotaRefreshEveryNRequests, quotaBackoffActive, } from "./accounts.js";
+// Capture real setTimeout before tests can mock globalThis.setTimeout
+const nativeSetTimeout = globalThis.setTimeout;
+/**
+ * Stable, non-reversible fingerprint of an access token. Used to detect a
+ * main-account switch so a different account's persisted/cached quota is never
+ * reused. Not a secret — a truncated SHA-256, safe to persist alongside quota.
+ */
+export function tokenFingerprint(token) {
+    return createHash('sha256').update(token).digest('hex').slice(0, 16);
+}
+// ---------------------------------------------------------------------------
+// Class
+// ---------------------------------------------------------------------------
+export class QuotaManager {
+    // --- State ---
+    main = null;
+    mainTokenFp = null;
+    fallbacks = new Map();
+    // Fingerprint of the access token that produced each fallback cache entry, so
+    // a re-login (credential change) for the same account id invalidates the
+    // stale entry instead of being treated as fresh.
+    fallbackTokenFps = new Map();
+    // --- Inflight deduplication ---
+    inflightMain = null;
+    inflightFallbacks = new Map();
+    // --- Rate-limiting (scoped per route so a fallback 429 never backs off the
+    // main account or vice versa) ---
+    mainLastApiError = undefined;
+    fallbackApiErrors = new Map();
+    fallbackErrorTokenFps = new Map();
+    // --- Serial API gate (prevents concurrent quota API calls) ---
+    apiGate = Promise.resolve();
+    lastApiCallAt = 0;
+    // --- Config ---
+    storage;
+    fetchImpl;
+    now;
+    onMainQuotaFetched;
+    onApiError;
+    constructor(opts) {
+        this.storage = opts.storage;
+        this.fetchImpl = opts.fetchImpl ?? fetch;
+        this.now = opts.now ?? Date.now;
+        this.onMainQuotaFetched = opts.onMainQuotaFetched;
+        this.onApiError = opts.onApiError;
+        // Seed main quota from persisted storage, bound to the token fingerprint
+        // that produced it. refreshMain() drops this seed if the live token's
+        // fingerprint differs (main-account switch), preventing stale wrong-account
+        // quota from being served during backoff.
+        const persisted = getPersistedMainQuota(opts.storage);
+        if (persisted) {
+            this.main = {
+                quota: persisted.quota,
+                refreshAfter: getQuotaNextRefreshAt(persisted.quota, opts.storage, persisted.checkedAt),
+                checkedAt: persisted.checkedAt,
+            };
+            this.mainTokenFp = persisted.tokenFingerprint ?? null;
+        }
+        // Seed backoff state from persisted storage
+        const persistedError = opts.storage?.quota?.mainLastQuotaApiError;
+        if (persistedError && quotaBackoffActive(persistedError, this.now())) {
+            this.mainLastApiError = persistedError;
+        }
+    }
+    // =========================================================================
+    // Get (synchronous, from cache)
+    // =========================================================================
+    /**
+     * Cached main quota entry. Pass the live access token to enforce token
+     * binding: if the cached entry was produced by a different token (main
+     * account switched), it is dropped and null is returned so the caller
+     * refetches for the current account. Called without a token (e.g. for
+     * display) it returns whatever is cached.
+     */
+    getMain(accessToken) {
+        if (accessToken &&
+            this.main &&
+            this.mainTokenFp &&
+            this.mainTokenFp !== tokenFingerprint(accessToken)) {
+            this.main = null;
+            this.mainTokenFp = null;
+        }
+        return this.main;
+    }
+    /**
+     * Cached fallback quota entry. Pass the live access token to enforce token
+     * binding: if the entry was produced by a different token (account re-login),
+     * it is dropped and null is returned so the caller refetches.
+     */
+    getFallback(accountId, accessToken) {
+        const entry = this.fallbacks.get(accountId) ?? null;
+        if (!accessToken || !entry)
+            return entry;
+        const fp = this.fallbackTokenFps.get(accountId);
+        if (fp !== tokenFingerprint(accessToken)) {
+            this.fallbacks.delete(accountId);
+            this.fallbackTokenFps.delete(accountId);
+            return null;
+        }
+        return entry;
+    }
+    getAllFallbacks() {
+        return this.fallbacks;
+    }
+    // =========================================================================
+    // Set (manual inject — seeding from persisted account.quota on boot)
+    // =========================================================================
+    setMain(accessToken, entry) {
+        this.mainTokenFp = tokenFingerprint(accessToken);
+        this.main = entry;
+    }
+    setFallback(accountId, entry, accessToken) {
+        this.fallbacks.set(accountId, entry);
+        if (accessToken) {
+            this.fallbackTokenFps.set(accountId, tokenFingerprint(accessToken));
+        }
+        else {
+            this.fallbackTokenFps.delete(accountId);
+        }
+    }
+    // =========================================================================
+    // Refresh (async, deduplicated, rate-limited)
+    // =========================================================================
+    async refreshMain(accessToken) {
+        // If the main account/token changed, invalidate the cache (including a
+        // persisted seed) BEFORE the backoff short-circuit so a different account's
+        // stale quota is never returned while the quota API is backed off.
+        const fp = tokenFingerprint(accessToken);
+        if (this.mainTokenFp && this.mainTokenFp !== fp) {
+            this.main = null;
+            this.mainTokenFp = null;
+        }
+        // Deduplicate — return in-flight promise if already fetching
+        if (this.inflightMain)
+            return this.inflightMain;
+        // Rate-limit — if API recently 429'd, return stale or throw
+        if (this.isBackedOff()) {
+            if (this.main)
+                return this.main.quota;
+            throw new Error('Quota API rate-limited — try again later');
+        }
+        this.inflightMain = this._fetchMain(accessToken);
+        return this.inflightMain;
+    }
+    async refreshFallback(accountId, accessToken) {
+        // Deduplicate per account+token so a same-label re-login never joins a
+        // quota probe that was started with the previous credentials.
+        const inflightKey = QuotaManager.fallbackInflightKey(accountId, accessToken);
+        const inflight = this.inflightFallbacks.get(inflightKey);
+        if (inflight)
+            return inflight;
+        // Rate-limit — scoped to THIS fallback account only
+        if (this.isFallbackBackedOff(accountId, accessToken)) {
+            const cached = this.getFallback(accountId, accessToken);
+            if (cached)
+                return cached.quota;
+            throw new Error('Quota API rate-limited — try again later');
+        }
+        const promise = this._fetchFallback(accountId, accessToken);
+        this.inflightFallbacks.set(inflightKey, promise);
+        return promise;
+    }
+    async refreshAllFallbacks(accounts) {
+        const now = this.now();
+        for (const account of accounts) {
+            if (account.enabled === false)
+                continue;
+            if (!account.access)
+                continue;
+            const cached = this.getFallback(account.id, account.access);
+            if (cached && now < cached.refreshAfter)
+                continue;
+            try {
+                await this.refreshFallback(account.id, account.access);
+            }
+            catch {
+                // Best-effort — keep stale cache entry if fetch fails
+            }
+        }
+    }
+    /**
+     * Fire-and-forget refresh. Does not await, swallows errors.
+     */
+    refreshMainInBackground(accessToken) {
+        if (this.inflightMain)
+            return;
+        if (this.isBackedOff())
+            return;
+        void this.refreshMain(accessToken).catch(() => { });
+    }
+    // =========================================================================
+    // Staleness queries
+    // =========================================================================
+    isMainStale() {
+        if (!this.main)
+            return true;
+        return this.now() >= this.main.refreshAfter;
+    }
+    isFallbackStale(accountId, accessToken) {
+        // Token-aware: a credential change invalidates the entry (treated as stale).
+        const entry = this.getFallback(accountId, accessToken);
+        if (!entry)
+            return true;
+        return this.now() >= entry.refreshAfter;
+    }
+    shouldRefreshOnRequestCount(requestCount) {
+        const everyN = getQuotaRefreshEveryNRequests(this.storage);
+        if (everyN <= 0)
+            return false;
+        return requestCount > 0 && requestCount % everyN === 0;
+    }
+    /**
+     * Combined check: should a refresh happen right now?
+     * True if main is stale by time OR triggered by request count.
+     */
+    needsRefresh(requestCount) {
+        return this.isMainStale() || this.shouldRefreshOnRequestCount(requestCount);
+    }
+    // =========================================================================
+    // Config
+    // =========================================================================
+    updateStorage(storage) {
+        this.storage = storage;
+    }
+    /**
+     * Seed fallback cache entries from persisted account.quota data.
+     * Only seeds accounts that don't already have a cache entry.
+     * Prevents unnecessary API calls when persisted quota is still fresh.
+     */
+    seedFallbacksFromAccounts(accounts) {
+        const checkInterval = getQuotaCheckIntervalMs(this.storage);
+        for (const account of accounts) {
+            if (account.enabled === false)
+                continue;
+            if (this.getFallback(account.id, account.access))
+                continue;
+            if (!account.quota)
+                continue;
+            const checkedAt = Math.max(account.quota.five_hour?.checkedAt ?? 0, account.quota.seven_day?.checkedAt ?? 0);
+            if (checkedAt <= 0)
+                continue;
+            this.setFallback(account.id, {
+                quota: account.quota,
+                refreshAfter: checkedAt + checkInterval,
+                checkedAt,
+            }, account.access);
+        }
+    }
+    /**
+     * Whether the MAIN quota API is currently in backoff. Scoped to the main
+     * account — a fallback account's 429 never reports here.
+     */
+    isBackedOff() {
+        return quotaBackoffActive(this.mainLastApiError, this.now());
+    }
+    /**
+     * Whether a specific fallback account's quota API is in backoff.
+     */
+    isFallbackBackedOff(accountId, accessToken) {
+        if (accessToken) {
+            const errorFp = this.fallbackErrorTokenFps.get(accountId);
+            if (errorFp !== tokenFingerprint(accessToken))
+                return false;
+        }
+        return quotaBackoffActive(this.fallbackApiErrors.get(accountId), this.now());
+    }
+    getLastApiError() {
+        return this.mainLastApiError;
+    }
+    // =========================================================================
+    // Private
+    // =========================================================================
+    /** Minimum gap between consecutive quota API calls (ms). */
+    static API_CALL_GAP_MS = 1_000;
+    static fallbackInflightKey(accountId, accessToken) {
+        return JSON.stringify([accountId, tokenFingerprint(accessToken)]);
+    }
+    /**
+     * Serialize API calls through a shared gate so only one
+     * quota API request runs at a time, with a minimum gap
+     * between calls. Prevents concurrent and rapid-fire calls
+     * from triggering Anthropic's rate limits.
+     */
+    _enqueueApiFetch(fn) {
+        const gatedFn = async () => {
+            // Wait until minimum gap since last API call
+            const elapsed = this.now() - this.lastApiCallAt;
+            if (elapsed < QuotaManager.API_CALL_GAP_MS) {
+                await new Promise((r) => {
+                    const id = nativeSetTimeout(r, QuotaManager.API_CALL_GAP_MS - elapsed);
+                    if (typeof id === 'object' && 'unref' in id)
+                        id.unref();
+                });
+            }
+            this.lastApiCallAt = this.now();
+            return fn();
+        };
+        const queued = this.apiGate.then(gatedFn, gatedFn);
+        this.apiGate = queued.catch(() => { });
+        return queued;
+    }
+    async _fetchMain(accessToken) {
+        return this._enqueueApiFetch(async () => {
+            try {
+                // Re-check backoff inside gate — may have been set by
+                // a preceding queued call while we waited
+                if (this.isBackedOff()) {
+                    if (this.main)
+                        return this.main.quota;
+                    throw new Error('Quota API rate-limited — try again later');
+                }
+                const fileLock = await acquireRefreshFileLock({
+                    name: 'opencode-main-quota-refresh',
+                    ttlMs: 30_000,
+                });
+                if (!fileLock) {
+                    if (this.main)
+                        return this.main.quota;
+                    throw new Error('Quota refresh is already in progress');
+                }
+                try {
+                    const quota = await fetchOAuthQuotaSnapshot({
+                        accessToken,
+                        fetchImpl: this.fetchImpl,
+                        now: this.now,
+                    });
+                    const now = this.now();
+                    this.mainTokenFp = tokenFingerprint(accessToken);
+                    this.main = {
+                        quota,
+                        refreshAfter: getQuotaNextRefreshAt(quota, this.storage, now),
+                        checkedAt: now,
+                    };
+                    this.mainLastApiError = undefined;
+                    this.onMainQuotaFetched?.(quota, now, this.mainTokenFp);
+                    return quota;
+                }
+                catch (error) {
+                    this._handleMainFetchError(error);
+                    throw error;
+                }
+                finally {
+                    await fileLock.release();
+                }
+            }
+            finally {
+                this.inflightMain = null;
+            }
+        });
+    }
+    async _fetchFallback(accountId, accessToken) {
+        return this._enqueueApiFetch(async () => {
+            try {
+                // Re-check backoff inside gate — scoped to this fallback account
+                if (this.isFallbackBackedOff(accountId, accessToken)) {
+                    const cached = this.getFallback(accountId, accessToken);
+                    if (cached)
+                        return cached.quota;
+                    throw new Error('Quota API rate-limited — try again later');
+                }
+                const quota = await fetchOAuthQuotaSnapshot({
+                    accessToken,
+                    fetchImpl: this.fetchImpl,
+                    now: this.now,
+                });
+                const now = this.now();
+                this.setFallback(accountId, {
+                    quota,
+                    refreshAfter: now + getQuotaCheckIntervalMs(this.storage),
+                    checkedAt: now,
+                }, accessToken);
+                this.fallbackApiErrors.delete(accountId);
+                this.fallbackErrorTokenFps.delete(accountId);
+                return quota;
+            }
+            catch (error) {
+                this._handleFallbackFetchError(accountId, accessToken, error);
+                throw error;
+            }
+            finally {
+                this.inflightFallbacks.delete(QuotaManager.fallbackInflightKey(accountId, accessToken));
+            }
+        });
+    }
+    // A 401 is an auth/token problem, not a rate limit. The caller refreshes the
+    // token and retries; backing off the quota API here would block that retry,
+    // so surface 401s without recording backoff state.
+    static isAuthError(error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return /quota check failed: 401\b/.test(message);
+    }
+    /** Main quota failure: arms main-only backoff and persists via onApiError. */
+    _handleMainFetchError(error) {
+        if (QuotaManager.isAuthError(error))
+            return;
+        this.mainLastApiError = buildQuotaOperationError({
+            error,
+            now: this.now(),
+            previous: this.mainLastApiError,
+        });
+        this.onApiError?.(this.mainLastApiError);
+    }
+    /**
+     * Fallback quota failure: arms backoff for THIS account only. Never touches
+     * main backoff state and never calls onApiError (which persists the main
+     * quota error) — the per-account error is recorded by the caller via the
+     * account's lastQuotaRefreshError.
+     */
+    _handleFallbackFetchError(accountId, accessToken, error) {
+        if (QuotaManager.isAuthError(error))
+            return;
+        const tokenFp = tokenFingerprint(accessToken);
+        const previous = this.fallbackErrorTokenFps.get(accountId) === tokenFp
+            ? this.fallbackApiErrors.get(accountId)
+            : undefined;
+        this.fallbackApiErrors.set(accountId, buildQuotaOperationError({
+            error,
+            now: this.now(),
+            previous,
+        }));
+        this.fallbackErrorTokenFps.set(accountId, tokenFp);
+    }
+}