@kenkaiiii/gg-ai 5.68.1 → 5.69.0

package/dist/index.cjs

@@ -35,14 +35,17 @@ __export(index_exports, {
   ProviderError: () => ProviderError,
   REDACTION_MARKER: () => REDACTED,
   StreamResult: () => StreamResult,
+  TOOL_CALL_NAME_RULES: () => TOOL_CALL_NAME_RULES,
   clampProviderContextImages: () => clampProviderContextImages,
   classifyProviderError: () => classifyProviderError,
+  dropInvalidToolCalls: () => dropInvalidToolCalls,
   environmentSecrets: () => environmentSecrets,
   formatError: () => formatError,
   formatErrorForDisplay: () => formatErrorForDisplay,
   hasLoneSurrogate: () => hasLoneSurrogate,
   isHardBillingMessage: () => isHardBillingMessage,
   isUsageLimitError: () => isUsageLimitError,
+  isValidToolCallName: () => isValidToolCallName,
   localWireModelId: () => localWireModelId,
   palsuAssistantMessage: () => palsuAssistantMessage,
   palsuText: () => palsuText,
@@ -61,7 +64,8 @@ __export(index_exports, {
   stream: () => stream,
   toAnthropicMessages: () => toAnthropicMessages,
   toOpenAIMessages: () => toOpenAIMessages,
-  toWellFormedText: () => toWellFormedText
+  toWellFormedText: () => toWellFormedText,
+  toolCallNameRuleFor: () => toolCallNameRuleFor
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -515,7 +519,11 @@ function zodToJsonSchema(schema) {
   return normalized;
 }
 function resolveToolSchema(tool) {
-  return tool.rawInputSchema ?? zodToJsonSchema(tool.parameters);
+  const schema = tool.rawInputSchema ?? zodToJsonSchema(tool.parameters);
+  if (schema.type === "object" && schema.properties === void 0) {
+    return { ...schema, properties: {} };
+  }
+  return schema;
 }
 function normalizeRootForAnthropic(schema) {
   const branches = schema.oneOf ?? schema.anyOf;
@@ -722,6 +730,10 @@ var ANTHROPIC_INPUT_BLOCK_TYPES = /* @__PURE__ */ new Set([
   "connector_text",
   "container_upload",
   "document",
+  // Server-side refusal fallback marker. Only reaches the wire when the request
+  // carries the server-side-fallback beta; otherwise applyServerFallbackReplay
+  // strips it first (see toAnthropicMessages' `fallbackBlocks` option).
+  "fallback",
   "image",
   "mid_conv_system",
   "redacted_thinking",
@@ -743,6 +755,42 @@ function isPositionSensitiveThinking(part) {
   if (part.type === "thinking") return hasValidThinkingSignature(part);
   return isRawThinking(part);
 }
+function isServerFallbackBlock(part) {
+  return part.type === "raw" && part.data.type === "fallback";
+}
+function applyServerFallbackReplay(content, keepMarkers, droppedToolCallIds) {
+  let lastFallbackIdx = -1;
+  content.forEach((part, idx) => {
+    if (isServerFallbackBlock(part)) lastFallbackIdx = idx;
+  });
+  if (lastFallbackIdx === -1) return content;
+  const resultIds = /* @__PURE__ */ new Set();
+  for (const part of content) {
+    if (part.type === "server_tool_result") resultIds.add(part.toolUseId);
+    else if (part.type === "raw" && typeof part.data.tool_use_id === "string")
+      resultIds.add(part.data.tool_use_id);
+  }
+  const out = [];
+  content.forEach((part, idx) => {
+    if (isServerFallbackBlock(part)) {
+      if (keepMarkers) out.push(part);
+      return;
+    }
+    if (idx < lastFallbackIdx) {
+      if (part.type === "thinking" || isRawThinking(part)) return;
+      if (part.type === "raw" && part.data.type === "connector_text") return;
+      if (part.type === "tool_call") {
+        droppedToolCallIds?.add(part.id);
+        return;
+      }
+      if (part.type === "server_tool_call" && !resultIds.has(part.id)) return;
+      if (part.type === "raw" && part.data.type === "server_tool_use" && !resultIds.has(String(part.data.id)))
+        return;
+    }
+    out.push(part);
+  });
+  return out.every(isServerFallbackBlock) ? [] : out;
+}
 function toAnthropicAssistantPart(part, idMap) {
   if (part.type === "text") return { type: "text", text: part.text };
   if (part.type === "thinking") {
@@ -854,6 +902,144 @@ function clampProviderContextImages(messages, provider, supportsImages) {
     return message;
   });
 }
+var TOOL_CALL_NAME_RULES = {
+  // Anthropic Messages API: tool / tool_use name `^[a-zA-Z0-9_-]{1,128}$`.
+  anthropic: { id: "anthropic", maxLength: 128, pattern: /^[a-zA-Z0-9_-]{1,128}$/ },
+  // OpenAI Chat Completions: function name a-z A-Z 0-9 _ -, max length 64.
+  "openai-chat": { id: "openai-chat", maxLength: 64, pattern: /^[a-zA-Z0-9_-]{1,64}$/ },
+  // OpenAI Responses (Codex): same charset; replayed `input[N].name` over 128
+  // chars is rejected with `string_above_max_length`.
+  "openai-responses": {
+    id: "openai-responses",
+    maxLength: 128,
+    pattern: /^[a-zA-Z0-9_-]{1,128}$/
+  },
+  // Gemini FunctionDeclaration name: starts with a letter or underscore, then
+  // a-z A-Z 0-9 _ . : -, max length 128.
+  gemini: { id: "gemini", maxLength: 128, pattern: /^[a-zA-Z_][a-zA-Z0-9_.:-]{0,127}$/ },
+  // OpenAI-compatible third parties (GLM, Kimi, DeepSeek, OpenRouter, xAI,
+  // local servers, MiniMax, …) don't share one documented charset, so only
+  // reject what no declared tool name can contain: blank, >128 chars, or any
+  // whitespace / control character (the signature of invocation text).
+  generic: { id: "generic", maxLength: 128 }
+};
+var TOOL_NAME_FORBIDDEN_CHARS = /[\s\p{Cc}]/u;
+function isValidToolCallName(name, rule) {
+  if (typeof name !== "string" || name.trim().length === 0) return false;
+  if (name.length > rule.maxLength) return false;
+  if (TOOL_NAME_FORBIDDEN_CHARS.test(name)) return false;
+  return rule.pattern ? rule.pattern.test(name) : true;
+}
+function isDefaultOrHost(baseUrl, host) {
+  if (!baseUrl) return true;
+  try {
+    return new URL(baseUrl).hostname === host;
+  } catch {
+    return false;
+  }
+}
+function toolCallNameRuleFor(provider, options) {
+  switch (provider) {
+    case "anthropic":
+      return TOOL_CALL_NAME_RULES.anthropic;
+    case "openai":
+      if (options?.accountId) return TOOL_CALL_NAME_RULES["openai-responses"];
+      return isDefaultOrHost(options?.baseUrl, "api.openai.com") ? TOOL_CALL_NAME_RULES["openai-chat"] : TOOL_CALL_NAME_RULES.generic;
+    case "gemini":
+      return TOOL_CALL_NAME_RULES.gemini;
+    default:
+      return TOOL_CALL_NAME_RULES.generic;
+  }
+}
+function isValidToolCallId(id) {
+  return typeof id === "string" && id.trim().length > 0;
+}
+function isRawReasoning(part) {
+  return part.type === "raw" && part.data.type === "reasoning";
+}
+function isDanglingReasoning(parts, idx) {
+  for (let i = idx + 1; i < parts.length; i++) {
+    const next = parts[i];
+    if (isRawReasoning(next)) return true;
+    if (next.type === "text" || next.type === "tool_call") return false;
+  }
+  return true;
+}
+function hasReplayableAssistantContent(parts) {
+  return parts.some((part) => {
+    if (part.type === "text") return part.text.length > 0;
+    if (part.type === "thinking") return false;
+    if (part.type === "raw") {
+      const t = part.data.type;
+      return !(t === "thinking" || t === "redacted_thinking" || t === "reasoning" || t === "fallback");
+    }
+    return true;
+  });
+}
+function dropInvalidToolCalls(messages, rule) {
+  const isInvalid = (part) => part.type === "tool_call" && (!isValidToolCallName(part.name, rule) || !isValidToolCallId(part.id));
+  const hasInvalid = messages.some(
+    (m) => m.role === "assistant" && Array.isArray(m.content) && m.content.some(isInvalid)
+  );
+  if (!hasInvalid) return messages;
+  const out = [];
+  let pending = /* @__PURE__ */ new Map();
+  let prunedAssistant = null;
+  for (const msg of messages) {
+    if (msg.role === "user" || msg.role === "system") {
+      if (msg.role === "user") pending = /* @__PURE__ */ new Map();
+      out.push(msg);
+      continue;
+    }
+    if (msg.role === "assistant") {
+      pending = /* @__PURE__ */ new Map();
+      if (typeof msg.content === "string") {
+        out.push(msg);
+        continue;
+      }
+      const original = msg.content;
+      let dropped = false;
+      const kept = [];
+      for (const part of original) {
+        if (part.type === "tool_call") {
+          const keep = !isInvalid(part);
+          const queue = pending.get(part.id) ?? [];
+          queue.push(keep);
+          pending.set(part.id, queue);
+          if (!keep) {
+            dropped = true;
+            continue;
+          }
+        }
+        kept.push(part);
+      }
+      if (!dropped) {
+        out.push(msg);
+        continue;
+      }
+      const content = kept.filter(
+        (part, idx) => !isRawReasoning(part) || !isDanglingReasoning(kept, idx) || isDanglingReasoning(original, original.indexOf(part))
+      );
+      if (hasReplayableAssistantContent(content)) {
+        const pruned = { ...msg, content };
+        out.push(pruned);
+        prunedAssistant = pruned;
+      }
+      continue;
+    }
+    let changed = false;
+    const results = msg.content.filter((result) => {
+      const queue = pending.get(result.toolCallId);
+      const keep = queue && queue.length > 0 ? queue.shift() : true;
+      if (!keep) changed = true;
+      return keep;
+    });
+    if (!changed) out.push(msg);
+    else if (results.length > 0) out.push({ ...msg, content: results });
+  }
+  if (prunedAssistant && out[out.length - 1] === prunedAssistant) out.pop();
+  return out;
+}
 var NON_VISION_USER_IMAGE_PLACEHOLDER = "(image omitted: model does not support images)";
 var NON_VISION_TOOL_IMAGE_PLACEHOLDER = "(tool image omitted: model does not support images)";
 var NON_VIDEO_USER_PLACEHOLDER = "(video omitted: model does not support video)";
@@ -960,10 +1146,12 @@ function remapAnthropicToolCallId(id, idMap) {
   idMap.set(id, mapped);
   return mapped;
 }
-function toAnthropicMessages(messages, cacheControl) {
+function toAnthropicMessages(messages, cacheControl, options) {
   let systemText;
   const out = [];
   const idMap = /* @__PURE__ */ new Map();
+  const keepFallbackBlocks = options?.fallbackBlocks === true;
+  const droppedToolCallIds = /* @__PURE__ */ new Set();
   const trajectoryStartIdx = messages.reduce(
     (last, m, i) => m.role === "user" ? i : last,
     -1
@@ -1009,17 +1197,23 @@ function toAnthropicMessages(messages, cacheControl) {
     }
     if (msg.role === "assistant") {
       if (typeof msg.content === "string" && msg.content === "") continue;
-      const content = typeof msg.content === "string" ? msg.content : toAnthropicAssistantContent(msg.content, msgIdx > trajectoryStartIdx, idMap);
+      const content = typeof msg.content === "string" ? msg.content : toAnthropicAssistantContent(
+        applyServerFallbackReplay(msg.content, keepFallbackBlocks, droppedToolCallIds),
+        msgIdx > trajectoryStartIdx,
+        idMap
+      );
       if (Array.isArray(content) && content.length === 0) continue;
       out.push({ role: "assistant", content });
       continue;
     }
     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: msg.content.map((result) => ({
+        content: results.map((result) => ({
           type: "tool_result",
           tool_use_id: remapAnthropicToolCallId(result.toolCallId, idMap),
           content: toAnthropicToolResultContent(result.content),
@@ -1359,6 +1553,48 @@ function fineGrainedToolStreamingEnabled() {
   const v = raw.trim().toLowerCase();
   return v === "1" || v === "true" || v === "yes" || v === "on";
 }
+var SERVER_FALLBACK_BETA = "server-side-fallback-2026-07-01";
+var anthropicServerFallback = {
+  disabled: /* @__PURE__ */ new Set(),
+  reset() {
+    this.disabled.clear();
+  }
+};
+function serverFallbackKey(options) {
+  const auth = options.apiKey?.startsWith("sk-ant-oat") ? "oauth" : "key";
+  return `${options.baseUrl ?? process.env.ANTHROPIC_BASE_URL ?? ""}|${auth}`;
+}
+function isDirectAnthropicApi(baseUrl) {
+  const effective = baseUrl ?? process.env.ANTHROPIC_BASE_URL;
+  if (!effective) return true;
+  try {
+    const url = new URL(effective);
+    return url.protocol === "https:" && url.hostname === "api.anthropic.com";
+  } catch {
+    return false;
+  }
+}
+function isServerFallbackRejection(err) {
+  const status = err?.status;
+  if (status !== 400) return false;
+  const message = err instanceof Error ? err.message : String(err);
+  return /fallbacks|server-side-fallback/i.test(message);
+}
+function sumUsageIterations(usage) {
+  const iterations = usage?.iterations;
+  if (!Array.isArray(iterations) || iterations.length === 0) return null;
+  const num = (v) => typeof v === "number" && Number.isFinite(v) ? v : 0;
+  const totals = { inputTokens: 0, outputTokens: 0, cacheRead: 0, cacheWrite: 0 };
+  for (const it of iterations) {
+    if (!it || typeof it !== "object") continue;
+    const rec = it;
+    totals.inputTokens += num(rec.input_tokens);
+    totals.outputTokens += num(rec.output_tokens);
+    totals.cacheRead += num(rec.cache_read_input_tokens);
+    totals.cacheWrite += num(rec.cache_creation_input_tokens);
+  }
+  return totals;
+}
 function createClient(options) {
   const isOAuth = options.apiKey?.startsWith("sk-ant-oat");
   const userAgent = isOAuth ? options.userAgent ?? "claude-cli/2.1.75 (external, cli)" : "";
@@ -1455,7 +1691,11 @@ async function* runStream(options) {
   const supportsFirstPartyToolExtras = !options.baseUrl || options.baseUrl.includes("api.anthropic.com");
   const downgradedImages = downgradeUnsupportedImages(options.messages, options.supportsImages);
   const downgradedMessages = downgradeUnsupportedVideos(downgradedImages, options.supportsVideo);
-  const { system: rawSystem, messages } = toAnthropicMessages(downgradedMessages, cacheControl);
+  const fallbackKey = serverFallbackKey(options);
+  const useServerFallback = options.provider !== "minimax" && isDirectAnthropicApi(options.baseUrl) && !anthropicServerFallback.disabled.has(fallbackKey);
+  const { system: rawSystem, messages } = toAnthropicMessages(downgradedMessages, cacheControl, {
+    fallbackBlocks: useServerFallback
+  });
   const system = isOAuth ? [
     {
       type: "text",
@@ -1525,6 +1765,7 @@ async function* runStream(options) {
       ];
       return contextEdits.length ? { context_management: { edits: contextEdits } } : {};
     })(),
+    ...useServerFallback ? { fallbacks: "default" } : {},
     stream: useStreaming
   };
   const hasAdaptiveThinking = isAdaptiveThinkingModel(options.model);
@@ -1541,20 +1782,41 @@ async function* runStream(options) {
     // it Anthropic silently ignores ttl:"1h" and falls back to the 5-min default,
     // so a pre-warmed cache expires before the user's first turn. cacheControl.ttl
     // is only "1h" on the first-party endpoint (see toAnthropicCacheControl).
-    ...cacheControl?.ttl === "1h" ? ["extended-cache-ttl-2025-04-11"] : []
+    ...cacheControl?.ttl === "1h" ? ["extended-cache-ttl-2025-04-11"] : [],
+    ...useServerFallback ? [SERVER_FALLBACK_BETA] : []
   ];
-  const requestOptions = {
+  const toRequestOptions = (betas) => ({
     signal: options.signal ?? void 0,
-    ...betaHeaders.length ? { headers: { "anthropic-beta": betaHeaders.join(",") } } : {}
+    ...betas.length ? { headers: { "anthropic-beta": betas.join(",") } } : {}
+  });
+  const requestOptions = toRequestOptions(betaHeaders);
+  const send = async (create) => {
+    try {
+      return await create(params, requestOptions);
+    } catch (err) {
+      if (!useServerFallback || !isServerFallbackRejection(err)) throw err;
+      anthropicServerFallback.disabled.add(fallbackKey);
+      const { fallbacks: _dropped, ...rest } = params;
+      const retryParams = {
+        ...rest,
+        messages: toAnthropicMessages(downgradedMessages, cacheControl, { fallbackBlocks: false }).messages
+      };
+      return create(
+        retryParams,
+        toRequestOptions(betaHeaders.filter((b) => b !== SERVER_FALLBACK_BETA))
+      );
+    }
   };
   if (!useStreaming) {
     try {
       const nonStreamingClient = client.withOptions({
         timeout: NON_STREAMING_REQUEST_TIMEOUT_MS
       });
-      const message = await nonStreamingClient.messages.create(
-        { ...params, stream: false },
-        requestOptions
+      const message = await send(
+        (p, o) => nonStreamingClient.messages.create(
+          { ...p, stream: false },
+          o
+        )
       );
       yield* synthesizeEventsFromMessage(message);
       return messageToResponse(message);
@@ -1572,9 +1834,8 @@ async function* runStream(options) {
   const keepalive = { type: "keepalive" };
   let receivedAnyEvent = false;
   try {
-    const stream2 = await client.messages.create(
-      params,
-      requestOptions
+    const stream2 = await send(
+      (p, o) => client.messages.create(p, o)
     );
     for await (const event of stream2) {
       receivedAnyEvent = true;
@@ -1752,6 +2013,13 @@ async function* runStream(options) {
           if (usage?.output_tokens != null) {
             outputTokens = usage.output_tokens;
           }
+          const totals = sumUsageIterations(usage);
+          if (totals) {
+            inputTokens = totals.inputTokens;
+            outputTokens = totals.outputTokens;
+            cacheRead = totals.cacheRead;
+            cacheWrite = totals.cacheWrite;
+          }
           yield keepalive;
           break;
         }
@@ -1881,10 +2149,11 @@ function messageToResponse(message) {
     }
   }
   const usage = message.usage;
-  const inputTokens = usage.input_tokens ?? 0;
-  const outputTokens = usage.output_tokens ?? 0;
-  const cacheRead = usage.cache_read_input_tokens;
-  const cacheWrite = usage.cache_creation_input_tokens;
+  const totals = sumUsageIterations(usage);
+  const inputTokens = totals?.inputTokens ?? usage.input_tokens ?? 0;
+  const outputTokens = totals?.outputTokens ?? usage.output_tokens ?? 0;
+  const cacheRead = totals?.cacheRead ?? usage.cache_read_input_tokens;
+  const cacheWrite = totals?.cacheWrite ?? usage.cache_creation_input_tokens;
   return {
     message: {
       role: "assistant",
@@ -4092,15 +4361,23 @@ function stream(options) {
     throw new VideoUnsupportedError();
   }
   const wireMessages = stripMessageProvenance(options.messages);
-  const messages = clampProviderContextImages(
-    sanitizeMessagesForWire(wireMessages),
-    options.provider,
-    options.supportsImages
+  const sanitized = sanitizeMessagesForWire(wireMessages);
+  const replayable = dropInvalidToolCalls(
+    sanitized,
+    toolCallNameRuleFor(options.provider, {
+      accountId: options.accountId,
+      baseUrl: options.baseUrl
+    })
   );
+  const messages = clampProviderContextImages(replayable, options.provider, options.supportsImages);
   if (options.onContextPrepared) {
     try {
       options.onContextPrepared(
-        observePreparedContext(wireMessages, messages, options.tools ?? [])
+        observePreparedContext(
+          replayable === sanitized ? wireMessages : replayable,
+          messages,
+          options.tools ?? []
+        )
       );
     } catch {
     }
@@ -4516,14 +4793,17 @@ function registerPalsuProvider(config) {
   ProviderError,
   REDACTION_MARKER,
   StreamResult,
+  TOOL_CALL_NAME_RULES,
   clampProviderContextImages,
   classifyProviderError,
+  dropInvalidToolCalls,
   environmentSecrets,
   formatError,
   formatErrorForDisplay,
   hasLoneSurrogate,
   isHardBillingMessage,
   isUsageLimitError,
+  isValidToolCallName,
   localWireModelId,
   palsuAssistantMessage,
   palsuText,
@@ -4542,6 +4822,7 @@ function registerPalsuProvider(config) {
   stream,
   toAnthropicMessages,
   toOpenAIMessages,
-  toWellFormedText
+  toWellFormedText,
+  toolCallNameRuleFor
 });
 //# sourceMappingURL=index.cjs.map