@kenkaiiii/gg-ai 4.11.3 → 4.12.1

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,
@@ -335,7 +336,7 @@ var EventStream = class {
     }
   }
 };
-var StreamResult = class {
+var StreamResult = class _StreamResult {
   response;
   buffer = [];
   done = false;
@@ -343,6 +344,18 @@ var StreamResult = class {
   resolveResponse;
   rejectResponse;
   resolveWait = null;
+  /**
+   * High-water mark: when the buffer exceeds this many unconsumed events,
+   * the pump pauses until the consumer drains below the low-water mark.
+   * Prevents unbounded memory growth when a consumer is slow.
+   * Only active when someone IS iterating — if nobody iterates (the `then()`
+   * path), backpressure is skipped so the pump can complete and resolve.
+   */
+  static HIGH_WATER = 5e3;
+  static LOW_WATER = 1e3;
+  iterating = false;
+  paused = false;
+  resolveDrain = null;
   constructor(generator, signal) {
     this.response = new Promise((resolve, reject) => {
       this.resolveResponse = resolve;
@@ -357,6 +370,13 @@ var StreamResult = class {
         this.buffer.push(next.value);
         this.resolveWait?.();
         this.resolveWait = null;
+        if (this.iterating && this.buffer.length > _StreamResult.HIGH_WATER) {
+          this.paused = true;
+          await new Promise((r) => {
+            this.resolveDrain = r;
+          });
+          this.paused = false;
+        }
         next = await this._nextWithAbort(generator, signal);
       }
       this.done = true;
@@ -395,11 +415,20 @@ var StreamResult = class {
     }
   }
   async *[Symbol.asyncIterator]() {
+    this.iterating = true;
     let index = 0;
     while (true) {
       while (index < this.buffer.length) {
         yield this.buffer[index++];
       }
+      if (this.paused && index > _StreamResult.LOW_WATER) {
+        this.resolveDrain?.();
+        this.resolveDrain = null;
+      }
+      if (index > 0 && !this.paused) {
+        this.buffer.splice(0, index);
+        index = 0;
+      }
       if (this.error) throw this.error;
       if (this.done) return;
       await new Promise((r) => {
@@ -412,16 +441,26 @@ var StreamResult = class {
     }
   }
   then(onfulfilled, onrejected) {
+    if (this.paused) {
+      this.paused = false;
+      this.resolveDrain?.();
+      this.resolveDrain = null;
+    }
     return this.response.then(onfulfilled, onrejected);
   }
 };
 
 // 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);
@@ -1029,26 +1068,83 @@ 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
-        // (ggcoder) 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)",
+        "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);
@@ -1628,13 +1724,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);
@@ -2049,9 +2159,6 @@ async function* runStream3(options) {
     body.tools = toCodexTools(options.tools);
   }
   body.prompt_cache_key = normalizePromptCacheKey(options.promptCacheKey ?? "ggcoder");
-  if (options.cacheRetention === "long") {
-    body.prompt_cache_retention = "24h";
-  }
   if (options.temperature != null && !options.thinking) {
     body.temperature = options.temperature;
   }
@@ -3365,6 +3472,7 @@ function registerPalsuProvider(config) {
   palsuText,
   palsuThinking,
   palsuToolCall,
+  prewarmAnthropicCache,
   providerRegistry,
   registerPalsuProvider,
   setProviderDiagnostic,