@prestyj/ai 4.6.3 → 4.10.1

package/README.md

@@ -43,7 +43,7 @@ Tool parameters are Zod schemas. Converted to JSON Schema at the provider bounda
 | `anthropic` | Claude Fable 5, Opus 4.8, Sonnet 4.6, 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 |
-| `moonshot` | Kimi K2.6 | Moonshot platform, OpenAI-compatible |
+| `moonshot` | Kimi K2.7 | Moonshot platform, OpenAI-compatible |
 
 ---
 

package/dist/index.cjs

@@ -34,6 +34,7 @@ __export(index_exports, {
   EventStream: () => EventStream,
   ProviderError: () => ProviderError,
   StreamResult: () => StreamResult,
+  classifyProviderError: () => classifyProviderError,
   formatError: () => formatError,
   formatErrorForDisplay: () => formatErrorForDisplay,
   isHardBillingMessage: () => isHardBillingMessage,
@@ -137,10 +138,25 @@ function formatResetTime(resetsAt) {
     minute: "2-digit"
   });
 }
+function isMythosAccessError(message) {
+  const lower = message.toLowerCase();
+  return lower.includes("mythos") && (lower.includes("not_found") || lower.includes("not found") || lower.includes("no access"));
+}
 function formatError(err) {
   if (err instanceof ProviderError) {
     const name = providerDisplayName(err.provider);
     const cleanMessage = cleanProviderMessage(err.message);
+    if (isMythosAccessError(cleanMessage)) {
+      return {
+        headline: "Claude Mythos 5 is invitation-only.",
+        source: "provider",
+        message: "Your Anthropic account isn't approved for Project Glasswing, so the API reports the model as not found.",
+        provider: err.provider,
+        statusCode: err.statusCode,
+        ...err.requestId ? { requestId: err.requestId } : {},
+        guidance: "Request access via your Anthropic account team (see platform.claude.com/docs/en/about-claude/models/overview), or switch to claude-fable-5 with /model \u2014 same underlying model, generally available."
+      };
+    }
     if (isUsageLimitError(err)) {
       const resetClause = err.resetsAt ? ` It resets at ${formatResetTime(err.resetsAt)}.` : "";
       return {
@@ -327,21 +343,21 @@ var StreamResult = class {
   resolveResponse;
   rejectResponse;
   resolveWait = null;
-  constructor(generator) {
+  constructor(generator, signal) {
     this.response = new Promise((resolve, reject) => {
       this.resolveResponse = resolve;
       this.rejectResponse = reject;
     });
-    this.pump(generator);
+    this.pump(generator, signal);
   }
-  async pump(generator) {
+  async pump(generator, signal) {
     try {
-      let next = await generator.next();
+      let next = await this._nextWithAbort(generator, signal);
       while (!next.done) {
         this.buffer.push(next.value);
         this.resolveWait?.();
         this.resolveWait = null;
-        next = await generator.next();
+        next = await this._nextWithAbort(generator, signal);
       }
       this.done = true;
       this.resolveResponse(next.value);
@@ -356,6 +372,28 @@ var StreamResult = class {
       this.resolveWait = null;
     }
   }
+  async _nextWithAbort(generator, signal) {
+    if (!signal) {
+      return generator.next();
+    }
+    if (signal.aborted) {
+      return Promise.reject(new DOMException("Aborted", "AbortError"));
+    }
+    let onAbort;
+    const abortPromise = new Promise((_, reject) => {
+      onAbort = () => {
+        generator.return?.(void 0).catch(() => {
+        });
+        reject(new DOMException("Aborted", "AbortError"));
+      };
+      signal.addEventListener("abort", onAbort, { once: true });
+    });
+    try {
+      return await Promise.race([generator.next(), abortPromise]);
+    } finally {
+      if (onAbort) signal.removeEventListener("abort", onAbort);
+    }
+  }
   async *[Symbol.asyncIterator]() {
     let index = 0;
     while (true) {
@@ -452,6 +490,29 @@ function isRawThinking(part) {
   const t = part.data.type;
   return t === "thinking" || t === "redacted_thinking";
 }
+var ANTHROPIC_INPUT_BLOCK_TYPES = /* @__PURE__ */ new Set([
+  "bash_code_execution_tool_result",
+  "code_execution_tool_result",
+  "connector_text",
+  "container_upload",
+  "document",
+  "image",
+  "mid_conv_system",
+  "redacted_thinking",
+  "search_result",
+  "server_tool_use",
+  "text",
+  "text_editor_code_execution_tool_result",
+  "thinking",
+  "tool_result",
+  "tool_search_tool_result",
+  "tool_use",
+  "web_fetch_tool_result",
+  "web_search_tool_result"
+]);
+function isAnthropicCompatibleRaw(part) {
+  return ANTHROPIC_INPUT_BLOCK_TYPES.has(part.data.type);
+}
 function isPositionSensitiveThinking(part) {
   if (part.type === "thinking") return hasValidThinkingSignature(part);
   return isRawThinking(part);
@@ -478,7 +539,8 @@ function toAnthropicAssistantPart(part, idMap) {
     };
   if (part.type === "server_tool_result")
     return part.data;
-  if (part.type === "raw") return part.data;
+  if (part.type === "raw")
+    return isAnthropicCompatibleRaw(part) ? part.data : null;
   return null;
 }
 function toAnthropicAssistantContent(content, preserveThinking, idMap) {
@@ -737,12 +799,12 @@ function toAnthropicToolChoice(choice) {
   return { type: "tool", name: choice.name };
 }
 function isAdaptiveThinkingModel(model) {
-  return /fable-5|opus-4[-.]8|opus-4[-.]7|opus-4[-.]6|sonnet-4[-.]6/.test(model);
+  return /opus-4[-.]8|opus-4[-.]7|opus-4[-.]6|sonnet-4[-.]6|fable-5|mythos-5/.test(model);
 }
 function toAnthropicThinking(level, maxTokens, model) {
   if (isAdaptiveThinkingModel(model)) {
     let effort = level;
-    if (effort === "xhigh" && !/opus-4-8|opus-4-7|fable-5/.test(model)) {
+    if (effort === "xhigh" && !/opus-4-8|opus-4-7/.test(model)) {
       effort = "high";
     }
     return {
@@ -972,10 +1034,10 @@ function createClient(options) {
     ...isOAuth ? { apiKey: null, authToken: options.apiKey } : { apiKey: options.apiKey },
     ...options.baseUrl ? { baseURL: options.baseUrl } : {},
     ...options.fetch ? { fetch: options.fetch } : {},
-    // Allow SDK retries for connection-level failures (socket hang up, 500s,
-    // connection refused).  Our stall detection handles abort-initiated retries
-    // separately — SDK retries only fire on genuine transport errors.
-    maxRetries: 2,
+    // Disable SDK retries — the agent loop has its own stall/overload retry
+    // logic that surfaces errors properly. SDK retries on 429s can cause
+    // multi-minute hangs when the provider stops responding mid-retry.
+    maxRetries: 0,
     ...isOAuth ? {
       defaultHeaders: {
         // Anthropic's OAuth edge validates the claude-cli version. Callers
@@ -988,7 +1050,7 @@ function createClient(options) {
   });
 }
 function streamAnthropic(options) {
-  return new StreamResult(runStream(options));
+  return new StreamResult(runStream(options), options.signal);
 }
 async function* runStream(options) {
   const client = createClient(options);
@@ -1083,7 +1145,6 @@ async function* runStream(options) {
       throw toError(err);
     }
   }
-  const stream2 = client.messages.stream(params, requestOptions);
   const contentParts = [];
   const blocks = /* @__PURE__ */ new Map();
   let inputTokens = 0;
@@ -1092,8 +1153,14 @@ async function* runStream(options) {
   let cacheWrite;
   let stopReason = null;
   const keepalive = { type: "keepalive" };
+  let receivedAnyEvent = false;
   try {
+    const stream2 = await client.messages.create(
+      params,
+      requestOptions
+    );
     for await (const event of stream2) {
+      receivedAnyEvent = true;
       switch (event.type) {
         case "message_start": {
           const usage = event.message.usage;
@@ -1130,7 +1197,7 @@ async function* runStream(options) {
             accum.toolId = block.id;
             accum.toolName = block.name;
             accum.input = block.input;
-          } else if (block.type === "redacted_thinking") {
+          } else if (block.type !== "text" && block.type !== "thinking") {
             accum.raw = block;
           }
           blocks.set(idx, accum);
@@ -1227,8 +1294,7 @@ async function* runStream(options) {
             contentParts.push({ type: "raw", data: accum.raw });
             yield keepalive;
           } else {
-            const msg = stream2.currentMessage;
-            const rawBlock = msg?.content[event.index];
+            const rawBlock = accum.raw;
             if (rawBlock) {
               const blockType = rawBlock.type;
               if (blockType === "web_search_tool_result") {
@@ -1274,6 +1340,11 @@ async function* runStream(options) {
   } catch (err) {
     throw toError(err);
   }
+  if (!receivedAnyEvent) {
+    throw new ProviderError("anthropic", "Stream ended without producing any events.", {
+      statusCode: 504
+    });
+  }
   const normalizedStop = normalizeAnthropicStopReason(stopReason);
   const response = {
     message: {
@@ -1565,7 +1636,7 @@ function createClient2(options) {
   });
 }
 function streamOpenAI(options) {
-  return new StreamResult(runStream2(options));
+  return new StreamResult(runStream2(options), options.signal);
 }
 async function* runStream2(options) {
   const providerName = options.provider ?? "openai";
@@ -1657,51 +1728,62 @@ async function* runStream2(options) {
   let outputTokens = 0;
   let cacheRead = 0;
   let finishReason = null;
-  for await (const chunk of stream2) {
-    const choice = chunk.choices?.[0];
-    if (chunk.usage) {
-      ({ inputTokens, outputTokens, cacheRead } = extractOpenAIUsage(chunk.usage));
-    }
-    if (!choice) continue;
-    if (choice.finish_reason) {
-      finishReason = choice.finish_reason;
-    }
-    const delta = choice.delta;
-    const reasoningContent = delta.reasoning_content;
-    if (typeof reasoningContent === "string" && reasoningContent) {
-      thinkingAccum += reasoningContent;
-      if (options.thinking) {
-        yield { type: "thinking_delta", text: reasoningContent };
+  let receivedAnyChunk = false;
+  try {
+    for await (const chunk of stream2) {
+      receivedAnyChunk = true;
+      const choice = chunk.choices?.[0];
+      if (chunk.usage) {
+        ({ inputTokens, outputTokens, cacheRead } = extractOpenAIUsage(chunk.usage));
       }
-    }
-    if (delta.content) {
-      textAccum += delta.content;
-      yield { type: "text_delta", text: delta.content };
-    }
-    if (delta.tool_calls) {
-      for (const tc of delta.tool_calls) {
-        let accum = toolCallAccum.get(tc.index);
-        if (!accum) {
-          accum = {
-            id: tc.id ?? "",
-            name: tc.function?.name ?? "",
-            argsJson: ""
-          };
-          toolCallAccum.set(tc.index, accum);
+      if (!choice) continue;
+      if (choice.finish_reason) {
+        finishReason = choice.finish_reason;
+      }
+      const delta = choice.delta;
+      const reasoningContent = delta.reasoning_content;
+      if (typeof reasoningContent === "string" && reasoningContent) {
+        thinkingAccum += reasoningContent;
+        if (options.thinking) {
+          yield { type: "thinking_delta", text: reasoningContent };
         }
-        if (tc.id) accum.id = tc.id;
-        if (tc.function?.name) accum.name = tc.function.name;
-        if (tc.function?.arguments) {
-          accum.argsJson += tc.function.arguments;
-          yield {
-            type: "toolcall_delta",
-            id: accum.id,
-            name: accum.name,
-            argsJson: tc.function.arguments
-          };
+      }
+      if (delta.content) {
+        textAccum += delta.content;
+        yield { type: "text_delta", text: delta.content };
+      }
+      if (delta.tool_calls) {
+        for (const tc of delta.tool_calls) {
+          let accum = toolCallAccum.get(tc.index);
+          if (!accum) {
+            accum = {
+              id: tc.id ?? "",
+              name: tc.function?.name ?? "",
+              argsJson: ""
+            };
+            toolCallAccum.set(tc.index, accum);
+          }
+          if (tc.id) accum.id = tc.id;
+          if (tc.function?.name) accum.name = tc.function.name;
+          if (tc.function?.arguments) {
+            accum.argsJson += tc.function.arguments;
+            yield {
+              type: "toolcall_delta",
+              id: accum.id,
+              name: accum.name,
+              argsJson: tc.function.arguments
+            };
+          }
         }
       }
     }
+  } catch (err) {
+    throw toError2(err, providerName);
+  }
+  if (!receivedAnyChunk) {
+    throw new ProviderError(providerName, "Stream ended without producing any chunks.", {
+      statusCode: 504
+    });
   }
   if (thinkingAccum) {
     contentParts.push({ type: "thinking", text: thinkingAccum });
@@ -1944,7 +2026,7 @@ function isVisibleOutputItem(itemType) {
   return itemType === "message";
 }
 function streamOpenAICodex(options) {
-  return new StreamResult(runStream3(options));
+  return new StreamResult(runStream3(options), options.signal);
 }
 async function* runStream3(options) {
   const baseUrl = (options.baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, "");
@@ -2274,10 +2356,16 @@ async function* parseSSE(body) {
   }
 }
 function remapCodexId(id, idMap) {
-  if (id.startsWith("fc_") || id.startsWith("fc-")) return id;
   const existing = idMap.get(id);
   if (existing) return existing;
-  const mapped = `fc_${id.replace(/^toolu_/, "")}`;
+  const withPrefix = id.startsWith("fc_") || id.startsWith("fc-") ? id : `fc_${id.replace(/^toolu_/, "")}`;
+  const sanitized = withPrefix.replace(/[^A-Za-z0-9_-]/g, "_");
+  let mapped = sanitized;
+  let suffix = 2;
+  const used = new Set(idMap.values());
+  while (used.has(mapped)) {
+    mapped = `${sanitized}_${suffix++}`;
+  }
   idMap.set(id, mapped);
   return mapped;
 }
@@ -2800,7 +2888,7 @@ async function fetchCodeAssistWithRetry(plan, options) {
   throw lastError ?? new ProviderError("gemini", "Gemini Code Assist request failed.");
 }
 function streamGemini(options) {
-  return new StreamResult(runStream4(options));
+  return new StreamResult(runStream4(options), options.signal);
 }
 async function* runStream4(options) {
   const useStreaming = options.streaming !== false;
@@ -3020,6 +3108,96 @@ function messagesContainVideo(messages) {
   return false;
 }
 
+// src/error-classification.ts
+var CONTEXT_OVERFLOW_PATTERNS = [
+  /context_length_exceeded/i,
+  /context length exceeded/i,
+  /context window/i,
+  // OpenAI Codex / Responses
+  /maximum context length/i,
+  // OpenAI / OpenRouter / Mistral
+  /prompt is too long/i,
+  // Anthropic
+  /request_too_large/i,
+  // Anthropic HTTP 413
+  /input is too long/i,
+  // Bedrock
+  /input token count.*exceeds the maximum/i,
+  // Gemini
+  /maximum prompt length/i,
+  // xAI / Grok
+  /reduce the length of the messages/i,
+  // Groq
+  /too large for model/i,
+  // Mistral
+  /token limit/i
+  // generic
+];
+var RATE_LIMIT_PATTERNS = [
+  /rate[ _-]?limit/i,
+  /\b429\b/,
+  /too many requests/i,
+  /tokens per minute/i,
+  /requests per minute/i
+];
+var PROVIDER_TRANSIENT_PATTERNS = [
+  /\b5\d\d\b/,
+  /api_error/i,
+  /server_error/i,
+  /internal server error/i,
+  /bad gateway/i,
+  /service unavailable/i,
+  /gateway timeout/i,
+  /overloaded/i,
+  /\b529\b/
+];
+var BILLING_PATTERNS = [
+  /payment required/i,
+  /\b402\b/,
+  /quota_exceeded/i,
+  // underscore variant not in isHardBillingMessage
+  /credit balance/i
+];
+var AUTH_PATTERNS = [
+  /invalid[ _]api[ _]key/i,
+  /unauthorized/i,
+  /\b401\b/,
+  /authentication[ _]failed/i,
+  /please run \/login/i
+  // Anthropic Claude Code-style hint
+];
+function matchesAny(message, patterns) {
+  return patterns.some((p) => p.test(message));
+}
+function classifyProviderError(message) {
+  if (matchesAny(message, CONTEXT_OVERFLOW_PATTERNS)) {
+    return `[context_overflow] Worker context window exceeded \u2014 the conversation is too large to continue. Recovery: call reset_worker(project) to wipe history, then re-prompt with the task. Re-prompting WITHOUT reset will fail the same way.
+
+Original: ${message}`;
+  }
+  if (isHardBillingMessage(message) || matchesAny(message, BILLING_PATTERNS)) {
+    return `[billing] Provider billing/quota issue. Recovery: surface to the user \u2014 they need to top up or switch providers. Do NOT retry.
+
+Original: ${message}`;
+  }
+  if (matchesAny(message, AUTH_PATTERNS)) {
+    return `[auth] Provider authentication failed. Recovery: surface to the user \u2014 they need to re-login. Do NOT retry.
+
+Original: ${message}`;
+  }
+  if (matchesAny(message, RATE_LIMIT_PATTERNS)) {
+    return `[rate_limited] Provider rate limit hit. Recovery: wait ~30s, then re-prompt the same worker (no reset needed).
+
+Original: ${message}`;
+  }
+  if (matchesAny(message, PROVIDER_TRANSIENT_PATTERNS)) {
+    return `[provider_transient] Provider server-side/transient error. Recovery: wait briefly, then re-prompt the same worker (no reset needed). If it keeps happening, switch models/providers or check provider status.
+
+Original: ${message}`;
+  }
+  return message;
+}
+
 // src/providers/palsu.ts
 function palsuText(text) {
   return { role: "assistant", content: text ? [{ type: "text", text }] : [] };
@@ -3166,7 +3344,7 @@ function registerPalsuProvider(config) {
         const stopReason = explicitStop ?? (hasToolCalls ? "tool_use" : "end_turn");
         return yield* simulateStream(message, stopReason, options.signal, cacheUsage);
       })();
-      return new StreamResult(gen);
+      return new StreamResult(gen, options.signal);
     }
   });
   return handle;
@@ -3177,6 +3355,7 @@ function registerPalsuProvider(config) {
   EventStream,
   ProviderError,
   StreamResult,
+  classifyProviderError,
   formatError,
   formatErrorForDisplay,
   isHardBillingMessage,