@cortexkit/anthropic-auth-core 1.9.2 → 1.9.4

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/auth.js

@@ -1,4 +1,4 @@
-import { AUTHORIZE_URLS, CLIENT_ID, CODE_CALLBACK_URL, OAUTH_SCOPES, TOKEN_URL, } from "./constants.js";
+import { AUTHORIZE_URLS, AXIOS_USER_AGENT, CLIENT_ID, CODE_CALLBACK_URL, OAUTH_SCOPES, REFRESH_SCOPE, TOKEN_URL, } from "./constants.js";
 import { generatePKCE } from "./pkce.js";
 function parseRetryAfterHeader(value) {
     if (!value)
@@ -50,13 +50,14 @@ export async function refreshClaudeOAuthToken(input) {
                 method: 'POST',
                 headers: {
                     'Content-Type': 'application/json',
-                    Accept: 'application/json',
-                    'User-Agent': 'axios/1.13.6',
+                    Accept: 'application/json, text/plain, */*',
+                    'User-Agent': AXIOS_USER_AGENT,
                 },
                 body: JSON.stringify({
                     grant_type: 'refresh_token',
                     refresh_token: input.refreshToken,
                     client_id: CLIENT_ID,
+                    scope: REFRESH_SCOPE,
                 }),
             });
             if (!response.ok) {
@@ -120,7 +121,7 @@ async function exchangeCode(callback, verifier, redirectUri) {
         headers: {
             'Content-Type': 'application/json',
             Accept: 'application/json, text/plain, */*',
-            'User-Agent': 'axios/1.13.6',
+            'User-Agent': AXIOS_USER_AGENT,
         },
         body: JSON.stringify({
             code: callback.code,

package/dist/claude-code.d.ts

@@ -7,7 +7,7 @@ export declare function getClaudeCodeIdentity(seed: string): ClaudeCodeIdentity;
 export declare function resolveClaudeCodeIdentity(accessToken: string, model?: string): Promise<ClaudeCodeIdentity>;
 export declare function buildClaudeCodeMetadataUserId(identity: ClaudeCodeIdentity): string | null;
 export declare function applyClaudeCodeMetadata(body: Record<string, unknown>, identity: ClaudeCodeIdentity): boolean;
-export declare const CLAUDE_CODE_FULL_AGENT_BETAS: readonly ["claude-code-20250219", "oauth-2025-04-20", "interleaved-thinking-2025-05-14", "context-management-2025-06-27", "prompt-caching-scope-2026-01-05", "advisor-tool-2026-03-01", "advanced-tool-use-2025-11-20", "context-1m-2025-08-07", "effort-2025-11-24", "extended-cache-ttl-2025-04-11", "cache-diagnosis-2026-04-07"];
+export declare const CLAUDE_CODE_FULL_AGENT_BETAS: readonly ["oauth-2025-04-20", "interleaved-thinking-2025-05-14", "thinking-token-count-2026-05-13", "context-management-2025-06-27", "prompt-caching-scope-2026-01-05", "claude-code-20250219", "advisor-tool-2026-03-01", "advanced-tool-use-2025-11-20", "extended-cache-ttl-2025-04-11", "cache-diagnosis-2026-04-07"];
 export declare function selectClaudeCodeBetas(body?: Record<string, unknown> | null, extraBetas?: string[]): string;
 export declare function applyClaudeCodeHeaders(headers: Headers, accessToken: string, options?: {
     body?: Record<string, unknown> | null;

package/dist/claude-code.js

@@ -130,21 +130,21 @@ export function applyClaudeCodeMetadata(body, identity) {
     return true;
 }
 export const CLAUDE_CODE_FULL_AGENT_BETAS = [
-    'claude-code-20250219',
     'oauth-2025-04-20',
     'interleaved-thinking-2025-05-14',
+    'thinking-token-count-2026-05-13',
     'context-management-2025-06-27',
     'prompt-caching-scope-2026-01-05',
+    'claude-code-20250219',
     'advisor-tool-2026-03-01',
     'advanced-tool-use-2025-11-20',
-    'context-1m-2025-08-07',
-    'effort-2025-11-24',
     'extended-cache-ttl-2025-04-11',
     'cache-diagnosis-2026-04-07',
 ];
 const CLAUDE_CODE_STRUCTURED_OUTPUT_BETAS = [
     'oauth-2025-04-20',
     'interleaved-thinking-2025-05-14',
+    'thinking-token-count-2026-05-13',
     'context-management-2025-06-27',
     'prompt-caching-scope-2026-01-05',
     'advisor-tool-2026-03-01',
@@ -154,9 +154,12 @@ const CLAUDE_CODE_STRUCTURED_OUTPUT_BETAS = [
 const CLAUDE_CODE_BASE_BETAS = [
     'oauth-2025-04-20',
     'interleaved-thinking-2025-05-14',
+    'thinking-token-count-2026-05-13',
     'context-management-2025-06-27',
     'prompt-caching-scope-2026-01-05',
     'advisor-tool-2026-03-01',
+    'advanced-tool-use-2025-11-20',
+    'extended-cache-ttl-2025-04-11',
     'cache-diagnosis-2026-04-07',
 ];
 function hasStructuredOutput(body) {

package/dist/constants.d.ts

@@ -1,27 +1,29 @@
 export declare const CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
 export declare const AUTHORIZE_URLS: {
     readonly console: "https://platform.claude.com/oauth/authorize";
-    readonly max: "https://claude.ai/oauth/authorize";
+    readonly max: "https://claude.com/cai/oauth/authorize";
 };
 export declare const CODE_CALLBACK_URL = "https://platform.claude.com/oauth/code/callback";
 export declare const TOKEN_URL = "https://platform.claude.com/v1/oauth/token";
+export declare const AXIOS_USER_AGENT = "axios/1.15.2";
 export declare const OAUTH_SCOPES: string[];
+export declare const REFRESH_SCOPE = "user:profile user:inference user:sessions:claude_code user:mcp_servers user:file_upload";
 export declare const TOOL_PREFIX = "mcp_";
 export declare const REQUIRED_BETAS: string[];
 export declare const FAST_MODE_BETA = "fast-mode-2026-02-01";
 export declare function mergeAnthropicBetas(existing: string | null | undefined, betas: string[]): string;
 export declare function isFastModeSupportedModel(model: unknown): boolean;
 export declare const OPENCODE_IDENTITY_PREFIX = "You are OpenCode";
-export declare const CLAUDE_CODE_IDENTITY = "You are a Claude agent, built on Anthropic's Claude Agent SDK.";
+export declare const CLAUDE_CODE_IDENTITY = "You are Claude Code, Anthropic's official CLI for Claude.";
 export declare const PARALLEL_TOOL_CALLS_SYSTEM_PROMPT: string;
 export declare const CCH_SALT = "59cf53e54c78";
 export declare const CCH_POSITIONS: number[];
-export declare const CLAUDE_CODE_VERSION = "2.1.141";
-export declare const CLAUDE_CODE_BUILD_HASH = "67b";
-export declare const CLAUDE_CODE_ENTRYPOINT = "sdk-cli";
+export declare const CLAUDE_CODE_VERSION = "2.1.177";
+export declare const CLAUDE_CODE_BUILD_HASH = "3bf";
+export declare const CLAUDE_CODE_ENTRYPOINT = "cli";
 export declare const CLAUDE_CODE_STAINLESS_PACKAGE_VERSION = "0.94.0";
 export declare const CLAUDE_CODE_STAINLESS_RUNTIME_VERSION = "v24.3.0";
-export declare const USER_AGENT = "claude-cli/2.1.141 (external, sdk-cli)";
+export declare const USER_AGENT = "claude-cli/2.1.177 (external, cli)";
 export declare const CACHE_1H_MODES: readonly ["explicit", "automatic", "hybrid"];
 export type Cache1hMode = (typeof CACHE_1H_MODES)[number];
 export declare const DEFAULT_CACHE_1H_MODE: Cache1hMode;

package/dist/constants.js

@@ -1,10 +1,11 @@
 export const CLIENT_ID = '9d1c250a-e61b-44d9-88ed-5944d1962f5e';
 export const AUTHORIZE_URLS = {
     console: 'https://platform.claude.com/oauth/authorize',
-    max: 'https://claude.ai/oauth/authorize',
+    max: 'https://claude.com/cai/oauth/authorize',
 };
 export const CODE_CALLBACK_URL = 'https://platform.claude.com/oauth/code/callback';
 export const TOKEN_URL = 'https://platform.claude.com/v1/oauth/token';
+export const AXIOS_USER_AGENT = 'axios/1.15.2';
 export const OAUTH_SCOPES = [
     'org:create_api_key',
     'user:profile',
@@ -13,6 +14,7 @@ export const OAUTH_SCOPES = [
     'user:mcp_servers',
     'user:file_upload',
 ];
+export const REFRESH_SCOPE = 'user:profile user:inference user:sessions:claude_code user:mcp_servers user:file_upload';
 export const TOOL_PREFIX = 'mcp_';
 export const REQUIRED_BETAS = [
     'oauth-2025-04-20',
@@ -33,7 +35,7 @@ export function isFastModeSupportedModel(model) {
             model.startsWith('claude-opus-4-8')));
 }
 export const OPENCODE_IDENTITY_PREFIX = 'You are OpenCode';
-export const CLAUDE_CODE_IDENTITY = "You are a Claude agent, built on Anthropic's Claude Agent SDK.";
+export const CLAUDE_CODE_IDENTITY = "You are Claude Code, Anthropic's official CLI for Claude.";
 export const PARALLEL_TOOL_CALLS_SYSTEM_PROMPT = [
     '<use_parallel_tool_calls>',
     'For maximum efficiency, whenever you perform multiple independent operations, invoke all relevant tools simultaneously rather than sequentially. Prioritize calling independent tools in parallel whenever possible. For example, when reading 3 known files, run 3 tool calls in parallel to read all 3 files into context at the same time. When running multiple independent read-only commands like `ls` or `list_dir`, run all of those commands in parallel. Err on the side of maximizing parallel tool calls for independent work rather than running too many tools sequentially.',
@@ -43,12 +45,12 @@ export const PARALLEL_TOOL_CALLS_SYSTEM_PROMPT = [
 ].join('\n');
 export const CCH_SALT = '59cf53e54c78';
 export const CCH_POSITIONS = [4, 7, 20];
-export const CLAUDE_CODE_VERSION = '2.1.141';
-export const CLAUDE_CODE_BUILD_HASH = '67b';
-export const CLAUDE_CODE_ENTRYPOINT = 'sdk-cli';
+export const CLAUDE_CODE_VERSION = '2.1.177';
+export const CLAUDE_CODE_BUILD_HASH = '3bf';
+export const CLAUDE_CODE_ENTRYPOINT = 'cli';
 export const CLAUDE_CODE_STAINLESS_PACKAGE_VERSION = '0.94.0';
 export const CLAUDE_CODE_STAINLESS_RUNTIME_VERSION = 'v24.3.0';
-export const USER_AGENT = 'claude-cli/2.1.141 (external, sdk-cli)';
+export const USER_AGENT = 'claude-cli/2.1.177 (external, cli)';
 export const CACHE_1H_MODES = ['explicit', 'automatic', 'hybrid'];
 export const DEFAULT_CACHE_1H_MODE = 'explicit';
 /**

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.4",
   "type": "module",
   "repository": {
     "type": "git",