@prestyj/ai 5.10.0 → 5.12.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);
 
@@ -1221,7 +1226,7 @@ function parseToolArguments(argsJson) {
 var NON_STREAMING_TIMEOUT_MS = 60 * 60 * 1e3;
 var anthropicClientCache = /* @__PURE__ */ new Map();
 function fineGrainedToolStreamingEnabled() {
-  const raw = process.env.GG_FINE_GRAINED_TOOL_STREAMING ?? process.env.CLAUDE_CODE_ENABLE_FINE_GRAINED_TOOL_STREAMING;
+  const raw = process.env.EZ_FINE_GRAINED_TOOL_STREAMING ?? process.env.CLAUDE_CODE_ENABLE_FINE_GRAINED_TOOL_STREAMING;
   if (!raw) return false;
   const v = raw.trim().toLowerCase();
   return v === "1" || v === "true" || v === "yes" || v === "on";
@@ -2086,7 +2091,15 @@ async function* runStream2(options) {
       if (chunk.usage) {
         ({ inputTokens, outputTokens, cacheRead, cacheWrite } = extractOpenAIUsage(chunk.usage));
       }
-      if (!choice) continue;
+      if (!choice) {
+        const gatewayError = classifyChoicelessFrame(chunk);
+        if (gatewayError) {
+          throw new ProviderError(providerName, gatewayError.message, {
+            statusCode: gatewayError.statusCode
+          });
+        }
+        continue;
+      }
       if (choice.finish_reason) {
         finishReason = choice.finish_reason;
       }
@@ -2270,6 +2283,31 @@ function completionToResponse(completion, endpointKey) {
     }
   };
 }
+function classifyChoicelessFrame(frame) {
+  if (!frame || typeof frame !== "object" || Array.isArray(frame)) return null;
+  const rec = frame;
+  if (Array.isArray(rec.choices)) return null;
+  const statusOf = (value) => {
+    const n = typeof value === "string" ? Number(value) : value;
+    return typeof n === "number" && Number.isFinite(n) && n >= 400 && n <= 599 ? n : void 0;
+  };
+  const statusCode = statusOf(rec.status) ?? statusOf(rec.statusCode) ?? statusOf(rec.code);
+  const typeIsError = typeof rec.type === "string" && rec.type.toLowerCase() === "error";
+  let detailText;
+  const detail = rec.detail;
+  if (typeof detail === "string" && detail.trim()) {
+    detailText = detail.trim();
+  } else if (Array.isArray(detail)) {
+    const parts = detail.map(
+      (d) => d && typeof d === "object" && typeof d.msg === "string" ? d.msg : typeof d === "string" ? d : ""
+    ).filter(Boolean);
+    if (parts.length) detailText = parts.join("; ");
+  }
+  if (statusCode === void 0 && !typeIsError && !detailText) return null;
+  const rawMessage = (typeof rec.message === "string" && rec.message.trim() ? rec.message.trim() : void 0) ?? detailText ?? (typeof rec.error === "string" && rec.error.trim() ? rec.error.trim() : void 0) ?? (statusCode !== void 0 ? `Gateway returned status ${statusCode}.` : "Gateway error.");
+  const message = rawMessage.slice(0, 500);
+  return { message, statusCode };
+}
 function classifyOpenAICompatLimit(args) {
   const { status, code, type, message } = args;
   const codeType = `${code ?? ""} ${type ?? ""}`.toLowerCase();
@@ -2281,6 +2319,7 @@ function classifyOpenAICompatLimit(args) {
   return null;
 }
 function toError2(err, provider = "openai") {
+  if (err instanceof ProviderError) return err;
   if (err instanceof import_openai.default.APIError) {
     const body = err.error;
     const bodyMessage = typeof body?.message === "string" && body.message.trim() ? body.message.trim() : void 0;
@@ -3380,14 +3419,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 +3484,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 +3494,7 @@ async function* runStream4(options) {
     usage: {
       inputTokens: adjustedInputTokens,
       outputTokens,
+      ...reasoningTokens > 0 ? { reasoningTokens } : {},
       ...cacheRead > 0 ? { cacheRead } : {}
     }
   };
@@ -3500,9 +3543,145 @@ 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"}`;
+var GROK_CLI_PROXY_HOST = "cli-chat-proxy.grok.com";
+var GROK_CLI_VERSION = process.env.GROK_CLI_VERSION ?? "0.2.101";
 providerRegistry.register("anthropic", {
   stream: (options) => streamAnthropic(options)
 });
@@ -3569,13 +3748,25 @@ providerRegistry.register("xai", {
   // xAI's public API (console.x.ai key) is OpenAI-compatible — ride the Chat
   // Completions transport like Moonshot/DeepSeek. Grok reasoning models take
   // top-level `reasoning_effort` (low/medium/high), which the shared thinking
-  // path already sends. xAI's OAuth path exists but only via the Grok CLI's
-  // private Responses proxy (cli-chat-proxy.grok.com) with reverse-engineered
-  // attribution headers and account-tier gating — intentionally not wired.
-  stream: (options) => streamOpenAI({
-    ...options,
-    baseUrl: options.baseUrl ?? "https://api.x.ai/v1"
-  })
+  // path already sends.
+  //
+  // Subscription OAuth (SuperGrok / X Premium) routes to the Grok CLI chat proxy
+  // instead, which speaks the same Chat Completions wire but gates on Grok-CLI
+  // client identity. Inject those headers centrally here — exactly as the Kimi
+  // endpoint above — so EVERY stream (agent loop, compaction, title-gen,
+  // sub-agents) is accepted rather than depending on each call site to thread
+  // headers. Caller-provided headers still win on collision.
+  stream: (options) => {
+    const baseUrl = options.baseUrl ?? "https://api.x.ai/v1";
+    const defaultHeaders = baseUrl.includes(GROK_CLI_PROXY_HOST) ? {
+      "X-XAI-Token-Auth": "xai-grok-cli",
+      "x-grok-client-version": GROK_CLI_VERSION,
+      "x-grok-client-identifier": "ezcoder",
+      "x-grok-model-override": options.model,
+      ...options.defaultHeaders
+    } : options.defaultHeaders;
+    return streamOpenAI({ ...options, baseUrl, defaultHeaders });
+  }
 });
 providerRegistry.register("minimax", {
   stream: (options) => streamAnthropic({
@@ -3621,13 +3812,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 +4216,7 @@ function registerPalsuProvider(config) {
   environmentSecrets,
   formatError,
   formatErrorForDisplay,
+  hasLoneSurrogate,
   isHardBillingMessage,
   isUsageLimitError,
   localWireModelId,
@@ -4025,9 +4229,13 @@ function registerPalsuProvider(config) {
   redactText,
   redactValue,
   registerPalsuProvider,
+  sanitizeMessagesForWire,
   setProviderDiagnostic,
+  sliceHead,
+  sliceTail,
   stream,
   toAnthropicMessages,
-  toOpenAIMessages
+  toOpenAIMessages,
+  toWellFormedText
 });
 //# sourceMappingURL=index.cjs.map