@cortexkit/anthropic-auth-core 1.13.0 → 1.15.0

package/dist/accounts.d.ts

@@ -68,6 +68,7 @@ export type AccountScopedQuotaWindow = AccountQuotaWindow & {
 };
 export type OAuthQuotaSnapshot = Partial<Record<QuotaWindowName, AccountQuotaWindow>> & {
     scoped?: AccountScopedQuotaWindow[];
+    checkedAt?: number;
 };
 export type RoutingMode = 'main-first' | 'fallback-first';
 export type KillswitchThresholds = Partial<Record<QuotaWindowName | '5h' | '1w' | 'scoped', number>>;

package/dist/accounts.js

@@ -178,6 +178,14 @@ function normalizeQuota(value) {
         if (normalized)
             quota[key] = normalized;
     }
+    // Persist a top-level snapshot checkedAt through normalize so the
+    // mergeAccountRuntimeState freshness comparison stays meaningful when the
+    // snapshot has no per-window checkedAt (e.g. {scoped:[]}). Pre-feature
+    // inputs without this key are unaffected — only on-disk snapshots that
+    // already carry it reach this branch.
+    if (typeof value.checkedAt === 'number' && Number.isFinite(value.checkedAt)) {
+        quota.checkedAt = value.checkedAt;
+    }
     if (Array.isArray(value.scoped)) {
         const scoped = value.scoped
             .map((entry) => {
@@ -206,8 +214,11 @@ function normalizeQuota(value) {
             };
         })
             .filter((entry) => entry != null);
-        if (scoped.length)
-            quota.scoped = scoped;
+        // Preserve empty `[]` so a downstream reader can distinguish "scoped
+        // owned by anthropic-auth, none visible" from "no scoped data on this
+        // snapshot". Pre-feature inputs without a `scoped` key are not affected
+        // — only inputs that already carried an array reach this line.
+        quota.scoped = scoped;
     }
     return Object.keys(quota).length ? quota : undefined;
 }
