@kenkaiiii/gg-ai 5.87.3 → 5.88.0

package/dist/index.cjs

@@ -35,6 +35,7 @@ __export(index_exports, {
   EventStream: () => EventStream,
   FAST_MODE_SUFFIX: () => FAST_MODE_SUFFIX,
   GGAIError: () => GGAIError,
+  PRECONNECT_INTERVAL_MS: () => PRECONNECT_INTERVAL_MS,
   ProviderError: () => ProviderError,
   REDACTION_MARKER: () => REDACTED,
   ResponseStalledError: () => ResponseStalledError,
@@ -66,6 +67,8 @@ __export(index_exports, {
   palsuToolCall: () => palsuToolCall,
   parseFastModeRejection: () => parseFastModeRejection,
   pendingClaudeCodeVersionRefresh: () => pendingClaudeCodeVersionRefresh,
+  preconnectOrigin: () => preconnectOrigin,
+  preconnectProvider: () => preconnectProvider,
   prewarmAnthropicCache: () => prewarmAnthropicCache,
   providerRegistry: () => providerRegistry,
   redactText: () => redactText,
@@ -488,6 +491,26 @@ function providerGuidance(provider, message, statusCode) {
 // src/providers/anthropic.ts
 var import_sdk = __toESM(require("@anthropic-ai/sdk"), 1);
 
+// src/providers/cache-minimums.ts
+var ANTHROPIC_MIN_CACHEABLE_TOKENS = [
+  [/haiku-4-5|opus-4-[56]/, 4096],
+  [/haiku-3-5|haiku-3\b/, 2048],
+  [/[a-z]-(?:[5-9]|\d{2})(?:-|$)/, 512],
+  // 5.x and later families (family name, then major)
+  [/sonnet-4|opus-4|sonnet-3-7/, 1024]
+];
+function anthropicMinCacheableTokens(model) {
+  for (const [pattern, min] of ANTHROPIC_MIN_CACHEABLE_TOKENS) {
+    if (pattern.test(model)) return min;
+  }
+  return 1024;
+}
+function estimatePrefixTokens(...parts) {
+  let chars = 0;
+  for (const part of parts) if (part !== void 0) chars += JSON.stringify(part).length;
+  return Math.ceil(chars / 3.5);
+}
+
 // src/utils/event-stream.ts
 var EventStream = class {
   queue = [];
@@ -1485,6 +1508,41 @@ function toolResultVideos(content) {
   if (typeof content === "string") return [];
   return content.filter((b) => b.type === "video");
 }
+function planDeferredTools(tools, catalog, messages) {
+  if (!catalog?.length) return void 0;
+  const byName = /* @__PURE__ */ new Map();
+  for (const tool of catalog) if (!byName.has(tool.name)) byName.set(tool.name, tool);
+  const loaded = /* @__PURE__ */ new Set();
+  for (const message of messages) {
+    if (message.role !== "tool") continue;
+    for (const result of message.content) {
+      for (const name of result.loadedTools ?? []) if (byName.has(name)) loaded.add(name);
+    }
+  }
+  const live = (tools ?? []).filter((tool) => !(byName.has(tool.name) && loaded.has(tool.name)));
+  if (live.length === 0) return void 0;
+  const liveNames = new Set(live.map((tool) => tool.name));
+  const deferred = [...byName.values()].filter((tool) => !liveNames.has(tool.name));
+  return { live, deferred, loaded, byName };
+}
+function supportsAnthropicDeferredTools(model) {
+  return /opus-4[-.][5-9]|sonnet-4[-.][5-9]|haiku-4[-.]5|opus-5|sonnet-5|haiku-5|fable-5|mythos-5/.test(
+    model
+  );
+}
+function supportsResponsesToolSearch(model) {
+  return /^gpt-(5\.[4-9]|[6-9])/.test(model);
+}
+function usesDeferredToolLoading(options) {
+  if (options.provider === "anthropic") {
+    const firstParty = !options.baseUrl || options.baseUrl.includes("api.anthropic.com");
+    return firstParty && supportsAnthropicDeferredTools(options.model);
+  }
+  if (options.provider === "openai" && options.accountId) {
+    return supportsResponsesToolSearch(options.model);
+  }
+  return false;
+}
 function toAnthropicCacheControl(retention, baseUrl) {
   const resolved = retention ?? "short";
   if (resolved === "none") return void 0;
@@ -1527,6 +1585,8 @@ function toAnthropicMessages(messages, cacheControl, options) {
   const keepFallbackBlocks = options?.fallbackBlocks === true;
   const droppedToolCallIds = /* @__PURE__ */ new Set();
   const unresolvedServerToolIds = unresolvedServerToolUseIds(messages);
+  const toolReferences = options?.toolReferences;
+  const referencedTools = /* @__PURE__ */ new Set();
   const trajectoryStartIdx = messages.reduce(
     (last, m, i) => opensTurn(m) ? i : last,
     -1
@@ -1589,16 +1649,43 @@ function toAnthropicMessages(messages, cacheControl, options) {
     if (msg.role === "tool") {
       const results = droppedToolCallIds.size ? msg.content.filter((r) => !droppedToolCallIds.has(r.toolCallId)) : msg.content;
       if (results.length === 0) continue;
-      out.push({
-        role: "user",
-        // Cast covers the video block (used by the Anthropic-compatible MiniMax
-        // API), which isn't in the first-party Anthropic tool_result types.
-        content: results.map((result) => ({
+      const trailing = [];
+      const blocks = results.map((result) => {
+        const toolUseId = remapAnthropicToolCallId(result.toolCallId, idMap);
+        const refs = toolReferences ? (result.loadedTools ?? []).filter(
+          (name) => toolReferences.has(name) && !referencedTools.has(name)
+        ) : [];
+        if (refs.length === 0) {
+          return {
+            type: "tool_result",
+            tool_use_id: toolUseId,
+            content: toAnthropicToolResultContent(result.content),
+            is_error: result.isError
+          };
+        }
+        for (const name of refs) referencedTools.add(name);
+        const original = toAnthropicToolResultContent(result.content);
+        const parts = typeof original === "string" ? [{ type: "text", text: original }] : original;
+        const first = parts.findIndex((part) => part.type === "text" && part.text !== "");
+        parts.forEach((part, index) => {
+          if (part.type === "text" && part.text === "") return;
+          trailing.push(
+            index === first && part.type === "text" ? { type: "text", text: `Result of tool call ${toolUseId}:
+${part.text}` } : part
+          );
+        });
+        return {
           type: "tool_result",
-          tool_use_id: remapAnthropicToolCallId(result.toolCallId, idMap),
-          content: toAnthropicToolResultContent(result.content),
+          tool_use_id: toolUseId,
+          content: refs.map((name) => ({ type: "tool_reference", tool_name: name })),
           is_error: result.isError
-        }))
+        };
+      });
+      out.push({
+        role: "user",
+        // Cast covers the video and tool_reference blocks, which aren't in this
+        // SDK's first-party tool_result types.
+        content: [...blocks, ...trailing]
       });
     }
   }
@@ -1614,7 +1701,8 @@ function toAnthropicMessages(messages, cacheControl, options) {
           markAnthropicCacheBreakpoint(out, tail, cacheControl);
         } else {
           if (anchor !== void 0) markAnthropicCacheBreakpoint(out, anchor, cacheControl);
-          markAnthropicCacheBreakpoint(out, tail, { type: "ephemeral" });
+          const longRun = isLongToolRun(messages, trajectoryStartIdx);
+          markAnthropicCacheBreakpoint(out, tail, longRun ? cacheControl : { type: "ephemeral" });
         }
       } else {
         markAnthropicCacheBreakpoint(out, tail, cacheControl);
@@ -1644,6 +1732,28 @@ function toAnthropicMessages(messages, cacheControl, options) {
   }
   return { system, messages: out };
 }
+var BLOCKING_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "wait_agent",
+  "task_output",
+  "subagent",
+  "ask_user"
+]);
+var LONG_RUN_ROUNDS = 6;
+function isLongToolRun(messages, trajectoryStartIdx) {
+  let rounds = 0;
+  for (let i = Math.max(0, trajectoryStartIdx + 1); i < messages.length; i++) {
+    const m = messages[i];
+    if (m?.role !== "assistant" || typeof m.content === "string") continue;
+    let called = false;
+    for (const part of m.content) {
+      if (part.type !== "tool_call") continue;
+      called = true;
+      if (BLOCKING_TOOL_NAMES.has(part.name)) return true;
+    }
+    if (called && ++rounds >= LONG_RUN_ROUNDS) return true;
+  }
+  return false;
+}
 function markAnthropicCacheBreakpoint(out, index, cacheControl) {
   const message = out[index];
   if (!message) return;
@@ -1664,6 +1774,18 @@ function markAnthropicCacheBreakpoint(out, index, cacheControl) {
   }
 }
 function toAnthropicTools(tools, options) {
+  const deferred = (options?.deferred ?? []).map(
+    (tool) => ({
+      name: tool.name,
+      description: tool.description,
+      input_schema: tool.rawInputSchema ?? zodToJsonSchema(tool.parameters),
+      ...options?.enableFineGrainedToolStreaming ? { eager_input_streaming: true } : {},
+      defer_loading: true
+    })
+  );
+  return [...toAnthropicLiveTools(tools, options), ...deferred];
+}
+function toAnthropicLiveTools(tools, options) {
   return tools.map((tool, index) => {
     const anthropicTool = {
       name: tool.name,
@@ -1950,6 +2072,7 @@ function parseToolArguments(argsJson) {
 // src/utils/provider-fetch.ts
 var import_undici = require("undici");
 var PROVIDER_TRANSPORT_TIMEOUT_MS = 45 * 6e4;
+var PROVIDER_KEEP_ALIVE_TIMEOUT_MS = 3e4;
 function nodeUsesEnvProxy({
   env = process.env,
   execArgv = process.execArgv,
@@ -1962,7 +2085,11 @@ function nodeUsesEnvProxy({
   return major >= 24 || major === 22 && minor >= 21;
 }
 function createProviderFetch(timeoutMs, { useEnvProxy = nodeUsesEnvProxy() } = {}) {
-  const timeouts = { headersTimeout: timeoutMs, bodyTimeout: timeoutMs };
+  const timeouts = {
+    headersTimeout: timeoutMs,
+    bodyTimeout: timeoutMs,
+    keepAliveTimeout: PROVIDER_KEEP_ALIVE_TIMEOUT_MS
+  };
   const dispatcher = useEnvProxy ? new import_undici.EnvHttpProxyAgent(timeouts) : new import_undici.Agent(timeouts);
   const builtinFetch = globalThis.fetch;
   const providerFetch2 = async (input, init2) => {
@@ -2117,6 +2244,9 @@ async function prewarmAnthropicCache(options) {
       // prewarmed prompt cache actually hits — both are gated by the flag.
       enableFineGrainedToolStreaming: fineGrainedToolStreamingEnabled()
     }) : void 0;
+    if (estimatePrefixTokens(fullSystem, tools) < anthropicMinCacheableTokens(options.model)) {
+      return;
+    }
     await client.messages.create(
       {
         model: options.model,
@@ -2157,8 +2287,11 @@ async function* runStream(options) {
   const downgradedMessages = downgradeUnsupportedVideos(downgradedImages, options.supportsVideo);
   const fallbackKey = serverFallbackKey(options);
   const useServerFallback = options.provider !== "minimax" && isDirectAnthropicApi(options.baseUrl) && !anthropicServerFallback.disabled.has(fallbackKey);
+  const deferredPlan = options.provider === "anthropic" && isDirectAnthropicApi(options.baseUrl) && supportsAnthropicDeferredTools(options.model) ? planDeferredTools(options.tools, options.deferredTools, downgradedMessages) : void 0;
+  const toolReferences = deferredPlan?.loaded;
   const { system: rawSystem, messages } = toAnthropicMessages(downgradedMessages, cacheControl, {
-    fallbackBlocks: useServerFallback
+    fallbackBlocks: useServerFallback,
+    toolReferences
   });
   const useFastMode = options.speed === "fast" && options.provider === "anthropic" && isDirectAnthropicApi(options.baseUrl);
   const system = isOAuth ? [
@@ -2200,20 +2333,20 @@ async function* runStream(options) {
     ...options.temperature != null && !thinking ? { temperature: options.temperature } : {},
     ...options.topP != null ? { top_p: options.topP } : {},
     ...options.stop ? { stop_sequences: options.stop } : {},
-    ...options.tools?.length || options.serverTools?.length || options.webSearch ? (() => {
+    ...(deferredPlan?.live ?? options.tools)?.length || options.serverTools?.length || options.webSearch ? (() => {
       const reservedServerNames = /* @__PURE__ */ new Set();
       if (options.webSearch) reservedServerNames.add("web_search");
       for (const t of options.serverTools ?? []) {
         const name = t.name;
         if (name) reservedServerNames.add(name);
       }
-      const clientTools = options.tools?.length ? toAnthropicTools(
-        options.tools.filter((t) => !reservedServerNames.has(t.name)),
-        {
-          ...supportsFirstPartyToolExtras && cacheControl ? { cacheControl } : {},
-          ...supportsFirstPartyToolExtras && fineGrainedToolStreamingEnabled() ? { enableFineGrainedToolStreaming: true } : {}
-        }
-      ) : [];
+      const notReserved = (t) => !reservedServerNames.has(t.name);
+      const liveTools = deferredPlan?.live ?? options.tools ?? [];
+      const clientTools = liveTools.length ? toAnthropicTools(liveTools.filter(notReserved), {
+        ...supportsFirstPartyToolExtras && cacheControl ? { cacheControl } : {},
+        ...supportsFirstPartyToolExtras && fineGrainedToolStreamingEnabled() ? { enableFineGrainedToolStreaming: true } : {},
+        ...deferredPlan ? { deferred: deferredPlan.deferred.filter(notReserved) } : {}
+      }) : [];
       return {
         tools: [
           ...clientTools,
@@ -2234,6 +2367,13 @@ async function* runStream(options) {
     ...useFastMode ? { speed: "fast" } : {},
     stream: useStreaming
   };
+  if (options.prewarm && estimatePrefixTokens(baseParams.system, baseParams.tools) < anthropicMinCacheableTokens(options.model)) {
+    return {
+      message: { role: "assistant", content: [] },
+      stopReason: "end_turn",
+      usage: { inputTokens: 0, outputTokens: 0 }
+    };
+  }
   const params = mergeProviderOptions(baseParams, options.providerOptions);
   const hasAdaptiveThinking = isAdaptiveThinkingModel(options.model);
   const betaHeaders = [
@@ -2267,7 +2407,10 @@ async function* runStream(options) {
       const { fallbacks: _dropped, ...rest } = params;
       const retryParams = {
         ...rest,
-        messages: toAnthropicMessages(downgradedMessages, cacheControl, { fallbackBlocks: false }).messages
+        messages: toAnthropicMessages(downgradedMessages, cacheControl, {
+          fallbackBlocks: false,
+          toolReferences
+        }).messages
       };
       return create(
         retryParams,
@@ -2843,6 +2986,10 @@ function createClient2(options) {
     ...options.baseUrl ? { baseURL: options.baseUrl } : {},
     // Default transport lifts undici's 300s header/body caps (see provider-fetch.ts).
     fetch: options.fetch ?? providerFetch,
+    // The agent loop owns retries (classified backoff, Retry-After, UI retry
+    // events). The SDK default of 2 silent retries stacked under it: one 5xx
+    // cost up to 3 hidden requests plus SDK sleeps before the loop even saw it.
+    maxRetries: 0,
     ...options.defaultHeaders ? { defaultHeaders: options.defaultHeaders } : {}
   });
   if (!options.fetch) {
@@ -3617,6 +3764,15 @@ async function* consumeResponsesEvents(events, ctx) {
       droppedToolCalls
     });
   }
+  const addedOrder = [...toolCalls.keys()];
+  const toolSlots = orderedItems.flatMap((e, i) => e.kind === "tool" ? [i] : []);
+  const sortedTools = toolSlots.map((i) => orderedItems[i]).sort(
+    (a, b) => a?.kind === "tool" && b?.kind === "tool" ? addedOrder.indexOf(a.id) - addedOrder.indexOf(b.id) : 0
+  );
+  toolSlots.forEach((slot, k) => {
+    const entry = sortedTools[k];
+    if (entry) orderedItems[slot] = entry;
+  });
   const seenTool = /* @__PURE__ */ new Set();
   let textInserted = false;
   for (const entry of orderedItems) {
@@ -3693,6 +3849,8 @@ function toResponsesInput(messages, options) {
   let system;
   const input = [];
   const idMap = /* @__PURE__ */ new Map();
+  const loadedTools = /* @__PURE__ */ new Set();
+  let toolLoads = 0;
   for (const msg of messages) {
     if (msg.role === "system") {
       system = msg.content;
@@ -3746,6 +3904,28 @@ function toResponsesInput(messages, options) {
           call_id: mapId(callId, idMap),
           output: text.length > 0 ? text : "(see attached image)"
         });
+        const loads = options.toolSearchLoads;
+        const names = loads ? (result.loadedTools ?? []).filter((name) => loads.has(name) && !loadedTools.has(name)) : [];
+        if (loads && names.length > 0) {
+          for (const name of names) loadedTools.add(name);
+          const loadId = `gg_tool_load_${++toolLoads}`;
+          input.push(
+            {
+              type: "tool_search_call",
+              call_id: loadId,
+              execution: "client",
+              status: "completed",
+              arguments: { query: names.join(" "), limit: names.length }
+            },
+            {
+              type: "tool_search_output",
+              call_id: loadId,
+              execution: "client",
+              status: "completed",
+              tools: names.map((name) => loads.get(name))
+            }
+          );
+        }
         if (options.supportsImages !== false && Array.isArray(result.content)) {
           for (const block of result.content) {
             if (block.type === "image") toolImages.push(block);
@@ -3844,8 +4024,19 @@ async function* runStream3(options, retriedWithoutReasoning = false) {
   const url = `${baseUrl}/codex/responses`;
   const downgradedImages = downgradeUnsupportedImages(options.messages, options.supportsImages);
   const downgraded = downgradeUnsupportedVideos(downgradedImages, options.supportsVideo);
+  const deferredPlan = supportsResponsesToolSearch(options.model) ? planDeferredTools(options.tools, options.deferredTools, downgraded) : void 0;
+  const strictTools = options.strictTools ?? true;
+  const toolSearchLoads = deferredPlan ? new Map(
+    [...deferredPlan.loaded].map((name) => {
+      const tool = deferredPlan.byName.get(name);
+      const [wire] = tool ? toCodexTools([tool], strictTools) : [];
+      return [name, { ...wire, defer_loading: true }];
+    })
+  ) : void 0;
+  const liveTools = deferredPlan?.live ?? options.tools;
   const { system, input } = toResponsesInput(downgraded, {
     supportsImages: options.supportsImages,
+    toolSearchLoads,
     mapId: remapCodexId,
     // Stamped reasoning belongs to another transport (e.g. Grok's) and would
     // be rejected here; Codex's own items are never stamped.
@@ -3859,12 +4050,12 @@ async function* runStream3(options, retriedWithoutReasoning = false) {
     stream: true,
     instructions: system,
     input,
-    tool_choice: toCodexToolChoice(options.toolChoice, options.tools),
+    tool_choice: toCodexToolChoice(options.toolChoice, liveTools),
     parallel_tool_calls: !liteShape,
     include: ["reasoning.encrypted_content"]
   };
-  if (options.tools?.length) {
-    body.tools = toCodexTools(options.tools, options.strictTools ?? true);
+  if (liveTools?.length) {
+    body.tools = toCodexTools(liveTools, strictTools);
   }
   body.prompt_cache_key = normalizePromptCacheKey(options.promptCacheKey ?? "ggcoder");
   if (options.temperature != null && !options.thinking) {
@@ -5606,7 +5797,7 @@ function stream(requested) {
         observePreparedContext(
           replayable === sanitized ? wireMessages : replayable,
           messages,
-          options.tools ?? []
+          observedTools(options, messages)
         )
       );
     } catch {
@@ -5614,6 +5805,11 @@ function stream(requested) {
   }
   return entry.stream(messages === options.messages ? options : { ...options, messages });
 }
+function observedTools(options, messages) {
+  if (!usesDeferredToolLoading(options)) return options.tools ?? [];
+  const plan = planDeferredTools(options.tools, options.deferredTools, messages);
+  return plan ? [...plan.live, ...plan.deferred] : options.tools ?? [];
+}
 function stripMessageProvenance(messages) {
   let stripped;
   for (let index = 0; index < messages.length; index++) {
@@ -5753,6 +5949,85 @@ function l2Normalize(vector) {
   return vector.map((value) => value / norm);
 }
 
+// src/utils/preconnect.ts
+var PRECONNECT_INTERVAL_MS = 3e4;
+function defaultBaseUrl(provider, accountId) {
+  switch (provider) {
+    case "anthropic":
+      return "https://api.anthropic.com";
+    case "openai":
+      return accountId ? "https://chatgpt.com/backend-api" : "https://api.openai.com/v1";
+    case "gemini":
+      return "https://cloudcode-pa.googleapis.com";
+    case "glm":
+      return "https://api.z.ai/api/coding/paas/v4";
+    case "moonshot":
+      return "https://api.moonshot.ai/v1";
+    case "deepseek":
+      return "https://api.deepseek.com/v1";
+    case "openrouter":
+      return "https://openrouter.ai/api/v1";
+    case "xiaomi":
+      return "https://token-plan-sgp.xiaomimimo.com/v1";
+    case "minimax":
+      return "https://api.minimax.io/anthropic";
+    case "xai":
+      return "https://api.x.ai/v1";
+    case "huggingface":
+      return "https://router.huggingface.co/v1";
+    case "sakana":
+      return "https://api.sakana.ai/v1";
+    case "local":
+    case "palsu":
+      return void 0;
+  }
+}
+function isLocalHost(hostname) {
+  const host = hostname.replace(/^\[|\]$/g, "").toLowerCase();
+  if (host === "localhost" || host.endsWith(".localhost") || host.endsWith(".local")) return true;
+  if (host === "::1" || host === "0.0.0.0") return true;
+  if (host.includes(":")) return /^(f[cd]|fe[89ab])/.test(host);
+  const octets = host.split(".").map(Number);
+  if (octets.length !== 4 || octets.some((n) => !Number.isInteger(n))) return false;
+  const [a = 0, b = 0] = octets;
+  return a === 127 || a === 10 || a === 192 && b === 168 || a === 172 && b >= 16 && b <= 31;
+}
+function preconnectTarget(options) {
+  const raw = options.baseUrl ?? defaultBaseUrl(options.provider, options.accountId);
+  if (!raw || options.provider === "local" || options.provider === "palsu") return void 0;
+  let url;
+  try {
+    url = new URL(raw);
+  } catch {
+    return void 0;
+  }
+  if (url.protocol !== "https:" || isLocalHost(url.hostname)) return void 0;
+  url.pathname = url.pathname.replace(/\/+$/, "") || "/";
+  url.search = "";
+  url.hash = "";
+  return url;
+}
+function preconnectOrigin(options) {
+  return preconnectTarget(options)?.origin;
+}
+function preconnectProvider(options) {
+  const target = preconnectTarget(options);
+  if (!target) return void 0;
+  const origin = target.origin;
+  const now = options.now ?? Date.now();
+  const last = options.warmedAt.get(origin);
+  if (last !== void 0 && now - last < PRECONNECT_INTERVAL_MS) return void 0;
+  options.warmedAt.set(origin, now);
+  const fetchImpl = options.fetch ?? providerFetch;
+  void fetchImpl(target.href, {
+    method: "HEAD",
+    redirect: "manual",
+    signal: AbortSignal.timeout(1e4)
+  }).then((response) => response.body?.cancel()).catch(() => {
+  });
+  return origin;
+}
+
 // src/chat-error.ts
 function causeCode(error) {
   if (!(error instanceof Error) || !error.cause || typeof error.cause !== "object") return "";
@@ -6231,6 +6506,7 @@ function palsuRerankScore(query, document) {
   EventStream,
   FAST_MODE_SUFFIX,
   GGAIError,
+  PRECONNECT_INTERVAL_MS,
   ProviderError,
   REDACTION_MARKER,
   ResponseStalledError,
@@ -6262,6 +6538,8 @@ function palsuRerankScore(query, document) {
   palsuToolCall,
   parseFastModeRejection,
   pendingClaudeCodeVersionRefresh,
+  preconnectOrigin,
+  preconnectProvider,
   prewarmAnthropicCache,
   providerRegistry,
   redactText,