@prestyj/ai 4.3.15 → 4.3.54

package/README.md

@@ -40,10 +40,10 @@ Tool parameters are Zod schemas. Converted to JSON Schema at the provider bounda
 
 | Provider | Models | Notes |
 |---|---|---|
-| `anthropic` | Claude Opus 4.6, Sonnet 4.6, Haiku 4.5 | Extended thinking, prompt caching, server-side compaction |
+| `anthropic` | Claude Opus 4.7, 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.5 | Moonshot platform, OpenAI-compatible |
+| `moonshot` | Kimi K2.6 | Moonshot platform, OpenAI-compatible |
 
 ---
 

package/dist/index.cjs

@@ -174,12 +174,70 @@ function zodToJsonSchema(schema) {
 }
 
 // src/providers/transform.ts
+var NON_VISION_USER_IMAGE_PLACEHOLDER = "(image omitted: model does not support images)";
+var NON_VISION_TOOL_IMAGE_PLACEHOLDER = "(tool image omitted: model does not support images)";
+function stripImages(content, placeholder) {
+  const out = [];
+  let lastWasPlaceholder = false;
+  for (const block of content) {
+    if (block.type === "image") {
+      if (!lastWasPlaceholder) out.push({ type: "text", text: placeholder });
+      lastWasPlaceholder = true;
+      continue;
+    }
+    out.push(block);
+    lastWasPlaceholder = block.text === placeholder;
+  }
+  return out;
+}
+function downgradeUnsupportedImages(messages, supportsImages) {
+  if (supportsImages !== false) return messages;
+  return messages.map((msg) => {
+    if (msg.role === "user" && Array.isArray(msg.content)) {
+      return { ...msg, content: stripImages(msg.content, NON_VISION_USER_IMAGE_PLACEHOLDER) };
+    }
+    if (msg.role === "tool") {
+      return {
+        ...msg,
+        content: msg.content.map(
+          (tr) => Array.isArray(tr.content) ? {
+            ...tr,
+            content: stripImages(tr.content, NON_VISION_TOOL_IMAGE_PLACEHOLDER)
+          } : tr
+        )
+      };
+    }
+    return msg;
+  });
+}
+function toolResultText(content) {
+  if (typeof content === "string") return content;
+  return content.filter((b) => b.type === "text").map((b) => b.text).join("\n");
+}
+function toolResultImages(content) {
+  if (typeof content === "string") return [];
+  return content.filter((b) => b.type === "image");
+}
 function toAnthropicCacheControl(retention, baseUrl) {
   const resolved = retention ?? "short";
   if (resolved === "none") return void 0;
   const ttl = resolved === "long" && (!baseUrl || baseUrl.includes("api.anthropic.com")) ? "1h" : void 0;
   return { type: "ephemeral", ...ttl && { ttl } };
 }
+function toAnthropicToolResultContent(content) {
+  if (typeof content === "string") return content;
+  return content.map((block) => {
+    if (block.type === "text") return { type: "text", text: block.text };
+    return {
+      type: "image",
+      source: {
+        type: "base64",
+        media_type: block.mediaType,
+        data: block.data
+      }
+    };
+  });
+}
 function toAnthropicMessages(messages, cacheControl) {
   let systemText;
   const out = [];
@@ -243,7 +301,7 @@ function toAnthropicMessages(messages, cacheControl) {
         content: msg.content.map((result) => ({
           type: "tool_result",
           tool_use_id: result.toolCallId,
-          content: result.content,
+          content: toAnthropicToolResultContent(result.content),
           is_error: result.isError
         }))
       });
@@ -312,7 +370,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)) {
@@ -339,10 +397,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;
 }
