@prestyj/ai 5.28.0 → 5.29.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") {
@@ -810,10 +858,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)) {
@@ -847,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)";
@@ -953,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
@@ -1002,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),
@@ -1356,6 +1557,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)" : "";
@@ -1450,12 +1693,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",
@@ -1474,6 +1721,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,
@@ -1514,6 +1772,7 @@ async function* runStream(options) {
       ];
       return contextEdits.length ? { context_management: { edits: contextEdits } } : {};
     })(),
+    ...useServerFallback ? { fallbacks: "default" } : {},
     stream: useStreaming
   };
   const hasAdaptiveThinking = isAdaptiveThinkingModel(options.model);
@@ -1530,18 +1789,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);
@@ -1559,9 +1839,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;
@@ -1739,6 +2018,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;
         }
@@ -1868,10 +2154,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",
@@ -2577,7 +2864,7 @@ function extractRequestIdFromMessage(message) {
 
 // src/providers/openai-codex.ts
 var DEFAULT_BASE_URL = "https://chatgpt.com/backend-api";
-var CODEX_CLIENT_VERSION = "0.155.1";
+var CODEX_CLIENT_VERSION = "0.159.1";
 var CODEX_REQUEST_COMPRESSION_MIN_BYTES = 16 * 1024;
 var zstdInitPromise;
 async function encodeCodexRequest(body) {
@@ -2623,7 +2910,7 @@ async function encodeCodexRequest(body) {
   }
 }
 function usesResponsesLite(model) {
-  return model.startsWith("gpt-5.6-") || model.startsWith("gpt-6-");
+  return model.startsWith("gpt-5.6-") || model.startsWith("gpt-6-") || model.startsWith("gpt-6.");
 }
 function outputTextKey(itemId, contentIndex) {
   return `${itemId ?? ""}:${contentIndex ?? 0}`;
@@ -2745,7 +3032,7 @@ async function* runStream3(options, retriedWithoutReasoning = false) {
     if (response.status === 400 && message === `The '${options.model}' model is not supported when using Codex with a ChatGPT account.`) {
       hint = "This model is not available through your ChatGPT account. Switch to a model listed for OpenAI via the model selector, or check your ChatGPT usage limits.";
     } else if (response.status === 404 && text.includes("does not exist")) {
-      hint = "This model is not in OpenAI's current catalog for your ChatGPT account. Switch to GPT-6 Astra, GPT-6 Sol, or GPT-6 Luna via the model selector.";
+      hint = "This model is not in OpenAI's current catalog for your ChatGPT account. Switch to GPT-6 Astra, GPT-6.1 Sol, or GPT-6 Luna via the model selector.";
     }
     throw new ProviderError("openai", message, {
       statusCode: response.status,
@@ -2759,6 +3046,8 @@ async function* runStream3(options, retriedWithoutReasoning = false) {
   const contentParts = [];
   let textAccum = "";
   const toolCalls = /* @__PURE__ */ new Map();
+  const finishedToolCalls = /* @__PURE__ */ new Set();
+  let terminal;
   const orderedItems = [];
   const outputItemTypes = /* @__PURE__ */ new Map();
   const outputTextByPart = /* @__PURE__ */ new Map();
@@ -2902,6 +3191,7 @@ async function* runStream3(options, retriedWithoutReasoning = false) {
       for (const [key, tc] of toolCalls) {
         if (key.endsWith(`|${itemId}`)) {
           tc.argsJson = argsStr;
+          finishedToolCalls.add(key);
           break;
         }
       }
@@ -2927,6 +3217,7 @@ async function* runStream3(options, retriedWithoutReasoning = false) {
         const id = `${callId}|${itemId}`;
         const tc = toolCalls.get(id);
         if (tc) {
+          finishedToolCalls.add(id);
           orderedItems.push({ kind: "tool", id });
           const args = parseToolArguments(tc.argsJson);
           yield {
@@ -2938,8 +3229,17 @@ async function* runStream3(options, retriedWithoutReasoning = false) {
         }
       }
     }
-    if (type === "response.completed" || type === "response.done") {
+    if (type === "response.completed" || type === "response.done" || type === "response.incomplete") {
       const resp = event.response;
+      if (type === "response.incomplete" || resp?.status === "incomplete") {
+        const details = resp?.incomplete_details;
+        terminal = {
+          status: "incomplete",
+          reason: typeof details?.reason === "string" ? details.reason : void 0
+        };
+      } else {
+        terminal = { status: "completed" };
+      }
       const usage = resp?.usage;
       if (usage) {
         cacheRead = usage.input_tokens_details?.cached_tokens ?? 0;
@@ -2949,6 +3249,25 @@ async function* runStream3(options, retriedWithoutReasoning = false) {
       }
     }
   }
+  if (!terminal) {
+    throw new ProviderError("openai", "Stream ended before completion (no response.completed).", {
+      statusCode: 504
+    });
+  }
+  const droppedToolCalls = [...toolCalls.keys()].filter((id) => !finishedToolCalls.has(id)).length;
+  if (terminal.status === "completed") {
+    for (const [id, tc] of toolCalls) {
+      if (!finishedToolCalls.has(id)) {
+        throw new ProviderError(
+          "openai",
+          `Codex reply completed with an unfinished tool call: ${tc.name} (${id}).`,
+          { statusCode: 502 }
+        );
+      }
+    }
+  } else {
+    providerDiag("codex_incomplete", { reason: terminal.reason ?? null, droppedToolCalls });
+  }
   const seenTool = /* @__PURE__ */ new Set();
   let textInserted = false;
   for (const entry of orderedItems) {
@@ -2975,7 +3294,7 @@ async function* runStream3(options, retriedWithoutReasoning = false) {
     contentParts.push({ type: "text", text: textAccum });
   }
   for (const [id, tc] of toolCalls) {
-    if (seenTool.has(id)) continue;
+    if (seenTool.has(id) || !finishedToolCalls.has(id)) continue;
     seenTool.add(id);
     contentParts.push({
       type: "tool_call",
@@ -2984,8 +3303,15 @@ async function* runStream3(options, retriedWithoutReasoning = false) {
       args: parseToolArguments(tc.argsJson)
     });
   }
+  if (droppedToolCalls > 0) {
+    let last = contentParts.at(-1);
+    while (last?.type === "raw" && isEncryptedReasoning(last.data)) {
+      contentParts.pop();
+      last = contentParts.at(-1);
+    }
+  }
   const hasToolCalls = contentParts.some((p) => p.type === "tool_call");
-  const stopReason = hasToolCalls ? "tool_use" : "end_turn";
+  const stopReason = terminal.status === "incomplete" ? incompleteStopReason(terminal.reason) : hasToolCalls ? "tool_use" : "end_turn";
   const streamResponse = {
     message: {
       role: "assistant",
@@ -3002,6 +3328,11 @@ async function* runStream3(options, retriedWithoutReasoning = false) {
   yield { type: "done", stopReason };
   return streamResponse;
 }
+function incompleteStopReason(reason) {
+  if (reason === "max_output_tokens") return "max_tokens";
+  if (reason === "content_filter") return "refusal";
+  return "error";
+}
 async function* parseSSE(body) {
   for await (const event of readSseStream(body)) {
     const data = event.data.trim();
@@ -3861,6 +4192,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"}`;
@@ -4009,11 +4375,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) {
@@ -4137,6 +4519,8 @@ var CIRCULAR = "[CIRCULAR]";
 var SENSITIVE_NAME = /(?:^|[_-])(?:api[_-]?key|access[_-]?token|refresh[_-]?token|token|key|auth(?:orization)?|bearer|cookie|credential|private[_-]?key|password|passwd|secret)(?:$|[_-])/i;
 var ENV_SECRET_ASSIGNMENT = /\b((?:[A-Z0-9]+_)*(?:API_?KEY|ACCESS_TOKEN|REFRESH_TOKEN|TOKEN|KEY|AUTH|AUTHORIZATION|BEARER|CREDENTIALS?|PASSWORD|PASSWD|SECRET))\b(\s*[=:]\s*)(["']?)(?!\$|process\.env|os\.environ|import\.meta|env\.)(?=[^\s,"';}]*\d)([^\s,"';}=$][^\s,"';}]{7,})\3/g;
 var COMPACT_SECRET_ASSIGNMENT = /\b((?:[a-z0-9]+[_-])*(?:api[_-]?key|access[_-]?token|refresh[_-]?token|token|auth|authorization|credentials?|password|passwd|secret)|(?:[a-z0-9]+[_-])+key)=(["']?)(?!\$)([^\s,"'&;}=][^\s,"'&;}]{7,})\2/gi;
+var URL_USERINFO = /\b([a-z][a-z0-9+.-]*:\/\/)[^\s/?#@:"'`<>]*:[^\s/?#"'`<>]+@/gi;
+var URL_USERINFO_TO_FIRST_AT = /\b([a-z][a-z0-9+.-]*:\/\/)[^\s/@:]*:[^\s/@]+@/gi;
 function escaped(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -4160,7 +4544,8 @@ function redactText(text, options = {}) {
     /-----BEGIN (?:[A-Z0-9 ]+ )?PRIVATE KEY-----[\s\S]*?-----END (?:[A-Z0-9 ]+ )?PRIVATE KEY-----/g,
     REDACTED
   );
-  result = result.replace(/\b([a-z][a-z0-9+.-]*:\/\/)[^\s/@:]+:[^\s/@]+@/gi, `$1${REDACTED}@`);
+  result = result.replace(URL_USERINFO, `$1${REDACTED}@`);
+  result = result.replace(URL_USERINFO_TO_FIRST_AT, `$1${REDACTED}@`);
   result = result.replace(
     /\b(authorization\s*[:=]\s*)(?:bearer|basic)\s+[^\s,;]+/gi,
     `$1${REDACTED}`
@@ -4422,14 +4807,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,
@@ -4448,6 +4836,7 @@ function registerPalsuProvider(config) {
   stream,
   toAnthropicMessages,
   toOpenAIMessages,
-  toWellFormedText
+  toWellFormedText,
+  toolCallNameRuleFor
 });
 //# sourceMappingURL=index.cjs.map