@cortexkit/anthropic-auth-core 1.14.0 → 1.15.1

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.14.0",
+  "version": "1.15.1",
   "type": "module",
   "repository": {
     "type": "git",