@kenkaiiii/gg-ai 4.2.90 → 4.2.92

package/dist/index.js

@@ -58,44 +58,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
@@ -337,8 +355,10 @@ function toOpenAIMessages(messages, options) {
         content: parts || textParts || null,
         ...toolCalls?.length ? { tool_calls: toolCalls } : {}
       };
-      if (thinkingParts || toolCalls?.length) {
-        assistantMsg.reasoning_content = thinkingParts || " ";
+      if (thinkingParts) {
+        assistantMsg.reasoning_content = thinkingParts;
+      } else if (options?.provider === "moonshot" && toolCalls?.length) {
+        assistantMsg.reasoning_content = " ";
       }
       out.push(assistantMsg);
       continue;
@@ -405,11 +425,9 @@ 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;
+  return new StreamResult(runStream(options));
 }
-async function runStream(options, result) {
+async function* runStream(options) {
   const isOAuth = options.apiKey?.startsWith("sk-ant-oat");
   const client = new Anthropic({
     ...isOAuth ? { apiKey: null, authToken: options.apiKey } : { apiKey: options.apiKey },
@@ -479,116 +497,185 @@ async function runStream(options, result) {
     ...betaHeaders.length ? { headers: { "anthropic-beta": betaHeaders.join(",") } } : {}
   });
   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;
-      }
-    }
-  });
-  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
-      };
-      contentParts.push(tc);
-      result.push({
-        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
-      };
-      contentParts.push(stc);
-      result.push({
-        type: "server_toolcall",
-        id: stc.id,
-        name: stc.name,
-        input: stc.input
-      });
-    } 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 });
-      }
-    }
-  });
+  const blocks = /* @__PURE__ */ new Map();
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let cacheRead;
+  let cacheWrite;
+  let stopReason = null;
   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
+    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;
+          }
+          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;
+          } else if (block.type === "redacted_thinking") {
+            accum.raw = block;
+          }
+          blocks.set(idx, accum);
+          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
+            });
+          } 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 });
+          } 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;
+          }
+          break;
         }
       }
-    };
-    result.push({ type: "done", stopReason });
-    result.complete(response);
+    }
   } catch (err) {
-    const error = toError(err);
-    result.push({ type: "error", error });
-    result.abort(error);
+    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 toError(err) {
   if (err instanceof Anthropic.APIError) {
@@ -606,12 +693,10 @@ function toError(err) {
 // src/providers/openai.ts
 import OpenAI from "openai";
 function streamOpenAI(options) {
-  const result = new StreamResult();
-  const providerName = options.provider ?? "openai";
-  runStream2(options, result).catch((err) => result.abort(toError2(err, providerName)));
-  return result;
+  return new StreamResult(runStream2(options));
 }
-async function runStream2(options, result) {
+async function* runStream2(options) {
+  const providerName = options.provider ?? "openai";
   const client = new OpenAI({
     apiKey: options.apiKey,
     ...options.baseUrl ? { baseURL: options.baseUrl } : {},
@@ -645,9 +730,14 @@ async function runStream2(options, result) {
   if (usesThinkingParam) {
     params.thinking = options.thinking ? { type: "enabled" } : { type: "disabled" };
   }
-  const stream2 = await client.chat.completions.create(params, {
-    signal: options.signal ?? void 0
-  });
+  let stream2;
+  try {
+    stream2 = await client.chat.completions.create(params, {
+      signal: options.signal ?? void 0
+    });
+  } catch (err) {
+    throw toError2(err, providerName);
+  }
   const contentParts = [];
   const toolCallAccum = /* @__PURE__ */ new Map();
   let textAccum = "";
@@ -674,11 +764,11 @@ async function runStream2(options, result) {
     const reasoningContent = delta.reasoning_content;
     if (typeof reasoningContent === "string" && reasoningContent) {
       thinkingAccum += reasoningContent;
-      result.push({ type: "thinking_delta", text: reasoningContent });
+      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) {
@@ -695,12 +785,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
-          });
+          };
         }
       }
     }
@@ -724,12 +814,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 = {
@@ -740,8 +830,8 @@ 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 toError2(err, provider = "openai") {
   if (err instanceof OpenAI.APIError) {
@@ -765,11 +855,9 @@ function toError2(err, provider = "openai") {
 import os from "os";
 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);
@@ -846,11 +934,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;
@@ -868,12 +956,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;
         }
       }
@@ -901,12 +989,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
-          });
+          };
         }
       }
     }
@@ -946,8 +1034,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();
@@ -1061,13 +1149,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 {
@@ -1141,32 +1222,28 @@ 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;
+  return new StreamResult(runGLMWithFallback(options));
 }
-async function runGLMWithFallback(options, result) {
-  const codingResult = streamOpenAI({ ...options, baseUrl: GLM_CODING_BASE_URL });
-  codingResult.response.catch(() => {
+async function* runGLMWithFallback(options) {
+  const coding = streamOpenAI({ ...options, baseUrl: GLM_CODING_BASE_URL });
+  coding.response.catch(() => {
   });
   try {
-    for await (const event of codingResult) {
-      result.push(event);
+    for await (const event of coding) {
+      yield event;
     }
-    result.complete(await codingResult.response);
+    return await coding.response;
   } catch {
-    const regularResult = streamOpenAI({ ...options, baseUrl: GLM_REGULAR_BASE_URL });
-    regularResult.response.catch(() => {
+    const regular = streamOpenAI({ ...options, baseUrl: GLM_REGULAR_BASE_URL });
+    regular.response.catch(() => {
     });
     try {
-      for await (const event of regularResult) {
-        result.push(event);
+      for await (const event of regular) {
+        yield event;
       }
-      result.complete(await regularResult.response);
+      return await regular.response;
     } catch (fallbackErr) {
-      result.abort(fallbackErr instanceof Error ? fallbackErr : new Error(String(fallbackErr)));
+      throw fallbackErr instanceof Error ? fallbackErr : new Error(String(fallbackErr));
     }
   }
 }
@@ -1197,31 +1274,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;
     }
   }
@@ -1232,8 +1307,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) {
@@ -1305,24 +1380,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;