@prestyj/ai 4.10.1 → 4.12.0

package/dist/index.cjs

@@ -43,6 +43,7 @@ __export(index_exports, {
   palsuText: () => palsuText,
   palsuThinking: () => palsuThinking,
   palsuToolCall: () => palsuToolCall,
+  prewarmAnthropicCache: () => prewarmAnthropicCache,
   providerRegistry: () => providerRegistry,
   registerPalsuProvider: () => registerPalsuProvider,
   setProviderDiagnostic: () => setProviderDiagnostic,
@@ -418,10 +419,15 @@ var StreamResult = class {
 
 // src/utils/zod-to-json-schema.ts
 var import_zod = require("zod");
+var schemaCache = /* @__PURE__ */ new WeakMap();
 function zodToJsonSchema(schema) {
+  const cached = schemaCache.get(schema);
+  if (cached) return cached;
   const jsonSchema = import_zod.z.toJSONSchema(schema);
   const { $schema: _schema, ...rest } = jsonSchema;
-  return normalizeRootForAnthropic(rest);
+  const normalized = normalizeRootForAnthropic(rest);
+  schemaCache.set(schema, normalized);
+  return normalized;
 }
 function resolveToolSchema(tool) {
   return tool.rawInputSchema ?? zodToJsonSchema(tool.parameters);
@@ -813,16 +819,17 @@ function toAnthropicThinking(level, maxTokens, model) {
       outputConfig: { effort }
     };
   }
+  const VISIBLE_FLOOR = 1024;
   const effectiveLevel = level === "xhigh" || level === "max" ? "high" : level;
   const budgetMap = {
-    low: Math.max(1024, Math.floor(maxTokens * 0.25)),
-    medium: Math.max(2048, Math.floor(maxTokens * 0.5)),
-    high: Math.max(4096, maxTokens)
+    low: Math.max(1024, Math.floor(maxTokens * 0.2)),
+    medium: Math.max(2048, Math.floor(maxTokens * 0.45)),
+    high: Math.max(4096, Math.floor(maxTokens * 0.8))
   };
-  const budget = budgetMap[effectiveLevel];
+  const budget = Math.max(0, Math.min(budgetMap[effectiveLevel], maxTokens - VISIBLE_FLOOR));
   return {
     thinking: { type: "enabled", budget_tokens: budget },
-    maxTokens: maxTokens + budget
+    maxTokens
   };
 }
 function remapToolCallId(id, idMap) {
@@ -1028,26 +1035,86 @@ function parseToolArguments(argsJson) {
 }
 
 // src/providers/anthropic.ts
+var anthropicClientCache = /* @__PURE__ */ new Map();
 function createClient(options) {
   const isOAuth = options.apiKey?.startsWith("sk-ant-oat");
-  return new import_sdk.default({
+  const userAgent = isOAuth ? options.userAgent ?? "claude-cli/2.1.75 (external, cli)" : "";
+  const cacheKey = `${options.apiKey ?? ""}|${options.baseUrl ?? ""}|${userAgent}`;
+  if (!options.fetch) {
+    const cached = anthropicClientCache.get(cacheKey);
+    if (cached) return cached;
+  }
+  const client = new import_sdk.default({
     ...isOAuth ? { apiKey: null, authToken: options.apiKey } : { apiKey: options.apiKey },
     ...options.baseUrl ? { baseURL: options.baseUrl } : {},
     ...options.fetch ? { fetch: options.fetch } : {},
-    // Disable SDK retries — the agent loop has its own stall/overload retry
-    // logic that surfaces errors properly. SDK retries on 429s can cause
-    // multi-minute hangs when the provider stops responding mid-retry.
     maxRetries: 0,
     ...isOAuth ? {
       defaultHeaders: {
         // Anthropic's OAuth edge validates the claude-cli version. Callers
         // (ezcoder) resolve the live version at runtime; the literal here
-        // is the offline fallback for direct gg-ai consumers.
-        "user-agent": options.userAgent ?? "claude-cli/2.1.75 (external, cli)",
+        // is the offline fallback for direct ai consumers.
+        "user-agent": userAgent,
         "x-app": "cli"
       }
     } : {}
   });
+  if (!options.fetch) {
+    if (anthropicClientCache.size >= 8) {
+      const oldest = anthropicClientCache.keys().next().value;
+      if (oldest) anthropicClientCache.delete(oldest);
+    }
+    anthropicClientCache.set(cacheKey, client);
+  }
+  return client;
+}
+async function prewarmAnthropicCache(options) {
+  try {
+    const client = createClient({
+      apiKey: options.apiKey,
+      baseUrl: options.baseUrl,
+      userAgent: options.userAgent
+    });
+    const cacheControl = toAnthropicCacheControl(options.cacheRetention ?? "long", options.baseUrl);
+    const { system, messages } = toAnthropicMessages(
+      [
+        { role: "system", content: options.system },
+        { role: "user", content: "." }
+      ],
+      cacheControl
+    );
+    const isOAuth = options.apiKey.startsWith("sk-ant-oat");
+    const fullSystem = isOAuth ? [
+      {
+        type: "text",
+        text: "You are Claude Code, Anthropic's official CLI for Claude."
+      },
+      ...system ?? []
+    ] : system;
+    const tools = options.tools?.length ? toAnthropicTools(options.tools, {
+      cacheControl,
+      enableFineGrainedToolStreaming: true
+    }) : void 0;
+    await client.messages.create(
+      {
+        model: options.model,
+        max_tokens: 1,
+        messages,
+        ...fullSystem ? { system: fullSystem } : {},
+        ...tools ? {
+          tools: [
+            ...tools,
+            ...options.serverTools ?? []
+          ]
+        } : {}
+      },
+      {
+        signal: options.signal ?? void 0,
+        ...isOAuth ? { headers: { "anthropic-beta": "claude-code-20250219,oauth-2025-04-20" } } : {}
+      }
+    );
+  } catch {
+  }
 }
 function streamAnthropic(options) {
   return new StreamResult(runStream(options), options.signal);
@@ -1627,13 +1694,27 @@ function extractOpenAIUsage(usage) {
     cacheRead
   };
 }
+var openaiClientCache = /* @__PURE__ */ new Map();
 function createClient2(options) {
-  return new import_openai.default({
+  const cacheKey = `${options.apiKey ?? ""}|${options.baseUrl ?? ""}|${JSON.stringify(options.defaultHeaders ?? {})}`;
+  if (!options.fetch) {
+    const cached = openaiClientCache.get(cacheKey);
+    if (cached) return cached;
+  }
+  const client = new import_openai.default({
     apiKey: options.apiKey,
     ...options.baseUrl ? { baseURL: options.baseUrl } : {},
     ...options.fetch ? { fetch: options.fetch } : {},
     ...options.defaultHeaders ? { defaultHeaders: options.defaultHeaders } : {}
   });
+  if (!options.fetch) {
+    if (openaiClientCache.size >= 8) {
+      const oldest = openaiClientCache.keys().next().value;
+      if (oldest) openaiClientCache.delete(oldest);
+    }
+    openaiClientCache.set(cacheKey, client);
+  }
+  return client;
 }
 function streamOpenAI(options) {
   return new StreamResult(runStream2(options), options.signal);
@@ -2048,9 +2129,6 @@ async function* runStream3(options) {
     body.tools = toCodexTools(options.tools);
   }
   body.prompt_cache_key = normalizePromptCacheKey(options.promptCacheKey ?? "ezcoder");
-  if (options.cacheRetention === "long") {
-    body.prompt_cache_retention = "24h";
-  }
   if (options.temperature != null && !options.thinking) {
     body.temperature = options.temperature;
   }
@@ -3364,6 +3442,7 @@ function registerPalsuProvider(config) {
   palsuText,
   palsuThinking,
   palsuToolCall,
+  prewarmAnthropicCache,
   providerRegistry,
   registerPalsuProvider,
   setProviderDiagnostic,