@prestyj/ai 4.3.15 → 4.3.34

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 
-type Provider = "anthropic" | "xiaomi" | "openai" | "glm" | "moonshot" | "minimax" | "palsu";
+type Provider = "anthropic" | "xiaomi" | "openai" | "glm" | "moonshot" | "minimax" | "openrouter" | "palsu";
 type ThinkingLevel = "low" | "medium" | "high" | "max";
 type CacheRetention = "none" | "short" | "long";
 interface TextContent {
@@ -174,6 +174,12 @@ interface StreamOptions {
      *  where the default `globalThis.fetch` doesn't support streaming properly.
      *  Passed directly to the underlying provider SDK. */
     fetch?: typeof globalThis.fetch;
+    /** Use streaming transport (default: true). When false, providers issue a
+     *  single non-streaming request and synthesize events from the full response.
+     *  The agent loop flips this to `false` as a fallback after repeated stream
+     *  stalls — broken SSE connections (transient CDN / proxy issues) often
+     *  recover when the same request is issued over a plain HTTP request/response. */
+    streaming?: boolean;
 }
 
 /**

package/dist/index.js

@@ -266,7 +266,7 @@ function toAnthropicToolChoice(choice) {
   return { type: "tool", name: choice.name };
 }
 function supportsAdaptiveThinking(model) {
-  return /opus-4-6|sonnet-4-6/.test(model);
+  return /opus-4-7|opus-4-6|sonnet-4-6/.test(model);
 }
 function toAnthropicThinking(level, maxTokens, model) {
   if (supportsAdaptiveThinking(model)) {
@@ -293,10 +293,10 @@ function toAnthropicThinking(level, maxTokens, model) {
   };
 }
 function remapToolCallId(id, idMap) {
-  if (id.startsWith("call_")) return id;
+  if (!id.startsWith("toolu_")) return id;
   const existing = idMap.get(id);
   if (existing) return existing;
-  const mapped = `call_${id.replace(/^toolu_/, "")}`;
+  const mapped = `call_${id.slice(5)}`;
   idMap.set(id, mapped);
   return mapped;
 }
@@ -361,6 +361,8 @@ function toOpenAIMessages(messages, options) {
       };
       if (thinkingParts) {
         assistantMsg.reasoning_content = thinkingParts;
+      } else if (options?.thinking && hasToolCalls && options.provider !== "glm") {
+        assistantMsg.reasoning_content = " ";
       }
       out.push(assistantMsg);
       continue;
@@ -450,6 +452,7 @@ 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 cacheControl = toAnthropicCacheControl(options.cacheRetention, options.baseUrl);
   const { system: rawSystem, messages } = toAnthropicMessages(options.messages, cacheControl);
   const system = isOAuth ? [
@@ -495,9 +498,9 @@ async function* runStream(options) {
       ];
       return contextEdits.length ? { context_management: { edits: contextEdits } } : {};
     })(),
-    stream: true
+    stream: useStreaming
   };
-  const hasAdaptiveThinking = options.model.includes("opus-4-6") || options.model.includes("opus-4.6") || options.model.includes("sonnet-4-6") || options.model.includes("sonnet-4.6");
+  const hasAdaptiveThinking = options.model.includes("opus-4-7") || options.model.includes("opus-4.7") || options.model.includes("opus-4-6") || options.model.includes("opus-4.6") || options.model.includes("sonnet-4-6") || options.model.includes("sonnet-4.6");
   const betaHeaders = [
     ...isOAuth ? ["claude-code-20250219", "oauth-2025-04-20"] : [],
     ...options.compaction ? ["compact-2026-01-12"] : [],
@@ -505,10 +508,23 @@ async function* runStream(options) {
     "fine-grained-tool-streaming-2025-05-14",
     ...!hasAdaptiveThinking ? ["interleaved-thinking-2025-05-14"] : []
   ];
-  const stream2 = client.messages.stream(params, {
+  const requestOptions = {
     signal: options.signal ?? void 0,
     ...betaHeaders.length ? { headers: { "anthropic-beta": betaHeaders.join(",") } } : {}
-  });
+  };
+  if (!useStreaming) {
+    try {
+      const message = await client.messages.create(
+        { ...params, stream: false },
+        requestOptions
+      );
+      yield* synthesizeEventsFromMessage(message);
+      return messageToResponse(message);
+    } catch (err) {
+      throw toError(err);
+    }
+  }
+  const stream2 = client.messages.stream(params, requestOptions);
   const contentParts = [];
   const blocks = /* @__PURE__ */ new Map();
   let inputTokens = 0;
@@ -701,6 +717,105 @@ async function* runStream(options) {
   yield { type: "done", stopReason: normalizedStop };
   return response;
 }
+function* synthesizeEventsFromMessage(message) {
+  for (const block of message.content) {
+    const blk = block;
+    const type = blk.type;
+    if (type === "text") {
+      const text = blk.text;
+      if (text) yield { type: "text_delta", text };
+    } else if (type === "thinking") {
+      const text = blk.thinking;
+      if (text) yield { type: "thinking_delta", text };
+    } else if (type === "tool_use") {
+      const argsJson = JSON.stringify(blk.input ?? {});
+      yield {
+        type: "toolcall_delta",
+        id: blk.id,
+        name: blk.name,
+        argsJson
+      };
+      yield {
+        type: "toolcall_done",
+        id: blk.id,
+        name: blk.name,
+        args: blk.input ?? {}
+      };
+    } else if (type === "server_tool_use") {
+      yield {
+        type: "server_toolcall",
+        id: blk.id,
+        name: blk.name,
+        input: blk.input
+      };
+    } else if (type === "web_search_tool_result") {
+      yield {
+        type: "server_toolresult",
+        toolUseId: blk.tool_use_id,
+        resultType: type,
+        data: blk
+      };
+    }
+  }
+  yield { type: "done", stopReason: normalizeAnthropicStopReason(message.stop_reason) };
+}
+function messageToResponse(message) {
+  const contentParts = [];
+  for (const block of message.content) {
+    const blk = block;
+    const type = blk.type;
+    if (type === "text") {
+      contentParts.push({ type: "text", text: blk.text });
+    } else if (type === "thinking") {
+      contentParts.push({
+        type: "thinking",
+        text: blk.thinking,
+        signature: blk.signature ?? ""
+      });
+    } else if (type === "tool_use") {
+      contentParts.push({
+        type: "tool_call",
+        id: blk.id,
+        name: blk.name,
+        args: blk.input ?? {}
+      });
+    } else if (type === "server_tool_use") {
+      contentParts.push({
+        type: "server_tool_call",
+        id: blk.id,
+        name: blk.name,
+        input: blk.input
+      });
+    } else if (type === "web_search_tool_result") {
+      contentParts.push({
+        type: "server_tool_result",
+        toolUseId: blk.tool_use_id,
+        resultType: type,
+        data: blk
+      });
+    } else {
+      contentParts.push({ type: "raw", data: blk });
+    }
+  }
+  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;
+  return {
+    message: {
+      role: "assistant",
+      content: contentParts.length > 0 ? contentParts : ""
+    },
+    stopReason: normalizeAnthropicStopReason(message.stop_reason),
+    usage: {
+      inputTokens,
+      outputTokens,
+      ...cacheRead != null && { cacheRead },
+      ...cacheWrite != null && { cacheWrite }
+    }
+  };
+}
 function toError(err) {
   if (err instanceof Anthropic.APIError) {
     return new ProviderError("anthropic", err.message, {
@@ -728,15 +843,19 @@ function streamOpenAI(options) {
 }
 async function* runStream2(options) {
   const providerName = options.provider ?? "openai";
+  const useStreaming = options.streaming !== false;
   const client = createClient2(options);
   const usesThinkingParam = options.provider === "glm" || options.provider === "moonshot" || options.provider === "xiaomi";
-  const messages = toOpenAIMessages(options.messages, { provider: options.provider });
+  const messages = toOpenAIMessages(options.messages, {
+    provider: options.provider,
+    thinking: !!options.thinking
+  });
   const defaultTemp = options.provider === "glm" ? 0.6 : void 0;
   const effectiveTemp = options.temperature ?? defaultTemp;
   const params = {
     model: options.model,
     messages,
-    stream: true,
+    stream: useStreaming,
     ...options.maxTokens ? { max_completion_tokens: options.maxTokens } : {},
     ...effectiveTemp != null && !options.thinking ? { temperature: effectiveTemp } : {},
     ...options.topP != null ? { top_p: options.topP } : {},
@@ -744,14 +863,14 @@ async function* runStream2(options) {
     ...options.thinking && !usesThinkingParam ? { reasoning_effort: toOpenAIReasoningEffort(options.thinking) } : {},
     ...options.tools?.length ? { tools: toOpenAITools(options.tools) } : {},
     ...options.toolChoice && options.tools?.length ? { tool_choice: toOpenAIToolChoice(options.toolChoice) } : {},
-    stream_options: { include_usage: true }
+    ...useStreaming ? { stream_options: { include_usage: true } } : {}
   };
-  if (options.webSearch) {
-    if (options.provider === "moonshot") {
-      const raw = params;
-      const tools = (raw.tools ?? []).slice();
-      tools.push({ type: "builtin_function", function: { name: "$web_search" } });
-      raw.tools = tools;
+  if (options.provider === "openai" || options.provider === "moonshot") {
+    const paramsAny = params;
+    paramsAny.prompt_cache_key = "ezcoder";
+    const retention = options.cacheRetention ?? "short";
+    if (retention === "long") {
+      paramsAny.prompt_cache_retention = "24h";
     }
   }
   if (usesThinkingParam) {
@@ -772,6 +891,17 @@ async function* runStream2(options) {
 `
     );
   }
+  if (!useStreaming) {
+    try {
+      const completion = await client.chat.completions.create(params, {
+        signal: options.signal ?? void 0
+      });
+      yield* synthesizeEventsFromCompletion(completion, !!options.thinking);
+      return completionToResponse(completion);
+    } catch (err) {
+      throw toError2(err, providerName);
+    }
+  }
   let stream2;
   try {
     stream2 = await client.chat.completions.create(params, {
@@ -796,6 +926,10 @@ async function* runStream2(options) {
       if (details?.cached_tokens) {
         cacheRead = details.cached_tokens;
       }
+      const usageAny = chunk.usage;
+      if (!cacheRead && typeof usageAny.cached_tokens === "number" && usageAny.cached_tokens > 0) {
+        cacheRead = usageAny.cached_tokens;
+      }
       inputTokens = chunk.usage.prompt_tokens - cacheRead;
     }
     if (!choice) continue;
@@ -877,6 +1011,102 @@ async function* runStream2(options) {
   yield { type: "done", stopReason };
   return response;
 }
+function* synthesizeEventsFromCompletion(completion, thinkingEnabled) {
+  const choice = completion.choices?.[0];
+  if (!choice) {
+    yield { type: "done", stopReason: normalizeOpenAIStopReason(null) };
+    return;
+  }
+  const msg = choice.message;
+  const reasoning = msg.reasoning_content;
+  if (typeof reasoning === "string" && reasoning && thinkingEnabled) {
+    yield { type: "thinking_delta", text: reasoning };
+  }
+  if (typeof msg.content === "string" && msg.content) {
+    yield { type: "text_delta", text: msg.content };
+  }
+  const toolCalls = msg.tool_calls;
+  if (toolCalls) {
+    for (const tc of toolCalls) {
+      const argsJson = tc.function?.arguments ?? "";
+      if (argsJson) {
+        yield {
+          type: "toolcall_delta",
+          id: tc.id,
+          name: tc.function?.name ?? "",
+          argsJson
+        };
+      }
+      let args = {};
+      try {
+        args = JSON.parse(argsJson);
+      } catch {
+      }
+      yield {
+        type: "toolcall_done",
+        id: tc.id,
+        name: tc.function?.name ?? "",
+        args
+      };
+    }
+  }
+  yield { type: "done", stopReason: normalizeOpenAIStopReason(choice.finish_reason ?? null) };
+}
+function completionToResponse(completion) {
+  const choice = completion.choices?.[0];
+  const contentParts = [];
+  let textAccum = "";
+  if (choice) {
+    const msg = choice.message;
+    const reasoning = msg.reasoning_content;
+    if (typeof reasoning === "string" && reasoning) {
+      contentParts.push({ type: "thinking", text: reasoning });
+    }
+    if (typeof msg.content === "string" && msg.content) {
+      textAccum = msg.content;
+      contentParts.push({ type: "text", text: msg.content });
+    }
+    const toolCalls = msg.tool_calls;
+    if (toolCalls) {
+      for (const tc of toolCalls) {
+        let args = {};
+        try {
+          args = JSON.parse(tc.function?.arguments ?? "{}");
+        } catch {
+        }
+        const toolCall = {
+          type: "tool_call",
+          id: tc.id,
+          name: tc.function?.name ?? "",
+          args
+        };
+        contentParts.push(toolCall);
+      }
+    }
+  }
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let cacheRead = 0;
+  if (completion.usage) {
+    outputTokens = completion.usage.completion_tokens;
+    const details = completion.usage.prompt_tokens_details;
+    if (details?.cached_tokens) cacheRead = details.cached_tokens;
+    const usageAny = completion.usage;
+    if (!cacheRead && typeof usageAny.cached_tokens === "number" && usageAny.cached_tokens > 0) {
+      cacheRead = usageAny.cached_tokens;
+    }
+    inputTokens = completion.usage.prompt_tokens - cacheRead;
+  }
+  const stopReason = normalizeOpenAIStopReason(choice?.finish_reason ?? null);
+  return {
+    message: {
+      role: "assistant",
+      content: contentParts.length > 0 ? contentParts : textAccum
+    },
+    stopReason,
+    usage: { inputTokens, outputTokens, ...cacheRead > 0 && { cacheRead } }
+  };
+}
 function toError2(err, provider = "openai") {
   if (err instanceof OpenAI.APIError) {
     let msg = err.message;
@@ -1273,6 +1503,12 @@ providerRegistry.register("moonshot", {
     baseUrl: options.baseUrl ?? "https://api.moonshot.ai/v1"
   })
 });
+providerRegistry.register("openrouter", {
+  stream: (options) => streamOpenAI({
+    ...options,
+    baseUrl: options.baseUrl ?? "https://openrouter.ai/api/v1"
+  })
+});
 providerRegistry.register("minimax", {
   stream: (options) => streamAnthropic({
     ...options,