@@ -384,7 +395,7 @@ function accountRuntimeState(account) {
     });
 }
 function quotaSnapshotCheckedAt(quota) {
-    return Math.max(quota?.five_hour?.checkedAt ?? 0, quota?.seven_day?.checkedAt ?? 0, ...(quota?.scoped?.map((window) => window.checkedAt) ?? []));
+    return Math.max(quota?.five_hour?.checkedAt ?? 0, quota?.seven_day?.checkedAt ?? 0, ...(quota?.scoped?.map((window) => window.checkedAt) ?? []), quota?.checkedAt ?? 0);
 }
 function mergeAccountRuntimeState(existing, incoming) {
     if (!isRecord(existing))
@@ -1404,7 +1415,7 @@ function slugForQuotaIdentity(value) {
 }
 function mapScopedWeeklyLimits(limits, checkedAt) {
     if (!Array.isArray(limits))
-        return undefined;
+        return [];
     const seen = new Set();
     const scoped = [];
     for (const limit of limits) {
@@ -1437,7 +1448,7 @@ function mapScopedWeeklyLimits(limits, checkedAt) {
             checkedAt,
         });
     }
-    return scoped.length ? scoped : undefined;
+    return scoped;
 }
 function mapUsageWindow(window, checkedAt) {
     if (typeof window?.utilization !== 'number')
@@ -1478,6 +1489,7 @@ export async function fetchOAuthQuotaSnapshot(input) {
         five_hour: mapUsageWindow(usage.five_hour, checkedAt),
         seven_day: mapUsageWindow(usage.seven_day, checkedAt),
         scoped: mapScopedWeeklyLimits(usage.limits, checkedAt),
+        checkedAt,
     };
 }
 function updateStoredAccount(storage, account) {

package/dist/cachekeep.d.ts

@@ -7,6 +7,7 @@ export declare const CACHE_KEEP_EXTENDED_TTL_BETA = "extended-cache-ttl-2025-04-
 export declare const CACHE_KEEP_MAX_TARGETS = 32;
 export declare const CACHE_KEEP_MAX_BODY_BYTES: number;
 export declare const CACHE_KEEP_STALE_TARGET_MS: number;
+export declare const CACHE_KEEP_PREWARM_TIMEOUT_MS = 30000;
 export type CacheKeepWindow = {
     startHour: number;
     endHour: number;
@@ -63,6 +64,18 @@ export type CacheKeepTarget = {
     dayKey: string;
     oauthAccountId?: string;
 };
+export type CacheKeepPrewarmResult = {
+    ok: true;
+    usage?: {
+        input_tokens?: number;
+        cache_creation_input_tokens?: number;
+        cache_read_input_tokens?: number;
+    };
+} | {
+    ok: false;
+    reason: string;
+    status?: number;
+};
 export declare class CacheKeepManager {
     private readonly options;
     private readonly targets;
@@ -71,6 +84,7 @@ export declare class CacheKeepManager {
         loadStorage: () => Promise<AccountStorage | null>;
         fetchImpl?: typeof fetch;
         now?: () => number;
+        prewarmTimeoutMs?: number;
         prepareHeaders?: (headers: Headers, target: CacheKeepTarget) => Promise<Headers> | Headers;
     });
     start(): void;
@@ -98,6 +112,14 @@ export declare class CacheKeepManager {
         tracked: boolean;
         reason?: undefined;
     };
+    prewarmNow(input: {
+        sessionId: string;
+        url: string;
+        headers: Headers;
+        bodyText: string;
+        oauthAccountId?: string;
+    }): Promise<CacheKeepPrewarmResult>;
     tick(): Promise<void>;
+    private sendPrewarm;
     private prewarm;
 }

package/dist/cachekeep.js

@@ -9,6 +9,7 @@ export const CACHE_KEEP_EXTENDED_TTL_BETA = 'extended-cache-ttl-2025-04-11';
 export const CACHE_KEEP_MAX_TARGETS = 32;
 export const CACHE_KEEP_MAX_BODY_BYTES = 16 * 1024 * 1024;
 export const CACHE_KEEP_STALE_TARGET_MS = 2 * CACHE_KEEP_TTL_MS;
+export const CACHE_KEEP_PREWARM_TIMEOUT_MS = 30_000;
 const STATUS_TITLE = '## Claude Cache Keep Status';
 const ENABLED_TITLE = '## Claude Cache Keep Enabled';
 const DISABLED_TITLE = '## Claude Cache Keep Disabled';
@@ -293,6 +294,22 @@ export class CacheKeepManager {
         this.start();
         return { tracked: true };
     }
+    async prewarmNow(input) {
+        const headers = {};
+        input.headers.forEach((value, key) => {
+            headers[key] = value;
+        });
+        const target = {
+            id: input.sessionId,
+            url: input.url,
+            headers,
+            bodyText: input.bodyText,
+            cacheExpiresAt: this.options.now?.() ?? Date.now(),
+            dayKey: '',
+            oauthAccountId: input.oauthAccountId,
+        };
+        return this.sendPrewarm(target);
+    }
     async tick() {
         const storage = await this.options.loadStorage();
         const window = getCacheKeepWindow(storage);
@@ -315,16 +332,10 @@ export class CacheKeepManager {
             await this.prewarm(target, now);
         }
     }
-    async prewarm(target, now) {
+    async sendPrewarm(target) {
         const prewarm = await buildCacheKeepPrewarmBody(target.bodyText);
-        if (!prewarm.ok) {
-            logger.debug('cachekeep', 'prewarm skipped', {
-                session: target.id,
-                reason: prewarm.reason,
-            });
-            this.targets.delete(target.id);
-            return;
-        }
+        if (!prewarm.ok)
+            return prewarm;
         const fetchImpl = this.options.fetchImpl ?? fetch;
         const prewarmTarget = { ...target, bodyText: prewarm.bodyText };
         const headers = this.options.prepareHeaders
@@ -336,27 +347,46 @@ export class CacheKeepManager {
             method: 'POST',
             headers,
             body: prewarm.bodyText,
+            signal: AbortSignal.timeout(this.options.prewarmTimeoutMs ?? CACHE_KEEP_PREWARM_TIMEOUT_MS),
         });
         if (!response.ok) {
-            logger.warn('cachekeep', 'prewarm failed', {
-                session: target.id,
+            return {
+                ok: false,
+                reason: await response
+                    .text()
+                    .catch(() => '')
+                    .then((body) => body || `HTTP ${response.status}`),
                 status: response.status,
-                body: await response.text().catch(() => ''),
-            });
-            target.cacheExpiresAt = now + CACHE_KEEP_PREWARM_LEAD_MS + 5 * 60_000;
-            return;
+            };
         }
         const data = (await response.json().catch(() => null));
         const usage = data?.usage;
-        target.cacheExpiresAt = now + CACHE_KEEP_TTL_MS;
-        if (usage) {
-            logger.debug('cachekeep', 'prewarm succeeded', {
-                session: target.id,
-                usage,
-            });
-        }
-        else {
-            logger.debug('cachekeep', 'prewarm succeeded', { session: target.id });
+        return { ok: true, ...(usage && { usage }) };
+    }
+    async prewarm(target, now) {
+        const result = await this.sendPrewarm(target);
+        if (!result.ok) {
+            if (result.status == null) {
+                logger.debug('cachekeep', 'prewarm skipped', {
+                    session: target.id,
+                    reason: result.reason,
+                });
+                this.targets.delete(target.id);
+            }
+            else {
+                logger.warn('cachekeep', 'prewarm failed', {
+                    session: target.id,
+                    status: result.status,
+                    reason: result.reason,
+                });
+                target.cacheExpiresAt = now + CACHE_KEEP_PREWARM_LEAD_MS + 5 * 60_000;
+            }
+            return;
         }
+        target.cacheExpiresAt = now + CACHE_KEEP_TTL_MS;
+        logger.debug('cachekeep', 'prewarm succeeded', {
+            session: target.id,
+            ...(result.usage && { usage: result.usage }),
+        });
     }
 }

package/package.json

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