@prestyj/agent 4.12.1 → 4.13.3

package/dist/index.cjs

@@ -293,23 +293,25 @@ async function* agentLoop(messages, options) {
     while (turn < maxTurns) {
       options.signal?.throwIfAborted();
       turn++;
-      let msgChars = 0;
-      for (const m of messages) {
-        if (typeof m.content === "string") msgChars += m.content.length;
-        else if (Array.isArray(m.content)) {
-          for (const p of m.content) {
-            if ("text" in p && typeof p.text === "string") msgChars += p.text.length;
-            if ("content" in p && typeof p.content === "string") msgChars += p.content.length;
+      if (_diagFn) {
+        let msgChars = 0;
+        for (const m of messages) {
+          if (typeof m.content === "string") msgChars += m.content.length;
+          else if (Array.isArray(m.content)) {
+            for (const p of m.content) {
+              if ("text" in p && typeof p.text === "string") msgChars += p.text.length;
+              if ("content" in p && typeof p.content === "string") msgChars += p.content.length;
+            }
           }
         }
+        diag("turn_start", {
+          turn,
+          messages: messages.length,
+          chars: msgChars,
+          provider: options.provider,
+          model: options.model
+        });
       }
-      diag("turn_start", {
-        turn,
-        messages: messages.length,
-        chars: msgChars,
-        provider: options.provider,
-        model: options.model
-      });
       if (firstTurn && options.getSteeringMessages) {
         const steering = await options.getSteeringMessages();
         if (steering && steering.length > 0) {
@@ -851,7 +853,7 @@ async function* agentLoop(messages, options) {
       const hasSequentialToolCall = toolCalls.some(
         (toolCall) => toolMap.get(toolCall.name)?.executionMode === "sequential"
       );
-      const executionResult = hasSequentialToolCall ? yield* executeToolCallsSequential(toolCalls, toolResults, executionOptions) : yield* executeToolCallsParallel(toolCalls, toolResults, executionOptions);
+      const executionResult = hasSequentialToolCall ? yield* executeToolCallsMixed(toolCalls, toolResults, executionOptions) : yield* executeToolCallsParallel(toolCalls, toolResults, executionOptions);
       messages.push({ role: "tool", content: executionResult.toolResults });
       const toolsAborted = executionResult.aborted;
       if (fatalToolArgumentError) {
@@ -911,8 +913,10 @@ async function executeSingleToolCall(toolCall, options, pushEvent) {
   } else {
     try {
       const parsed = tool.parameters.parse(toolCall.args);
+      const callerSignal = options.signal;
+      const toolTimeout = AbortSignal.timeout(3e5);
       const ctx = {
-        signal: options.signal ?? AbortSignal.timeout(3e5),
+        signal: callerSignal ? AbortSignal.any([callerSignal, toolTimeout]) : toolTimeout,
         toolCallId: toolCall.id,
         onUpdate: (update) => {
           pushEvent({
@@ -964,22 +968,59 @@ async function executeSingleToolCall(toolCall, options, pushEvent) {
   });
   return { toolCallId: toolCall.id, content: resultContent, isError };
 }
-async function* executeToolCallsSequential(toolCalls, initialToolResults, options) {
+async function* executeToolCallsMixed(toolCalls, initialToolResults, options) {
   const eventStream = new import_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 });
+  const phases = [];
+  let currentParallel = [];
+  for (const toolCall of toolCalls) {
+    const isSequential = options.toolMap.get(toolCall.name)?.executionMode === "sequential";
+    if (isSequential) {
+      if (currentParallel.length > 0) {
+        phases.push({ parallel: currentParallel, sequential: null });
+        currentParallel = [];
+      }
+      phases.push({ parallel: [], sequential: toolCall });
+    } else {
+      currentParallel.push(toolCall);
+    }
+  }
+  if (currentParallel.length > 0) {
+    phases.push({ parallel: currentParallel, sequential: null });
+  }
   void (async () => {
     try {
-      for (const toolCall of toolCalls) {
+      for (const phase of phases) {
         if (options.signal?.aborted) break;
-        const record = await executeSingleToolCall(
-          toolCall,
-          options,
-          (event) => pushToolEvent(eventStream, state, event)
-        );
-        resultsById.set(record.toolCallId, record);
+        if (phase.sequential) {
+          const record = await executeSingleToolCall(
+            phase.sequential,
+            options,
+            (event) => pushToolEvent(eventStream, state, event)
+          );
+          resultsById.set(record.toolCallId, record);
+        } else if (phase.parallel.length === 1) {
+          const record = await executeSingleToolCall(
+            phase.parallel[0],
+            options,
+            (event) => pushToolEvent(eventStream, state, event)
+          );
+          resultsById.set(record.toolCallId, record);
+        } else {
+          await Promise.all(
+            phase.parallel.map(async (toolCall) => {
+              const record = await executeSingleToolCall(
+                toolCall,
+                options,
+                (event) => pushToolEvent(eventStream, state, event)
+              );
+              resultsById.set(record.toolCallId, record);
+            })
+          );
+        }
       }
       if (!state.finalized) eventStream.close();
     } catch (err) {