@prestyj/ai 5.11.0 → 5.13.0

package/README.md

@@ -42,7 +42,7 @@ Tool parameters are Zod schemas. Converted to JSON Schema at the provider bounda
 |---|---|---|
 | `anthropic` | Claude Opus 5, Sonnet 5, Haiku 4.5 | Extended thinking, prompt caching, server-side compaction |
 | `openai` | GPT-4.1, o3, o4-mini | Supports OAuth (codex endpoint) and API keys |
-| `glm` | GLM-5.1, GLM-4.7 | Z.AI platform, OpenAI-compatible |
+| `glm` | GLM-5.3 | Z.AI platform, OpenAI-compatible |
 | `moonshot` | Kimi K3, Kimi K2.7 Code | Moonshot platform, OpenAI-compatible |
 
 ---

package/dist/index.cjs

@@ -53,6 +53,7 @@ __export(index_exports, {
   redactText: () => redactText,
   redactValue: () => redactValue,
   registerPalsuProvider: () => registerPalsuProvider,
+  resolveToolSchema: () => resolveToolSchema,
   sanitizeMessagesForWire: () => sanitizeMessagesForWire,
   setProviderDiagnostic: () => setProviderDiagnostic,
   sliceHead: () => sliceHead,
@@ -1171,6 +1172,9 @@ function toLocalReasoningEffort(level) {
   if (level === "max" || level === "ultra" || level === "xhigh") return "max";
   return level;
 }
+function toGlmReasoningEffort(level) {
+  return level === "ultra" ? "max" : level;
+}
 function toOpenAIReasoningEffort(level, model) {
   const effort = level === "max" || level === "ultra" ? "xhigh" : level;
   if (model.startsWith("fugu") && (effort === "low" || effort === "medium")) {
@@ -1226,7 +1230,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";
@@ -2040,6 +2044,11 @@ async function* runStream2(options) {
   if (usesThinkingParam) {
     if (options.thinking) {
       params.thinking = { type: "enabled" };
+      if (options.provider === "glm") {
+        params.reasoning_effort = toGlmReasoningEffort(
+          options.thinking
+        );
+      }
     } else {
       params.thinking = { type: "disabled" };
     }
@@ -2091,7 +2100,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;
       }
@@ -2275,6 +2292,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();
@@ -2286,6 +2328,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;
@@ -3646,6 +3689,8 @@ function sanitizeMessagesForWire(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)
 });
@@ -3712,13 +3757,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({
@@ -4181,6 +4238,7 @@ function registerPalsuProvider(config) {
   redactText,
   redactValue,
   registerPalsuProvider,
+  resolveToolSchema,
   sanitizeMessagesForWire,
   setProviderDiagnostic,
   sliceHead,