@kenkaiiii/gg-ai 5.87.1 → 5.87.3

package/dist/index.cjs

@@ -30,6 +30,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  CLAUDE_CODE_FALLBACK_VERSION: () => CLAUDE_CODE_FALLBACK_VERSION,
   CODEX_CLIENT_VERSION: () => CODEX_CLIENT_VERSION,
   EventStream: () => EventStream,
   FAST_MODE_SUFFIX: () => FAST_MODE_SUFFIX,
@@ -49,6 +50,8 @@ __export(index_exports, {
   formatChatError: () => formatChatError,
   formatError: () => formatError,
   formatErrorForDisplay: () => formatErrorForDisplay,
+  getClaudeCliUserAgent: () => getClaudeCliUserAgent,
+  getClaudeCodeVersion: () => getClaudeCodeVersion,
   hasLoneSurrogate: () => hasLoneSurrogate,
   isHardBillingMessage: () => isHardBillingMessage,
   isUsageLimitError: () => isUsageLimitError,
@@ -62,6 +65,7 @@ __export(index_exports, {
   palsuThinking: () => palsuThinking,
   palsuToolCall: () => palsuToolCall,
   parseFastModeRejection: () => parseFastModeRejection,
+  pendingClaudeCodeVersionRefresh: () => pendingClaudeCodeVersionRefresh,
   prewarmAnthropicCache: () => prewarmAnthropicCache,
   providerRegistry: () => providerRegistry,
   redactText: () => redactText,
@@ -639,6 +643,145 @@ var StreamResult = class _StreamResult {
   }
 };
 
+// src/claude-code-version.ts
+var import_promises = __toESM(require("fs/promises"), 1);
+var import_node_os = __toESM(require("os"), 1);
+var import_node_path = __toESM(require("path"), 1);
+
+// 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 import_node_path.default.join(import_node_os.default.homedir(), ".gg");
+}
+function cachePath() {
+  return import_node_path.default.join(agentDir(), "claude-code-version.json");
+}
+async function readDiskCache() {
+  try {
+    const raw = await import_promises.default.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 import_promises.default.mkdir(agentDir(), { recursive: true, mode: 448 });
+    await import_promises.default.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",
@@ -1806,7 +1949,7 @@ function parseToolArguments(argsJson) {
 
 // src/utils/provider-fetch.ts
 var import_undici = require("undici");
-var PROVIDER_TRANSPORT_TIMEOUT_MS = 30 * 6e4;
+var PROVIDER_TRANSPORT_TIMEOUT_MS = 45 * 6e4;
 function nodeUsesEnvProxy({
   env = process.env,
   execArgv = process.execArgv,
@@ -1834,6 +1977,25 @@ function createProviderFetch(timeoutMs, { useEnvProxy = nodeUsesEnvProxy() } = {
   };
   return Object.assign(providerFetch2, { Response: globalThis.Response });
 }
+function withBodyActivity(fetchImpl, onActivity) {
+  return async (input, init2) => {
+    const response = await fetchImpl(input, init2);
+    if (!response.body || !response.headers.get("content-type")?.includes("text/event-stream")) {
+      return response;
+    }
+    const tap = new TransformStream({
+      transform(chunk, controller) {
+        onActivity();
+        controller.enqueue(chunk);
+      }
+    });
+    return new Response(response.body.pipeThrough(tap), {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+  };
+}
 var providerFetch = createProviderFetch(
   PROVIDER_TRANSPORT_TIMEOUT_MS
 );
@@ -1890,9 +2052,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);
@@ -1922,11 +2088,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(
       [
@@ -1980,7 +2148,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);
@@ -2134,8 +2302,10 @@ async function* runStream(options) {
   const keepalive = { type: "keepalive" };
   let receivedAnyEvent = false;
   try {
+    const onActivity = options.onTransportActivity;
+    const streamClient = onActivity ? client.withOptions({ fetch: withBodyActivity(options.fetch ?? providerFetch, onActivity) }) : client;
     const stream2 = await send(
-      (p, o) => client.messages.create(p, o)
+      (p, o) => streamClient.messages.create(p, o)
     );
     for await (const event of stream2) {
       receivedAnyEvent = true;
@@ -2559,15 +2729,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) {
@@ -2793,11 +2954,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}
 `
@@ -3127,7 +3288,7 @@ function toError2(err, provider = "openai") {
 }
 
 // src/providers/openai-codex.ts
-var import_node_os = __toESM(require("os"), 1);
+var import_node_os2 = __toESM(require("os"), 1);
 var zstd = __toESM(require("@bokuweb/zstd-wasm"), 1);
 
 // src/utils/sse.ts
@@ -3729,7 +3890,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 (${import_node_os.default.platform()} ${import_node_os.default.release()}; ${import_node_os.default.arch()})`,
+    "User-Agent": responsesLite ? `codex_cli_rs/${CODEX_CLIENT_VERSION}` : `ggcoder (${import_node_os2.default.platform()} ${import_node_os2.default.release()}; ${import_node_os2.default.arch()})`,
     ...responsesLite ? { version: CODEX_CLIENT_VERSION } : {},
     ...liteShape ? { "X-OpenAI-Internal-Codex-Responses-Lite": "true" } : {}
   };
@@ -4853,8 +5014,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
@@ -6065,6 +6226,7 @@ function palsuRerankScore(query, document) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  CLAUDE_CODE_FALLBACK_VERSION,
   CODEX_CLIENT_VERSION,
   EventStream,
   FAST_MODE_SUFFIX,
@@ -6084,6 +6246,8 @@ function palsuRerankScore(query, document) {
   formatChatError,
   formatError,
   formatErrorForDisplay,
+  getClaudeCliUserAgent,
+  getClaudeCodeVersion,
   hasLoneSurrogate,
   isHardBillingMessage,
   isUsageLimitError,
@@ -6097,6 +6261,7 @@ function palsuRerankScore(query, document) {
   palsuThinking,
   palsuToolCall,
   parseFastModeRejection,
+  pendingClaudeCodeVersionRefresh,
   prewarmAnthropicCache,
   providerRegistry,
   redactText,