@prestyj/agent 4.12.1 → 4.14.0

package/dist/index.js

@@ -258,29 +258,34 @@ async function* agentLoop(messages, options) {
   const STREAM_THINKING_IDLE_TIMEOUT_MS = 3e5;
   const STREAM_THINKING_HARD_TIMEOUT_MS = 6e5;
   const NON_STREAMING_HARD_TIMEOUT_MS = 3e5;
+  const isSakana = options.provider === "sakana";
+  const firstEventTimeoutMs = isSakana ? STREAM_THINKING_IDLE_TIMEOUT_MS : STREAM_FIRST_EVENT_TIMEOUT_MS;
+  const initialHardTimeoutMs = isSakana ? STREAM_THINKING_HARD_TIMEOUT_MS : STREAM_HARD_TIMEOUT_MS;
   const MAX_TOOLCALL_DELTA_CHARS = 1e6;
   const MAX_TOOLCALL_DELTA_EVENTS = 2e4;
   try {
     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) {
@@ -327,7 +332,7 @@ async function* agentLoop(messages, options) {
       const resetIdleTimer = () => {
         if (useNonStreamingFallback) return;
         if (idleTimer) clearTimeout(idleTimer);
-        const timeoutMs = hasReceivedEvent ? STREAM_IDLE_TIMEOUT_MS : hasReceivedThinking ? STREAM_THINKING_IDLE_TIMEOUT_MS : STREAM_FIRST_EVENT_TIMEOUT_MS;
+        const timeoutMs = hasReceivedEvent ? STREAM_IDLE_TIMEOUT_MS : hasReceivedThinking ? STREAM_THINKING_IDLE_TIMEOUT_MS : firstEventTimeoutMs;
         idleTimer = setTimeout(() => {
           diag("idle_timeout_fired", {
             events: streamEventCount,
@@ -341,7 +346,7 @@ async function* agentLoop(messages, options) {
           streamController.abort();
         }, timeoutMs);
       };
-      let hardTimeoutMs = useNonStreamingFallback ? NON_STREAMING_HARD_TIMEOUT_MS : STREAM_HARD_TIMEOUT_MS;
+      let hardTimeoutMs = useNonStreamingFallback ? NON_STREAMING_HARD_TIMEOUT_MS : initialHardTimeoutMs;
       hardTimer = setTimeout(() => {
         diag("hard_timeout_fired", {
           events: typeof streamEventCount !== "undefined" ? streamEventCount : 0,
@@ -822,7 +827,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) {
@@ -882,8 +887,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({
@@ -935,22 +942,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 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) {