@prestyj/ai 4.2.77 → 4.3.34

package/dist/index.cjs

@@ -104,44 +104,62 @@ var EventStream = class {
   }
 };
 var StreamResult = class {
-  events;
   response;
+  buffer = [];
+  done = false;
+  error = null;
   resolveResponse;
   rejectResponse;
-  hasConsumer = false;
-  constructor() {
-    this.events = new EventStream();
+  resolveWait = null;
+  constructor(generator) {
     this.response = new Promise((resolve, reject) => {
       this.resolveResponse = resolve;
       this.rejectResponse = reject;
     });
+    this.pump(generator);
   }
-  push(event) {
-    this.events.push(event);
-  }
-  complete(response) {
-    this.events.close();
-    this.resolveResponse(response);
-  }
-  abort(error) {
-    this.events.abort(error);
-    this.rejectResponse(error);
+  async pump(generator) {
+    try {
+      let next = await generator.next();
+      while (!next.done) {
+        this.buffer.push(next.value);
+        this.resolveWait?.();
+        this.resolveWait = null;
+        next = await generator.next();
+      }
+      this.done = true;
+      this.resolveResponse(next.value);
+      this.resolveWait?.();
+      this.resolveWait = null;
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      this.error = error;
+      this.done = true;
+      this.rejectResponse(error);
+      this.resolveWait?.();
+      this.resolveWait = null;
+    }
   }
-  [Symbol.asyncIterator]() {
-    this.hasConsumer = true;
-    return this.events[Symbol.asyncIterator]();
+  async *[Symbol.asyncIterator]() {
+    let index = 0;
+    while (true) {
+      while (index < this.buffer.length) {
+        yield this.buffer[index++];
+      }
+      if (this.error) throw this.error;
+      if (this.done) return;
+      await new Promise((r) => {
+        this.resolveWait = r;
+        if (this.buffer.length > index || this.done || this.error) {
+          this.resolveWait = null;
+          r();
+        }
+      });
+    }
   }
   then(onfulfilled, onrejected) {
-    this.drainEvents().catch(() => {
-    });
     return this.response.then(onfulfilled, onrejected);
   }
-  async drainEvents() {
-    if (this.hasConsumer) return;
-    this.hasConsumer = true;
-    for await (const _ of this.events) {
-    }
-  }
 };
 
 // src/providers/anthropic.ts
@@ -215,6 +233,7 @@ function toAnthropicMessages(messages, cacheControl) {
         if (part.type === "raw") return part.data;
         return null;
       }).filter(Boolean);
+      if (Array.isArray(content) && content.length === 0) continue;
       out.push({ role: "assistant", content });
       continue;
     }
@@ -293,7 +312,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)) {
@@ -320,10 +339,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;
 }
@@ -378,13 +397,18 @@ function toOpenAIMessages(messages, options) {
       ) : void 0;
       const textParts = typeof msg.content !== "string" ? msg.content.filter((p) => p.type === "text").map((p) => p.text).join("") : void 0;
       const thinkingParts = typeof msg.content !== "string" ? msg.content.filter((p) => p.type === "thinking").map((p) => p.text).join("") : void 0;
+      const contentValue = parts || textParts || null;
+      const hasToolCalls = toolCalls && toolCalls.length > 0;
+      if (!contentValue && !hasToolCalls) continue;
       const assistantMsg = {
         role: "assistant",
-        content: parts || textParts || null,
-        ...toolCalls?.length ? { tool_calls: toolCalls } : {}
+        content: contentValue,
+        ...hasToolCalls ? { tool_calls: toolCalls } : {}
       };
