@ai-sdk/workflow 2.0.71 → 2.0.72

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/workflow",
-  "version": "2.0.71",
+  "version": "2.0.72",
   "type": "module",
   "description": "WorkflowAgent for building AI agents with AI SDK",
   "license": "Apache-2.0",
@@ -38,11 +38,11 @@
   "dependencies": {
     "@ai-sdk/provider": "4.0.27",
     "@ai-sdk/provider-utils": "5.0.59",
-    "ai": "7.0.139",
+    "ai": "7.0.140",
     "ajv": "^8.20.0"
   },
   "devDependencies": {
-    "@ai-sdk/otel": "1.0.139",
+    "@ai-sdk/otel": "1.0.140",
     "@opentelemetry/api": "1.9.1",
     "@opentelemetry/sdk-trace-base": "2.7.1",
     "@types/node": "22.19.19",

package/src/test/concurrency-workflows.ts

@@ -0,0 +1,66 @@
+import { tool, type ModelMessage } from 'ai';
+import { createHook } from 'workflow';
+import { z } from 'zod/v4';
+import { mockTextModel } from '../providers/mock.js';
+import { WorkflowAgent } from '../workflow-agent.js';
+
+async function completeAction(id: string) {
+  'use step';
+  return id;
+}
+
+export async function resumeSequentialApprovals(mode: 'generate' | 'stream') {
+  'use workflow';
+  const events: string[] = [];
+  const agent = new WorkflowAgent({
+    model: mockTextModel('Done.'),
+    toolCallConcurrency: 1,
+    tools: {
+      action: tool({
+        inputSchema: z.object({ id: z.string() }),
+        needsApproval: true,
+        execute: async ({ id }) => {
+          events.push(`start:${id}`);
+          if (id === 'first') {
+            using hook = createHook<string>();
+            await hook;
+          }
+          const result = await completeAction(id);
+          events.push(`end:${id}`);
+          return result;
+        },
+      }),
+    },
+  });
+  const ids = ['first', 'second'];
+  const messages: ModelMessage[] = [
+    { role: 'user', content: 'Run the tools.' },
+    {
+      role: 'assistant',
+      content: ids.flatMap(id => [
+        {
+          type: 'tool-call' as const,
+          toolCallId: id,
+          toolName: 'action',
+          input: { id },
+        },
+        {
+          type: 'tool-approval-request' as const,
+          toolCallId: id,
+          approvalId: `approval-${id}`,
+        },
+      ]),
+    },
+    {
+      role: 'tool',
+      content: [...ids].reverse().map(id => ({
+        type: 'tool-approval-response' as const,
+        approvalId: `approval-${id}`,
+        approved: true,
+      })),
+    },
+  ];
+  if (mode === 'generate') await agent.generate({ messages });
+  else await agent.stream({ messages });
+  return events;
+}

package/src/workflow-agent.ts

@@ -51,6 +51,8 @@ import {
   convertToLanguageModelPrompt,
   mergeAbortSignals,
   mergeCallbacks,
+  mapWithConcurrency,
+  prepareToolCallConcurrency,
   signToolApproval,
   standardizePrompt,
   validateApprovedToolApprovals,
@@ -426,6 +428,7 @@ export interface PrepareCallOptions<
   tools: TTools;
   instructions?: Instructions;
   toolChoice?: ToolChoice<TTools>;
+  toolCallConcurrency?: number;
   stopWhen?:
     | StopCondition<NoInfer<TTools>, TRuntimeContext>
     | Array<StopCondition<NoInfer<TTools>, TRuntimeContext>>;
@@ -514,6 +517,13 @@ export type WorkflowAgentOptions<
      */
     toolChoice?: ToolChoice<TTools>;
 
+    /**
+     * Maximum number of local tool calls that may execute concurrently within a step.
+     * Set to `1` to execute calls sequentially in model order, including approved
+     * calls. By default, all local tool calls execute concurrently.
+     */
+    toolCallConcurrency?: number;
+
     /**
      * Optional telemetry configuration.
      */
@@ -999,6 +1009,13 @@ export type WorkflowAgentCallOptions<
      */
     toolChoice?: ToolChoice<TTools>;
 
+    /**
+     * Maximum number of local tool calls that may execute concurrently within a step.
+     * Set to `1` to execute calls sequentially in model order, including approved
+     * calls. By default, all local tool calls execute concurrently.
+     */
+    toolCallConcurrency?: number;
+
     /**
      * Limits the tools that are available for the model to call without
      * changing the tool call and result types in the result.
@@ -1540,6 +1557,7 @@ export class WorkflowAgent<
   private instructions?: Instructions;
   private generationSettings: GenerationSettings;
   private toolChoice?: ToolChoice<TBaseTools>;
+  private toolCallConcurrency?: number;
   private telemetry?: TelemetryOptions<TRuntimeContext, TBaseTools>;
   private runtimeContext?: TRuntimeContext;
   private toolsContext?: InferToolSetContext<TBaseTools>;
@@ -1588,6 +1606,7 @@ export class WorkflowAgent<
     // `instructions` takes precedence over deprecated `system`
     this.instructions = options.instructions ?? options.system;
     this.toolChoice = options.toolChoice;
+    this.toolCallConcurrency = options.toolCallConcurrency;
     this.telemetry = options.telemetry;
     this.runtimeContext = options.runtimeContext;
     this.toolsContext = options.toolsContext;
@@ -1727,6 +1746,8 @@ export class WorkflowAgent<
         Context | undefined
       >;
     let effectiveToolChoiceFromPrepare = options.toolChoice ?? this.toolChoice;
+    let effectiveToolCallConcurrency =
+      options.toolCallConcurrency ?? this.toolCallConcurrency;
     let effectiveStopWhenFromPrepare =
       options.stopWhen ??
       this.stopWhen ??
@@ -1754,6 +1775,7 @@ export class WorkflowAgent<
         tools: this.tools,
         instructions: effectiveInstructions,
         toolChoice: effectiveToolChoiceFromPrepare as ToolChoice<TBaseTools>,
+        toolCallConcurrency: effectiveToolCallConcurrency,
         stopWhen: effectiveStopWhenFromPrepare,
         activeTools: effectiveActiveToolsFromPrepare,
         experimental_download: effectiveDownloadFromPrepare,
@@ -1781,6 +1803,8 @@ export class WorkflowAgent<
       if (prepared.toolChoice !== undefined)
         effectiveToolChoiceFromPrepare =
           prepared.toolChoice as ToolChoice<TBaseTools>;
+      if (prepared.toolCallConcurrency !== undefined)
+        effectiveToolCallConcurrency = prepared.toolCallConcurrency;
       if (prepared.stopWhen !== undefined)
         effectiveStopWhenFromPrepare = prepared.stopWhen;
       if (prepared.activeTools !== undefined)
@@ -1818,6 +1842,9 @@ export class WorkflowAgent<
         effectiveGenerationSettings.providerOptions = prepared.providerOptions;
     }
 
+    const toolCallConcurrency = prepareToolCallConcurrency(
+      options.toolCallConcurrency ?? effectiveToolCallConcurrency,
+    );
     const effectiveTelemetry = effectiveTelemetryFromPrepare;
     const telemetryDispatcher = createRestrictedTelemetryDispatcher<
       any,
@@ -1869,6 +1896,7 @@ export class WorkflowAgent<
       effectiveRuntimeContext,
       effectiveToolsContext,
       effectiveToolChoiceFromPrepare,
+      toolCallConcurrency,
       effectiveStopWhenFromPrepare,
       effectiveActiveToolsFromPrepare,
       effectiveToolApprovalSecret,
@@ -1906,6 +1934,7 @@ export class WorkflowAgent<
       effectiveRuntimeContext,
       effectiveToolsContext,
       effectiveToolChoiceFromPrepare,
+      toolCallConcurrency,
       effectiveStopWhenFromPrepare,
       effectiveActiveToolsFromPrepare,
       effectiveToolApprovalSecret,
@@ -1985,52 +2014,56 @@ export class WorkflowAgent<
         output: unknown;
       }> = [];
 
-      // Execute approved tools
-      for (const approval of approvedToolApprovals) {
-        // Provider-executed approvals are forwarded to the provider via the
-        // preserved approval response below, not executed locally.
-        if (approval.providerExecuted) {
-          continue;
-        }
-        const tool = (this.tools as ToolSet)[approval.toolName];
-        if (tool && typeof tool.execute === 'function') {
-          if (!tool.needsApproval) {
-            const reason = `Tool "${approval.toolName}" does not require approval`;
-            toolResultContent.push({
-              type: 'tool-result' as const,
-              toolCallId: approval.toolCallId,
-              toolName: approval.toolName,
-              output: await createLanguageModelToolResultOutput({
+      // Execute approved calls in model order with the same limit as new calls.
+      const approvedResults = await mapWithConcurrency({
+        items: approvedToolApprovals.filter(
+          approval => !approval.providerExecuted,
+        ),
+        concurrency: toolCallConcurrency,
+        abortSignal: effectiveAbortSignal,
+        execute: async approval => {
+          const tool = (this.tools as ToolSet)[approval.toolName];
+          if (tool && typeof tool.execute === 'function') {
+            if (!tool.needsApproval) {
+              const reason = `Tool "${approval.toolName}" does not require approval`;
+              return {
+                modelResult: {
+                  type: 'tool-result' as const,
+                  toolCallId: approval.toolCallId,
+                  toolName: approval.toolName,
+                  output: await createLanguageModelToolResultOutput({
+                    toolCallId: approval.toolCallId,
+                    toolName: approval.toolName,
+                    input: approval.input,
+                    output: reason,
+                    tool,
+                    errorMode: 'text',
+                    supportedUrls: {},
+                    download: workflowDownload,
+                  }),
+                },
+              };
+            }
+
+            // Re-validate through the shared core implementation: input schema,
+            // approval signature (when configured), and approval policy.
+            // Convert invalid input, denial, or signature errors to a tool error
+            // result so the agent loop can continue gracefully.
+            let revalidationReason: string | undefined;
+            try {
+              await validateWorkflowToolApprovalSignature({
+                secret: effectiveToolApprovalSecret,
+                approvalId: approval.collected.approvalRequest.approvalId,
                 toolCallId: approval.toolCallId,
                 toolName: approval.toolName,
                 input: approval.input,
-                output: reason,
-                tool,
-                errorMode: 'text',
-                supportedUrls: {},
-                download: workflowDownload,
-              }),
-            });
-            continue;
-          }
-
-          // Re-validate through the shared core implementation: input schema,
-          // approval signature (when configured), and approval policy.
-          // Convert invalid input, denial, or signature errors to a tool error
-          // result so the agent loop can continue gracefully.
-          let revalidationReason: string | undefined;
-          try {
-            await validateWorkflowToolApprovalSignature({
-              secret: effectiveToolApprovalSecret,
-              approvalId: approval.collected.approvalRequest.approvalId,
-              toolCallId: approval.toolCallId,
-              toolName: approval.toolName,
-              input: approval.input,
-              signature: approval.collected.approvalRequest.signature,
-            });
+                signature: approval.collected.approvalRequest.signature,
+              });
 
-            const { deniedToolApprovals: policyDenied, invalidToolApprovals } =
-              await validateApprovedToolApprovals({
+              const {
+                deniedToolApprovals: policyDenied,
+                invalidToolApprovals,
+              } = await validateApprovedToolApprovals({
                 approvedToolApprovals: [approval.collected],
                 tools: this.tools as ToolSet,
                 toolApproval: undefined,
@@ -2040,58 +2073,67 @@ export class WorkflowAgent<
                 runtimeContext: effectiveRuntimeContext,
               });
 
-            if (invalidToolApprovals.length > 0) {
-              revalidationReason = getErrorMessage(
-                invalidToolApprovals[0].error,
-              );
-            } else if (policyDenied.length > 0) {
-              revalidationReason =
-                policyDenied[0].approvalResponse.reason ??
-                'Tool approval denied';
+              if (invalidToolApprovals.length > 0) {
+                revalidationReason = getErrorMessage(
+                  invalidToolApprovals[0].error,
+                );
+              } else if (policyDenied.length > 0) {
+                revalidationReason =
+                  policyDenied[0].approvalResponse.reason ??
+                  'Tool approval denied';
+              }
+            } catch (error) {
+              revalidationReason = getErrorMessage(error);
             }
-          } catch (error) {
-            revalidationReason = getErrorMessage(error);
-          }
 
-          if (revalidationReason != null) {
-            toolResultContent.push({
-              type: 'tool-result' as const,
-              toolCallId: approval.toolCallId,
-              toolName: approval.toolName,
-              output: await createLanguageModelToolResultOutput({
+            if (revalidationReason != null) {
+              return {
+                modelResult: {
+                  type: 'tool-result' as const,
+                  toolCallId: approval.toolCallId,
+                  toolName: approval.toolName,
+                  output: await createLanguageModelToolResultOutput({
+                    toolCallId: approval.toolCallId,
+                    toolName: approval.toolName,
+                    input: approval.input,
+                    output: revalidationReason,
+                    tool,
+                    errorMode: 'text',
+                    supportedUrls: {},
+                    download: workflowDownload,
+                  }),
+                },
+              };
+            }
+
+            const result = await executeToolWithCallbacks(
+              {
                 toolCallId: approval.toolCallId,
                 toolName: approval.toolName,
                 input: approval.input,
-                output: revalidationReason,
-                tool,
-                errorMode: 'text',
-                supportedUrls: {},
-                download: workflowDownload,
-              }),
-            });
-            continue;
+              },
+              this.tools as ToolSet,
+              prompt.messages as unknown as LanguageModelV4Prompt,
+              effectiveToolsContext,
+              0,
+              sandbox,
+            );
+            return {
+              modelResult: result.modelResult,
+              rawResult: {
+                toolCallId: approval.toolCallId,
+                toolName: approval.toolName,
+                input: approval.input,
+                output: result.rawOutput,
+              },
+            };
           }
-
-          const result = await executeToolWithCallbacks(
-            {
-              toolCallId: approval.toolCallId,
-              toolName: approval.toolName,
-              input: approval.input,
-            },
-            this.tools as ToolSet,
-            prompt.messages as unknown as LanguageModelV4Prompt,
-            effectiveToolsContext,
-            0,
-            sandbox,
-          );
-          toolResultContent.push(result.modelResult);
-          approvedRawResults.push({
-            toolCallId: approval.toolCallId,
-            toolName: approval.toolName,
-            input: approval.input,
-            output: result.rawOutput,
-          });
-        }
+        },
+      });
+      for (const result of approvedResults) {
+        if (result == null) continue;
+        toolResultContent.push(result.modelResult);
+        if (result.rawResult != null) approvedRawResults.push(result.rawResult);
       }
 
       // Create denial results for denied tools
@@ -2711,19 +2753,20 @@ export class WorkflowAgent<
             providerApprovalRequests.length > 0
           ) {
             // Execute any executable tools that were also called in this step
-            const executableResults = await Promise.all(
-              executableToolCalls.map(
-                (toolCall): Promise<WorkflowToolExecutionResult> =>
-                  executeToolWithCallbacks(
-                    toolCall,
-                    stepTools,
-                    iterMessages,
-                    toolsContext,
-                    currentStepNumber,
-                    toolExecutionSandbox,
-                  ),
-              ),
-            );
+            const executableResults = await mapWithConcurrency({
+              items: executableToolCalls,
+              concurrency: toolCallConcurrency,
+              abortSignal: effectiveAbortSignal,
+              execute: toolCall =>
+                executeToolWithCallbacks(
+                  toolCall,
+                  stepTools,
+                  iterMessages,
+                  toolsContext,
+                  currentStepNumber,
+                  toolExecutionSandbox,
+                ),
+            });
 
             // Collect provider tool results
             const providerResultEntries = await Promise.all(
@@ -2926,19 +2969,20 @@ export class WorkflowAgent<
           }
 
           // Execute client tools (all have execute functions at this point)
-          const clientToolResults = await Promise.all(
-            nonProviderToolCalls.map(
-              (toolCall): Promise<WorkflowToolExecutionResult> =>
-                executeToolWithCallbacks(
-                  toolCall,
-                  stepTools,
-                  iterMessages,
-                  toolsContext,
-                  currentStepNumber,
-                  toolExecutionSandbox,
-                ),
-            ),
-          );
+          const clientToolResults = await mapWithConcurrency({
+            items: nonProviderToolCalls,
+            concurrency: toolCallConcurrency,
+            abortSignal: effectiveAbortSignal,
+            execute: toolCall =>
+              executeToolWithCallbacks(
+                toolCall,
+                stepTools,
+                iterMessages,
+                toolsContext,
+                currentStepNumber,
+                toolExecutionSandbox,
+              ),
+          });
 
           // For provider-executed tools, use the results from the stream
           const providerToolResultEntries = await Promise.all(