@cortexkit/anthropic-auth-core 1.19.1 → 1.21.0

package/dist/quota-header-feed.d.ts

@@ -0,0 +1,40 @@
+import { type AccountStorage, type OAuthQuotaSnapshot } from './accounts.ts';
+export declare const QUOTA_HEADER_FEED_SCHEMA_VERSION = 2;
+export declare const QUOTA_HEADER_FEED_LEASE_MS = 180000;
+export type QuotaHeaderFeedIdentity = {
+    identity_source: 'credential_id';
+    credential_id: string;
+} | {
+    identity_source: 'account_ref';
+    account_ref: string;
+} | {
+    identity_source: 'none';
+};
+export type QuotaHeaderFeedEntry = QuotaHeaderFeedIdentity & {
+    schema_version: typeof QUOTA_HEADER_FEED_SCHEMA_VERSION;
+    provider: 'anthropic';
+    configured_account_count: number;
+    observed_at_ms: number;
+    quota: Pick<OAuthQuotaSnapshot, 'five_hour' | 'seven_day' | 'bindingWindow' | 'fallbackAdvised' | 'scoped' | 'extraUsage'>;
+};
+export declare function getDefaultQuotaHeaderFeedDirectory(): string;
+export declare function configuredAnthropicOAuthAccountCount(input: {
+    storage: AccountStorage | null;
+    mainOAuthConfigured: boolean;
+}): number;
+export declare class QuotaHeaderFeedRegistry {
+    private readonly options;
+    private readonly filePath;
+    private writeChain;
+    constructor(options?: {
+        directory?: string;
+        now?: () => number;
+        leaseMs?: number;
+        instanceId?: string;
+    });
+    publish(entry: QuotaHeaderFeedEntry & {
+        accountKey: string;
+    }): Promise<void>;
+    list(): Promise<QuotaHeaderFeedEntry[]>;
+    dispose(): Promise<void>;
+}

package/dist/quota-header-feed.js

