@kenkaiiii/gg-agent 4.3.199 → 4.3.201

package/dist/index.cjs

@@ -740,136 +740,23 @@ async function* agentLoop(messages, options) {
           toolCalls.push(tc);
         }
       }
-      const eventStream = new import_gg_ai.EventStream();
       let fatalToolArgumentError = null;
-      const executions = toolCalls.map(async (toolCall) => {
-        const startTime = Date.now();
-        eventStream.push({
-          type: "tool_call_start",
-          toolCallId: toolCall.id,
-          name: toolCall.name,
-          args: toolCall.args
-        });
-        let resultContent;
-        let details;
-        let isError = false;
-        const tool = toolMap.get(toolCall.name);
-        if (!tool) {
-          resultContent = `Unknown tool: ${toolCall.name}`;
-          isError = true;
-        } else {
-          try {
-            const parsed = tool.parameters.parse(toolCall.args);
-            const ctx = {
-              signal: options.signal ?? AbortSignal.timeout(3e5),
-              toolCallId: toolCall.id,
-              onUpdate: (update) => {
-                eventStream.push({
-                  type: "tool_call_update",
-                  toolCallId: toolCall.id,
-                  update
-                });
-              }
-            };
-            const raw = await tool.execute(parsed, ctx);
-            const normalized = normalizeToolResult(raw);
-            resultContent = normalized.content;
-            details = normalized.details;
-            for (const key of invalidToolArgumentCounts.keys()) {
-              if (key.startsWith(`${toolCall.name}:`)) invalidToolArgumentCounts.delete(key);
-            }
-          } catch (err) {
-            isError = true;
-            if (err instanceof import_zod.ZodError) {
-              const prettyError = (0, import_zod.prettifyError)(err);
-              const failureKey = `${toolCall.name}:${prettyError}`;
-              const failureCount = (invalidToolArgumentCounts.get(failureKey) ?? 0) + 1;
-              invalidToolArgumentCounts.set(failureKey, failureCount);
-              resultContent = `Invalid arguments for tool \`${toolCall.name}\`:
-` + prettyError + "\nRe-issue the call with each field as the correct type.";
-              if (failureCount >= 3) {
-                fatalToolArgumentError = new Error(
-                  `The model repeatedly issued invalid arguments for tool \`${toolCall.name}\`. This is usually an upstream model/tool-calling bug. Your conversation is preserved; send another message or switch models to continue.`
-                );
-              }
-            } else {
-              resultContent = err instanceof Error ? err.message : String(err);
-            }
-          }
-        }
-        const durationMs = Date.now() - startTime;
-        eventStream.push({
-          type: "tool_call_end",
-          toolCallId: toolCall.id,
-          result: toolResultPreview(resultContent),
-          details,
-          isError,
-          durationMs
-        });
-        return { toolCallId: toolCall.id, content: resultContent, isError };
-      });
-      const abortHandler = () => eventStream.abort(new Error("aborted"));
-      options.signal?.addEventListener("abort", abortHandler, { once: true });
-      let toolResultsFinalized = false;
-      Promise.all(executions).then((results) => {
-        if (toolResultsFinalized) return;
-        const resultsMap = new Map(results.map((r) => [r.toolCallId, r]));
-        for (const tc of toolCalls) {
-          const r = resultsMap.get(tc.id);
-          toolResults.push({
-            type: "tool_result",
-            toolCallId: tc.id,
-            content: r.content,
-            isError: r.isError || void 0
-          });
-        }
-        eventStream.close();
-      }).catch((err) => eventStream.abort(err instanceof Error ? err : new Error(String(err))));
-      let toolsAborted = false;
-      try {
-        for await (const event of eventStream) {
-          yield event;
-        }
-      } catch (err) {
-        if (isAbortError(err) || options.signal?.aborted) {
-          toolsAborted = true;
-        } else {
-          throw err;
-        }
-      } finally {
-        options.signal?.removeEventListener("abort", abortHandler);
-        toolResultsFinalized = true;
-        const resolvedIds = new Set(toolResults.map((r) => r.toolCallId));
-        for (const tc of toolCalls) {
-          if (!resolvedIds.has(tc.id)) {
-            toolResults.push({
-              type: "tool_result",
-              toolCallId: tc.id,
-              content: "Tool execution was aborted.",
-              isError: true
-            });
-          }
-        }
-        if (options.maxToolResultChars) {
-          const HARD_MAX = 4e5;
-          const max = Math.min(options.maxToolResultChars, HARD_MAX);
-          for (const tr of toolResults) {
-            if (typeof tr.content === "string" && tr.content.length > max) {
-              const headChars = Math.floor(max * 0.7);
-              const tailChars = max - headChars;
-              const head = tr.content.slice(0, headChars);
-              const tail = tr.content.slice(-tailChars);
-              const omitted = tr.content.length - headChars - tailChars;
-              tr.content = head + `
-
-[... ${omitted} characters omitted ...]
-
-` + tail;
-            }
-          }
-        }
-        messages.push({ role: "tool", content: toolResults });
-      }
+      const markFatalToolArgumentError = (error) => {
+        fatalToolArgumentError = error;
+      };
+      const executionOptions = {
+        signal: options.signal,
+        maxToolResultChars: options.maxToolResultChars,
+        toolMap,
+        invalidToolArgumentCounts,
+        markFatalToolArgumentError
+      };
+      const hasSequentialToolCall = toolCalls.some(
+        (toolCall) => toolMap.get(toolCall.name)?.executionMode === "sequential"
+      );
+      const executionResult = hasSequentialToolCall ? yield* executeToolCallsSequential(toolCalls, toolResults, executionOptions) : yield* executeToolCallsParallel(toolCalls, toolResults, executionOptions);
+      messages.push({ role: "tool", content: executionResult.toolResults });
+      const toolsAborted = executionResult.aborted;
       if (fatalToolArgumentError) {
         yield { type: "error", error: fatalToolArgumentError };
         break;
@@ -906,6 +793,197 @@ async function* agentLoop(messages, options) {
     totalUsage: { ...totalUsage }
   };
 }
