@ai-sdk/workflow 2.0.71 → 2.0.73

package/src/to-ui-message-chunk.ts

@@ -191,6 +191,9 @@ export function toUIMessageChunk(
         approvalId: part.approvalId,
         toolCallId:
           'toolCallId' in part ? part.toolCallId : part.toolCall.toolCallId,
+        ...('inputSchemaInput' in part && part.inputSchemaInput !== undefined
+          ? { inputSchemaInput: part.inputSchemaInput }
+          : {}),
         ...(part.signature != null ? { signature: part.signature } : {}),
       };
 

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(
@@ -2800,6 +2843,8 @@ export class WorkflowAgent<
             );
             const approvalRequests = await Promise.all(
               approvalToolCalls.map(async tc => {
+                const { inputSchemaInput, ...toolCallWithoutInputSchemaInput } =
+                  tc;
                 const approvalId = `approval-${tc.toolCallId}`;
                 const signature =
                   effectiveToolApprovalSecret == null
@@ -2814,15 +2859,23 @@ export class WorkflowAgent<
                 return {
                   type: 'tool-approval-request' as const,
                   approvalId,
+                  ...(inputSchemaInput !== undefined
+                    ? { inputSchemaInput }
+                    : {}),
                   toolCall: {
-                    ...tc,
+                    ...toolCallWithoutInputSchemaInput,
                     type: 'tool-call' as const,
                   } as StepResult<ToolSet>['toolCalls'][number],
                   ...(signature != null ? { signature } : {}),
                 };
               }),
             );
-            step?.content.push(...approvalRequests);
+            step?.content.push(
+              ...approvalRequests.map(
+                ({ inputSchemaInput: _inputSchemaInput, ...request }) =>
+                  request,
+              ),
+            );
             const approvalMessages = approvalRequests.map(
               ({ toolCall, ...request }) => ({
                 ...request,
@@ -2926,19 +2979,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(
@@ -3269,6 +3323,7 @@ async function writeApprovalRequests(
     approvalId: string;
     toolCallId: string;
     signature?: string;
+    inputSchemaInput?: unknown;
   }>,
 ) {
   'use step';
@@ -3280,6 +3335,9 @@ async function writeApprovalRequests(
         approvalId: request.approvalId,
         toolCallId: request.toolCallId,
         ...(request.signature != null ? { signature: request.signature } : {}),
+        ...(request.inputSchemaInput !== undefined
+          ? { inputSchemaInput: request.inputSchemaInput }
+          : {}),
       });
     }
   } finally {
@@ -3692,6 +3750,7 @@ function addApprovalRequestsToMessages(
     approvalId: string;
     toolCallId: string;
     signature?: string;
+    inputSchemaInput?: unknown;
   }>,
 ): ModelMessage[] {
   if (requests.length === 0) return messages;