@prestyj/ai 5.28.1 → 5.29.0

package/dist/index.js

@@ -448,7 +448,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;
@@ -655,6 +659,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",
@@ -676,6 +684,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") {
@@ -743,10 +787,17 @@ function countContextImages(messages) {
   }
   return count;
 }
+var IMAGE_DROP_BATCH = 30;
+function providerImageDropCount(imageCount2, budget) {
+  const overflow = imageCount2 - budget;
+  if (overflow <= 0) return 0;
+  const batch = Math.max(1, Math.min(IMAGE_DROP_BATCH, Math.floor(budget / 3)));
+  return Math.min(imageCount2, Math.ceil(overflow / batch) * batch);
+}
 function clampProviderContextImages(messages, provider, supportsImages) {
   if (supportsImages === false) return messages;
   const budget = PROVIDER_IMAGE_BUDGETS[provider] ?? 5;
-  let remainingToRemove = countContextImages(messages) - budget;
+  let remainingToRemove = providerImageDropCount(countContextImages(messages), budget);
   if (remainingToRemove <= 0) return messages;
   return messages.map((message) => {
     if (message.role === "user" && Array.isArray(message.content)) {
@@ -780,6 +831,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)";
@@ -886,10 +1075,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
@@ -935,17 +1126,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),
@@ -1289,6 +1486,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)" : "";
@@ -1383,12 +1622,16 @@ function streamAnthropic(options) {
 async function* runStream(options) {
   const client = createClient(options);
   const isOAuth = options.apiKey?.startsWith("sk-ant-oat");
-  const useStreaming = options.streaming !== false;
+  const useStreaming = options.streaming !== false && !options.prewarm;
   const cacheControl = toAnthropicCacheControl(options.cacheRetention, options.baseUrl);
   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",
@@ -1407,6 +1650,17 @@ async function* runStream(options) {
       outputConfig = t.outputConfig;
     }
   }
+  if (options.prewarm) {
+    const budget = thinking?.budget_tokens;
+    if (budget != null && budget >= 1) {
+      return {
+        message: { role: "assistant", content: [] },
+        stopReason: "end_turn",
+        usage: { inputTokens: 0, outputTokens: 0 }
+      };
+    }
+    maxTokens = 1;
+  }
   const params = {
     model: options.model,
     max_tokens: maxTokens,
@@ -1447,6 +1701,7 @@ async function* runStream(options) {
       ];
       return contextEdits.length ? { context_management: { edits: contextEdits } } : {};
     })(),
+    ...useServerFallback ? { fallbacks: "default" } : {},
     stream: useStreaming
   };
   const hasAdaptiveThinking = isAdaptiveThinkingModel(options.model);
@@ -1463,18 +1718,39 @@ 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) {
     const nonStreamingClient = client.withOptions({ timeout: NON_STREAMING_TIMEOUT_MS });
     try {
-      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);
@@ -1492,9 +1768,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;
@@ -1672,6 +1947,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;
         }
@@ -1801,10 +2083,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",
@@ -3838,6 +4121,41 @@ function sanitizeMessagesForWire(messages) {
   return sanitized ?? messages;
 }
 
+// src/utils/context-observation.ts
+function imageCount(message) {
+  if (!message || !Array.isArray(message.content)) return 0;
+  if (message.role === "user")
+    return message.content.filter((part) => part.type === "image").length;
+  if (message.role !== "tool") return 0;
+  return message.content.reduce(
+    (count, result) => count + (Array.isArray(result.content) ? result.content.filter((part) => part.type === "image").length : 0),
+    0
+  );
+}
+function observePreparedContext(before, after, tools) {
+  let imagesBefore = 0;
+  let imagesAfter = 0;
+  let firstImageDropMessage = null;
+  for (let index = 0; index < before.length; index++) {
+    const oldCount = imageCount(before[index]);
+    const newCount = imageCount(after[index]);
+    imagesBefore += oldCount;
+    imagesAfter += newCount;
+    if (firstImageDropMessage === null && newCount < oldCount) firstImageDropMessage = index;
+  }
+  return {
+    messages: after,
+    tools: tools.map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      parameters: resolveToolSchema(tool)
+    })),
+    imagesBefore,
+    imagesAfter,
+    firstImageDropMessage
+  };
+}
+
 // src/stream.ts
 var GLM_CODING_BASE_URL = "https://api.z.ai/api/coding/paas/v4";
 var KIMI_CODE_USER_AGENT = `kimi-code-cli/${process.env.KIMI_CODE_VERSION ?? "1.0.11"}`;
@@ -3986,11 +4304,27 @@ 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(
+          replayable === sanitized ? wireMessages : replayable,
+          messages,
+          options.tools ?? []
+        )
+      );
+    } catch {
+    }
+  }
   return entry.stream(messages === options.messages ? options : { ...options, messages });
 }
 function stripMessageProvenance(messages) {
@@ -4401,14 +4735,17 @@ export {
   ProviderError,
   REDACTED as REDACTION_MARKER,
   StreamResult,
+  TOOL_CALL_NAME_RULES,
   clampProviderContextImages,
   classifyProviderError,
+  dropInvalidToolCalls,
   environmentSecrets,
   formatError,
   formatErrorForDisplay,
   hasLoneSurrogate,
   isHardBillingMessage,
   isUsageLimitError,
+  isValidToolCallName,
   localWireModelId,
   palsuAssistantMessage,
   palsuText,
@@ -4427,6 +4764,7 @@ export {
   stream,
   toAnthropicMessages,
   toOpenAIMessages,
-  toWellFormedText
+  toWellFormedText,
+  toolCallNameRuleFor
 };
 //# sourceMappingURL=index.js.map