@ai-sdk/workflow 2.0.71 → 2.0.73

package/dist/index.js

@@ -1,7 +1,7 @@
 import { n as normalizeUIMessageStreamParts, t as WorkflowChatTransport } from "./workflow-chat-transport-Dj1poviu.js";
-import { asArray, asSchema, convertUint8ArrayToBase64, createIdGenerator, generateId, getErrorMessage, isAbortError, jsonSchema, validateTypes, withUserAgentSuffix } from "@ai-sdk/provider-utils";
-import { DefaultGeneratedFile, InvalidToolApprovalSignatureError, NoOutputGeneratedError, Output, ToolChoiceViolationError, dynamicTool, experimental_filterActiveTools, experimental_streamLanguageModelCall, gateway, isStepCount, tool, wrapLanguageModel } from "ai";
-import { DefaultGenerateTextResult, DefaultStepResult, addLanguageModelUsage, asLanguageModelUsage, calculateTokensPerSecond, collectToolApprovals, convertLanguageModelContent, convertToLanguageModelPrompt, createDefaultDownloadFunction, createNullLanguageModelUsage, createRestrictedTelemetryDispatcher, createTelemetryDispatcher, createToolModelOutput, createToolSearchState, downloadAssets, isOutputChunk, mapToolResultOutput, mergeAbortSignals, mergeCallbacks, parseToolCall, prepareLanguageModelCallOptions, prepareRetries, prepareToolChoice, prepareTools, resolveLanguageModel, signToolApproval, standardizePrompt, validateApprovedToolApprovals, verifyToolApprovalSignature } from "ai/internal";
+import { asArray, asSchema, convertUint8ArrayToBase64, createIdGenerator, generateId, getErrorMessage, isAbortError, jsonSchema, safeParseJSON, validateTypes, withUserAgentSuffix } from "@ai-sdk/provider-utils";
+import { DefaultGeneratedFile, InvalidToolApprovalSignatureError, InvalidToolInputError, NoOutputGeneratedError, Output, ToolChoiceViolationError, dynamicTool, experimental_filterActiveTools, experimental_streamLanguageModelCall, gateway, isDeepEqualData, isStepCount, tool, wrapLanguageModel } from "ai";
+import { DefaultGenerateTextResult, DefaultStepResult, addLanguageModelUsage, asLanguageModelUsage, calculateTokensPerSecond, collectToolApprovals, convertLanguageModelContent, convertToLanguageModelPrompt, createDefaultDownloadFunction, createNullLanguageModelUsage, createRestrictedTelemetryDispatcher, createTelemetryDispatcher, createToolModelOutput, createToolSearchState, downloadAssets, filterIncludedContext, isOutputChunk, mapToolResultOutput, mapWithConcurrency, mergeAbortSignals, mergeCallbacks, parseToolCall, prepareLanguageModelCallOptions, prepareRetries, prepareToolCallConcurrency, prepareToolChoice, prepareTools, resolveLanguageModel, signToolApproval, standardizePrompt, validateApprovedToolApprovals, verifyToolApprovalSignature } from "ai/internal";
 import { getWorkflowMetadata } from "workflow";
 import Ajv from "ajv";
 import Ajv2020 from "ajv/dist/2020.js";
