@kenkaiiii/gg-ai 5.87.2 → 5.88.0

package/dist/index.js

@@ -399,6 +399,26 @@ function providerGuidance(provider, message, statusCode) {
 // src/providers/anthropic.ts
 import Anthropic from "@anthropic-ai/sdk";
 
+// 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 = [];
@@ -554,6 +574,145 @@ var StreamResult = class _StreamResult {
   }
 };
 
+// src/claude-code-version.ts
+import fs from "fs/promises";
+import os from "os";
+import path from "path";
+
+// src/utils/diag.ts
+var _diagFn = null;
+function setProviderDiagnostic(fn) {
+  _diagFn = fn;
+}
+function providerDiag(phase, data) {
+  _diagFn?.(phase, data);
+}
+
+// src/claude-code-version.ts
+var NPM_LATEST_URL = "https://registry.npmjs.org/@anthropic-ai/claude-code/latest";
+var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+var FETCH_TIMEOUT_MS = 3e3;
+var CLAUDE_CODE_FALLBACK_VERSION = "2.1.316";
+function isOlder(a, b) {
+  const pa = a.split(".").map((n) => Number.parseInt(n, 10) || 0);
+  const pb = b.split(".").map((n) => Number.parseInt(n, 10) || 0);
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    const x = pa[i] ?? 0;
+    const y = pb[i] ?? 0;
+    if (x !== y) return x < y;
+  }
+  return false;
+}
+function atLeastFallback(version) {
+  return isOlder(version, CLAUDE_CODE_FALLBACK_VERSION) ? CLAUDE_CODE_FALLBACK_VERSION : version;
+}
+var memoryCache = null;
+var inflight = null;
+function agentDir() {
+  return path.join(os.homedir(), ".gg");
+}
+function cachePath() {
+  return path.join(agentDir(), "claude-code-version.json");
+}
+async function readDiskCache() {
+  try {
+    const raw = await fs.readFile(cachePath(), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.version === "string" && typeof parsed.fetchedAt === "number") {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function writeDiskCache(data) {
+  try {
+    await fs.mkdir(agentDir(), { recursive: true, mode: 448 });
+    await fs.writeFile(cachePath(), JSON.stringify(data), { mode: 384 });
+  } catch (err) {
+    providerDiag("claude_code_version_cache_write_failed", {
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+async function fetchLatest() {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  try {
+    const response = await fetch(NPM_LATEST_URL, { signal: controller.signal });
+    if (!response.ok) return null;
+    const data = await response.json();
+    if (typeof data.version === "string" && /^\d/.test(data.version)) {
+      return data.version;
+    }
+    return null;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+var refreshing = null;
+function refreshInBackground() {
+  refreshing ??= (async () => {
+    try {
+      const fetched = await fetchLatest();
+      if (!fetched) return;
+      await writeDiskCache({ version: fetched, fetchedAt: Date.now() });
+      memoryCache = { version: fetched, expiresAt: Date.now() + CACHE_TTL_MS };
+    } finally {
+      refreshing = null;
+    }
+  })();
+  return refreshing;
+}
+function pendingClaudeCodeVersionRefresh() {
+  return refreshing;
+}
+async function getClaudeCodeVersion() {
+  if (memoryCache && Date.now() < memoryCache.expiresAt) {
+    return memoryCache.version;
+  }
+  if (inflight) return inflight;
+  inflight = (async () => {
+    const disk = await readDiskCache();
+    const diskFresh = disk && Date.now() - disk.fetchedAt < CACHE_TTL_MS;
+    if (disk && diskFresh) {
+      const version = atLeastFallback(disk.version);
+      memoryCache = { version, expiresAt: Date.now() + CACHE_TTL_MS };
+      return version;
+    }
+    if (disk) {
+      const version = atLeastFallback(disk.version);
+      memoryCache = { version, expiresAt: Date.now() + 5 * 60 * 1e3 };
+      void refreshInBackground();
+      return version;
+    }
+    const fetched = await fetchLatest();
+    if (fetched) {
+      await writeDiskCache({ version: fetched, fetchedAt: Date.now() });
+      memoryCache = { version: fetched, expiresAt: Date.now() + CACHE_TTL_MS };
+      return fetched;
+    }
+    const resolved = CLAUDE_CODE_FALLBACK_VERSION;
+    memoryCache = { version: resolved, expiresAt: Date.now() + 5 * 60 * 1e3 };
+    providerDiag("claude_code_version_fallback", { version: resolved });
+    return resolved;
+  })();
+  try {
+    return await inflight;
+  } finally {
+    inflight = null;
+  }
+}
+function claudeCliUserAgent(version) {
+  return `claude-cli/${version} (external, cli)`;
+}
+async function getClaudeCliUserAgent() {
+  return claudeCliUserAgent(await getClaudeCodeVersion());
+}
+
 // src/utils/provider-options.ts
 var RESERVED_BODY_FIELDS = /* @__PURE__ */ new Set([
   "contents",
@@ -1257,6 +1416,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;
@@ -1299,6 +1493,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
@@ -1361,16 +1557,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]
       });
     }
   }
@@ -1386,7 +1609,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);
@@ -1416,6 +1640,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;
@@ -1436,6 +1682,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,
@@ -1722,6 +1980,7 @@ function parseToolArguments(argsJson) {
 // src/utils/provider-fetch.ts
 import { Agent, EnvHttpProxyAgent, fetch as undiciFetch } from "undici";
 var PROVIDER_TRANSPORT_TIMEOUT_MS = 45 * 6e4;
+var PROVIDER_KEEP_ALIVE_TIMEOUT_MS = 3e4;
 function nodeUsesEnvProxy({
   env = process.env,
   execArgv = process.execArgv,
@@ -1734,7 +1993,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 EnvHttpProxyAgent(timeouts) : new Agent(timeouts);
   const builtinFetch = globalThis.fetch;
   const providerFetch2 = async (input, init2) => {
@@ -1824,9 +2087,13 @@ function sumUsageIterations(usage) {
   }
   return totals;
 }
+async function withClaudeUserAgent(options) {
+  if (options.userAgent || !options.apiKey?.startsWith("sk-ant-oat")) return options;
+  return { ...options, userAgent: await getClaudeCliUserAgent() };
+}
 function createClient(options) {
   const isOAuth = options.apiKey?.startsWith("sk-ant-oat");
-  const userAgent = isOAuth ? options.userAgent ?? "claude-cli/2.1.75 (external, cli)" : "";
+  const userAgent = isOAuth ? options.userAgent ?? claudeCliUserAgent(CLAUDE_CODE_FALLBACK_VERSION) : "";
   const cacheKey = `${options.apiKey ?? ""}|${options.baseUrl ?? ""}|${userAgent}`;
   if (!options.fetch) {
     const cached = anthropicClientCache.get(cacheKey);
@@ -1856,11 +2123,13 @@ function createClient(options) {
 }
 async function prewarmAnthropicCache(options) {
   try {
-    const client = createClient({
-      apiKey: options.apiKey,
-      baseUrl: options.baseUrl,
-      userAgent: options.userAgent
-    });
+    const client = createClient(
+      await withClaudeUserAgent({
+        apiKey: options.apiKey,
+        baseUrl: options.baseUrl,
+        userAgent: options.userAgent
+      })
+    );
     const cacheControl = toAnthropicCacheControl(options.cacheRetention ?? "long", options.baseUrl);
     const { system, messages } = toAnthropicMessages(
       [
@@ -1883,6 +2152,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,
@@ -1914,7 +2186,7 @@ function streamAnthropic(options) {
   return new StreamResult(runStream(options), options.signal);
 }
 async function* runStream(options) {
-  const client = createClient(options);
+  const client = createClient(await withClaudeUserAgent(options));
   const isOAuth = options.apiKey?.startsWith("sk-ant-oat");
   const useStreaming = options.streaming !== false && !options.prewarm;
   const cacheControl = toAnthropicCacheControl(options.cacheRetention, options.baseUrl);
@@ -1923,8 +2195,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 ? [
@@ -1966,20 +2241,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,
@@ -2000,6 +2275,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 = [
@@ -2033,7 +2315,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,
@@ -2495,15 +2780,6 @@ function fnv1aHash(value) {
   return (hash >>> 0).toString(16).padStart(8, "0");
 }
 
-// src/utils/diag.ts
-var _diagFn = null;
-function setProviderDiagnostic(fn) {
-  _diagFn = fn;
-}
-function providerDiag(phase, data) {
-  _diagFn?.(phase, data);
-}
-
 // src/providers/moonshot-video.ts
 async function uploadMoonshotVideos(client, messages, signal) {
   for (const msg of messages) {
@@ -2618,6 +2894,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) {
@@ -2729,11 +3009,11 @@ async function* runStream2(options) {
   }
   const requestParams = mergeProviderOptions(params, options.providerOptions);
   if (getEnvironment()?.GGAI_DUMP_REQUEST) {
-    const fs = await import("fs");
+    const fs2 = await import("fs");
     const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
     const dumpPath = `/tmp/ggai-request-${ts}.json`;
-    fs.writeFileSync(dumpPath, JSON.stringify(requestParams, null, 2));
-    fs.appendFileSync(
+    fs2.writeFileSync(dumpPath, JSON.stringify(requestParams, null, 2));
+    fs2.appendFileSync(
       "/tmp/ggai-requests.log",
       `[${ts}] ${dumpPath} messages=${requestParams.messages.length}
 `
@@ -3063,7 +3343,7 @@ function toError2(err, provider = "openai") {
 }
 
 // src/providers/openai-codex.ts
-import os from "os";
+import os2 from "os";
 import * as zstd from "@bokuweb/zstd-wasm";
 
 // src/utils/sse.ts
@@ -3392,6 +3672,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) {
@@ -3468,6 +3757,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;
@@ -3521,6 +3812,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);
@@ -3619,8 +3932,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.
@@ -3634,12 +3958,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) {
@@ -3665,7 +3989,7 @@ async function* runStream3(options, retriedWithoutReasoning = false) {
     Authorization: `Bearer ${options.apiKey}`,
     "OpenAI-Beta": "responses=experimental",
     originator: responsesLite ? "codex_cli_rs" : "ggcoder",
-    "User-Agent": responsesLite ? `codex_cli_rs/${CODEX_CLIENT_VERSION}` : `ggcoder (${os.platform()} ${os.release()}; ${os.arch()})`,
+    "User-Agent": responsesLite ? `codex_cli_rs/${CODEX_CLIENT_VERSION}` : `ggcoder (${os2.platform()} ${os2.release()}; ${os2.arch()})`,
     ...responsesLite ? { version: CODEX_CLIENT_VERSION } : {},
     ...liteShape ? { "X-OpenAI-Internal-Codex-Responses-Lite": "true" } : {}
   };
@@ -4789,8 +5113,8 @@ function bound(text) {
   const trimmed = text.trim();
   return trimmed.length > MAX_ERROR_MESSAGE_CHARS ? `${trimmed.slice(0, MAX_ERROR_MESSAGE_CHARS)}\u2026` : trimmed;
 }
-function joinUrl(baseUrl, path) {
-  return `${baseUrl.replace(/\/+$/, "")}/${path.replace(/^\/+/, "")}`;
+function joinUrl(baseUrl, path2) {
+  return `${baseUrl.replace(/\/+$/, "")}/${path2.replace(/^\/+/, "")}`;
 }
 
 // src/providers/gemini-embeddings.ts
@@ -5381,7 +5705,7 @@ function stream(requested) {
         observePreparedContext(
           replayable === sanitized ? wireMessages : replayable,
           messages,
-          options.tools ?? []
+          observedTools(options, messages)
         )
       );
     } catch {
@@ -5389,6 +5713,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++) {
@@ -5528,6 +5857,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 "";
@@ -6000,10 +6408,12 @@ function palsuRerankScore(query, document) {
   return hits / queryTokens.size;
 }
 export {
+  CLAUDE_CODE_FALLBACK_VERSION,
   CODEX_CLIENT_VERSION,
   EventStream,
   FAST_MODE_SUFFIX,
   GGAIError,
+  PRECONNECT_INTERVAL_MS,
   ProviderError,
   REDACTED as REDACTION_MARKER,
   ResponseStalledError,
@@ -6019,6 +6429,8 @@ export {
   formatChatError,
   formatError,
   formatErrorForDisplay,
+  getClaudeCliUserAgent,
+  getClaudeCodeVersion,
   hasLoneSurrogate,
   isHardBillingMessage,
   isUsageLimitError,
@@ -6032,6 +6444,9 @@ export {
   palsuThinking,
   palsuToolCall,
   parseFastModeRejection,
+  pendingClaudeCodeVersionRefresh,
+  preconnectOrigin,
+  preconnectProvider,
   prewarmAnthropicCache,
   providerRegistry,
   redactText,