@prestyj/ai 5.10.0 → 5.11.0

package/dist/index.cjs

@@ -40,6 +40,7 @@ __export(index_exports, {
   environmentSecrets: () => environmentSecrets,
   formatError: () => formatError,
   formatErrorForDisplay: () => formatErrorForDisplay,
+  hasLoneSurrogate: () => hasLoneSurrogate,
   isHardBillingMessage: () => isHardBillingMessage,
   isUsageLimitError: () => isUsageLimitError,
   localWireModelId: () => localWireModelId,
@@ -52,10 +53,14 @@ __export(index_exports, {
   redactText: () => redactText,
   redactValue: () => redactValue,
   registerPalsuProvider: () => registerPalsuProvider,
+  sanitizeMessagesForWire: () => sanitizeMessagesForWire,
   setProviderDiagnostic: () => setProviderDiagnostic,
+  sliceHead: () => sliceHead,
+  sliceTail: () => sliceTail,
   stream: () => stream,
   toAnthropicMessages: () => toAnthropicMessages,
-  toOpenAIMessages: () => toOpenAIMessages
+  toOpenAIMessages: () => toOpenAIMessages,
+  toWellFormedText: () => toWellFormedText
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -3380,14 +3385,16 @@ async function* runStream4(options) {
   let thinkingAccum = "";
   let stopReason = "end_turn";
   let inputTokens = 0;
-  let outputTokens = 0;
+  let candidateTokens = 0;
+  let reasoningTokens = 0;
   let cacheRead = 0;
   let toolIndex = 0;
   const handleResponse = function* (chunk) {
     const usage = usageFromResponse(chunk);
     if (usage) {
       inputTokens = usage.promptTokenCount ?? inputTokens;
-      outputTokens = usage.candidatesTokenCount ?? outputTokens;
+      candidateTokens = usage.candidatesTokenCount ?? candidateTokens;
+      reasoningTokens = usage.thoughtsTokenCount ?? reasoningTokens;
       cacheRead = usage.cachedContentTokenCount ?? cacheRead;
     }
     const reason = finishReasonFromResponse(chunk);
@@ -3443,6 +3450,7 @@ async function* runStream4(options) {
   }
   if (pendingToolCalls.length > 0) stopReason = "tool_use";
   const adjustedInputTokens = Math.max(0, inputTokens - cacheRead);
+  const outputTokens = candidateTokens + reasoningTokens;
   const streamResponse = {
     message: {
       role: "assistant",
@@ -3452,6 +3460,7 @@ async function* runStream4(options) {
     usage: {
       inputTokens: adjustedInputTokens,
       outputTokens,
+      ...reasoningTokens > 0 ? { reasoningTokens } : {},
       ...cacheRead > 0 ? { cacheRead } : {}
     }
   };
@@ -3500,6 +3509,140 @@ var ProviderRegistryImpl = class {
 };
 var providerRegistry = new ProviderRegistryImpl();
 
+// src/utils/well-formed.ts
+var LONE_SURROGATE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/;
+var LONE_SURROGATE_GLOBAL = new RegExp(LONE_SURROGATE, "g");
+var REPLACEMENT = "\uFFFD";
+function hasLoneSurrogate(text) {
+  const isWellFormed = text.isWellFormed;
+  if (typeof isWellFormed === "function") return !isWellFormed.call(text);
+  return LONE_SURROGATE.test(text);
+}
+function toWellFormedText(text) {
+  if (!hasLoneSurrogate(text)) return text;
+  const toWellFormed = text.toWellFormed;
+  if (typeof toWellFormed === "function") return toWellFormed.call(text);
+  return text.replace(LONE_SURROGATE_GLOBAL, REPLACEMENT);
+}
+function isHighSurrogate(code) {
+  return code !== void 0 && code >= 55296 && code <= 56319;
+}
+function isLowSurrogate(code) {
+  return code !== void 0 && code >= 56320 && code <= 57343;
+}
+function sliceHead(text, chars) {
+  if (chars <= 0) return "";
+  if (chars >= text.length) return text;
+  const end = isHighSurrogate(text.charCodeAt(chars - 1)) ? chars - 1 : chars;
+  return text.slice(0, end);
+}
+function sliceTail(text, chars) {
+  if (chars <= 0) return "";
+  if (chars >= text.length) return text;
+  const start = text.length - chars;
+  return text.slice(isLowSurrogate(text.charCodeAt(start)) ? start + 1 : start);
+}
+function sanitizeJsonValue(value) {
+  if (typeof value === "string") return toWellFormedText(value);
+  if (Array.isArray(value)) {
+    let changed = false;
+    const next = value.map((item) => {
+      const sanitized = sanitizeJsonValue(item);
+      if (sanitized !== item) changed = true;
+      return sanitized;
+    });
+    return changed ? next : value;
+  }
+  if (value !== null && typeof value === "object") {
+    let changed = false;
+    const next = {};
+    for (const [key, item] of Object.entries(value)) {
+      const sanitizedKey = toWellFormedText(key);
+      const sanitized = sanitizeJsonValue(item);
+      if (sanitizedKey !== key || sanitized !== item) changed = true;
+      next[sanitizedKey] = sanitized;
+    }
+    return changed ? next : value;
+  }
+  return value;
+}
+function sanitizeRecord(value) {
+  return sanitizeJsonValue(value);
+}
+function sanitizePart(part) {
+  switch (part.type) {
+    case "text":
+    case "thinking": {
+      const text = toWellFormedText(part.text);
+      return text === part.text ? part : { ...part, text };
+    }
+    case "tool_call": {
+      const args = sanitizeRecord(part.args);
+      return args === part.args ? part : { ...part, args };
+    }
+    case "server_tool_call": {
+      const input = sanitizeJsonValue(part.input);
+      return input === part.input ? part : { ...part, input };
+    }
+    case "server_tool_result": {
+      const data = sanitizeJsonValue(part.data);
+      return data === part.data ? part : { ...part, data };
+    }
+    case "raw": {
+      const data = sanitizeRecord(part.data);
+      return data === part.data ? part : { ...part, data };
+    }
+    default:
+      return part;
+  }
+}
+function sanitizeParts(parts) {
+  let changed = false;
+  const next = parts.map((part) => {
+    const sanitized = sanitizePart(part);
+    if (sanitized !== part) changed = true;
+    return sanitized;
+  });
+  return changed ? next : parts;
+}
+function sanitizeToolResultContent(content) {
+  if (typeof content === "string") return toWellFormedText(content);
+  return sanitizeParts(content);
+}
+function sanitizeToolResults(results) {
+  let changed = false;
+  const next = results.map((result) => {
+    const content = sanitizeToolResultContent(result.content);
+    if (content === result.content) return result;
+    changed = true;
+    return { ...result, content };
+  });
+  return changed ? next : results;
+}
+function sanitizeMessage(message) {
+  if (message.role === "tool") {
+    const content2 = sanitizeToolResults(message.content);
+    return content2 === message.content ? message : { ...message, content: content2 };
+  }
+  if (typeof message.content === "string") {
+    const content2 = toWellFormedText(message.content);
+    return content2 === message.content ? message : { ...message, content: content2 };
+  }
+  const content = sanitizeParts(message.content);
+  return content === message.content ? message : { ...message, content };
+}
+function sanitizeMessagesForWire(messages) {
+  let sanitized;
+  for (let index = 0; index < messages.length; index++) {
+    const message = messages[index];
+    const next = sanitizeMessage(message);
+    if (next === message) continue;
+    sanitized ??= messages.slice();
+    sanitized[index] = next;
+  }
+  return sanitized ?? messages;
+}
+
 // 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"}`;
@@ -3621,13 +3764,25 @@ function stream(options) {
   if (options.supportsVideo !== true && messagesContainVideo(options.messages)) {
     throw new VideoUnsupportedError();
   }
+  const wireMessages = stripMessageProvenance(options.messages);
   const messages = clampProviderContextImages(
-    options.messages,
+    sanitizeMessagesForWire(wireMessages),
     options.provider,
     options.supportsImages
   );
   return entry.stream(messages === options.messages ? options : { ...options, messages });
 }
+function stripMessageProvenance(messages) {
+  let stripped;
+  for (let index = 0; index < messages.length; index++) {
+    const message = messages[index];
+    if (!message.provenance) continue;
+    stripped ??= messages.slice();
+    const { provenance: _provenance, ...wireMessage } = message;
+    stripped[index] = wireMessage;
+  }
+  return stripped ?? messages;
+}
 function messagesContainVideo(messages) {
   for (const msg of messages) {
     if (typeof msg.content === "string" || !Array.isArray(msg.content)) continue;
@@ -4013,6 +4168,7 @@ function registerPalsuProvider(config) {
   environmentSecrets,
   formatError,
   formatErrorForDisplay,
+  hasLoneSurrogate,
   isHardBillingMessage,
   isUsageLimitError,
   localWireModelId,
@@ -4025,9 +4181,13 @@ function registerPalsuProvider(config) {
   redactText,
   redactValue,
   registerPalsuProvider,
+  sanitizeMessagesForWire,
   setProviderDiagnostic,
+  sliceHead,
+  sliceTail,
   stream,
   toAnthropicMessages,
-  toOpenAIMessages
+  toOpenAIMessages,
+  toWellFormedText
 });
 //# sourceMappingURL=index.cjs.map