@@ -143,9 +143,9 @@ async function buildModelStepResult(raw, toolCalls, finish, providerExecutedTool
 				if (!("reasoningIndex" in part)) providerContent.push(part);
 				break;
 			case "tool-call": {
-				const call = toolCalls[part.toolCallIndex];
+				const { inputSchemaInput: _inputSchemaInput, ...publicCall } = toolCalls[part.toolCallIndex];
 				providerContent.push({
-					...call,
+					...publicCall,
 					input: "",
 					type: "tool-call"
 				});
@@ -410,6 +410,7 @@ function languageModelPromptToModelMessages(prompt) {
 */
 function serializeToolSet(tools, { toolsContext = {}, experimental_sandbox: sandbox } = {}) {
 	return Object.fromEntries(Object.entries(tools).map(([name, t]) => {
+		const inputSchema = asSchema(t.inputSchema);
 		const def = {
 			title: t.title,
 			metadata: t.metadata,
@@ -419,11 +420,12 @@ function serializeToolSet(tools, { toolsContext = {}, experimental_sandbox: sand
 				toolsContext,
 				experimental_sandbox: sandbox
 			}),
-			inputSchema: asSchema(t.inputSchema).jsonSchema,
+			inputSchema: inputSchema.jsonSchema,
 			strict: t.strict,
 			inputExamples: t.inputExamples,
 			providerOptions: t.providerOptions
 		};
+		if (inputSchema.validate != null) def.hasOwnValidator = true;
 		if (t.type === "dynamic") def.type = "dynamic";
 		if (t.onInputStart != null) def.hasOnInputStart = true;
 		if (t.onInputDelta != null) def.hasOnInputDelta = true;
@@ -457,9 +459,9 @@ function formatAjvError(error) {
 /**
 * Reconstructs tool objects from serializable tool definitions inside a step.
 *
-* Wraps each tool's JSON Schema with `jsonSchema()` and validates tool call
-* arguments against the schema using Ajv. This provides runtime type safety
-* equivalent to using zod schemas directly with the AI SDK.
+* Wraps each tool's JSON Schema with `jsonSchema()`. Tools without their own
+* validator are validated with Ajv. Tools with their own validator are
+* validated after the workflow step, where the original schema is available.
 */
 function resolveSerializableTools(tools) {
 	const ajvOptions = {
@@ -482,6 +484,7 @@ function resolveSerializableTools(tools) {
 			};
 		} });
 	};
+	const createInputSchema = (tool) => tool.hasOwnValidator ? jsonSchema(tool.inputSchema) : createValidatedInputSchema(tool.inputSchema);
 	return Object.fromEntries(Object.entries(tools).map(([name, t]) => {
 		if (t.type === "provider") {
 			const providerTool = {
@@ -506,7 +509,7 @@ function resolveSerializableTools(tools) {
 			description: t.description,
 			inputExamples: t.inputExamples,
 			providerOptions: t.providerOptions,
-			inputSchema: createValidatedInputSchema(t.inputSchema)
+			inputSchema: createInputSchema(t)
 		})];
 		const functionTool = {
 			title: t.title,
@@ -515,7 +518,7 @@ function resolveSerializableTools(tools) {
 			strict: t.strict,
 			inputExamples: t.inputExamples,
 			providerOptions: t.providerOptions,
-			inputSchema: createValidatedInputSchema(t.inputSchema)
+			inputSchema: createInputSchema(t)
 		};
 		return [name, t.type === "dynamic" ? tool({
 			...functionTool,
@@ -573,7 +576,7 @@ async function runModelCallWithTelemetry({ telemetry, modelInit, prompt, seriali
 		reasoning: options?.reasoning,
 		providerOptions: options?.providerOptions,
 		output: void 0,
-		runtimeContext: {},
+		runtimeContext: telemetry.runtimeContext ?? {},
 		toolsContext: {}
 	});
 	await dispatcher.onStepStart?.({
@@ -589,7 +592,7 @@ async function runModelCallWithTelemetry({ telemetry, modelInit, prompt, seriali
 		steps: [],
 		providerOptions: options?.providerOptions,
 		output: void 0,
-		runtimeContext: {},
+		runtimeContext: telemetry.runtimeContext ?? {},
 		toolsContext: {}
 	});
 	let result;
@@ -625,7 +628,7 @@ async function runModelCallWithTelemetry({ telemetry, modelInit, prompt, seriali
 		callId,
 		tools,
 		stepNumber: telemetry.stepNumber,
-		runtimeContext: {},
+		runtimeContext: telemetry.runtimeContext ?? {},
 		toolsContext: {}
 	});
 	await dispatcher.onStepEnd?.(step);
@@ -733,10 +736,17 @@ async function generateModelCall(prompt, modelInit, serializedTools, options, la
 		performance: { responseTimeMs }
 	});
 	abortSignal?.throwIfAborted();
+	const repairedToolCallIds = /* @__PURE__ */ new Set();
+	const repairToolCall = options.repairToolCall;
+	const trackedRepairToolCall = repairToolCall ? async (repairOptions) => {
+		const repaired = await repairToolCall(repairOptions);
+		if (repaired != null) repairedToolCallIds.add(repairOptions.toolCall.toolCallId);
+		return repaired;
+	} : void 0;
 	const toolCalls = await Promise.all(response.content.filter((part) => part.type === "tool-call").map((toolCall) => parseToolCall({
 		toolCall,
 		tools,
-		repairToolCall: options.repairToolCall,
+		repairToolCall: trackedRepairToolCall,
 		instructions: modelPrompt.filter((message) => message.role === "system").map((message) => message.content).join("\n") || void 0,
 		messages: prompt.filter((message) => message.role !== "system")
 	})));
@@ -808,7 +818,8 @@ async function generateModelCall(prompt, modelInit, serializedTools, options, la
 			}
 		},
 		providerExecutedToolResults,
-		toolInputLifecycleEvents
+		toolInputLifecycleEvents,
+		repairedToolCallIds: [...repairedToolCallIds]
 	};
 }
 doGenerateStep.maxRetries = 0;
@@ -832,6 +843,13 @@ async function streamModelStep(conversationPrompt, modelInit, writable, serializ
 	const abortSignal = timeout == null ? options?.abortSignal : options?.abortSignal == null ? AbortSignal.timeout(timeout) : AbortSignal.any([options.abortSignal, AbortSignal.timeout(timeout)]);
 	const model = typeof modelInit === "string" ? gateway.languageModel(modelInit) : modelInit;
 	const toolInputLifecycleEvents = [];
+	const repairedToolCallIds = /* @__PURE__ */ new Set();
+	const repairToolCall = options?.repairToolCall;
+	const trackedRepairToolCall = repairToolCall ? async (repairOptions) => {
+		const repaired = await repairToolCall(repairOptions);
+		if (repaired != null) repairedToolCallIds.add(repairOptions.toolCall.toolCallId);
+		return repaired;
+	} : void 0;
 	const tools = serializedTools ? resolveSerializableTools(serializedTools) : void 0;
 	const modelWithTransforms = options?.experimental_transform == null ? model : wrapLanguageModel({
 		model,
@@ -885,7 +903,7 @@ async function streamModelStep(conversationPrompt, modelInit, writable, serializ
 				frequencyPenalty: options?.frequencyPenalty,
 				stopSequences: options?.stopSequences,
 				seed: options?.seed,
-				repairToolCall: options?.repairToolCall,
+				repairToolCall: trackedRepairToolCall,
 				download: options?.download,
 				...languageModelCallTelemetry
 			}));
@@ -1086,7 +1104,7 @@ async function streamModelStep(conversationPrompt, modelInit, writable, serializ
 					toolCallId: part.toolCall.toolCallId,
 					...part.signature != null ? { signature: part.signature } : {}
 				});
-				else await writer.write(part);
+				else if (!((part.type === "tool-call" || part.type === "tool-error" && !part.providerExecuted) && serializedTools?.[part.toolName]?.hasOwnValidator)) await writer.write(part);
 			}
 			if (part.type === "error" && !hasTerminalError) {
 				terminalError = part.error;
@@ -1116,6 +1134,7 @@ async function streamModelStep(conversationPrompt, modelInit, writable, serializ
 		},
 		providerExecutedToolResults,
 		toolInputLifecycleEvents,
+		repairedToolCallIds: [...repairedToolCallIds],
 		...hasTerminalError ? { terminalError } : {}
 	};
 }
@@ -1343,7 +1362,12 @@ async function* modelCallIterator({ prompt, mode = "stream", include, initialIns
 					functionId: telemetry?.functionId,
 					recordInputs: telemetry?.recordInputs,
 					recordOutputs: telemetry?.recordOutputs,
-					stepNumber
+					stepNumber,
+					includeRuntimeContext: telemetry?.includeRuntimeContext,
+					runtimeContext: filterIncludedContext({
+						context: currentRuntimeContext,
+						includeContext: telemetry?.includeRuntimeContext
+					})
 				} : void 0
 			};
 			const modelCallResult = mode === "generate" ? await doGenerateStep(conversationPrompt, currentModel, serializedTools, callOptions) : await doStreamStep(conversationPrompt, currentModel, writable, serializedTools, callOptions);
@@ -1356,7 +1380,18 @@ async function* modelCallIterator({ prompt, mode = "stream", include, initialIns
 				terminalError = modelCallResult.terminalError;
 				hasTerminalError = true;
 			}
-			const { toolCalls, finish, raw, providerExecutedToolResults, toolInputLifecycleEvents } = modelCallResult;
+			const { toolCalls: serializedToolCalls, finish, raw, providerExecutedToolResults, toolInputLifecycleEvents, repairedToolCallIds } = modelCallResult;
+			const toolCalls = await validateToolCallInputs({
+				toolCalls: serializedToolCalls,
+				tools: effectiveTools,
+				serializedTools,
+				repairToolCall,
+				repairedToolCallIds: new Set(repairedToolCallIds),
+				instructions: conversationPrompt.filter((message) => message.role === "system").map((message) => message.content).join("\n") || initialInstructions,
+				messages: stepInputMessages.filter((message) => message.role !== "system"),
+				abortSignal: currentGenerationSettings.abortSignal
+			});
+			if (mode === "stream" && writable != null) await writeDeferredToolCalls(writable, toolCalls.filter((_, index) => serializedTools[serializedToolCalls[index].toolName]?.hasOwnValidator));
 			await invokeToolInputLifecycleCallbacks({
 				events: toolInputLifecycleEvents ?? [],
 				toolCalls,
@@ -1460,6 +1495,100 @@ async function* modelCallIterator({ prompt, mode = "stream", include, initialIns
 	};
 	return conversationPrompt;
 }
+async function validateToolCallInputs({ toolCalls, tools, serializedTools, repairToolCall, repairedToolCallIds, instructions, messages, abortSignal }) {
+	return Promise.all(toolCalls.map(async (toolCall) => {
+		if (toolCall.invalid || toolCall.providerExecuted) return toolCall;
+		const tool = tools[toolCall.toolName];
+		if (tool == null) return toolCall;
+		if (asSchema(tool.inputSchema).validate == null) return toolCall;
+		let repairedInput;
+		const parsedToolCall = await parseToolCall({
+			toolCall: {
+				type: "tool-call",
+				toolCallId: toolCall.toolCallId,
+				toolName: toolCall.toolName,
+				input: JSON.stringify(toolCall.input) ?? (toolCall.input == null ? "" : String(toolCall.input)),
+				providerExecuted: toolCall.providerExecuted,
+				providerMetadata: toolCall.providerMetadata
+			},
+			tools,
+			repairToolCall: repairToolCall == null || repairedToolCallIds.has(toolCall.toolCallId) ? void 0 : async (options) => {
+				const repairedToolCall = await repairToolCallInStep({
+					repairToolCall,
+					serializedTools,
+					toolCall: options.toolCall,
+					error: {
+						toolName: options.toolCall.toolName,
+						toolInput: options.toolCall.input,
+						message: getErrorMessage(options.error)
+					},
+					instructions,
+					messages: options.messages
+				});
+				if (repairedToolCall != null) {
+					const parsedRepairedInput = repairedToolCall.input.trim() === "" ? {
+						success: true,
+						value: {}
+					} : await safeParseJSON({ text: repairedToolCall.input });
+					if (parsedRepairedInput.success) repairedInput = { value: parsedRepairedInput.value };
+				}
+				return repairedToolCall;
+			},
+			instructions,
+			messages,
+			abortSignal
+		});
+		const inputSchemaInput = repairedInput ?? { value: toolCall.input };
+		return {
+			...toolCall,
+			...parsedToolCall,
+			...!parsedToolCall.invalid && !isDeepEqualData(inputSchemaInput.value, parsedToolCall.input) ? { inputSchemaInput: inputSchemaInput.value } : {}
+		};
+	}));
+}
+/**
+* Runs `repairToolCall` inside a step. The callback may be a `'use step'`
+* function, so its arguments must be serializable: the tools and the
+* `inputSchema` accessor are rebuilt here instead of crossing the boundary
+* from the workflow body.
+*/
+async function repairToolCallInStep({ repairToolCall, serializedTools, toolCall, error, instructions, messages }) {
+	"use step";
+	const tools = resolveSerializableTools(serializedTools);
+	return repairToolCall({
+		toolCall,
+		tools,
+		inputSchema: async ({ toolName }) => asSchema(tools[toolName]?.inputSchema).jsonSchema,
+		instructions,
+		system: instructions,
+		messages,
+		error: new InvalidToolInputError({
+			toolName: error.toolName,
+			toolInput: error.toolInput,
+			cause: new Error(error.message),
+			message: error.message
+		})
+	});
+}
+async function writeDeferredToolCalls(writable, toolCalls) {
+	"use step";
+	const writer = writable.getWriter();
+	try {
+		for (const toolCall of toolCalls) {
+			await writer.write(toolCall);
+			if (toolCall.invalid && !toolCall.providerExecuted) await writer.write({
+				type: "tool-error",
+				toolCallId: toolCall.toolCallId,
+				toolName: toolCall.toolName,
+				input: toolCall.input,
+				error: getErrorMessage(toolCall.error),
+				dynamic: true
+			});
+		}
+	} finally {
+		writer.releaseLock();
+	}
+}
 async function invokeToolInputLifecycleCallbacks({ events, toolCalls, tools, messages, abortSignal, toolsContext, experimental_sandbox }) {
 	const toolNamesByCallId = /* @__PURE__ */ new Map();
 	const toolCallsById = new Map(toolCalls.map((toolCall) => [toolCall.toolCallId, toolCall]));
@@ -1499,7 +1628,7 @@ async function invokeToolInputLifecycleCallbacks({ events, toolCalls, tools, mes
 				break;
 			case "available": {
 				const toolCall = toolCallsById.get(toolCallId);
-				if (toolCall == null) break;
+				if (toolCall == null || toolCall.invalid) break;
 				await tool.onInputAvailable?.({
 					...options,
 					input: toolCall.input
@@ -1686,6 +1815,7 @@ var WorkflowAgent = class {
 		this.tools = options.tools ?? {};
 		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;
@@ -1759,6 +1889,7 @@ var WorkflowAgent = class {
 		let effectiveRuntimeContext = options.runtimeContext ?? this.runtimeContext ?? {};
 		let effectiveToolsContext = options.toolsContext ?? this.toolsContext ?? {};
 		let effectiveToolChoiceFromPrepare = options.toolChoice ?? this.toolChoice;
+		let effectiveToolCallConcurrency = options.toolCallConcurrency ?? this.toolCallConcurrency;
 		let effectiveStopWhenFromPrepare = options.stopWhen ?? this.stopWhen ?? (mode === "generate" ? isStepCount(20) : void 0);
 		let effectiveActiveToolsFromPrepare = options.activeTools ?? this.activeTools;
 		let effectiveDownloadFromPrepare = options.experimental_download ?? this.experimentalDownload;
@@ -1774,6 +1905,7 @@ var WorkflowAgent = class {
 				tools: this.tools,
 				instructions: effectiveInstructions,
 				toolChoice: effectiveToolChoiceFromPrepare,
+				toolCallConcurrency: effectiveToolCallConcurrency,
 				stopWhen: effectiveStopWhenFromPrepare,
 				activeTools: effectiveActiveToolsFromPrepare,
 				experimental_download: effectiveDownloadFromPrepare,
@@ -1792,6 +1924,7 @@ var WorkflowAgent = class {
 			if (prepared.runtimeContext !== void 0) effectiveRuntimeContext = prepared.runtimeContext;
 			if (prepared.toolsContext !== void 0) effectiveToolsContext = prepared.toolsContext;
 			if (prepared.toolChoice !== void 0) effectiveToolChoiceFromPrepare = prepared.toolChoice;
+			if (prepared.toolCallConcurrency !== void 0) effectiveToolCallConcurrency = prepared.toolCallConcurrency;
 			if (prepared.stopWhen !== void 0) effectiveStopWhenFromPrepare = prepared.stopWhen;
 			if (prepared.activeTools !== void 0) effectiveActiveToolsFromPrepare = prepared.activeTools;
 			if (prepared.experimental_download !== void 0) effectiveDownloadFromPrepare = prepared.experimental_download;
@@ -1810,6 +1943,7 @@ var WorkflowAgent = class {
 			if (prepared.reasoning !== void 0) effectiveGenerationSettings.reasoning = prepared.reasoning;
 			if (prepared.providerOptions !== void 0) effectiveGenerationSettings.providerOptions = prepared.providerOptions;
 		}
+		const toolCallConcurrency = prepareToolCallConcurrency(options.toolCallConcurrency ?? effectiveToolCallConcurrency);
 		const effectiveTelemetry = effectiveTelemetryFromPrepare;
 		const telemetryDispatcher = createRestrictedTelemetryDispatcher({
 			telemetry: effectiveTelemetry,
@@ -1836,6 +1970,7 @@ var WorkflowAgent = class {
 			effectiveRuntimeContext,
 			effectiveToolsContext,
 			effectiveToolChoiceFromPrepare,
+			toolCallConcurrency,
 			effectiveStopWhenFromPrepare,
 			effectiveActiveToolsFromPrepare,
 			effectiveToolApprovalSecret,
@@ -1852,7 +1987,7 @@ var WorkflowAgent = class {
 		};
 	}
 	async execute(options, mode = "stream") {
-		const { onEnd, effectiveModel, effectiveInstructions, effectiveGenerationSettings, effectiveRuntimeContext, effectiveToolsContext, effectiveToolChoiceFromPrepare, effectiveStopWhenFromPrepare, effectiveActiveToolsFromPrepare, effectiveToolApprovalSecret, effectiveTelemetry, telemetryDispatcher, prompt, download, workflowDownload, sandbox, effectiveAbortSignal, timeoutAt, mergedOnToolExecutionStart, mergedOnToolExecutionEnd } = await this.prepareInvocation(options, mode);
+		const { onEnd, effectiveModel, effectiveInstructions, effectiveGenerationSettings, effectiveRuntimeContext, effectiveToolsContext, effectiveToolChoiceFromPrepare, toolCallConcurrency, effectiveStopWhenFromPrepare, effectiveActiveToolsFromPrepare, effectiveToolApprovalSecret, effectiveTelemetry, telemetryDispatcher, prompt, download, workflowDownload, sandbox, effectiveAbortSignal, timeoutAt, mergedOnToolExecutionStart, mergedOnToolExecutionEnd } = await this.prepareInvocation(options, mode);
 		const initialResponseMessages = [];
 		const abortReason = () => effectiveAbortSignal?.reason === void 0 ? void 0 : { value: effectiveAbortSignal.reason };
 		const collectedApprovals = collectToolApprovals({ messages: prompt.messages });
@@ -1876,13 +2011,55 @@ var WorkflowAgent = class {
 		if (approvedToolApprovals.length > 0 || deniedToolApprovals.length > 0) {
 			const toolResultContent = [];
 			const approvedRawResults = [];
-			for (const approval of approvedToolApprovals) {
-				if (approval.providerExecuted) continue;
-				const tool = this.tools[approval.toolName];
-				if (tool && typeof tool.execute === "function") {
-					if (!tool.needsApproval) {
-						const reason = `Tool "${approval.toolName}" does not require approval`;
-						toolResultContent.push({
+			const approvedResults = await mapWithConcurrency({
+				items: approvedToolApprovals.filter((approval) => !approval.providerExecuted),
+				concurrency: toolCallConcurrency,
+				abortSignal: effectiveAbortSignal,
+				execute: async (approval) => {
+					const tool = this.tools[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",
+								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
+								})
+							} };
+						}
+						let revalidationReason;
+						try {
+							await validateWorkflowToolApprovalSignature({
+								secret: effectiveToolApprovalSecret,
+								approvalId: approval.collected.approvalRequest.approvalId,
+								toolCallId: approval.toolCallId,
+								toolName: approval.toolName,
+								input: approval.input,
+								signature: approval.collected.approvalRequest.signature
+							});
+							const { deniedToolApprovals: policyDenied, invalidToolApprovals } = await validateApprovedToolApprovals({
+								approvedToolApprovals: [approval.collected],
+								tools: this.tools,
+								toolApproval: void 0,
+								messages: prompt.messages,
+								toolsContext: effectiveToolsContext,
+								runtimeContext: effectiveRuntimeContext
+							});
+							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);
+						}
+						if (revalidationReason != null) return { modelResult: {
 							type: "tool-result",
 							toolCallId: approval.toolCallId,
 							toolName: approval.toolName,
@@ -1890,69 +2067,34 @@ var WorkflowAgent = class {
 								toolCallId: approval.toolCallId,
 								toolName: approval.toolName,
 								input: approval.input,
-								output: reason,
+								output: revalidationReason,
 								tool,
 								errorMode: "text",
 								supportedUrls: {},
 								download: workflowDownload
 							})
-						});
-						continue;
-					}
-					let revalidationReason;
-					try {
-						await validateWorkflowToolApprovalSignature({
-							secret: effectiveToolApprovalSecret,
-							approvalId: approval.collected.approvalRequest.approvalId,
-							toolCallId: approval.toolCallId,
-							toolName: approval.toolName,
-							input: approval.input,
-							signature: approval.collected.approvalRequest.signature
-						});
-						const { deniedToolApprovals: policyDenied, invalidToolApprovals } = await validateApprovedToolApprovals({
-							approvedToolApprovals: [approval.collected],
-							tools: this.tools,
-							toolApproval: void 0,
-							messages: prompt.messages,
-							toolsContext: effectiveToolsContext,
-							runtimeContext: effectiveRuntimeContext
-						});
-						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);
-					}
-					if (revalidationReason != null) {
-						toolResultContent.push({
-							type: "tool-result",
+						} };
+						const result = await executeToolWithCallbacks({
 							toolCallId: approval.toolCallId,
 							toolName: approval.toolName,
-							output: await createLanguageModelToolResultOutput({
+							input: approval.input
+						}, this.tools, prompt.messages, effectiveToolsContext, 0, sandbox);
+						return {
+							modelResult: result.modelResult,
+							rawResult: {
 								toolCallId: approval.toolCallId,
 								toolName: approval.toolName,
 								input: approval.input,
-								output: revalidationReason,
-								tool,
-								errorMode: "text",
-								supportedUrls: {},
-								download: workflowDownload
-							})
-						});
-						continue;
+								output: result.rawOutput
+							}
+						};
 					}
-					const result = await executeToolWithCallbacks({
-						toolCallId: approval.toolCallId,
-						toolName: approval.toolName,
-						input: approval.input
-					}, this.tools, prompt.messages, 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);
 			}
 			for (const denial of deniedToolApprovals) {
 				if (denial.providerExecuted || denial.existingToolResult !== void 0) continue;
@@ -2309,7 +2451,12 @@ var WorkflowAgent = class {
 					});
 					const providerApprovalRequests = step?.content.filter((part) => part.type === "tool-approval-request").filter((part) => part.toolCall.providerExecuted) ?? [];
 					if (pausedToolCalls.length > 0 || providerApprovalRequests.length > 0) {
-						const executableResults = await Promise.all(executableToolCalls.map((toolCall) => 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)
+						});
 						const providerResultEntries = await Promise.all(providerToolCallsForResults.filter((call) => !providerApprovalRequests.some((request) => request.toolCall.toolCallId === call.toolCallId)).map(async (toolCall) => ({
 							toolCall,
 							result: await resolveProviderToolResult(toolCall, capturedProviderToolResults, stepTools, workflowDownload)
@@ -2339,6 +2486,7 @@ var WorkflowAgent = class {
 						addToolResultsToStep(step, executedResults, mode);
 						const approvalToolCalls = pausedToolCalls.filter((tc) => approvalNeeded[nonProviderToolCalls.indexOf(tc)]);
 						const approvalRequests = await Promise.all(approvalToolCalls.map(async (tc) => {
+							const { inputSchemaInput, ...toolCallWithoutInputSchemaInput } = tc;
 							const approvalId = `approval-${tc.toolCallId}`;
 							const signature = effectiveToolApprovalSecret == null ? void 0 : await signWorkflowToolApproval({
 								secret: effectiveToolApprovalSecret,
@@ -2350,14 +2498,15 @@ var WorkflowAgent = class {
 							return {
 								type: "tool-approval-request",
 								approvalId,
+								...inputSchemaInput !== void 0 ? { inputSchemaInput } : {},
 								toolCall: {
-									...tc,
+									...toolCallWithoutInputSchemaInput,
 									type: "tool-call"
 								},
 								...signature != null ? { signature } : {}
 							};
 						}));
-						step?.content.push(...approvalRequests);
+						step?.content.push(...approvalRequests.map(({ inputSchemaInput: _inputSchemaInput, ...request }) => request));
 						const approvalMessages = approvalRequests.map(({ toolCall, ...request }) => ({
 							...request,
 							toolCallId: toolCall.toolCallId
@@ -2407,7 +2556,12 @@ var WorkflowAgent = class {
 							initialResponseMessages
 						};
 					}
-					const clientToolResults = await Promise.all(nonProviderToolCalls.map((toolCall) => 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)
+					});
 					const providerToolResultEntries = await Promise.all(providerToolCallsForResults.map(async (toolCall) => ({
 						toolCall,
 						result: await resolveProviderToolResult(toolCall, capturedProviderToolResults, stepTools, workflowDownload)
@@ -2621,7 +2775,8 @@ async function writeApprovalRequests(writable, approvalRequests) {
 			type: "tool-approval-request",
 			approvalId: request.approvalId,
 			toolCallId: request.toolCallId,
-			...request.signature != null ? { signature: request.signature } : {}
+			...request.signature != null ? { signature: request.signature } : {},
+			...request.inputSchemaInput !== void 0 ? { inputSchemaInput: request.inputSchemaInput } : {}
 		});
 	} finally {
 		writer.releaseLock();
@@ -3000,6 +3155,7 @@ function toUIMessageChunk(part) {
 			type: "tool-approval-request",
 			approvalId: part.approvalId,
 			toolCallId: "toolCallId" in part ? part.toolCallId : part.toolCall.toolCallId,
+			..."inputSchemaInput" in part && part.inputSchemaInput !== void 0 ? { inputSchemaInput: part.inputSchemaInput } : {},
 			...part.signature != null ? { signature: part.signature } : {}
 		};
 		default: {