@ai-sdk/harness 1.0.70 → 1.0.71

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @ai-sdk/harness
 
+## 1.0.71
+
+### Patch Changes
+
+- 8d717b3: Execute independent host tool calls concurrently within a harness step.
+- Updated dependencies [dc8caae]
+- Updated dependencies [72ec74f]
+- Updated dependencies [c5b0515]
+  - ai@7.0.65
+
 ## 1.0.70
 
 ### Patch Changes

package/dist/agent/index.js

@@ -1476,6 +1476,23 @@ function runPrompt(input) {
     let pendingStopBoundary;
     let finalFinish;
     const completedSteps = [];
+    const outstandingHostToolExecutions = [];
+    const startHostToolExecution = (execution) => {
+      outstandingHostToolExecutions.push(execution);
+      void execution.catch(() => {
+      });
+    };
+    const waitForOutstandingHostToolExecutions = async () => {
+      if (outstandingHostToolExecutions.length === 0) return;
+      const executions = outstandingHostToolExecutions.splice(0);
+      const results = await Promise.allSettled(executions);
+      const failedExecution = results.find(
+        (result2) => result2.status === "rejected"
+      );
+      if (failedExecution != null) {
+        throw failedExecution.reason;
+      }
+    };
     const releasePendingStopBoundary = () => {
       var _a6;
       (_a6 = pendingStopBoundary == null ? void 0 : pendingStopBoundary.releaseCheckpoint) == null ? void 0 : _a6.call(pendingStopBoundary);
@@ -1531,6 +1548,7 @@ function runPrompt(input) {
       return step;
     };
     const finishForHostInputPause = async (options) => {
+      await waitForOutstandingHostToolExecutions();
       if (options.completeCurrentStep) {
         await completeStep({
           finishReason: toolCallsFinishReason,
@@ -1799,6 +1817,7 @@ function runPrompt(input) {
           }
         }
         if (value.type === "error" && displayValue.type === "error") {
+          await waitForOutstandingHostToolExecutions();
           await telemetry.error(value.error);
           logBridgeError({
             harnessId: input.harness.harnessId,
@@ -1892,6 +1911,7 @@ function runPrompt(input) {
           return;
         }
         if (value.type === "finish-step") {
+          await waitForOutstandingHostToolExecutions();
           await completeStep({
             finishReason: value.finishReason,
             usage: value.usage,
@@ -1906,6 +1926,7 @@ function runPrompt(input) {
           }
         }
         if (value.type === "finish") {
+          await waitForOutstandingHostToolExecutions();
           finalFinish = value;
           await telemetry.end({
             finishReason: value.finishReason,
@@ -2009,41 +2030,51 @@ function runPrompt(input) {
             await finishForHostInputPause({ completeCurrentStep: true });
             return;
           }
-          const execution = await maybeExecuteHostTool({
-            event: toolCall,
-            tools: activeTools,
-            wrappedExecuteTool: telemetry.executeTool,
-            sandboxSession: input.sandboxSession,
-            abortSignal: input.abortSignal,
-            control,
-            onPreliminaryResult: (preliminaryOutput) => {
-              const stripped = stripWorkDir(
-                {
-                  type: "tool-result",
-                  toolCallId: toolCall.toolCallId,
-                  toolName: toolCall.toolName,
-                  result: preliminaryOutput
-                },
-                input.sessionWorkDir
-              );
-              result.enqueue({
-                type: "tool-result",
-                toolCallId: toolCall.toolCallId,
-                toolName: toolCall.toolName,
-                input: void 0,
-                output: stripped.result,
-                preliminary: true
-              });
-            }
-          });
-          if (!execution.executed) {
+          if (!isExecutableTool(activeTools[toolCall.toolName])) {
             recordPendingToolResult({ toolCall });
             await finishForHostInputPause({ completeCurrentStep: true });
             return;
           }
-          await telemetry.toolEnd(toolCall.toolCallId, execution.outcome);
+          startHostToolExecution(
+            (async () => {
+              const execution = await maybeExecuteHostTool({
+                event: toolCall,
+                tools: activeTools,
+                wrappedExecuteTool: telemetry.executeTool,
+                sandboxSession: input.sandboxSession,
+                abortSignal: input.abortSignal,
+                control,
+                onPreliminaryResult: (preliminaryOutput) => {
+                  const stripped = stripWorkDir(
+                    {
+                      type: "tool-result",
+                      toolCallId: toolCall.toolCallId,
+                      toolName: toolCall.toolName,
+                      result: preliminaryOutput
+                    },
+                    input.sessionWorkDir
+                  );
+                  result.enqueue({
+                    type: "tool-result",
+                    toolCallId: toolCall.toolCallId,
+                    toolName: toolCall.toolName,
+                    input: void 0,
+                    output: stripped.result,
+                    preliminary: true
+                  });
+                }
+              });
+              if (!execution.executed) {
+                throw new Error(
+                  `Harness '${input.harness.harnessId}' could not execute host tool '${toolCall.toolName}'.`
+                );
+              }
+              await telemetry.toolEnd(toolCall.toolCallId, execution.outcome);
+            })()
+          );
         }
       }
+      await waitForOutstandingHostToolExecutions();
       const isTurnSuspending = ((_j = input.isTurnSuspending) == null ? void 0 : _j.call(input)) === true;
       if (isTurnSuspending) {
         if (finalFinish == null) {
@@ -2062,6 +2093,10 @@ function runPrompt(input) {
         } : void 0
       );
     } catch (err) {
+      try {
+        await waitForOutstandingHostToolExecutions();
+      } catch (e) {
+      }
       await telemetry.error(err);
       logBridgeError({
         harnessId: input.harness.harnessId,