@@ -407,16 +465,36 @@ 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;
     }
     if (msg.role === "tool") {
+      const imageBlocks = [];
       for (const result of msg.content) {
+        const text = toolResultText(result.content);
+        const images = toolResultImages(result.content);
+        const hasText = text.length > 0;
         out.push({
           role: "tool",
           tool_call_id: remapToolCallId(result.toolCallId, idMap),
-          content: result.content
+          content: hasText ? text : "(see attached image)"
+        });
+        if (images.length > 0 && options?.supportsImages !== false) {
+          for (const img of images) {
+            imageBlocks.push({
+              type: "image_url",
+              image_url: { url: `data:${img.mediaType};base64,${img.data}` }
+            });
+          }
+        }
+      }
+      if (imageBlocks.length > 0) {
+        out.push({
+          role: "user",
+          content: [{ type: "text", text: "Attached image(s) from tool result:" }, ...imageBlocks]
         });
       }
     }
@@ -496,8 +574,10 @@ 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 downgradedMessages = downgradeUnsupportedImages(options.messages, options.supportsImages);
+  const { system: rawSystem, messages } = toAnthropicMessages(downgradedMessages, cacheControl);
   const system = isOAuth ? [
     {
       type: "text",
@@ -541,9 +621,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"] : [],
@@ -551,10 +631,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;
@@ -747,6 +840,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 import_sdk.default.APIError) {
     return new ProviderError("anthropic", err.message, {
@@ -774,15 +966,21 @@ 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 downgradedMessages = downgradeUnsupportedImages(options.messages, options.supportsImages);
+  const messages = toOpenAIMessages(downgradedMessages, {
+    provider: options.provider,
+    thinking: !!options.thinking,
+    supportsImages: options.supportsImages
+  });
   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 } : {},
@@ -790,14 +988,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) {
@@ -818,6 +1016,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, {
@@ -842,6 +1051,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;
@@ -923,6 +1136,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 import_openai.default.APIError) {
     let msg = err.message;
@@ -956,7 +1265,8 @@ function streamOpenAICodex(options) {
 async function* runStream3(options) {
   const baseUrl = (options.baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, "");
   const url = `${baseUrl}/codex/responses`;
-  const { system, input } = toCodexInput(options.messages);
+  const downgraded = downgradeUnsupportedImages(options.messages, options.supportsImages);
+  const { system, input } = toCodexInput(downgraded, { supportsImages: options.supportsImages });
   const body = {
     model: options.model,
     store: false,
@@ -1176,7 +1486,11 @@ function remapCodexId(id, idMap) {
   idMap.set(id, mapped);
   return mapped;
 }
-function toCodexInput(messages) {
+function codexToolResultText(content) {
+  if (typeof content === "string") return content;
+  return content.filter((b) => b.type === "text").map((b) => b.text).join("\n");
+}
+function toCodexInput(messages, options) {
   let system;
   const input = [];
   const idMap = /* @__PURE__ */ new Map();
@@ -1229,12 +1543,33 @@ function toCodexInput(messages) {
       continue;
     }
     if (msg.role === "tool") {
+      const toolImages = [];
       for (const result of msg.content) {
         const [callId] = result.toolCallId.includes("|") ? result.toolCallId.split("|", 2) : [result.toolCallId];
+        const text = codexToolResultText(result.content);
         input.push({
           type: "function_call_output",
           call_id: remapCodexId(callId, idMap),
-          output: result.content
+          output: text.length > 0 ? text : "(see attached image)"
+        });
+        if (options?.supportsImages !== false && Array.isArray(result.content)) {
+          for (const block of result.content) {
+            if (block.type === "image") toolImages.push(block);
+          }
+        }
+      }
+      if (toolImages.length > 0) {
+        input.push({
+          type: "message",
+          role: "user",
+          content: [
+            { type: "input_text", text: "Attached image(s) from tool result:" },
+            ...toolImages.map((img) => ({
+              type: "input_image",
+              detail: "auto",
+              image_url: `data:${img.mediaType};base64,${img.data}`
+            }))
+          ]
         });
       }
     }
@@ -1319,6 +1654,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,