@@ -0,0 +1,248 @@
+import { randomUUID } from 'node:crypto';
+import { chmod, mkdir, readdir, readFile, rename, rm, writeFile, } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { isOAuthAccount, } from './accounts.js';
+export const QUOTA_HEADER_FEED_SCHEMA_VERSION = 2;
+export const QUOTA_HEADER_FEED_LEASE_MS = 180_000;
+export function getDefaultQuotaHeaderFeedDirectory() {
+    return (process.env.OPENCODE_ANTHROPIC_AUTH_QUOTA_FEED_DIR ??
+        join(tmpdir(), 'opencode-anthropic-auth', 'quota-header-feed'));
+}
+export function configuredAnthropicOAuthAccountCount(input) {
+    const fallbackCount = input.storage?.accounts.filter(isOAuthAccount).length ?? 0;
+    return fallbackCount + (input.mainOAuthConfigured ? 1 : 0);
+}
+function validIdentity(entry) {
+    if (entry.schema_version !== QUOTA_HEADER_FEED_SCHEMA_VERSION ||
+        entry.provider !== 'anthropic')
+        return false;
+    if (!Number.isFinite(entry.configured_account_count) ||
+        !Number.isFinite(entry.observed_at_ms))
+        return false;
+    if (!entry.quota || typeof entry.quota !== 'object')
+        return false;
+    if (entry.identity_source === 'none') {
+        return !('credential_id' in entry) && !('account_ref' in entry);
+    }
+    if (entry.identity_source === 'credential_id') {
+        return (typeof entry.credential_id === 'string' &&
+            entry.credential_id.length > 0 &&
+            entry.credential_id !== 'main' &&
+            !('account_ref' in entry));
+    }
+    if (entry.identity_source === 'account_ref') {
+        return (typeof entry.account_ref === 'string' &&
+            entry.account_ref.length > 0 &&
+            entry.account_ref !== 'main' &&
+            !('credential_id' in entry));
+    }
+    return false;
+}
+function validatePublishEntry(entry) {
+    if (entry.schema_version !== QUOTA_HEADER_FEED_SCHEMA_VERSION ||
+        entry.provider !== 'anthropic' ||
+        !validIdentity(entry)) {
+        throw new Error('Invalid quota header feed entry');
+    }
+}
+function finiteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value);
+}
+function projectQuotaWindow(value) {
+    if (!value || typeof value !== 'object')
+        return undefined;
+    const candidate = value;
+    if (!finiteNumber(candidate.usedPercent) ||
+        !finiteNumber(candidate.remainingPercent) ||
+        !finiteNumber(candidate.checkedAt)) {
+        return undefined;
+    }
+    return {
+        usedPercent: candidate.usedPercent,
+        remainingPercent: candidate.remainingPercent,
+        ...(typeof candidate.resetsAt === 'string' && {
+            resetsAt: candidate.resetsAt,
+        }),
+        checkedAt: candidate.checkedAt,
+    };
+}
+function projectScopedQuotaWindow(value) {
+    if (!value || typeof value !== 'object')
+        return undefined;
+    const candidate = value;
+    const window = projectQuotaWindow(candidate);
+    if (!window ||
+        typeof candidate.id !== 'string' ||
+        !candidate.id.trim() ||
+        typeof candidate.title !== 'string' ||
+        !candidate.title.trim() ||
+        typeof candidate.modelName !== 'string' ||
+        !candidate.modelName.trim()) {
+        return undefined;
+    }
+    return {
+        ...window,
+        id: candidate.id,
+        title: candidate.title,
+        ...(typeof candidate.modelId === 'string' &&
+            candidate.modelId.trim() && {
+            modelId: candidate.modelId,
+        }),
+        modelName: candidate.modelName,
+    };
+}
+function projectQuotaMoney(value) {
+    if (!value || typeof value !== 'object')
+        return undefined;
+    const candidate = value;
+    if (!finiteNumber(candidate.amountMinor) ||
+        typeof candidate.currency !== 'string' ||
+        !candidate.currency.trim() ||
+        !finiteNumber(candidate.exponent)) {
+        return undefined;
+    }
+    return {
+        amountMinor: candidate.amountMinor,
+        currency: candidate.currency,
+        exponent: candidate.exponent,
+    };
+}
+function projectExtraUsage(value) {
+    if (!value || typeof value !== 'object')
+        return undefined;
+    const candidate = value;
+    const used = projectQuotaMoney(candidate.used);
+    const limit = projectQuotaMoney(candidate.limit);
+    if (!used || !limit || typeof candidate.exhausted !== 'boolean') {
+        return undefined;
+    }
+    return {
+        used,
+        limit,
+        ...(finiteNumber(candidate.utilizationPercent) && {
+            utilizationPercent: candidate.utilizationPercent,
+        }),
+        ...(typeof candidate.severity === 'string' && {
+            severity: candidate.severity,
+        }),
+        exhausted: candidate.exhausted,
+    };
+}
+function projectQuota(quota) {
+    const fiveHour = projectQuotaWindow(quota.five_hour);
+    const sevenDay = projectQuotaWindow(quota.seven_day);
+    const scoped = Array.isArray(quota.scoped)
+        ? quota.scoped
+            .map(projectScopedQuotaWindow)
+            .filter((entry) => entry != null)
+        : undefined;
+    const extraUsage = projectExtraUsage(quota.extraUsage);
+    return {
+        ...(fiveHour && { five_hour: fiveHour }),
+        ...(sevenDay && { seven_day: sevenDay }),
+        ...(typeof quota.bindingWindow === 'string' && {
+            bindingWindow: quota.bindingWindow,
+        }),
+        ...(typeof quota.fallbackAdvised === 'boolean' && {
+            fallbackAdvised: quota.fallbackAdvised,
+        }),
+        ...(scoped && { scoped }),
+        ...(extraUsage && { extraUsage }),
+    };
+}
+export class QuotaHeaderFeedRegistry {
+    options;
+    filePath;
+    writeChain = Promise.resolve();
+    constructor(options = {}) {
+        this.options = options;
+        const instanceId = options.instanceId ?? `${process.pid}-${randomUUID()}`;
+        this.filePath = join(options.directory ?? getDefaultQuotaHeaderFeedDirectory(), `${instanceId}.json`);
+    }
+    publish(entry) {
+        const { accountKey, quota, ...entryWithoutQuota } = entry;
+        const cleanEntry = {
+            ...entryWithoutQuota,
+            quota: projectQuota(quota),
+        };
+        try {
+            validatePublishEntry(cleanEntry);
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+        if (!accountKey)
+            return Promise.reject(new Error('Invalid quota header feed account key'));
+        this.writeChain = this.writeChain
+            .catch(() => { })
+            .then(async () => {
+            const directory = this.options.directory ?? getDefaultQuotaHeaderFeedDirectory();
+            await mkdir(directory, { recursive: true, mode: 0o700 });
+            await chmod(directory, 0o700);
+            let entries = {};
+            try {
+                const record = JSON.parse(await readFile(this.filePath, 'utf8'));
+                if (record.version === QUOTA_HEADER_FEED_SCHEMA_VERSION &&
+                    record.entries &&
+                    typeof record.entries === 'object')
+                    entries = record.entries;
+            }
+            catch { }
+            entries[accountKey] = cleanEntry;
+            const tempPath = `${this.filePath}.${randomUUID()}.tmp`;
+            try {
+                await writeFile(tempPath, `${JSON.stringify({ version: QUOTA_HEADER_FEED_SCHEMA_VERSION, entries })}\n`, { mode: 0o600 });
+                await chmod(tempPath, 0o600);
+                await rename(tempPath, this.filePath);
+            }
+            finally {
+                await rm(tempPath, { force: true });
+            }
+        });
+        return this.writeChain;
+    }
+    async list() {
+        await this.writeChain.catch(() => { });
+        const directory = this.options.directory ?? getDefaultQuotaHeaderFeedDirectory();
+        const now = this.options.now?.() ?? Date.now();
+        const leaseMs = this.options.leaseMs ?? QUOTA_HEADER_FEED_LEASE_MS;
+        let names;
+        try {
+            names = (await readdir(directory)).filter((name) => name.endsWith('.json'));
+        }
+        catch {
+            return [];
+        }
+        const newest = new Map();
+        await Promise.all(names.map(async (name) => {
+            try {
+                const record = JSON.parse(await readFile(join(directory, name), 'utf8'));
+                if (record.version !== QUOTA_HEADER_FEED_SCHEMA_VERSION ||
+                    !record.entries ||
+                    typeof record.entries !== 'object')
+                    return;
+                for (const [accountKey, candidate] of Object.entries(record.entries)) {
+                    if (!candidate ||
+                        typeof candidate !== 'object' ||
+                        candidate.schema_version !== QUOTA_HEADER_FEED_SCHEMA_VERSION ||
+                        candidate.provider !== 'anthropic' ||
+                        !validIdentity(candidate))
+                        continue;
+                    const observed = candidate.observed_at_ms;
+                    if (observed > now || now - observed >= leaseMs)
+                        continue;
+                    const existing = newest.get(accountKey);
+                    if (!existing || observed > existing.observed_at_ms)
+                        newest.set(accountKey, candidate);
+                }
+            }
+            catch { }
+        }));
+        return [...newest.values()].sort((a, b) => a.observed_at_ms - b.observed_at_ms);
+    }
+    async dispose() {
+        await this.writeChain.catch(() => { });
+        await rm(this.filePath, { force: true });
+    }
+}

package/dist/quota-headers.js

@@ -49,11 +49,13 @@ export function normalizeQuotaHeaders(headers, now = Date.now()) {
     return snapshot;
 }
 export function mergeHeaderQuotaSnapshot(existing, incoming) {
+    const { scoped: existingScoped, extraUsage: existingExtraUsage, ...existingWithoutPollOwnedFields } = existing ?? {};
+    const { scoped: _incomingScoped, extraUsage: _incomingExtraUsage, ...incomingWithoutPollOwnedFields } = incoming;
     return {
-        ...existing,
-        ...incoming,
-        scoped: existing && 'scoped' in existing ? existing.scoped : undefined,
-        extraUsage: existing?.extraUsage,
+        ...existingWithoutPollOwnedFields,
+        ...incomingWithoutPollOwnedFields,
+        ...(Array.isArray(existingScoped) && { scoped: existingScoped }),
+        ...(existingExtraUsage != null && { extraUsage: existingExtraUsage }),
         bindingWindow: existing?.bindingWindowSource === 'poll'
             ? existing.bindingWindow
             : (incoming.bindingWindow ?? existing?.bindingWindow),

package/dist/quota-manager.d.ts

@@ -12,24 +12,34 @@ export type QuotaEntry = {
     refreshAfter: number;
     checkedAt: number;
 };
+export type QuotaRefreshResult = {
+    quota: OAuthQuotaSnapshot;
+    /** False when backoff or a cross-process lock served the existing cache. */
+    fetched: boolean;
+};
 export type QuotaManagerOptions = {
     storage: AccountStorage | null;
     fetchImpl?: typeof fetch;
     now?: () => number;
-    onMainQuotaFetched?: (quota: OAuthQuotaSnapshot, checkedAt: number, tokenFingerprint: string, fetchStartedAt: number) => void;
-    onApiError?: (error: AccountOperationError) => void;
+    onMainQuotaFetched?: (quota: OAuthQuotaSnapshot, checkedAt: number, tokenFingerprint: string, fetchStartedAt: number, quotaErrorGeneration: number, quotaErrorClearedAt: number | undefined) => void;
+    onApiError?: (error: AccountOperationError, quotaErrorGeneration: number) => void;
 };
 export declare class QuotaManager {
     private main;
-    private mainTokenFp;
+    private mainAccountId;
+    private mainQuotaIdentityKnown;
+    private mainQuotaIdentityStrict;
+    private mainGeneration;
+    private mainQuotaErrorGeneration;
+    private mainQuotaErrorClearedAt;
     private fallbacks;
-    private fallbackTokenFps;
+    private fallbackAuthLineages;
+    private fallbackGenerations;
     private inflightMain;
-    private inflightMainFp;
+    private inflightMainAccountId;
     private inflightFallbacks;
     private mainLastApiError;
     private fallbackApiErrors;
-    private fallbackErrorTokenFps;
     private apiGate;
     private lastApiCallAt;
     private storage;
@@ -39,26 +49,26 @@ export declare class QuotaManager {
     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.
+     * Cached main quota entry, scoped to the account behind the main credential.
+     * An unresolved identity keeps a retained cache unverified rather than exposing it.
      */
-    getMain(accessToken?: string): QuotaEntry | null;
+    getMain(mainAccountId?: 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.
+     * Cached fallback quota entry, scoped to the configured account id.
      */
-    getFallback(accountId: string, accessToken?: string): QuotaEntry | null;
+    getFallback(accountId: string, account?: Pick<OAuthAccount, 'authLineageId'>): QuotaEntry | null;
     getAllFallbacks(): Map<string, QuotaEntry>;
-    setMain(accessToken: string, entry: QuotaEntry): void;
-    setFallback(accountId: string, entry: QuotaEntry, accessToken?: string): void;
-    pushMainFromHeaders(accessToken: string, incoming: OAuthQuotaSnapshot): QuotaEntry;
-    pushFallbackFromHeaders(accountId: string, accessToken: string, incoming: OAuthQuotaSnapshot): QuotaEntry;
-    refreshMain(accessToken: string): Promise<OAuthQuotaSnapshot>;
-    refreshFallback(accountId: string, accessToken: string): Promise<OAuthQuotaSnapshot>;
+    setMain(mainAccountId: string | undefined, entry: QuotaEntry): void;
+    /** Bind quota state to the account behind the current main credential. */
+    setMainQuotaAccountIdentity(accountIdentity: string | undefined, strict?: boolean): number | undefined;
+    setFallback(accountId: string, entry: QuotaEntry, account: Pick<OAuthAccount, 'authLineageId'> | undefined): void;
+    clearFallback(accountId: string): void;
+    pushMainFromHeaders(mainAccountId: string | undefined, incoming: OAuthQuotaSnapshot): QuotaEntry;
+    pushFallbackFromHeaders(accountId: string, incoming: OAuthQuotaSnapshot, account: Pick<OAuthAccount, 'authLineageId'> | undefined): QuotaEntry | null;
+    refreshMain(mainAccountIdOrAccessToken: string | undefined, accessToken?: string, expectedIdentityGeneration?: number): Promise<OAuthQuotaSnapshot>;
+    refreshMainWithMetadata(mainAccountIdOrAccessToken: string | undefined, accessToken?: string, expectedIdentityGeneration?: number): Promise<QuotaRefreshResult>;
+    refreshFallback(accountId: string, accessToken: string, account: Pick<OAuthAccount, 'authLineageId'> | undefined): Promise<OAuthQuotaSnapshot>;
+    refreshFallbackWithMetadata(accountId: string, accessToken: string, account: Pick<OAuthAccount, 'authLineageId'> | undefined): Promise<QuotaRefreshResult>;
     refreshAllFallbacks(accounts: OAuthAccount[]): Promise<void>;
     /**
      * Fire-and-forget refresh. Does not await, swallows errors.
@@ -66,7 +76,7 @@ export declare class QuotaManager {
     refreshMainInBackground(accessToken: string): void;
     private scopedWindowIsStale;
     isMainStale(modelId?: string): boolean;
-    isFallbackStale(accountId: string, accessToken?: string, modelId?: string): boolean;
+    isFallbackStale(accountId: string, _accessToken?: string, modelId?: string, account?: Pick<OAuthAccount, 'authLineageId'>): boolean;
     shouldRefreshOnRequestCount(requestCount: number): boolean;
     /**
      * Combined check: should a refresh happen right now?
@@ -80,7 +90,7 @@ export declare class QuotaManager {
      * can stop this process from showing "checking…" or making a redundant quota
      * API call.
      */
-    seedMainFromStorage(storage: AccountStorage | null, accessToken?: string): void;
+    seedMainFromStorage(storage: AccountStorage | null, mainAccountId?: string): void;
     private seedMainBackoffFromStorage;
     /**
      * Seed fallback cache entries from persisted account.quota data.
@@ -96,12 +106,18 @@ export declare class QuotaManager {
     /**
      * Whether a specific fallback account's quota API is in backoff.
      */
-    isFallbackBackedOff(accountId: string, accessToken?: string): boolean;
+    isFallbackBackedOff(accountId: string): boolean;
     getLastApiError(): AccountOperationError | undefined;
+    getMainQuotaErrorGeneration(): number;
+    getMainQuotaIdentityGeneration(): number;
+    getMainQuotaErrorClearedAt(): number | undefined;
+    clearMainBackoff(): number | undefined;
     /** Minimum gap between consecutive quota API calls (ms). */
     private static readonly API_CALL_GAP_MS;
     private static fallbackInflightKey;
     private static quotaLockName;
+    private bindFallbackLineage;
+    private acceptFallbackQuotaObservation;
     /**
      * Serialize API calls through a shared gate so only one
      * quota API request runs at a time, with a minimum gap