@kenkaiiii/gg-ai 4.5.0 → 4.6.1

package/dist/index.cjs

@@ -205,7 +205,7 @@ function finaliseBySource(source, message, requestId, hint) {
         headline: message,
         source,
         message: "",
-        guidance: hint ?? "Only Kimi, Gemini, and MiniMax can analyze video. Switch with /model.",
+        guidance: hint ?? "Only Kimi, Gemini, MiniMax, and MiMo-V2.5 can analyze video. Switch with /model.",
         ...requestId ? { requestId } : {}
       };
     case "ggcoder":
@@ -328,21 +328,21 @@ var StreamResult = class {
   resolveResponse;
   rejectResponse;
   resolveWait = null;
-  constructor(generator) {
+  constructor(generator, signal) {
     this.response = new Promise((resolve, reject) => {
       this.resolveResponse = resolve;
       this.rejectResponse = reject;
     });
-    this.pump(generator);
+    this.pump(generator, signal);
   }
-  async pump(generator) {
+  async pump(generator, signal) {
     try {
-      let next = await generator.next();
+      let next = await this._nextWithAbort(generator, signal);
       while (!next.done) {
         this.buffer.push(next.value);
         this.resolveWait?.();
         this.resolveWait = null;
-        next = await generator.next();
+        next = await this._nextWithAbort(generator, signal);
       }
       this.done = true;
       this.resolveResponse(next.value);
@@ -357,6 +357,28 @@ var StreamResult = class {
       this.resolveWait = null;
     }
   }
+  async _nextWithAbort(generator, signal) {
+    if (!signal) {
+      return generator.next();
+    }
+    if (signal.aborted) {
+      return Promise.reject(new DOMException("Aborted", "AbortError"));
+    }
+    let onAbort;
+    const abortPromise = new Promise((_, reject) => {
+      onAbort = () => {
+        generator.return?.(void 0).catch(() => {
+        });
+        reject(new DOMException("Aborted", "AbortError"));
+      };
+      signal.addEventListener("abort", onAbort, { once: true });
+    });
+    try {
+      return await Promise.race([generator.next(), abortPromise]);
+    } finally {
+      if (onAbort) signal.removeEventListener("abort", onAbort);
+    }
+  }
   async *[Symbol.asyncIterator]() {
     let index = 0;
     while (true) {
@@ -848,13 +870,14 @@ function toOpenAIMessages(messages, options) {
     }
     if (msg.role === "tool") {
       const isMoonshot = options?.provider === "moonshot";
-      const imageBlocks = [];
+      const followUpMediaBlocks = [];
+      let followUpHasVideo = false;
       for (const result of msg.content) {
         const text = toolResultText(result.content);
         const images = toolResultImages(result.content);
-        const videos = isMoonshot ? toolResultVideos(result.content) : [];
+        const videos = toolResultVideos(result.content);
         const hasText = text.length > 0;
-        if (videos.length > 0) {
+        if (isMoonshot && videos.length > 0) {
           const parts = [];
           if (hasText) parts.push({ type: "text", text });
           const videoParts = videos.map((v) => {
@@ -871,21 +894,31 @@ function toOpenAIMessages(messages, options) {
         out.push({
           role: "tool",
           tool_call_id: remapToolCallId(result.toolCallId, idMap),
-          content: hasText ? text : "(see attached image)"
+          content: hasText ? text : "(see attached media)"
         });
         if (images.length > 0 && options?.supportsImages !== false) {
           for (const img of images) {
-            imageBlocks.push({
+            followUpMediaBlocks.push({
               type: "image_url",
               image_url: { url: `data:${img.mediaType};base64,${img.data}` }
             });
           }
         }
+        if (!isMoonshot && videos.length > 0) {
+          for (const v of videos) {
+            followUpMediaBlocks.push({
+              type: "video_url",
+              video_url: { url: `data:${v.mediaType};base64,${v.data}` }
+            });
+            followUpHasVideo = true;
+          }
+        }
       }
-      if (imageBlocks.length > 0) {
+      if (followUpMediaBlocks.length > 0) {
+        const label = followUpHasVideo ? "Attached media from tool result:" : "Attached image(s) from tool result:";
         out.push({
           role: "user",
-          content: [{ type: "text", text: "Attached image(s) from tool result:" }, ...imageBlocks]
+          content: [{ type: "text", text: label }, ...followUpMediaBlocks]
         });
       }
     }
@@ -962,10 +995,10 @@ function createClient(options) {
     ...isOAuth ? { apiKey: null, authToken: options.apiKey } : { apiKey: options.apiKey },
     ...options.baseUrl ? { baseURL: options.baseUrl } : {},
     ...options.fetch ? { fetch: options.fetch } : {},
-    // Allow SDK retries for connection-level failures (socket hang up, 500s,
-    // connection refused).  Our stall detection handles abort-initiated retries
-    // separately — SDK retries only fire on genuine transport errors.
-    maxRetries: 2,
+    // Disable SDK retries — the agent loop has its own stall/overload retry
+    // logic that surfaces errors properly. SDK retries on 429s can cause
+    // multi-minute hangs when the provider stops responding mid-retry.
+    maxRetries: 0,
     ...isOAuth ? {
       defaultHeaders: {
         // Anthropic's OAuth edge validates the claude-cli version. Callers
@@ -978,7 +1011,7 @@ function createClient(options) {
   });
 }
 function streamAnthropic(options) {
-  return new StreamResult(runStream(options));
+  return new StreamResult(runStream(options), options.signal);
 }
 async function* runStream(options) {
   const client = createClient(options);
@@ -1073,7 +1106,6 @@ async function* runStream(options) {
       throw toError(err);
     }
   }
-  const stream2 = client.messages.stream(params, requestOptions);
   const contentParts = [];
   const blocks = /* @__PURE__ */ new Map();
   let inputTokens = 0;
@@ -1082,8 +1114,14 @@ async function* runStream(options) {
   let cacheWrite;
   let stopReason = null;
   const keepalive = { type: "keepalive" };
+  let receivedAnyEvent = false;
   try {
+    const stream2 = await client.messages.create(
+      params,
+      requestOptions
+    );
     for await (const event of stream2) {
+      receivedAnyEvent = true;
       switch (event.type) {
         case "message_start": {
           const usage = event.message.usage;
@@ -1120,7 +1158,7 @@ async function* runStream(options) {
             accum.toolId = block.id;
             accum.toolName = block.name;
             accum.input = block.input;
-          } else if (block.type === "redacted_thinking") {
+          } else if (block.type !== "text" && block.type !== "thinking") {
             accum.raw = block;
           }
           blocks.set(idx, accum);
@@ -1217,8 +1255,7 @@ async function* runStream(options) {
             contentParts.push({ type: "raw", data: accum.raw });
             yield keepalive;
           } else {
-            const msg = stream2.currentMessage;
-            const rawBlock = msg?.content[event.index];
+            const rawBlock = accum.raw;
             if (rawBlock) {
               const blockType = rawBlock.type;
               if (blockType === "web_search_tool_result") {
@@ -1264,6 +1301,11 @@ async function* runStream(options) {
   } catch (err) {
     throw toError(err);
   }
+  if (!receivedAnyEvent) {
+    throw new ProviderError("anthropic", "Stream ended without producing any events.", {
+      statusCode: 504
+    });
+  }
   const normalizedStop = normalizeAnthropicStopReason(stopReason);
   const response = {
     message: {
@@ -1555,7 +1597,7 @@ function createClient2(options) {
   });
 }
 function streamOpenAI(options) {
-  return new StreamResult(runStream2(options));
+  return new StreamResult(runStream2(options), options.signal);
 }
 async function* runStream2(options) {
   const providerName = options.provider ?? "openai";
@@ -1647,51 +1689,62 @@ async function* runStream2(options) {
   let outputTokens = 0;
   let cacheRead = 0;
   let finishReason = null;
-  for await (const chunk of stream2) {
-    const choice = chunk.choices?.[0];
-    if (chunk.usage) {
-      ({ inputTokens, outputTokens, cacheRead } = extractOpenAIUsage(chunk.usage));
-    }
-    if (!choice) continue;
-    if (choice.finish_reason) {
-      finishReason = choice.finish_reason;
-    }
-    const delta = choice.delta;
-    const reasoningContent = delta.reasoning_content;
-    if (typeof reasoningContent === "string" && reasoningContent) {
-      thinkingAccum += reasoningContent;
-      if (options.thinking) {
-        yield { type: "thinking_delta", text: reasoningContent };
+  let receivedAnyChunk = false;
+  try {
+    for await (const chunk of stream2) {
+      receivedAnyChunk = true;
+      const choice = chunk.choices?.[0];
+      if (chunk.usage) {
+        ({ inputTokens, outputTokens, cacheRead } = extractOpenAIUsage(chunk.usage));
       }
-    }
-    if (delta.content) {
-      textAccum += delta.content;
-      yield { type: "text_delta", text: delta.content };
-    }
-    if (delta.tool_calls) {
-      for (const tc of delta.tool_calls) {
-        let accum = toolCallAccum.get(tc.index);
-        if (!accum) {
-          accum = {
-            id: tc.id ?? "",
-            name: tc.function?.name ?? "",
-            argsJson: ""
-          };
-          toolCallAccum.set(tc.index, accum);
+      if (!choice) continue;
+      if (choice.finish_reason) {
+        finishReason = choice.finish_reason;
+      }
+      const delta = choice.delta;
+      const reasoningContent = delta.reasoning_content;
+      if (typeof reasoningContent === "string" && reasoningContent) {
+        thinkingAccum += reasoningContent;
+        if (options.thinking) {
+          yield { type: "thinking_delta", text: reasoningContent };
         }
-        if (tc.id) accum.id = tc.id;
-        if (tc.function?.name) accum.name = tc.function.name;
-        if (tc.function?.arguments) {
-          accum.argsJson += tc.function.arguments;
-          yield {
-            type: "toolcall_delta",
-            id: accum.id,
-            name: accum.name,
-            argsJson: tc.function.arguments
-          };
+      }
+      if (delta.content) {
+        textAccum += delta.content;
+        yield { type: "text_delta", text: delta.content };
+      }
+      if (delta.tool_calls) {
+        for (const tc of delta.tool_calls) {
+          let accum = toolCallAccum.get(tc.index);
+          if (!accum) {
+            accum = {
+              id: tc.id ?? "",
+              name: tc.function?.name ?? "",
+              argsJson: ""
+            };
+            toolCallAccum.set(tc.index, accum);
+          }
+          if (tc.id) accum.id = tc.id;
+          if (tc.function?.name) accum.name = tc.function.name;
+          if (tc.function?.arguments) {
+            accum.argsJson += tc.function.arguments;
+            yield {
+              type: "toolcall_delta",
+              id: accum.id,
+              name: accum.name,
+              argsJson: tc.function.arguments
+            };
+          }
         }
       }
     }
+  } catch (err) {
+    throw toError2(err, providerName);
+  }
+  if (!receivedAnyChunk) {
+    throw new ProviderError(providerName, "Stream ended without producing any chunks.", {
+      statusCode: 504
+    });
   }
   if (thinkingAccum) {
     contentParts.push({ type: "thinking", text: thinkingAccum });
@@ -1934,7 +1987,7 @@ function isVisibleOutputItem(itemType) {
   return itemType === "message";
 }
 function streamOpenAICodex(options) {
-  return new StreamResult(runStream3(options));
+  return new StreamResult(runStream3(options), options.signal);
 }
 async function* runStream3(options) {
   const baseUrl = (options.baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, "");
@@ -2264,10 +2317,16 @@ async function* parseSSE(body) {
   }
 }
 function remapCodexId(id, idMap) {
-  if (id.startsWith("fc_") || id.startsWith("fc-")) return id;
   const existing = idMap.get(id);
   if (existing) return existing;
-  const mapped = `fc_${id.replace(/^toolu_/, "")}`;
+  const withPrefix = id.startsWith("fc_") || id.startsWith("fc-") ? id : `fc_${id.replace(/^toolu_/, "")}`;
+  const sanitized = withPrefix.replace(/[^A-Za-z0-9_-]/g, "_");
+  let mapped = sanitized;
+  let suffix = 2;
+  const used = new Set(idMap.values());
+  while (used.has(mapped)) {
+    mapped = `${sanitized}_${suffix++}`;
+  }
   idMap.set(id, mapped);
   return mapped;
 }
@@ -2790,7 +2849,7 @@ async function fetchCodeAssistWithRetry(plan, options) {
   throw lastError ?? new ProviderError("gemini", "Gemini Code Assist request failed.");
 }
 function streamGemini(options) {
-  return new StreamResult(runStream4(options));
+  return new StreamResult(runStream4(options), options.signal);
 }
 async function* runStream4(options) {
   const useStreaming = options.streaming !== false;
@@ -3246,7 +3305,7 @@ function registerPalsuProvider(config) {
         const stopReason = explicitStop ?? (hasToolCalls ? "tool_use" : "end_turn");
         return yield* simulateStream(message, stopReason, options.signal, cacheUsage);
       })();
-      return new StreamResult(gen);
+      return new StreamResult(gen, options.signal);
     }
   });
   return handle;