@kenkaiiii/gg-ai 4.6.0 → 4.6.2

package/dist/index.cjs

@@ -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) {
@@ -973,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
@@ -989,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);
@@ -1084,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;
@@ -1093,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;
@@ -1131,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);
@@ -1228,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") {
@@ -1275,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: {
@@ -1566,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";
@@ -1658,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 });
@@ -1945,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(/\/+$/, "");
@@ -2275,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;
 }
@@ -2801,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;
@@ -3257,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;