+function pushToolEvent(eventStream, state, event) {
+  if (!state.finalized) eventStream.push(event);
+}
+async function executeSingleToolCall(toolCall, options, pushEvent) {
+  const startTime = Date.now();
+  pushEvent({
+    type: "tool_call_start",
+    toolCallId: toolCall.id,
+    name: toolCall.name,
+    args: toolCall.args
+  });
+  let resultContent;
+  let details;
+  let isError = false;
+  const tool = options.toolMap.get(toolCall.name);
+  if (!tool) {
+    resultContent = `Unknown tool: ${toolCall.name}`;
+    isError = true;
+  } else {
+    try {
+      const parsed = tool.parameters.parse(toolCall.args);
+      const ctx = {
+        signal: options.signal ?? AbortSignal.timeout(3e5),
+        toolCallId: toolCall.id,
+        onUpdate: (update) => {
+          pushEvent({
+            type: "tool_call_update",
+            toolCallId: toolCall.id,
+            update
+          });
+        }
+      };
+      const raw = await tool.execute(parsed, ctx);
+      const normalized = normalizeToolResult(raw);
+      resultContent = normalized.content;
+      details = normalized.details;
+      for (const key of options.invalidToolArgumentCounts.keys()) {
+        if (key.startsWith(`${toolCall.name}:`)) options.invalidToolArgumentCounts.delete(key);
+      }
+    } catch (err) {
+      isError = true;
+      if (err instanceof import_zod.ZodError) {
+        const prettyError = (0, import_zod.prettifyError)(err);
+        const failureKey = `${toolCall.name}:${prettyError}`;
+        const failureCount = (options.invalidToolArgumentCounts.get(failureKey) ?? 0) + 1;
+        options.invalidToolArgumentCounts.set(failureKey, failureCount);
+        resultContent = `Invalid arguments for tool \`${toolCall.name}\`:
+` + prettyError + "\nRe-issue the call with each field as the correct type.";
+        if (failureCount >= 3) {
+          options.markFatalToolArgumentError(
+            new Error(
+              `The model repeatedly issued invalid arguments for tool \`${toolCall.name}\`. This is usually an upstream model/tool-calling bug. Your conversation is preserved; send another message or switch models to continue.`
+            )
+          );
+        }
+      } else {
+        resultContent = err instanceof Error ? err.message : String(err);
+      }
+    }
+  }
+  const durationMs = Date.now() - startTime;
+  pushEvent({
+    type: "tool_call_end",
+    toolCallId: toolCall.id,
+    result: toolResultPreview(resultContent),
+    details,
+    isError,
+    durationMs
+  });
+  return { toolCallId: toolCall.id, content: resultContent, isError };
+}
+async function* executeToolCallsSequential(toolCalls, initialToolResults, options) {
+  const eventStream = new import_gg_ai.EventStream();
+  const state = { finalized: false };
+  const resultsById = /* @__PURE__ */ new Map();
+  const abortHandler = () => eventStream.abort(new Error("aborted"));
+  options.signal?.addEventListener("abort", abortHandler, { once: true });
+  void (async () => {
+    try {
+      for (const toolCall of toolCalls) {
+        if (options.signal?.aborted) break;
+        const record = await executeSingleToolCall(
+          toolCall,
+          options,
+          (event) => pushToolEvent(eventStream, state, event)
+        );
+        resultsById.set(record.toolCallId, record);
+      }
+      if (!state.finalized) eventStream.close();
+    } catch (err) {
+      if (!state.finalized) eventStream.abort(err instanceof Error ? err : new Error(String(err)));
+    }
+  })();
+  let aborted = false;
+  try {
+    for await (const event of eventStream) {
+      yield event;
+    }
+  } catch (err) {
+    if (isAbortError(err) || options.signal?.aborted) {
+      aborted = true;
+    } else {
+      throw err;
+    }
+  } finally {
+    options.signal?.removeEventListener("abort", abortHandler);
+    state.finalized = true;
+  }
+  const toolResults = buildToolResults(initialToolResults, toolCalls, resultsById);
+  capToolResults(toolResults, options.maxToolResultChars);
+  return { toolResults, aborted };
+}
+async function* executeToolCallsParallel(toolCalls, initialToolResults, options) {
+  const eventStream = new import_gg_ai.EventStream();
+  const state = { finalized: false };
+  const resultsById = /* @__PURE__ */ new Map();
+  const abortHandler = () => eventStream.abort(new Error("aborted"));
+  options.signal?.addEventListener("abort", abortHandler, { once: true });
+  Promise.all(
+    toolCalls.map(async (toolCall) => {
+      const record = await executeSingleToolCall(
+        toolCall,
+        options,
+        (event) => pushToolEvent(eventStream, state, event)
+      );
+      resultsById.set(record.toolCallId, record);
+    })
+  ).then(() => {
+    if (!state.finalized) eventStream.close();
+  }).catch((err) => {
+    if (!state.finalized) eventStream.abort(err instanceof Error ? err : new Error(String(err)));
+  });
+  let aborted = false;
+  try {
+    for await (const event of eventStream) {
+      yield event;
+    }
+  } catch (err) {
+    if (isAbortError(err) || options.signal?.aborted) {
+      aborted = true;
+    } else {
+      throw err;
+    }
+  } finally {
+    options.signal?.removeEventListener("abort", abortHandler);
+    state.finalized = true;
+  }
+  const toolResults = buildToolResults(initialToolResults, toolCalls, resultsById);
+  capToolResults(toolResults, options.maxToolResultChars);
+  return { toolResults, aborted };
+}
+function buildToolResults(initialToolResults, toolCalls, resultsById) {
+  const toolResults = [...initialToolResults];
+  for (const toolCall of toolCalls) {
+    const result = resultsById.get(toolCall.id);
+    if (result) {
+      toolResults.push({
+        type: "tool_result",
+        toolCallId: toolCall.id,
+        content: result.content,
+        isError: result.isError || void 0
+      });
+    } else {
+      toolResults.push({
+        type: "tool_result",
+        toolCallId: toolCall.id,
+        content: "Tool execution was aborted.",
+        isError: true
+      });
+    }
+  }
+  return toolResults;
+}
+function capToolResults(toolResults, maxToolResultChars) {
+  if (!maxToolResultChars) return;
+  const hardMax = 4e5;
+  const max = Math.min(maxToolResultChars, hardMax);
+  for (const toolResult of toolResults) {
+    if (typeof toolResult.content !== "string" || toolResult.content.length <= max) continue;
+    const headChars = Math.floor(max * 0.7);
+    const tailChars = max - headChars;
+    const head = toolResult.content.slice(0, headChars);
+    const tail = toolResult.content.slice(-tailChars);
+    const omitted = toolResult.content.length - headChars - tailChars;
+    toolResult.content = head + `
+
+[... ${omitted} characters omitted ...]
+
+` + tail;
+  }
+}
 function normalizeToolResult(raw) {
   return typeof raw === "string" ? { content: raw } : raw;
 }