-      if (thinkingParts || toolCalls?.length) {
-        assistantMsg.reasoning_content = thinkingParts || " ";
+      if (thinkingParts) {
+        assistantMsg.reasoning_content = thinkingParts;
+      } else if (options?.thinking && hasToolCalls && options.provider !== "glm") {
+        assistantMsg.reasoning_content = " ";
       }
       out.push(assistantMsg);
       continue;
@@ -450,17 +474,16 @@ function normalizeOpenAIStopReason(reason) {
 }
 
 // src/providers/anthropic.ts
-function streamAnthropic(options) {
-  const result = new StreamResult();
-  runStream(options, result).catch((err) => result.abort(toError(err)));
-  return result;
-}
-async function runStream(options, result) {
+function createClient(options) {
   const isOAuth = options.apiKey?.startsWith("sk-ant-oat");
-  const client = new import_sdk.default({
+  return new import_sdk.default({
     ...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,
     ...isOAuth ? {
       defaultHeaders: {
         "user-agent": "claude-cli/2.1.75",
@@ -468,6 +491,14 @@ async function runStream(options, result) {
       }
     } : {}
   });
+}
+function streamAnthropic(options) {
+  return new StreamResult(runStream(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 ? [
@@ -513,128 +544,323 @@ async function runStream(options, result) {
       ];
       return contextEdits.length ? { context_management: { edits: contextEdits } } : {};
     })(),
-    stream: true
+    stream: useStreaming
   };
+  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"] : [],
-    ...options.clearToolUses ? ["context-management-2025-06-27"] : []
+    ...options.clearToolUses ? ["context-management-2025-06-27"] : [],
+    "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 = [];
-  let currentToolId = "";
-  let currentToolName = "";
-  stream2.on("text", (text) => {
-    result.push({ type: "text_delta", text });
-  });
-  stream2.on("thinking", (thinkingDelta) => {
-    result.push({ type: "thinking_delta", text: thinkingDelta });
-  });
-  stream2.on("streamEvent", (event) => {
-    if (event.type === "content_block_start") {
-      if (event.content_block.type === "tool_use") {
-        currentToolId = event.content_block.id;
-        currentToolName = event.content_block.name;
-      }
-      if (event.content_block.type === "server_tool_use") {
-        currentToolId = event.content_block.id;
-        currentToolName = event.content_block.name;
+  const blocks = /* @__PURE__ */ new Map();
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let cacheRead;
+  let cacheWrite;
+  let stopReason = null;
+  const keepalive = { type: "keepalive" };
+  try {
+    for await (const event of stream2) {
+      switch (event.type) {
+        case "message_start": {
+          const usage = event.message.usage;
+          inputTokens = usage.input_tokens;
+          const usageAny = usage;
+          if (usageAny.cache_read_input_tokens != null) {
+            cacheRead = usageAny.cache_read_input_tokens;
+          }
+          if (usageAny.cache_creation_input_tokens != null) {
+            cacheWrite = usageAny.cache_creation_input_tokens;
+          }
+          yield keepalive;
+          break;
+        }
+        case "content_block_start": {
+          const block = event.content_block;
+          const idx = event.index;
+          const accum = {
+            type: block.type,
+            text: "",
+            thinking: "",
+            signature: "",
+            toolId: "",
+            toolName: "",
+            argsJson: "",
+            input: void 0,
+            raw: null
+          };
+          if (block.type === "tool_use") {
+            accum.toolId = block.id;
+            accum.toolName = block.name;
+          } else if (block.type === "server_tool_use") {
+            accum.toolId = block.id;
+            accum.toolName = block.name;
+            accum.input = block.input;
+          } else if (block.type === "redacted_thinking") {
+            accum.raw = block;
+          }
+          blocks.set(idx, accum);
+          yield keepalive;
+          break;
+        }
+        case "content_block_delta": {
+          const accum = blocks.get(event.index);
+          if (!accum) break;
+          const delta = event.delta;
+          const deltaType = delta.type;
+          if (deltaType === "text_delta") {
+            const text = delta.text;
+            accum.text += text;
+            yield { type: "text_delta", text };
+          } else if (deltaType === "thinking_delta") {
+            const text = delta.thinking;
+            accum.thinking += text;
+            yield { type: "thinking_delta", text };
+          } else if (deltaType === "input_json_delta") {
+            const partialJson = delta.partial_json;
+            accum.argsJson += partialJson;
+            yield {
+              type: "toolcall_delta",
+              id: accum.toolId,
+              name: accum.toolName,
+              argsJson: partialJson
+            };
+          } else if (deltaType === "signature_delta") {
+            accum.signature = delta.signature;
+          }
+          break;
+        }
+        case "content_block_stop": {
+          const accum = blocks.get(event.index);
+          if (!accum) break;
+          if (accum.type === "text") {
+            contentParts.push({ type: "text", text: accum.text });
+          } else if (accum.type === "thinking") {
+            contentParts.push({
+              type: "thinking",
+              text: accum.thinking,
+              signature: accum.signature
+            });
+            yield keepalive;
+          } else if (accum.type === "tool_use") {
+            let args = {};
+            try {
+              args = JSON.parse(accum.argsJson);
+            } catch {
+            }
+            const tc = {
+              type: "tool_call",
+              id: accum.toolId,
+              name: accum.toolName,
+              args
+            };
+            contentParts.push(tc);
+            yield {
+              type: "toolcall_done",
+              id: tc.id,
+              name: tc.name,
+              args: tc.args
+            };
+          } else if (accum.type === "server_tool_use") {
+            const stc = {
+              type: "server_tool_call",
+              id: accum.toolId,
+              name: accum.toolName,
+              input: accum.input
+            };
+            contentParts.push(stc);
+            yield {
+              type: "server_toolcall",
+              id: stc.id,
+              name: stc.name,
+              input: stc.input
+            };
+          } else if (accum.type === "redacted_thinking" && accum.raw) {
+            contentParts.push({ type: "raw", data: accum.raw });
+            yield keepalive;
+          } else {
+            const msg = stream2.currentMessage;
+            const rawBlock = msg?.content[event.index];
+            if (rawBlock) {
+              const blockType = rawBlock.type;
+              if (blockType === "web_search_tool_result") {
+                const str = {
+                  type: "server_tool_result",
+                  toolUseId: rawBlock.tool_use_id,
+                  resultType: blockType,
+                  data: rawBlock
+                };
+                contentParts.push(str);
+                yield {
+                  type: "server_toolresult",
+                  toolUseId: str.toolUseId,
+                  resultType: str.resultType,
+                  data: str.data
+                };
+              } else {
+                contentParts.push({ type: "raw", data: rawBlock });
+              }
+            }
+          }
+          blocks.delete(event.index);
+          break;
+        }
+        case "message_delta": {
+          const delta = event.delta;
+          if (delta.stop_reason) {
+            stopReason = delta.stop_reason;
+          }
+          const usage = event.usage;
+          if (usage?.output_tokens != null) {
+            outputTokens = usage.output_tokens;
+          }
+          yield keepalive;
+          break;
+        }
+        // message_stop — loop exits naturally
+        default:
+          yield keepalive;
+          break;
       }
     }
-  });
-  stream2.on("inputJson", (delta) => {
-    result.push({
-      type: "toolcall_delta",
-      id: currentToolId,
-      name: currentToolName,
-      argsJson: delta
-    });
-  });
-  stream2.on("contentBlock", (block) => {
-    if (block.type === "text") {
-      contentParts.push({ type: "text", text: block.text });
-    } else if (block.type === "thinking") {
-      contentParts.push({ type: "thinking", text: block.thinking, signature: block.signature });
-    } else if (block.type === "tool_use") {
-      const tc = {
-        type: "tool_call",
-        id: block.id,
-        name: block.name,
-        args: block.input
+  } catch (err) {
+    throw toError(err);
+  }
+  const normalizedStop = normalizeAnthropicStopReason(stopReason);
+  const response = {
+    message: {
+      role: "assistant",
+      content: contentParts.length > 0 ? contentParts : ""
+    },
+    stopReason: normalizedStop,
+    usage: {
+      inputTokens,
+      outputTokens,
+      ...cacheRead != null && { cacheRead },
+      ...cacheWrite != null && { cacheWrite }
+    }
+  };
+  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
       };
-      contentParts.push(tc);
-      result.push({
+      yield {
         type: "toolcall_done",
-        id: tc.id,
-        name: tc.name,
-        args: tc.args
-      });
-    } else if (block.type === "server_tool_use") {
-      const stc = {
-        type: "server_tool_call",
-        id: block.id,
-        name: block.name,
-        input: block.input
+        id: blk.id,
+        name: blk.name,
+        args: blk.input ?? {}
       };
-      contentParts.push(stc);
-      result.push({
+    } else if (type === "server_tool_use") {
+      yield {
         type: "server_toolcall",
-        id: stc.id,
-        name: stc.name,
-        input: stc.input
+        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 {
-      const raw = block;
-      const blockType = raw.type;
-      if (blockType === "web_search_tool_result") {
-        const str = {
-          type: "server_tool_result",
-          toolUseId: raw.tool_use_id,
-          resultType: blockType,
-          data: raw
-        };
-        contentParts.push(str);
-        result.push({
-          type: "server_toolresult",
-          toolUseId: str.toolUseId,
-          resultType: str.resultType,
-          data: str.data
-        });
-      } else {
-        contentParts.push({ type: "raw", data: raw });
-      }
+      contentParts.push({ type: "raw", data: blk });
     }
-  });
-  try {
-    const finalMessage = await stream2.finalMessage();
-    const stopReason = normalizeAnthropicStopReason(finalMessage.stop_reason);
-    const response = {
-      message: {
-        role: "assistant",
-        content: contentParts.length > 0 ? contentParts : ""
-      },
-      stopReason,
-      usage: {
-        inputTokens: finalMessage.usage.input_tokens,
-        outputTokens: finalMessage.usage.output_tokens,
-        ...finalMessage.usage.cache_read_input_tokens != null && {
-          cacheRead: finalMessage.usage.cache_read_input_tokens
-        },
-        ...finalMessage.usage.cache_creation_input_tokens != null && {
-          cacheWrite: finalMessage.usage.cache_creation_input_tokens
-        }
-      }
-    };
-    result.push({ type: "done", stopReason });
-    result.complete(response);
-  } catch (err) {
-    const error = toError(err);
-    result.push({ type: "error", error });
-    result.abort(error);
   }
+  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) {
@@ -651,49 +877,85 @@ function toError(err) {
 
 // src/providers/openai.ts
 var import_openai = __toESM(require("openai"), 1);
-function streamOpenAI(options) {
-  const result = new StreamResult();
-  const providerName = options.provider ?? "openai";
-  runStream2(options, result).catch((err) => result.abort(toError2(err, providerName)));
-  return result;
-}
-async function runStream2(options, result) {
-  const client = new import_openai.default({
+function createClient2(options) {
+  return new import_openai.default({
     apiKey: options.apiKey,
     ...options.baseUrl ? { baseURL: options.baseUrl } : {},
     ...options.fetch ? { fetch: options.fetch } : {}
   });
-  const usesThinkingParam = options.provider === "glm" || options.provider === "moonshot";
-  const messages = toOpenAIMessages(options.messages, { provider: options.provider });
+}
+function streamOpenAI(options) {
+  return new StreamResult(runStream2(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,
+    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,
-    ...options.maxTokens ? { max_tokens: options.maxTokens } : {},
+    stream: useStreaming,
+    ...options.maxTokens ? { max_completion_tokens: options.maxTokens } : {},
     ...effectiveTemp != null && !options.thinking ? { temperature: effectiveTemp } : {},
     ...options.topP != null ? { top_p: options.topP } : {},
     ...options.stop ? { stop: options.stop } : {},
     ...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) {
-    params.thinking = options.thinking ? { type: "enabled" } : { type: "disabled" };
+    if (options.thinking) {
+      params.thinking = { type: "enabled" };
+    } else {
+      params.thinking = { type: "disabled" };
+    }
+  }
+  if (globalThis.process && globalThis.process.env?.GGAI_DUMP_REQUEST) {
+    const fs = await import("fs");
+    const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    const dumpPath = `/tmp/ggai-request-${ts}.json`;
+    fs.writeFileSync(dumpPath, JSON.stringify(params, null, 2));
+    fs.appendFileSync(
+      "/tmp/ggai-requests.log",
+      `[${ts}] ${dumpPath} messages=${params.messages.length}
+`
+    );
+  }
+  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, {
+      signal: options.signal ?? void 0
+    });
+  } catch (err) {
+    throw toError2(err, providerName);
   }
-  const stream2 = await client.chat.completions.create(params, {
-    signal: options.signal ?? void 0
-  });
   const contentParts = [];
   const toolCallAccum = /* @__PURE__ */ new Map();
   let textAccum = "";
@@ -710,6 +972,10 @@ async function runStream2(options, result) {
       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;
@@ -720,11 +986,13 @@ async function runStream2(options, result) {
     const reasoningContent = delta.reasoning_content;
     if (typeof reasoningContent === "string" && reasoningContent) {
       thinkingAccum += reasoningContent;
-      result.push({ type: "thinking_delta", text: reasoningContent });
+      if (options.thinking) {
+        yield { type: "thinking_delta", text: reasoningContent };
+      }
     }
     if (delta.content) {
       textAccum += delta.content;
-      result.push({ type: "text_delta", text: delta.content });
+      yield { type: "text_delta", text: delta.content };
     }
     if (delta.tool_calls) {
       for (const tc of delta.tool_calls) {
@@ -741,12 +1009,12 @@ async function runStream2(options, result) {
         if (tc.function?.name) accum.name = tc.function.name;
         if (tc.function?.arguments) {
           accum.argsJson += tc.function.arguments;
-          result.push({
+          yield {
             type: "toolcall_delta",
             id: accum.id,
             name: accum.name,
             argsJson: tc.function.arguments
-          });
+          };
         }
       }
     }
@@ -770,12 +1038,12 @@ async function runStream2(options, result) {
       args
     };
     contentParts.push(toolCall);
-    result.push({
+    yield {
       type: "toolcall_done",
       id: tc.id,
       name: tc.name,
       args
-    });
+    };
   }
   const stopReason = normalizeOpenAIStopReason(finishReason);
   const response = {
@@ -786,14 +1054,116 @@ async function runStream2(options, result) {
     stopReason,
     usage: { inputTokens, outputTokens, ...cacheRead > 0 && { cacheRead } }
   };
-  result.push({ type: "done", stopReason });
-  result.complete(response);
+  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;
     const body = err.error;
     if (body) {
+      const modelName = body.model || "";
+      const _code = body.code || "";
+      const message = body.message || "";
+      if (modelName === "codex-mini-latest" || message.includes("codex-mini-latest")) {
+        msg = `codex-mini-latest requires an OpenAI Pro or Max subscription. You currently have access to GPT-5.4 and GPT-5.4 Mini with your account.`;
+      }
       msg += ` | body: ${JSON.stringify(body)}`;
     }
     return new ProviderError(provider, msg, {
@@ -811,11 +1181,9 @@ function toError2(err, provider = "openai") {
 var import_node_os = __toESM(require("os"), 1);
 var DEFAULT_BASE_URL = "https://chatgpt.com/backend-api";
 function streamOpenAICodex(options) {
-  const result = new StreamResult();
-  runStream3(options, result).catch((err) => result.abort(toError3(err)));
-  return result;
+  return new StreamResult(runStream3(options));
 }
-async function runStream3(options, result) {
+async function* runStream3(options) {
   const baseUrl = (options.baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, "");
   const url = `${baseUrl}/codex/responses`;
   const { system, input } = toCodexInput(options.messages);
@@ -865,6 +1233,11 @@ async function runStream3(options, result) {
       message += `
 
 Hint: Codex models require a ChatGPT Plus ($20/mo) or Pro ($200/mo) subscription. The "codex-spark" variants require ChatGPT Pro. Ensure your account has an active subscription at https://chatgpt.com/settings`;
+    }
+    if (response.status === 404 && text.includes("does not exist")) {
+      message += `
+
+Hint: codex-mini-latest requires an OpenAI Pro ($200/mo) or Max subscription. GPT-5.4 and GPT-5.4 Mini work with any active ChatGPT plan.`;
     }
     throw new ProviderError("openai", message, {
       statusCode: response.status
@@ -892,11 +1265,11 @@ Hint: Codex models require a ChatGPT Plus ($20/mo) or Pro ($200/mo) subscription
     if (type === "response.output_text.delta") {
       const delta = event.delta;
       textAccum += delta;
-      result.push({ type: "text_delta", text: delta });
+      yield { type: "text_delta", text: delta };
     }
     if (type === "response.reasoning_summary_text.delta") {
       const delta = event.delta;
-      result.push({ type: "thinking_delta", text: delta });
+      yield { type: "thinking_delta", text: delta };
     }
     if (type === "response.output_item.added") {
       const item = event.item;
@@ -914,12 +1287,12 @@ Hint: Codex models require a ChatGPT Plus ($20/mo) or Pro ($200/mo) subscription
       for (const [key, tc] of toolCalls) {
         if (key.endsWith(`|${itemId}`)) {
           tc.argsJson += delta;
-          result.push({
+          yield {
             type: "toolcall_delta",
             id: tc.id,
             name: tc.name,
             argsJson: delta
-          });
+          };
           break;
         }
       }
@@ -947,12 +1320,12 @@ Hint: Codex models require a ChatGPT Plus ($20/mo) or Pro ($200/mo) subscription
             args = JSON.parse(tc.argsJson);
           } catch {
           }
-          result.push({
+          yield {
             type: "toolcall_done",
             id: tc.id,
             name: tc.name,
             args
-          });
+          };
         }
       }
     }
@@ -992,8 +1365,8 @@ Hint: Codex models require a ChatGPT Plus ($20/mo) or Pro ($200/mo) subscription
     stopReason,
     usage: { inputTokens, outputTokens }
   };
-  result.push({ type: "done", stopReason });
-  result.complete(streamResponse);
+  yield { type: "done", stopReason };
+  return streamResponse;
 }
 async function* parseSSE(body) {
   const reader = body.getReader();
@@ -1107,13 +1480,6 @@ function toCodexTools(tools) {
     strict: null
   }));
 }
-function toError3(err) {
-  if (err instanceof ProviderError) return err;
-  if (err instanceof Error) {
-    return new ProviderError("openai", err.message, { cause: err });
-  }
-  return new ProviderError("openai", String(err));
-}
 
 // src/provider-registry.ts
 var ProviderRegistryImpl = class {
@@ -1153,10 +1519,16 @@ var providerRegistry = new ProviderRegistryImpl();
 
 // src/stream.ts
 var GLM_CODING_BASE_URL = "https://api.z.ai/api/coding/paas/v4";
-var GLM_REGULAR_BASE_URL = "https://api.z.ai/api/paas/v4";
 providerRegistry.register("anthropic", {
   stream: (options) => streamAnthropic(options)
 });
+providerRegistry.register("xiaomi", {
+  stream: (options) => streamOpenAI({
+    ...options,
+    baseUrl: options.baseUrl ?? "https://token-plan-sgp.xiaomimimo.com/v1",
+    webSearch: false
+  })
+});
 providerRegistry.register("openai", {
   stream: (options) => {
     if (options.accountId) {
@@ -1166,10 +1538,10 @@ providerRegistry.register("openai", {
   }
 });
 providerRegistry.register("glm", {
-  stream: (options) => {
-    if (options.baseUrl) return streamOpenAI(options);
-    return streamGLMWithFallback(options);
-  }
+  stream: (options) => streamOpenAI({
+    ...options,
+    baseUrl: options.baseUrl ?? GLM_CODING_BASE_URL
+  })
 });
 providerRegistry.register("moonshot", {
   stream: (options) => streamOpenAI({
@@ -1177,6 +1549,24 @@ 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,
+    baseUrl: options.baseUrl ?? "https://api.minimax.io/anthropic",
+    // MiniMax's Anthropic-compatible API does not support Anthropic-specific
+    // server tools (web_search), context_management, or server-side tools.
+    webSearch: false,
+    compaction: false,
+    clearToolUses: false,
+    serverTools: void 0
+  })
+});
 function stream(options) {
   const entry = providerRegistry.get(options.provider);
   if (!entry) {
@@ -1186,32 +1576,6 @@ function stream(options) {
   }
   return entry.stream(options);
 }
-function streamGLMWithFallback(options) {
-  const result = new StreamResult();
-  runGLMWithFallback(options, result).catch((err) => {
-    result.abort(err instanceof Error ? err : new Error(String(err)));
-  });
-  return result;
-}
-async function runGLMWithFallback(options, result) {
-  const codingResult = streamOpenAI({ ...options, baseUrl: GLM_CODING_BASE_URL });
-  try {
-    for await (const event of codingResult) {
-      result.push(event);
-    }
-    result.complete(await codingResult.response);
-  } catch {
-    const regularResult = streamOpenAI({ ...options, baseUrl: GLM_REGULAR_BASE_URL });
-    try {
-      for await (const event of regularResult) {
-        result.push(event);
-      }
-      result.complete(await regularResult.response);
-    } catch (fallbackErr) {
-      result.abort(fallbackErr instanceof Error ? fallbackErr : new Error(String(fallbackErr)));
-    }
-  }
-}
 
 // src/providers/palsu.ts
 function palsuText(text) {
@@ -1239,31 +1603,29 @@ function chunkText(text, size) {
   }
   return chunks.length > 0 ? chunks : [""];
 }
-function simulateStream(message, stopReason, result, signal, cacheUsage) {
+async function* simulateStream(message, stopReason, signal, cacheUsage) {
   if (signal?.aborted) {
-    result.abort(new Error("aborted"));
-    return;
+    throw new Error("aborted");
   }
   const content = typeof message.content === "string" ? message.content ? [{ type: "text", text: message.content }] : [] : message.content;
   let outputChars = 0;
   for (const part of content) {
     if (signal?.aborted) {
-      result.abort(new Error("aborted"));
-      return;
+      throw new Error("aborted");
     }
     if (part.type === "text") {
       const chunks = chunkText(part.text, DEFAULT_CHUNK_SIZE);
       for (const chunk of chunks) {
-        result.push({ type: "text_delta", text: chunk });
+        yield { type: "text_delta", text: chunk };
         outputChars += chunk.length;
       }
     } else if (part.type === "thinking") {
-      result.push({ type: "thinking_delta", text: part.text });
+      yield { type: "thinking_delta", text: part.text };
       outputChars += part.text.length;
     } else if (part.type === "tool_call") {
       const argsJson = JSON.stringify(part.args);
-      result.push({ type: "toolcall_delta", id: part.id, name: part.name, argsJson });
-      result.push({ type: "toolcall_done", id: part.id, name: part.name, args: part.args });
+      yield { type: "toolcall_delta", id: part.id, name: part.name, argsJson };
+      yield { type: "toolcall_done", id: part.id, name: part.name, args: part.args };
       outputChars += argsJson.length;
     }
   }
@@ -1274,8 +1636,8 @@ function simulateStream(message, stopReason, result, signal, cacheUsage) {
     ...cacheUsage?.cacheRead ? { cacheRead: cacheUsage.cacheRead } : {},
     ...cacheUsage?.cacheWrite ? { cacheWrite: cacheUsage.cacheWrite } : {}
   };
-  result.push({ type: "done", stopReason });
-  result.complete({ message, stopReason, usage });
+  yield { type: "done", stopReason };
+  return { message, stopReason, usage };
 }
 function computeCacheUsage(current, previous) {
   if (!previous) {
@@ -1347,24 +1709,21 @@ function registerPalsuProvider(config) {
       state.callCount++;
       const ms = modelStates.get(options.model);
       const responseDef = (ms && ms.responses.length > 0 ? ms.responses.shift() : void 0) ?? (responses.length > 0 ? responses.shift() : void 0) ?? ms?.defaultResponse ?? defaultResponse;
-      const result = new StreamResult();
       let cacheUsage;
       if (enableCache) {
         const serialized = JSON.stringify(options.messages);
         cacheUsage = computeCacheUsage(serialized, lastMessagesSerialized);
         lastMessagesSerialized = serialized;
       }
-      const rawMessage = typeof responseDef === "function" ? responseDef(options.messages, options, state) : responseDef;
-      Promise.resolve(rawMessage).then(
-        (message) => {
-          const hasToolCalls = Array.isArray(message.content) && message.content.some((p) => p.type === "tool_call");
-          const explicitStop = message._stopReason;
-          const stopReason = explicitStop ?? (hasToolCalls ? "tool_use" : "end_turn");
-          simulateStream(message, stopReason, result, options.signal, cacheUsage);
-        },
-        (err) => result.abort(err instanceof Error ? err : new Error(String(err)))
-      );
-      return result;
+      const gen = (async function* () {
+        const rawMessage = typeof responseDef === "function" ? responseDef(options.messages, options, state) : responseDef;
+        const message = await Promise.resolve(rawMessage);
+        const hasToolCalls = Array.isArray(message.content) && message.content.some((p) => p.type === "tool_call");
+        const explicitStop = message._stopReason;
+        const stopReason = explicitStop ?? (hasToolCalls ? "tool_use" : "end_turn");
+        return yield* simulateStream(message, stopReason, options.signal, cacheUsage);
+      })();
+      return new StreamResult(gen);
     }
   });
   return handle;