@cortexkit/anthropic-auth-core 1.20.0 → 1.22.0

package/dist/quota-header-feed.js

@@ -0,0 +1,279 @@
+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, QUOTA_FIELD_NAMES, } from './accounts.js';
+export const QUOTA_HEADER_FEED_SCHEMA_VERSION = 3;
+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 projectQuotaProvenance(value, presentFields) {
+    if (!value || typeof value !== 'object')
+        return undefined;
+    const candidate = value;
+    const provenance = {};
+    for (const field of QUOTA_FIELD_NAMES) {
+        if (!presentFields.has(field))
+            continue;
+        const source = candidate[field];
+        if (source === 'poll' || source === 'headers')
+            provenance[field] = source;
+    }
+    return Object.keys(provenance).length > 0 ? provenance : undefined;
+}
+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);
+    const presentFields = new Set();
+    if (fiveHour)
+        presentFields.add('five_hour');
+    if (sevenDay)
+        presentFields.add('seven_day');
+    if (typeof quota.bindingWindow === 'string') {
+        presentFields.add('bindingWindow');
+    }
+    if (typeof quota.fallbackAdvised === 'boolean') {
+        presentFields.add('fallbackAdvised');
+    }
+    if (scoped)
+        presentFields.add('scoped');
+    if (extraUsage)
+        presentFields.add('extraUsage');
+    const provenance = projectQuotaProvenance(quota.fieldSources, presentFields);
+    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 }),
+        ...(provenance && { provenance }),
+    };
+}
+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

@@ -1,3 +1,4 @@
+import { QUOTA_FIELD_NAMES, quotaFieldSource } from './accounts.js';
 const PREFIX = 'anthropic-ratelimit-unified-';
 const WINDOW_KEYS = {
     '5h': 'five_hour',
@@ -31,36 +32,90 @@ function normalizeWindow(headers, suffix, checkedAt) {
     };
 }
 export function normalizeQuotaHeaders(headers, now = Date.now()) {
+    const fieldSources = {};
+    const fallbackHeader = headers.get(`${PREFIX}fallback`);
     const snapshot = {
-        fallbackAdvised: headers.get(`${PREFIX}fallback`) === 'available',
+        fallbackAdvised: fallbackHeader === 'available',
         source: 'headers',
         checkedAt: now,
     };
     for (const [suffix, key] of Object.entries(WINDOW_KEYS)) {
         const window = normalizeWindow(headers, suffix, now);
-        if (window)
+        if (window) {
             snapshot[key] = window;
+            fieldSources[key] = 'headers';
+        }
     }
     const representativeClaim = headers.get(`${PREFIX}representative-claim`);
     if (representativeClaim) {
         snapshot.bindingWindow = representativeClaim;
         snapshot.bindingWindowSource = 'headers';
+        fieldSources.bindingWindow = 'headers';
     }
-    return snapshot;
+    if (fallbackHeader !== null)
+        fieldSources.fallbackAdvised = 'headers';
+    return {
+        ...snapshot,
+        fieldSources,
+    };
 }
 export function mergeHeaderQuotaSnapshot(existing, incoming) {
+    const { scoped: existingScoped, extraUsage: existingExtraUsage, fieldSources: existingFieldSources, ...existingWithoutPollOwnedFields } = existing ?? {};
+    const { scoped: _incomingScoped, extraUsage: _incomingExtraUsage, fieldSources: incomingFieldSources, ...incomingWithoutPollOwnedFields } = incoming;
+    const fieldSources = {};
+    for (const field of QUOTA_FIELD_NAMES) {
+        const value = field === 'scoped'
+            ? existingScoped
+            : field === 'extraUsage'
+                ? existingExtraUsage
+                : field === 'fallbackAdvised'
+                    ? incomingFieldSources?.fallbackAdvised !== undefined
+                        ? incoming.fallbackAdvised
+                        : (existing?.fallbackAdvised ?? incoming.fallbackAdvised)
+                    : field === 'bindingWindow'
+                        ? existing?.bindingWindowSource === 'poll'
+                            ? existing?.bindingWindow
+                            : (incoming.bindingWindow ?? existing?.bindingWindow)
+                        : (incoming[field] ?? existing?.[field]);
+        if (value === undefined)
+            continue;
+        const source = field === 'fallbackAdvised'
+            ? (incomingFieldSources?.fallbackAdvised ??
+                (existing?.fallbackAdvised !== undefined
+                    ? existingFieldSources
+                        ? existingFieldSources.fallbackAdvised
+                        : quotaFieldSource(existing, field)
+                    : undefined))
+            : (field === 'scoped' || field === 'extraUsage') && value !== undefined
+                ? 'poll'
+                : field === 'bindingWindow' &&
+                    existing?.bindingWindowSource === 'poll' &&
+                    existing.bindingWindow !== undefined
+                    ? 'poll'
+                    : incoming[field] !== undefined
+                        ? (incomingFieldSources?.[field] ??
+                            quotaFieldSource(incoming, field))
+                        : (existingFieldSources?.[field] ??
+                            quotaFieldSource(existing, field));
+        if (source)
+            fieldSources[field] = source;
+    }
     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 }),
+        fallbackAdvised: incomingFieldSources?.fallbackAdvised !== undefined
+            ? incoming.fallbackAdvised
+            : (existing?.fallbackAdvised ?? incoming.fallbackAdvised),
         bindingWindow: existing?.bindingWindowSource === 'poll'
             ? existing.bindingWindow
             : (incoming.bindingWindow ?? existing?.bindingWindow),
         bindingWindowSource: existing?.bindingWindowSource === 'poll'
             ? 'poll'
             : (incoming.bindingWindowSource ?? existing?.bindingWindowSource),
-        // Source tracks 5h/7d freshness; preserved scoped and credit fields remain poll-owned.
+        ...(Object.keys(fieldSources).length > 0 && { fieldSources }),
+        // Top-level source remains headers for compatibility; fieldSources records ownership after partial harvests.
         source: 'headers',
     };
 }

package/dist/quota-manager.d.ts

@@ -21,20 +21,27 @@ 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;
+    onFallbackQuotaFetched?: (accountId: string, quota: OAuthQuotaSnapshot, checkedAt: number, fetchStartedAt: number) => void;
+    onFallbackApiError?: (accountId: string, error: AccountOperationError) => 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;
@@ -42,38 +49,38 @@ export declare class QuotaManager {
     private readonly now;
     private readonly onMainQuotaFetched;
     private readonly onApiError;
+    private readonly onFallbackQuotaFetched;
+    private readonly onFallbackApiError;
     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>;
-    refreshMainWithMetadata(accessToken: string): Promise<QuotaRefreshResult>;
-    refreshFallback(accountId: string, accessToken: string): Promise<OAuthQuotaSnapshot>;
-    refreshFallbackWithMetadata(accountId: string, accessToken: string): Promise<QuotaRefreshResult>;
-    refreshAllFallbacks(accounts: OAuthAccount[]): Promise<void>;
+    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[], resolveAccessToken?: (account: OAuthAccount) => string | undefined): Promise<void>;
     /**
      * Fire-and-forget refresh. Does not await, swallows errors.
      */
     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?
@@ -87,7 +94,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.
@@ -103,12 +110,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