@cortexkit/anthropic-auth-core 1.21.0 → 1.23.0

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

@@ -1,6 +1,13 @@
-import { type AccountStorage, type OAuthQuotaSnapshot } from './accounts.ts';
-export declare const QUOTA_HEADER_FEED_SCHEMA_VERSION = 2;
+import { type AccountStorage, type OAuthQuotaSnapshot, type QuotaFieldName, type QuotaFieldSource, type QuotaFieldSources } from './accounts.ts';
+export declare const QUOTA_HEADER_FEED_SCHEMA_VERSION = 3;
 export declare const QUOTA_HEADER_FEED_LEASE_MS = 180000;
+/**
+ * Lease files are per process; each carries only the accounts whose response
+ * headers THAT process harvested. Consumers MUST union entries across all files
+ * inside `lease_horizon_ms`, deduplicating by account; "newest file wins" is wrong.
+ * `anthropic_account_uuid` is always present: null is unresolvable, while absence
+ * identifies an old producer. A fallback `account_ref` is store-local.
+ */
 export type QuotaHeaderFeedIdentity = {
     identity_source: 'credential_id';
     credential_id: string;
@@ -10,12 +17,28 @@ export type QuotaHeaderFeedIdentity = {
 } | {
     identity_source: 'none';
 };
-export type QuotaHeaderFeedEntry = QuotaHeaderFeedIdentity & {
+export type QuotaHeaderFeedProvenance = Partial<Record<QuotaFieldName, QuotaFieldSource>>;
+type QuotaHeaderFeedQuota = Pick<OAuthQuotaSnapshot, 'five_hour' | 'seven_day' | 'bindingWindow' | 'fallbackAdvised' | 'scoped' | 'extraUsage'> & {
+    provenance?: QuotaHeaderFeedProvenance;
+};
+type QuotaHeaderFeedMetadata = {
     schema_version: typeof QUOTA_HEADER_FEED_SCHEMA_VERSION;
     provider: 'anthropic';
     configured_account_count: number;
+    /** Header observation time; merged poll-owned fields retain their own checkedAt. */
     observed_at_ms: number;
-    quota: Pick<OAuthQuotaSnapshot, 'five_hour' | 'seven_day' | 'bindingWindow' | 'fallbackAdvised' | 'scoped' | 'extraUsage'>;
+};
+export type QuotaHeaderFeedEntry = QuotaHeaderFeedIdentity & QuotaHeaderFeedMetadata & {
+    /** Always present: null means UUID resolution failed; absence denotes an old producer. */
+    anthropic_account_uuid: string | null;
+    quota: QuotaHeaderFeedQuota;
+};
+export type QuotaHeaderFeedPublishEntry = QuotaHeaderFeedIdentity & QuotaHeaderFeedMetadata & {
+    anthropic_account_uuid: string | null;
+    quota: Omit<QuotaHeaderFeedQuota, 'provenance'> & {
+        fieldSources?: QuotaFieldSources;
+    };
+    accountKey: string;
 };
 export declare function getDefaultQuotaHeaderFeedDirectory(): string;
 export declare function configuredAnthropicOAuthAccountCount(input: {
@@ -31,10 +54,12 @@ export declare class QuotaHeaderFeedRegistry {
         now?: () => number;
         leaseMs?: number;
         instanceId?: string;
+        removeFile?: (path: string) => Promise<void>;
+        beforeRemoveFile?: (path: string) => Promise<void>;
     });
-    publish(entry: QuotaHeaderFeedEntry & {
-        accountKey: string;
-    }): Promise<void>;
+    publish(entry: QuotaHeaderFeedPublishEntry): Promise<void>;
+    private reapStaleSiblingLeases;
     list(): Promise<QuotaHeaderFeedEntry[]>;
     dispose(): Promise<void>;
 }
+export {};

package/dist/quota-header-feed.js

@@ -1,9 +1,9 @@
 import { randomUUID } from 'node:crypto';
-import { chmod, mkdir, readdir, readFile, rename, rm, writeFile, } from 'node:fs/promises';
+import { chmod, lstat, mkdir, readdir, readFile, rename, rm, stat, 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;
+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 ??
@@ -22,6 +22,10 @@ function validIdentity(entry) {
         return false;
     if (!entry.quota || typeof entry.quota !== 'object')
         return false;
+    if (!Object.hasOwn(entry, 'anthropic_account_uuid') ||
+        (entry.anthropic_account_uuid !== null &&
+            typeof entry.anthropic_account_uuid !== 'string'))
+        return false;
     if (entry.identity_source === 'none') {
         return !('credential_id' in entry) && !('account_ref' in entry);
     }
@@ -129,6 +133,20 @@ function projectExtraUsage(value) {
         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);
@@ -138,6 +156,22 @@ function projectQuota(quota) {
             .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 }),
@@ -149,6 +183,7 @@ function projectQuota(quota) {
         }),
         ...(scoped && { scoped }),
         ...(extraUsage && { extraUsage }),
+        ...(provenance && { provenance }),
     };
 }
 export class QuotaHeaderFeedRegistry {
@@ -161,17 +196,33 @@ export class QuotaHeaderFeedRegistry {
         this.filePath = join(options.directory ?? getDefaultQuotaHeaderFeedDirectory(), `${instanceId}.json`);
     }
     publish(entry) {
-        const { accountKey, quota, ...entryWithoutQuota } = entry;
-        const cleanEntry = {
-            ...entryWithoutQuota,
-            quota: projectQuota(quota),
-        };
+        const { accountKey, quota } = entry;
         try {
-            validatePublishEntry(cleanEntry);
+            validatePublishEntry(entry);
         }
         catch (error) {
             return Promise.reject(error);
         }
+        const identity = entry.identity_source === 'credential_id'
+            ? {
+                identity_source: 'credential_id',
+                credential_id: entry.credential_id,
+            }
+            : entry.identity_source === 'account_ref'
+                ? {
+                    identity_source: 'account_ref',
+                    account_ref: entry.account_ref,
+                }
+                : { identity_source: 'none' };
+        const cleanEntry = {
+            ...identity,
+            schema_version: entry.schema_version,
+            provider: entry.provider,
+            configured_account_count: entry.configured_account_count,
+            observed_at_ms: entry.observed_at_ms,
+            anthropic_account_uuid: entry.anthropic_account_uuid,
+            quota: projectQuota(quota),
+        };
         if (!accountKey)
             return Promise.reject(new Error('Invalid quota header feed account key'));
         this.writeChain = this.writeChain
@@ -180,6 +231,7 @@ export class QuotaHeaderFeedRegistry {
             const directory = this.options.directory ?? getDefaultQuotaHeaderFeedDirectory();
             await mkdir(directory, { recursive: true, mode: 0o700 });
             await chmod(directory, 0o700);
+            await this.reapStaleSiblingLeases(directory);
             let entries = {};
             try {
                 const record = JSON.parse(await readFile(this.filePath, 'utf8'));
@@ -192,7 +244,7 @@ export class QuotaHeaderFeedRegistry {
             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 writeFile(tempPath, `${JSON.stringify({ version: QUOTA_HEADER_FEED_SCHEMA_VERSION, lease_horizon_ms: this.options.leaseMs ?? QUOTA_HEADER_FEED_LEASE_MS, entries })}\n`, { mode: 0o600 });
                 await chmod(tempPath, 0o600);
                 await rename(tempPath, this.filePath);
             }
@@ -202,6 +254,37 @@ export class QuotaHeaderFeedRegistry {
         });
         return this.writeChain;
     }
+    async reapStaleSiblingLeases(directory) {
+        const now = this.options.now?.() ?? Date.now();
+        const leaseMs = this.options.leaseMs ?? QUOTA_HEADER_FEED_LEASE_MS;
+        let names;
+        try {
+            names = await readdir(directory);
+        }
+        catch {
+            return;
+        }
+        await Promise.all(names
+            .filter((name) => /^\d+-[0-9a-f-]+\.json$/i.test(name))
+            .map(async (name) => {
+            const path = join(directory, name);
+            if (path === this.filePath)
+                return;
+            try {
+                const file = await stat(path);
+                if (file.mtimeMs > now || now - file.mtimeMs < leaseMs)
+                    return;
+                await this.options.beforeRemoveFile?.(path);
+                const current = await lstat(path);
+                if (current.ino !== file.ino || current.mtimeMs !== file.mtimeMs)
+                    return;
+                await (this.options.removeFile ?? ((target) => rm(target)))(path);
+            }
+            catch {
+                // A missed cleanup must not prevent this process from refreshing its lease.
+            }
+        }));
+    }
     async list() {
         await this.writeChain.catch(() => { });
         const directory = this.options.directory ?? getDefaultQuotaHeaderFeedDirectory();

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,38 +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, ...existingWithoutPollOwnedFields } = existing ?? {};
-    const { scoped: _incomingScoped, extraUsage: _incomingExtraUsage, ...incomingWithoutPollOwnedFields } = 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 {
         ...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

@@ -20,9 +20,17 @@ export type QuotaRefreshResult = {
 export type QuotaManagerOptions = {
     storage: AccountStorage | null;
     fetchImpl?: typeof fetch;
+    /** Resolve custody credentials at the actual HTTP boundary, after quota gates. */
+    fetchQuotaSnapshot?: (request: {
+        kind: 'main' | 'fallback';
+        accountId: string | undefined;
+        accessToken: string;
+    }) => Promise<OAuthQuotaSnapshot>;
     now?: () => number;
     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;
@@ -37,6 +45,8 @@ export declare class QuotaManager {
     private fallbackGenerations;
     private inflightMain;
     private inflightMainAccountId;
+    private inflightMainAccessToken;
+    private inflightMainToken;
     private inflightFallbacks;
     private mainLastApiError;
     private fallbackApiErrors;
@@ -44,9 +54,12 @@ export declare class QuotaManager {
     private lastApiCallAt;
     private storage;
     private readonly fetchImpl;
+    private readonly fetchQuotaSnapshot;
     private readonly now;
     private readonly onMainQuotaFetched;
     private readonly onApiError;
+    private readonly onFallbackQuotaFetched;
+    private readonly onFallbackApiError;
     constructor(opts: QuotaManagerOptions);
     /**
      * Cached main quota entry, scoped to the account behind the main credential.
@@ -57,10 +70,13 @@ export declare class QuotaManager {
      * Cached fallback quota entry, scoped to the configured account id.
      */
     getFallback(accountId: string, account?: Pick<OAuthAccount, 'authLineageId'>): QuotaEntry | null;
+    /** A host transport resolves scoped credentials at dispatch time. */
+    canFetchWithoutAccessToken(): boolean;
     getAllFallbacks(): Map<string, QuotaEntry>;
     setMain(mainAccountId: string | undefined, entry: QuotaEntry): void;
+    clearMain(): void;
     /** Bind quota state to the account behind the current main credential. */
-    setMainQuotaAccountIdentity(accountIdentity: string | undefined, strict?: boolean): number | undefined;
+    setMainQuotaAccountIdentity(accountIdentity: string | undefined, strict?: boolean, force?: 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;
@@ -69,7 +85,7 @@ export declare class QuotaManager {
     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>;
+    refreshAllFallbacks(accounts: OAuthAccount[], resolveAccessToken?: (account: OAuthAccount) => string | undefined): Promise<void>;
     /**
      * Fire-and-forget refresh. Does not await, swallows errors.
      */
@@ -118,6 +134,8 @@ export declare class QuotaManager {
     private static quotaLockName;
     private bindFallbackLineage;
     private acceptFallbackQuotaObservation;
+    private isClosed;
+    close(): void;
     /**
      * Serialize API calls through a shared gate so only one
      * quota API request runs at a time, with a minimum gap