@cortexkit/anthropic-auth-core 1.9.2 → 1.9.3

package/dist/accounts.js

@@ -289,6 +289,46 @@ function accountRuntimeState(account) {
         quota: account.quota,
     });
 }
+function quotaSnapshotCheckedAt(quota) {
+    return Math.max(quota?.five_hour?.checkedAt ?? 0, quota?.seven_day?.checkedAt ?? 0);
+}
+function mergeAccountRuntimeState(existing, incoming) {
+    if (!isRecord(existing))
+        return incoming;
+    const existingEntry = existing;
+    const existingQuotaCheckedAt = quotaSnapshotCheckedAt(existingEntry.quota);
+    const incomingQuotaCheckedAt = quotaSnapshotCheckedAt(incoming.quota);
+    if (existingQuotaCheckedAt > incomingQuotaCheckedAt) {
+        const tokenChanged = Boolean(existingEntry.access &&
+            incoming.access &&
+            existingEntry.access !== incoming.access);
+        const existingRefreshAt = existingEntry.lastRefreshedAt ?? 0;
+        const incomingRefreshAt = incoming.lastRefreshedAt ?? 0;
+        if (tokenChanged && incomingRefreshAt <= existingRefreshAt) {
+            const merged = { ...existingEntry };
+            if (typeof incoming.lastUsed === 'number' &&
+                (!(typeof existingEntry.lastUsed === 'number') ||
+                    incoming.lastUsed > existingEntry.lastUsed)) {
+                merged.lastUsed = incoming.lastUsed;
+            }
+            return merged;
+        }
+        return {
+            ...existingEntry,
+            ...incoming,
+            quota: existingEntry.quota,
+            lastQuotaRefreshError: existingEntry.lastQuotaRefreshError,
+        };
+    }
+    const merged = { ...existingEntry, ...incoming };
+    if (!('lastQuotaRefreshError' in incoming)) {
+        delete merged.lastQuotaRefreshError;
+    }
+    if (!('lastRefreshError' in incoming)) {
+        delete merged.lastRefreshError;
+    }
+    return merged;
+}
 function configFromStorage(storage) {
     const refresh = storage.refresh
         ? objectWithDefinedEntries({
@@ -361,6 +401,14 @@ export async function saveAccounts(storage, path = getAccountStoragePath()) {
 }
 function applyMainQuotaStatePatch(state, storage) {
     state.main = state.main ?? {};
+    const existingCheckedAt = typeof state.main.quotaCheckedAt === 'number'
+        ? state.main.quotaCheckedAt
+        : quotaSnapshotCheckedAt(state.main.quota);
+    const incomingCheckedAt = typeof storage.quota?.mainQuotaCheckedAt === 'number'
+        ? storage.quota.mainQuotaCheckedAt
+        : quotaSnapshotCheckedAt(storage.quota?.mainQuota);
+    if (existingCheckedAt > incomingCheckedAt)
+        return;
     state.main.quota = storage.quota?.mainQuota;
     state.main.quotaCheckedAt = storage.quota?.mainQuotaCheckedAt;
     state.main.quotaToken = storage.quota?.mainQuotaToken;
@@ -402,7 +450,7 @@ export async function saveAccountState(storage, path = getAccountStoragePath(),
         for (const account of storage.accounts) {
             if (ids && !ids.has(account.id))
                 continue;
-            next.accounts[account.id] = accountRuntimeState(account);
+            next.accounts[account.id] = mergeAccountRuntimeState(next.accounts[account.id], accountRuntimeState(account));
         }
         if (ids) {
             for (const id of ids) {
@@ -876,15 +924,18 @@ function tokenNeedsRefresh(account, storage, now) {
         !account.expires ||
         account.expires - now <= refreshBeforeExpiryMs(storage));
 }
-function quotaIsStale(account, storage, now) {
+function quotaSnapshotIsFresh(quota, storage, now) {
     if (!quotaEnabled(storage))
-        return false;
+        return true;
     const maxAge = getQuotaCheckIntervalMs(storage);
-    return ['five_hour', 'seven_day'].some((key) => {
-        const window = account.quota?.[key];
-        return !window || now - window.checkedAt >= maxAge;
+    return ['five_hour', 'seven_day'].every((key) => {
+        const window = quota?.[key];
+        return Boolean(window && now - window.checkedAt < maxAge);
     });
 }
+function quotaIsStale(account, storage, now) {
+    return !quotaSnapshotIsFresh(account.quota, storage, now);
+}
 function cachedQuotaWindowStillRelevant(window, now) {
     if (!window)
         return false;
@@ -1012,13 +1063,14 @@ export class FallbackAccountManager {
     seedFallbackQuota(account, storage) {
         if (!this.quotaManager)
             return;
-        if (this.quotaManager.getFallback(account.id, account.access))
-            return;
         if (!account.quota)
             return;
         const checkedAt = Math.max(account.quota.five_hour?.checkedAt ?? 0, account.quota.seven_day?.checkedAt ?? 0);
         if (checkedAt <= 0)
             return;
+        const existing = this.quotaManager.getFallback(account.id, account.access);
+        if (existing && existing.checkedAt >= checkedAt)
+            return;
         const checkInterval = getQuotaCheckIntervalMs(storage);
         this.quotaManager.setFallback(account.id, {
             quota: account.quota,
@@ -1402,6 +1454,7 @@ export class FallbackAccountManager {
                 fetchImpl: this.fetchImpl,
                 now: this.now,
             });
+        const fetchStartedAt = this.now();
         try {
             target.quota = await fetchSnapshot(target.access);
         }
@@ -1417,6 +1470,24 @@ export class FallbackAccountManager {
             // 401 does not arm QuotaManager backoff, so this retry proceeds.
             target.quota = await fetchSnapshot(target.access);
         }
+        const latestStorage = await this.load();
+        const latestAccount = latestStorage?.accounts.find((candidate) => candidate.id === target.id && isOAuthAccount(candidate));
+        if (latestStorage &&
+            latestAccount &&
+            latestAccount.access !== target.access) {
+            this.seedFallbackQuota(latestAccount, latestStorage);
+            updateStoredAccount(storage, latestAccount);
+            return latestAccount;
+        }
+        if (latestStorage &&
+            latestAccount?.access === target.access &&
+            latestAccount.quota &&
+            quotaSnapshotCheckedAt(latestAccount.quota) >= fetchStartedAt &&
+            quotaSnapshotIsFresh(latestAccount.quota, latestStorage, this.now())) {
+            this.seedFallbackQuota(latestAccount, latestStorage);
+            updateStoredAccount(storage, latestAccount);
+            return latestAccount;
+        }
         target.lastQuotaRefreshError = undefined;
         updateStoredAccount(storage, target);
         // Sync to shared QuotaManager so all consumers see the same cache. The

package/dist/dump.d.ts

@@ -1,3 +1,4 @@
+type DumpHeaders = ConstructorParameters<typeof Headers>[0];
 export declare const CLAUDE_DUMP_COMMAND_NAME = "claude-dump";
 export type DumpCommandAction = {
     type: 'status';
@@ -20,6 +21,16 @@ export declare function executeDumpCommand(input: {
     argumentsText: string;
     enabled?: boolean;
 }): string;
+export declare function dumpDirectRequest(input: {
+    affinity?: string | null;
+    route?: string;
+    status?: number;
+    error?: string;
+    bodyText: string;
+    url?: string;
+    method?: string;
+    headers?: DumpHeaders;
+}): Promise<void>;
 export declare function dumpRelayRequest(input: {
     affinity: string;
     transport: 'http' | 'websocket';
@@ -31,3 +42,4 @@ export declare function dumpRelayRequest(input: {
     payload: unknown;
     relayBytes: number;
 }): Promise<void>;
+export {};

package/dist/dump.js

@@ -14,6 +14,8 @@ const DUMP_DIR_ENV = 'OPENCODE_ANTHROPIC_AUTH_DUMP_DIR';
 const DEFAULT_DUMP_DIR = join(tmpdir(), 'opencode-anthropic-auth-dumps');
 let dumpEnabled = false;
 let nextDumpId = 0;
+const DIRECT_DUMP_PREVIOUS_BODY_LIMIT = 100;
+const directDumpPreviousBodies = new Map();
 export function isDumpEnabled() {
     return dumpEnabled;
 }
@@ -22,6 +24,8 @@ export function setDumpEnabled(enabled) {
 }
 export function resetDumpState() {
     dumpEnabled = false;
+    nextDumpId = 0;
+    directDumpPreviousBodies.clear();
 }
 export function getDumpDirectory() {
     return process.env[DUMP_DIR_ENV] || DEFAULT_DUMP_DIR;
@@ -44,7 +48,7 @@ export function buildDumpStatusSummary(input) {
         `- Enabled: ${enabled ? 'enabled' : 'disabled'}`,
         `- Directory: ${getDumpDirectory()}`,
         '- Persisted: ~/.config/opencode/anthropic-auth.json',
-        '- Captures: final rewritten Anthropic body plus redacted relay payload metadata',
+        '- Captures: final rewritten Anthropic body in direct and relay modes; request/relay metadata is redacted',
         '- Warning: body dumps may contain prompt/session content; turn this off after debugging',
     ].join('\n');
 }
@@ -87,6 +91,35 @@ function dumpFileSessionSegment(affinity) {
         return 'session-unknown';
     return normalized.length <= 80 ? normalized : normalized.slice(0, 80);
 }
+function dumpRequestSegment(input) {
+    if (input.transport !== 'direct') {
+        return `${input.transport}-p${input.protocol}-${input.mode}`;
+    }
+    const route = input.route ? `-${dumpFileSessionSegment(input.route)}` : '';
+    return `direct${route}`;
+}
+function directDumpPreviousKey(input) {
+    const affinity = input.affinity?.trim();
+    if (affinity)
+        return `session:${affinity}`;
+    return `request:${input.route ?? 'direct'}:${input.url ?? ''}`;
+}
+function rememberDirectDumpBody(key, bodyText) {
+    if (!directDumpPreviousBodies.has(key)) {
+        while (directDumpPreviousBodies.size >= DIRECT_DUMP_PREVIOUS_BODY_LIMIT) {
+            const oldest = directDumpPreviousBodies.keys().next().value;
+            if (oldest === undefined)
+                break;
+            directDumpPreviousBodies.delete(oldest);
+        }
+    }
+    directDumpPreviousBodies.set(key, bodyText);
+}
+function headersToRecord(headers) {
+    if (headers == null)
+        return undefined;
+    return Object.fromEntries(new Headers(headers).entries());
+}
 function hashText(value) {
     return createHash('sha256').update(value).digest('hex');
 }
@@ -189,42 +222,92 @@ function redactForDump(value) {
     }
     return redacted;
 }
-export async function dumpRelayRequest(input) {
+async function dumpRequest(input) {
     if (!dumpEnabled)
         return;
     nextDumpId += 1;
-    const id = `${new Date().toISOString().replace(/[:.]/g, '-')}-${String(nextDumpId).padStart(5, '0')}-${dumpFileSessionSegment(input.affinity)}-${input.transport}-p${input.protocol}-${input.mode}`;
+    const affinity = input.affinity?.trim() || 'session-unknown';
+    const id = `${new Date().toISOString().replace(/[:.]/g, '-')}-${String(nextDumpId).padStart(5, '0')}-${dumpFileSessionSegment(affinity)}-${dumpRequestSegment(input)}`;
     const dumpDir = getDumpDirectory();
     const prefix = join(dumpDir, id);
+    const files = {
+        body: `${prefix}.body.json`,
+        metadata: `${prefix}.meta.json`,
+    };
+    if (input.payload !== undefined)
+        files.relay = `${prefix}.relay.json`;
+    if (input.request !== undefined)
+        files.request = `${prefix}.request.json`;
     try {
         await mkdir(dumpDir, { recursive: true });
         const metadata = {
             id,
             createdAt: new Date().toISOString(),
-            session: shortAffinity(input.affinity),
+            session: shortAffinity(affinity),
             transport: input.transport,
             protocol: input.protocol,
             mode: input.mode,
+            route: input.route,
             status: input.status,
+            error: input.error,
             bodyBytes: input.bodyText.length,
             relayBytes: input.relayBytes,
             bodyHash: hashText(input.bodyText),
             diff: diffSummary(input.previousBodyText, input.bodyText),
             body: bodyStructureSummary(input.bodyText),
-            files: {
-                body: `${prefix}.body.json`,
-                relay: `${prefix}.relay.json`,
-                metadata: `${prefix}.meta.json`,
-            },
+            files,
         };
-        await Promise.all([
-            writeFile(`${prefix}.body.json`, input.bodyText, 'utf8'),
-            writeFile(`${prefix}.relay.json`, `${JSON.stringify(redactForDump(input.payload), null, 2)}\n`, 'utf8'),
-            writeFile(`${prefix}.meta.json`, `${JSON.stringify(metadata, null, 2)}\n`, 'utf8'),
-        ]);
-        relayLog(`dumped request id=${id} session=${shortAffinity(input.affinity)} body=${prefix}.body.json meta=${prefix}.meta.json`);
+        const writes = [
+            writeFile(files.body, input.bodyText, 'utf8'),
+            writeFile(files.metadata, `${JSON.stringify(metadata, null, 2)}\n`, 'utf8'),
+        ];
+        if (input.payload !== undefined && files.relay) {
+            writes.push(writeFile(files.relay, `${JSON.stringify(redactForDump(input.payload), null, 2)}\n`, 'utf8'));
+        }
+        if (input.request !== undefined && files.request) {
+            writes.push(writeFile(files.request, `${JSON.stringify(redactForDump({
+                ...input.request,
+                headers: headersToRecord(input.request.headers),
+            }), null, 2)}\n`, 'utf8'));
+        }
+        await Promise.all(writes);
+        relayLog(`dumped request id=${id} session=${shortAffinity(affinity)} body=${files.body} meta=${files.metadata}`);
     }
     catch (error) {
         relayLog(`dump failed: ${error instanceof Error ? error.message : String(error)}`);
     }
 }
+export async function dumpDirectRequest(input) {
+    if (!dumpEnabled)
+        return;
+    const previousKey = directDumpPreviousKey(input);
+    const previousBodyText = directDumpPreviousBodies.get(previousKey);
+    await dumpRequest({
+        affinity: input.affinity,
+        transport: 'direct',
+        route: input.route,
+        status: input.status,
+        error: input.error,
+        bodyText: input.bodyText,
+        previousBodyText,
+        request: {
+            url: input.url,
+            method: input.method,
+            headers: input.headers,
+        },
+    });
+    rememberDirectDumpBody(previousKey, input.bodyText);
+}
+export async function dumpRelayRequest(input) {
+    await dumpRequest({
+        affinity: input.affinity,
+        transport: input.transport,
+        protocol: input.protocol,
+        mode: input.mode,
+        status: input.status,
+        bodyText: input.bodyText,
+        previousBodyText: input.previousBodyText,
+        payload: input.payload,
+        relayBytes: input.relayBytes,
+    });
+}

package/dist/models.d.ts

@@ -22,3 +22,4 @@ export declare const CLAUDE_FABLE_MYTHOS_5_MODEL_SPECS: Record<ClaudeFableMythos
     limited?: boolean;
 }>;
 export declare function isClaudeFableOrMythos5Model(model: unknown): boolean;
+export declare function isOpenAIReasoningSignature(value: unknown): boolean;

package/dist/models.js

@@ -33,3 +33,22 @@ export function isClaudeFableOrMythos5Model(model) {
     return (typeof model === 'string' &&
         CLAUDE_FABLE_MYTHOS_5_MODEL_IDS.some((id) => model === id || model.startsWith(`${id}-`)));
 }
+export function isOpenAIReasoningSignature(value) {
+    if (typeof value !== 'string')
+        return false;
+    if (value.startsWith('gAAAA'))
+        return true;
+    if (!value.startsWith('{'))
+        return false;
+    try {
+        const parsed = JSON.parse(value);
+        return (parsed.type === 'reasoning' &&
+            typeof parsed.id === 'string' &&
+            parsed.id.startsWith('rs_') &&
+            typeof parsed.encrypted_content === 'string' &&
+            parsed.encrypted_content.startsWith('gAAAA'));
+    }
+    catch {
+        return false;
+    }
+}

package/dist/quota-manager.d.ts

@@ -21,7 +21,7 @@ export type QuotaManagerOptions = {
     storage: AccountStorage | null;
     fetchImpl?: typeof fetch;
     now?: () => number;
-    onMainQuotaFetched?: (quota: OAuthQuotaSnapshot, checkedAt: number, tokenFingerprint: string) => void;
+    onMainQuotaFetched?: (quota: OAuthQuotaSnapshot, checkedAt: number, tokenFingerprint: string, fetchStartedAt: number) => void;
     onApiError?: (error: AccountOperationError) => void;
 };
 export declare class QuotaManager {
@@ -75,10 +75,18 @@ export declare class QuotaManager {
      */
     needsRefresh(requestCount: number): boolean;
     updateStorage(storage: AccountStorage | null): void;
+    /**
+     * Seed/update the main quota cache from persisted state. This is deliberately
+     * callable after every disk load so another plugin process's fresh quota write
+     * can stop this process from showing "checking…" or making a redundant quota
+     * API call.
+     */
+    seedMainFromStorage(storage: AccountStorage | null, accessToken?: string): void;
+    private seedMainBackoffFromStorage;
     /**
      * 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.
+     * Updates older in-memory entries so a fresh quota write from another plugin
+     * process prevents redundant checks and stale sidebar writes.
      */
     seedFallbacksFromAccounts(accounts: OAuthAccount[]): void;
     /**

package/dist/quota-manager.js

@@ -56,20 +56,8 @@ export class QuotaManager {
         // 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;
-        }
+        this.seedMainFromStorage(opts.storage);
+        this.seedMainBackoffFromStorage(opts.storage);
     }
     // =========================================================================
     // Get (synchronous, from cache)
@@ -230,24 +218,65 @@ export class QuotaManager {
     // =========================================================================
     updateStorage(storage) {
         this.storage = storage;
+        this.seedMainFromStorage(storage);
+        this.seedMainBackoffFromStorage(storage);
+    }
+    /**
+     * Seed/update the main quota cache from persisted state. This is deliberately
+     * callable after every disk load so another plugin process's fresh quota write
+     * can stop this process from showing "checking…" or making a redundant quota
+     * API call.
+     */
+    seedMainFromStorage(storage, accessToken) {
+        const persisted = getPersistedMainQuota(storage);
+        if (!persisted)
+            return;
+        const accessTokenFp = accessToken ? tokenFingerprint(accessToken) : null;
+        if (accessTokenFp &&
+            persisted.tokenFingerprint &&
+            persisted.tokenFingerprint !== accessTokenFp) {
+            return;
+        }
+        const entry = {
+            quota: persisted.quota,
+            refreshAfter: getQuotaNextRefreshAt(persisted.quota, storage, persisted.checkedAt),
+            checkedAt: persisted.checkedAt,
+        };
+        if (this.main &&
+            this.main.checkedAt >= entry.checkedAt &&
+            (!accessTokenFp ||
+                !this.mainTokenFp ||
+                this.mainTokenFp === accessTokenFp)) {
+            return;
+        }
+        this.main = entry;
+        this.mainTokenFp = persisted.tokenFingerprint ?? null;
+    }
+    seedMainBackoffFromStorage(storage) {
+        const persistedError = storage?.quota?.mainLastQuotaApiError;
+        this.mainLastApiError =
+            persistedError && quotaBackoffActive(persistedError, this.now())
+                ? persistedError
+                : undefined;
     }
     /**
      * 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.
+     * Updates older in-memory entries so a fresh quota write from another plugin
+     * process prevents redundant checks and stale sidebar writes.
      */
     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;
+            const existing = this.getFallback(account.id, account.access);
+            if (existing && existing.checkedAt >= checkedAt)
+                continue;
             this.setFallback(account.id, {
                 quota: account.quota,
                 refreshAfter: checkedAt + checkInterval,
@@ -327,11 +356,13 @@ export class QuotaManager {
                     ttlMs: 30_000,
                 });
                 if (!fileLock) {
-                    if (this.main)
-                        return this.main.quota;
+                    const cached = this.main;
+                    if (cached && this.now() < cached.refreshAfter)
+                        return cached.quota;
                     throw new Error('Quota refresh is already in progress');
                 }
                 try {
+                    const fetchStartedAt = this.now();
                     const quota = await fetchOAuthQuotaSnapshot({
                         accessToken,
                         fetchImpl: this.fetchImpl,
@@ -345,7 +376,7 @@ export class QuotaManager {
                         checkedAt: now,
                     };
                     this.mainLastApiError = undefined;
-                    this.onMainQuotaFetched?.(quota, now, this.mainTokenFp);
+                    this.onMainQuotaFetched?.(quota, now, this.mainTokenFp, fetchStartedAt);
                     return quota;
                 }
                 catch (error) {
@@ -377,7 +408,7 @@ export class QuotaManager {
                 });
                 if (!fileLock) {
                     const cached = this.getFallback(accountId, accessToken);
-                    if (cached)
+                    if (cached && this.now() < cached.refreshAfter)
                         return cached.quota;
                     throw new Error('Quota refresh is already in progress');
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cortexkit/anthropic-auth-core",
-  "version": "1.9.2",
+  "version": "1.9.3",
   "type": "module",
   "repository": {
     "type": "git",