@ai-sdk/workflow 2.0.69 → 2.0.71

package/dist/index.js

@@ -1,7 +1,7 @@
-import { n as normalizeUIMessageStreamParts, t as WorkflowChatTransport } from "./workflow-chat-transport-Bduf4ZDx.js";
-import { asArray, asSchema, convertUint8ArrayToBase64, generateId, getErrorMessage, isAbortError, jsonSchema, validateTypes, withUserAgentSuffix } from "@ai-sdk/provider-utils";
+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, createToolModelOutput, createToolSearchState, downloadAssets, mapToolResultOutput, mergeAbortSignals, mergeCallbacks, parseToolCall, prepareLanguageModelCallOptions, prepareRetries, prepareToolChoice, prepareTools, resolveLanguageModel, signToolApproval, standardizePrompt, validateApprovedToolApprovals, verifyToolApprovalSignature } from "ai/internal";
+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 { getWorkflowMetadata } from "workflow";
 import Ajv from "ajv";
 import Ajv2020 from "ajv/dist/2020.js";
@@ -182,7 +182,7 @@ async function buildModelStepResult(raw, toolCalls, finish, providerExecutedTool
 			durationMs: duration
 		});
 		return new DefaultStepResult({
-			callId: "workflow-agent",
+			callId: opts.callId ?? "workflow-agent",
 			stepNumber: opts.stepNumber,
 			provider: raw.generation.provider,
 			modelId: raw.generation.modelId,
@@ -311,7 +311,7 @@ async function buildModelStepResult(raw, toolCalls, finish, providerExecutedTool
 	}
 	const toolResults = content.filter((part) => part.type === "tool-result");
 	return {
-		callId: "workflow-agent",
+		callId: opts.callId ?? "workflow-agent",
 		stepNumber: opts.stepNumber,
 		model: {
 			provider: responseMetadata?.modelId?.split(":")[0] ?? "unknown",
@@ -382,6 +382,26 @@ async function buildModelStepResult(raw, toolCalls, finish, providerExecutedTool
 	};
 }
 //#endregion
+//#region src/language-model-prompt-to-model-messages.ts
+/**
+* Prepares a workflow-side `LanguageModelV4Prompt` for a second, model-aware
+* `convertToLanguageModelPrompt` pass inside a model step.
+*
+* The workflow-side conversion preserves URLs (it cannot download them) and
+* filters out approval responses for tools that are not provider-executed.
+* The remaining approval responses are restored with the `providerExecuted`
+* marker that the second conversion expects.
+*/
+function languageModelPromptToModelMessages(prompt) {
+	return prompt.map((message) => message.role !== "tool" ? message : {
+		...message,
+		content: message.content.map((part) => part.type === "tool-approval-response" ? {
+			...part,
+			providerExecuted: true
+		} : part)
+	});
+}
+//#endregion
 //#region src/serializable-schema.ts
 /**
 * Converts a ToolSet (with Zod/standard schemas and execute functions) to a
@@ -424,6 +444,16 @@ function resolveToolDescription({ tool, toolName, toolsContext, experimental_san
 		experimental_sandbox: sandbox
 	});
 }
+function formatAjvError(error) {
+	const path = `data${error.instancePath}`;
+	switch (error.keyword) {
+		case "enum": return `${path} must be one of ${error.params.allowedValues.map((value) => JSON.stringify(value)).join(", ")}`;
+		case "additionalProperties": return `${path} has unexpected property ${JSON.stringify(error.params.additionalProperty)}`;
+		case "const": return `${path} must equal ${JSON.stringify(error.params.allowedValue)}`;
+		case "required": return `${path} is missing required property ${JSON.stringify(error.params.missingProperty)}`;
+		default: return `${path} ${error.message ?? "is invalid"}`;
+	}
+}
 /**
 * Reconstructs tool objects from serializable tool definitions inside a step.
 *
@@ -433,14 +463,14 @@ function resolveToolDescription({ tool, toolName, toolsContext, experimental_san
 */
 function resolveSerializableTools(tools) {
 	const ajvOptions = {
+		allErrors: true,
 		strict: false,
 		validateFormats: false
 	};
 	const ajv = new Ajv(ajvOptions);
 	const ajv2020 = new Ajv2020(ajvOptions);
 	const createValidatedInputSchema = (inputSchema) => {
-		const schemaAjv = (typeof inputSchema.$schema === "string" ? inputSchema.$schema.replace(/#$/, "") : void 0) === "https://json-schema.org/draft/2020-12/schema" ? ajv2020 : ajv;
-		const validateFn = schemaAjv.compile(inputSchema);
+		const validateFn = ((typeof inputSchema.$schema === "string" ? inputSchema.$schema.replace(/#$/, "") : void 0) === "https://json-schema.org/draft/2020-12/schema" ? ajv2020 : ajv).compile(inputSchema);
 		return jsonSchema(inputSchema, { validate: (value) => {
 			if (validateFn(value)) return {
 				success: true,
@@ -448,7 +478,7 @@ function resolveSerializableTools(tools) {
 			};
 			return {
 				success: false,
-				error: new Error(schemaAjv.errorsText(validateFn.errors))
+				error: new Error(validateFn.errors.map(formatAjvError).join(", "))
 			};
 		} });
 	};
@@ -494,31 +524,164 @@ function resolveSerializableTools(tools) {
 	}));
 }
 //#endregion
+//#region src/model-call-telemetry.ts
+const generateCallId = createIdGenerator({
+	prefix: "call",
+	size: 24
+});
+/**
+* Global telemetry integrations are not visible in the workflow VM, so the
+* workflow body sends a serializable descriptor and the model step, which
+* runs in Node, dispatches the model call lifecycle itself.
+*
+* Each model call is reported as its own operation with a unique `callId`.
+*/
+function shouldDispatchModelCallTelemetryInStep(telemetry) {
+	return telemetry?.isEnabled !== false && telemetry?.integrations == null && globalThis.AI_SDK_TELEMETRY_INTEGRATIONS == null;
+}
+async function runModelCallWithTelemetry({ telemetry, modelInit, prompt, serializedTools, options, execute }) {
+	if (telemetry == null) return execute(void 0);
+	const dispatcher = createTelemetryDispatcher({ telemetry });
+	const callId = generateCallId();
+	const { provider, modelId } = typeof modelInit === "string" ? {
+		provider: "gateway",
+		modelId: modelInit
+	} : modelInit;
+	const tools = serializedTools == null ? void 0 : resolveSerializableTools(serializedTools);
+	const messages = prompt;
+	await dispatcher.onStart?.({
+		callId,
+		operationId: "ai.workflowAgent.stream",
+		provider,
+		modelId,
+		system: void 0,
+		messages,
+		tools,
+		toolChoice: options?.toolChoice,
+		activeTools: void 0,
+		maxOutputTokens: options?.maxOutputTokens,
+		temperature: options?.temperature,
+		topP: options?.topP,
+		topK: options?.topK,
+		presencePenalty: options?.presencePenalty,
+		frequencyPenalty: options?.frequencyPenalty,
+		stopSequences: options?.stopSequences,
+		seed: options?.seed,
+		maxRetries: options?.maxRetries ?? 2,
+		timeout: void 0,
+		headers: options?.headers,
+		reasoning: options?.reasoning,
+		providerOptions: options?.providerOptions,
+		output: void 0,
+		runtimeContext: {},
+		toolsContext: {}
+	});
+	await dispatcher.onStepStart?.({
+		callId,
+		provider,
+		modelId,
+		stepNumber: telemetry.stepNumber,
+		system: void 0,
+		messages,
+		tools,
+		toolChoice: options?.toolChoice,
+		activeTools: void 0,
+		steps: [],
+		providerOptions: options?.providerOptions,
+		output: void 0,
+		runtimeContext: {},
+		toolsContext: {}
+	});
+	let result;
+	try {
+		result = await execute({
+			callId,
+			onLanguageModelCallStart: dispatcher.onLanguageModelCallStart,
+			onLanguageModelCallEnd: dispatcher.onLanguageModelCallEnd,
+			executeLanguageModelCallInTelemetryContext: dispatcher.executeLanguageModelCall
+		});
+	} catch (error) {
+		await dispatcher.onError?.({
+			callId,
+			error
+		});
+		throw error;
+	}
+	if (result.aborted) {
+		await dispatcher.onAbort?.({
+			callId,
+			steps: []
+		});
+		return result;
+	}
+	if ("terminalError" in result) {
+		await dispatcher.onError?.({
+			callId,
+			error: result.terminalError
+		});
+		return result;
+	}
+	const step = await buildModelStepResult(result.raw, result.toolCalls, result.finish, result.providerExecutedToolResults, {
+		callId,
+		tools,
+		stepNumber: telemetry.stepNumber,
+		runtimeContext: {},
+		toolsContext: {}
+	});
+	await dispatcher.onStepEnd?.(step);
+	await dispatcher.onEnd?.(Object.assign(Object.create(Object.getPrototypeOf(step)), step, {
+		finalStep: step,
+		steps: [step],
+		usage: step.usage,
+		totalUsage: step.usage
+	}));
+	return result;
+}
+//#endregion
 //#region src/do-generate-step.ts
 /** A single durable provider call; orchestration and callbacks stay in the workflow. */
 async function doGenerateStep(prompt, modelInit, serializedTools, options = {}) {
 	"use step";
-	try {
-		return await generateModelCall(prompt, modelInit, serializedTools, options);
-	} catch (error) {
-		return {
-			toolCalls: [],
-			finish: void 0,
-			raw: {
-				content: [],
-				reasoning: []
-			},
-			providerExecutedToolResults: /* @__PURE__ */ new Map(),
-			terminalError: error
-		};
-	}
+	return runModelCallWithTelemetry({
+		telemetry: options.telemetry,
+		modelInit,
+		prompt,
+		serializedTools,
+		options,
+		execute: async (languageModelCallTelemetry) => {
+			try {
+				return await generateModelCall(prompt, modelInit, serializedTools, options, languageModelCallTelemetry);
+			} catch (error) {
+				return {
+					toolCalls: [],
+					finish: void 0,
+					raw: {
+						content: [],
+						reasoning: []
+					},
+					providerExecutedToolResults: /* @__PURE__ */ new Map(),
+					terminalError: error
+				};
+			}
+		}
+	});
 }
-async function generateModelCall(prompt, modelInit, serializedTools, options) {
+async function generateModelCall(prompt, modelInit, serializedTools, options, languageModelCallTelemetry) {
 	const remaining = options.timeoutAt == null ? void 0 : options.timeoutAt - Date.now();
 	options.abortSignal?.throwIfAborted();
 	if (remaining != null && remaining <= 0) throw new DOMException("The generation deadline expired.", "TimeoutError");
 	const abortSignal = remaining == null ? options.abortSignal : AbortSignal.any([...options.abortSignal == null ? [] : [options.abortSignal], AbortSignal.timeout(remaining)]);
 	const model = resolveLanguageModel(modelInit);
+	const modelPrompt = await convertToLanguageModelPrompt({
+		prompt: {
+			instructions: void 0,
+			messages: languageModelPromptToModelMessages(prompt)
+		},
+		supportedUrls: await model.supportedUrls,
+		download: options.download,
+		abortSignal,
+		provider: model.provider.split(".")[0]
+	});
 	const tools = resolveSerializableTools(serializedTools);
 	const toolChoice = prepareToolChoice({ toolChoice: options.toolChoice });
 	const modelTools = await prepareTools({ tools });
@@ -527,28 +690,54 @@ async function generateModelCall(prompt, modelInit, serializedTools, options) {
 		maxRetries: options.maxRetries,
 		abortSignal
 	});
+	const callId = languageModelCallTelemetry?.callId;
+	const executeLanguageModelCall = languageModelCallTelemetry?.executeLanguageModelCallInTelemetryContext ?? (({ execute }) => execute());
+	await languageModelCallTelemetry?.onLanguageModelCallStart?.({
+		callId,
+		provider: model.provider,
+		modelId: model.modelId,
+		messages: prompt,
+		tools: modelTools,
+		...settings,
+		providerOptions: options.providerOptions,
+		headers: options.headers
+	});
 	const start = Date.now();
 	const response = await retry(async () => {
 		abortSignal?.throwIfAborted();
 		if (options.timeoutAt != null && options.timeoutAt <= Date.now()) throw new DOMException("The generation deadline expired.", "TimeoutError");
-		return model.doGenerate({
-			...settings,
-			prompt: [...prompt],
-			tools: modelTools,
-			toolChoice,
-			responseFormat: options.responseFormat,
-			providerOptions: options.providerOptions,
-			headers: options.headers,
-			abortSignal
+		return executeLanguageModelCall({
+			callId: callId ?? "",
+			execute: () => model.doGenerate({
+				...settings,
+				prompt: modelPrompt,
+				tools: modelTools,
+				toolChoice,
+				responseFormat: options.responseFormat,
+				providerOptions: options.providerOptions,
+				headers: options.headers,
+				abortSignal
+			})
 		});
 	});
-	abortSignal?.throwIfAborted();
 	const responseTimeMs = Date.now() - start;
+	await languageModelCallTelemetry?.onLanguageModelCallEnd?.({
+		callId,
+		provider: model.provider,
+		modelId: response.response?.modelId ?? model.modelId,
+		finishReason: response.finishReason.unified,
+		usage: asLanguageModelUsage(response.usage),
+		content: response.content,
+		responseId: response.response?.id,
+		...response.providerMetadata != null ? { providerMetadata: response.providerMetadata } : {},
+		performance: { responseTimeMs }
+	});
+	abortSignal?.throwIfAborted();
 	const toolCalls = await Promise.all(response.content.filter((part) => part.type === "tool-call").map((toolCall) => parseToolCall({
 		toolCall,
 		tools,
 		repairToolCall: options.repairToolCall,
-		instructions: prompt.filter((message) => message.role === "system").map((message) => message.content).join("\n") || void 0,
+		instructions: modelPrompt.filter((message) => message.role === "system").map((message) => message.content).join("\n") || void 0,
 		messages: prompt.filter((message) => message.role !== "system")
 	})));
 	if ((toolChoice.type === "required" || toolChoice.type === "tool") && !toolCalls.some((call) => toolChoice.type === "required" || call.toolName === toolChoice.toolName)) throw new ToolChoiceViolationError({
@@ -627,6 +816,17 @@ doGenerateStep.maxRetries = 0;
 //#region src/do-stream-step.ts
 async function doStreamStep(conversationPrompt, modelInit, writable, serializedTools, options) {
 	"use step";
+	return runModelCallWithTelemetry({
+		telemetry: options?.telemetry,
+		modelInit,
+		prompt: conversationPrompt,
+		serializedTools,
+		options,
+		execute: (languageModelCallTelemetry) => streamModelStep(conversationPrompt, modelInit, writable, serializedTools, options, languageModelCallTelemetry)
+	});
+}
+doStreamStep.maxRetries = 0;
+async function streamModelStep(conversationPrompt, modelInit, writable, serializedTools, options, languageModelCallTelemetry) {
 	const timeout = options?.timeoutAt == null ? void 0 : options.timeoutAt - Date.now();
 	if (options?.abortSignal?.aborted || timeout != null && timeout <= 0) return { aborted: true };
 	const abortSignal = timeout == null ? options?.abortSignal : options?.abortSignal == null ? AbortSignal.timeout(timeout) : AbortSignal.any([options.abortSignal, AbortSignal.timeout(timeout)]);
@@ -667,13 +867,7 @@ async function doStreamStep(conversationPrompt, modelInit, writable, serializedT
 		try {
 			const { stream } = await retry(() => experimental_streamLanguageModelCall({
 				model: modelWithTransforms,
-				messages: conversationPrompt.map((message) => message.role !== "tool" ? message : {
-					...message,
-					content: message.content.map((part) => part.type === "tool-approval-response" ? {
-						...part,
-						providerExecuted: true
-					} : part)
-				}),
+				messages: languageModelPromptToModelMessages(conversationPrompt),
 				allowSystemInMessages: true,
 				tools,
 				toolChoice: options?.toolChoice,
@@ -691,7 +885,9 @@ async function doStreamStep(conversationPrompt, modelInit, writable, serializedT
 				frequencyPenalty: options?.frequencyPenalty,
 				stopSequences: options?.stopSequences,
 				seed: options?.seed,
-				repairToolCall: options?.repairToolCall
+				repairToolCall: options?.repairToolCall,
+				download: options?.download,
+				...languageModelCallTelemetry
 			}));
 			return stream;
 		} catch (error) {
@@ -712,11 +908,13 @@ async function doStreamStep(conversationPrompt, modelInit, writable, serializedT
 	let performance;
 	let terminalError;
 	let hasTerminalError = false;
+	let hasReceivedOutputChunk = false;
 	const ongoingToolCallToolNames = /* @__PURE__ */ new Map();
 	const writer = writable?.getWriter();
 	try {
 		await writer?.write({ type: "reset-step" });
 		for await (const part of modelStream) {
+			if (isOutputChunk(part)) hasReceivedOutputChunk = true;
 			switch (part.type) {
 				case "tool-input-start":
 					ongoingToolCallToolNames.set(part.id, part.toolName);
@@ -902,6 +1100,10 @@ async function doStreamStep(conversationPrompt, modelInit, writable, serializedT
 		writer?.releaseLock();
 	}
 	if (abortSignal?.aborted || options?.timeoutAt != null && options.timeoutAt <= Date.now()) return { aborted: true };
+	if (finish == null && !hasReceivedOutputChunk && !hasTerminalError) {
+		terminalError = new NoOutputGeneratedError({ message: "No output generated. The model stream ended without a finish chunk." });
+		hasTerminalError = true;
+	}
 	return {
 		toolCalls,
 		finish,
@@ -917,7 +1119,6 @@ async function doStreamStep(conversationPrompt, modelInit, writable, serializedT
 		...hasTerminalError ? { terminalError } : {}
 	};
 }
-doStreamStep.maxRetries = 0;
 function applyStreamTransforms({ stream, transforms, tools }) {
 	const sourceReader = stream.getReader();
 	let stopped = false;
@@ -1006,7 +1207,7 @@ function mergePrepareStepGenerationSettings(current, overrides) {
 		...definedOverrides
 	};
 }
-async function* modelCallIterator({ prompt, mode = "stream", include, initialInstructions, initialMessages = prompt, tools = {}, writable, model, stopConditions, onStepEnd, onStepFinish, onStepStart, onError, prepareStep, generationSettings, toolChoice, runtimeContext, toolsContext, telemetry, includeRawChunks = false, timeoutAt, repairToolCall, responseFormat, experimental_transform, experimental_sandbox: sandbox }) {
+async function* modelCallIterator({ prompt, mode = "stream", include, initialInstructions, initialMessages = prompt, tools = {}, writable, model, stopConditions, onStepEnd, onStepFinish, onStepStart, onError, prepareStep, generationSettings, toolChoice, runtimeContext, toolsContext, telemetry, includeRawChunks = false, timeoutAt, repairToolCall, download, responseFormat, experimental_transform, experimental_sandbox: sandbox }) {
 	let conversationPrompt = [...prompt];
 	let currentModel = model;
 	let currentGenerationSettings = generationSettings ?? {};
@@ -1032,6 +1233,7 @@ async function* modelCallIterator({ prompt, mode = "stream", include, initialIns
 		includeRuntimeContext: telemetry?.includeRuntimeContext,
 		includeToolsContext: telemetry?.includeToolsContext
 	});
+	const dispatchTelemetryInStep = shouldDispatchModelCallTelemetryInStep(telemetry);
 	while (!done) {
 		if (currentGenerationSettings.abortSignal?.aborted) {
 			if (mode === "generate") currentGenerationSettings.abortSignal.throwIfAborted();
@@ -1133,9 +1335,16 @@ async function* modelCallIterator({ prompt, mode = "stream", include, initialIns
 				includeRawChunks,
 				timeoutAt,
 				repairToolCall,
+				download,
 				responseFormat,
 				include,
-				experimental_transform
+				experimental_transform,
+				telemetry: dispatchTelemetryInStep ? {
+					functionId: telemetry?.functionId,
+					recordInputs: telemetry?.recordInputs,
+					recordOutputs: telemetry?.recordOutputs,
+					stepNumber
+				} : void 0
 			};
 			const modelCallResult = mode === "generate" ? await doGenerateStep(conversationPrompt, currentModel, serializedTools, callOptions) : await doStreamStep(conversationPrompt, currentModel, writable, serializedTools, callOptions);
 			if (modelCallResult.aborted) {
@@ -1182,10 +1391,10 @@ async function* modelCallIterator({ prompt, mode = "stream", include, initialIns
 			const isToolExecutionAllowed = finishReason === "tool-calls" || finishReason === "stop";
 			for (const toolCall of toolCalls) if (toolCall.providerExecuted && serializedTools[toolCall.toolName]?.supportsDeferredResults && !providerExecutedToolResults.has(toolCall.toolCallId)) pendingDeferredToolCallIds.add(toolCall.toolCallId);
 			for (const toolCallId of providerExecutedToolResults.keys()) pendingDeferredToolCallIds.delete(toolCallId);
-			const shouldProcessTools = isToolExecutionAllowed && (toolCalls.length > 0 || providerExecutedToolResults.size > 0);
-			if (hasTerminalError) done = true;
-			else if (shouldProcessTools) {
+			const shouldProcessTools = isToolExecutionAllowed && (toolCalls.length > 0 || providerExecutedToolResults.size > 0) || finishReason === "length" && providerExecutedToolResults.size > 0;
+			if (!hasTerminalError && shouldProcessTools) {
 				lastStepWasYielded = true;
+				const processableToolCalls = isToolExecutionAllowed ? toolCalls : toolCalls.filter((toolCall) => !toolCall.providerExecuted && toolCall.invalid || toolCall.providerExecuted && providerExecutedToolResults.has(toolCall.toolCallId));
 				const { content: assistantContent, providerExecutedToolResultPositions } = getAssistantMessageContent(step, mode);
 				const includedToolCallIds = new Set(assistantContent.flatMap((part) => part.type === "tool-call" ? [part.toolCallId] : []));
 				conversationPrompt.push({
@@ -1193,7 +1402,7 @@ async function* modelCallIterator({ prompt, mode = "stream", include, initialIns
 					content: [...assistantContent, ...toolCalls.filter((toolCall) => !includedToolCallIds.has(toolCall.toolCallId)).map(toAssistantToolCallContent)]
 				});
 				const toolResults = yield {
-					toolCalls,
+					toolCalls: processableToolCalls,
 					tools: effectiveTools,
 					messages: conversationPrompt,
 					step,
@@ -1206,14 +1415,14 @@ async function* modelCallIterator({ prompt, mode = "stream", include, initialIns
 				const responseMessages = addToolResultsToConversation({
 					messages: conversationPrompt,
 					toolResults,
-					providerExecutedToolCallIds: /* @__PURE__ */ new Set([...toolCalls.flatMap((toolCall) => toolCall.providerExecuted ? [toolCall.toolCallId] : []), ...providerExecutedToolResults.keys()]),
+					providerExecutedToolCallIds: /* @__PURE__ */ new Set([...processableToolCalls.flatMap((toolCall) => toolCall.providerExecuted ? [toolCall.toolCallId] : []), ...providerExecutedToolResults.keys()]),
 					providerExecutedToolResultPositions
 				});
 				step.response.messages.push(...mode === "generate" ? toModelResponseMessages(responseMessages) : responseMessages);
 				const stopConditionMet = (stopConditions == null ? [] : Array.isArray(stopConditions) ? stopConditions : [stopConditions]).some((test) => test({ steps }));
 				const hasClientToolCalls = toolCalls.some((toolCall) => !toolCall.providerExecuted);
-				done = stopConditionMet || !hasClientToolCalls && pendingDeferredToolCallIds.size === 0;
-			} else if (mode === "generate" || finishReason === "stop" || finishReason === "tool-calls" || finishReason === "length") {
+				done = !isToolExecutionAllowed || stopConditionMet || !hasClientToolCalls && pendingDeferredToolCallIds.size === 0;
+			} else if (hasTerminalError || mode === "generate" || finishReason === "stop" || finishReason === "tool-calls" || finishReason === "length" || finishReason === "content-filter" || finishReason === "error" || finishReason === "other" || finishReason === "unknown" || !finishReason) {
 				const { content: assistantContent } = getAssistantMessageContent(step, mode);
 				if (assistantContent.length > 0) {
 					const assistantMessage = {
@@ -1224,12 +1433,7 @@ async function* modelCallIterator({ prompt, mode = "stream", include, initialIns
 					step.response.messages.push(...mode === "generate" ? toModelResponseMessages([assistantMessage]) : [assistantMessage]);
 				}
 				done = true;
-			} else if (finishReason === "content-filter") done = true;
-			else if (finishReason === "error") done = true;
-			else if (finishReason === "other") done = true;
-			else if (finishReason === "unknown") done = true;
-			else if (!finishReason) done = true;
-			else throw new Error(`Unexpected finish reason: ${typeof finish?.finishReason === "object" ? JSON.stringify(finish?.finishReason) : finish?.finishReason}`);
+			} else throw new Error(`Unexpected finish reason: ${typeof finish?.finishReason === "object" ? JSON.stringify(finish?.finishReason) : finish?.finishReason}`);
 			const resolvedOnStepEnd = onStepEnd ?? onStepFinish;
 			if (resolvedOnStepEnd) await resolvedOnStepEnd(step);
 			await telemetryDispatcher.onStepEnd?.(normalizeStepForTelemetry$1(step));
@@ -1617,7 +1821,7 @@ var WorkflowAgent = class {
 			allowSystemInMessages: this.allowSystemInMessages,
 			...effectivePrompt != null ? { prompt: effectivePrompt } : { messages: effectiveMessages }
 		});
-		const download = effectiveDownloadFromPrepare;
+		const workflowDownload = async (requests) => requests.map(() => null);
 		const sandbox = options.experimental_sandbox ?? this.experimentalSandbox;
 		const abortSignalTimeout = isInWorkflow() ? void 0 : options.timeout;
 		const effectiveAbortSignal = mergeAbortSignals(options.abortSignal ?? effectiveGenerationSettings.abortSignal, abortSignalTimeout);
@@ -1638,7 +1842,8 @@ var WorkflowAgent = class {
 			effectiveTelemetry,
 			telemetryDispatcher,
 			prompt,
-			download,
+			download: effectiveDownloadFromPrepare,
+			workflowDownload,
 			sandbox,
 			effectiveAbortSignal,
 			timeoutAt,
@@ -1647,7 +1852,7 @@ var WorkflowAgent = class {
 		};
 	}
 	async execute(options, mode = "stream") {
-		const { onEnd, effectiveModel, effectiveInstructions, effectiveGenerationSettings, effectiveRuntimeContext, effectiveToolsContext, effectiveToolChoiceFromPrepare, effectiveStopWhenFromPrepare, effectiveActiveToolsFromPrepare, effectiveToolApprovalSecret, effectiveTelemetry, telemetryDispatcher, prompt, download, sandbox, effectiveAbortSignal, timeoutAt, mergedOnToolExecutionStart, mergedOnToolExecutionEnd } = await this.prepareInvocation(options, mode);
+		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 initialResponseMessages = [];
 		const abortReason = () => effectiveAbortSignal?.reason === void 0 ? void 0 : { value: effectiveAbortSignal.reason };
 		const collectedApprovals = collectToolApprovals({ messages: prompt.messages });
@@ -1689,7 +1894,7 @@ var WorkflowAgent = class {
 								tool,
 								errorMode: "text",
 								supportedUrls: {},
-								download
+								download: workflowDownload
 							})
 						});
 						continue;
@@ -1730,7 +1935,7 @@ var WorkflowAgent = class {
 								tool,
 								errorMode: "text",
 								supportedUrls: {},
-								download
+								download: workflowDownload
 							})
 						});
 						continue;
@@ -1797,7 +2002,7 @@ var WorkflowAgent = class {
 		const modelPrompt = await convertToLanguageModelPrompt({
 			prompt,
 			supportedUrls: {},
-			download
+			download: workflowDownload
 		});
 		const mergedGenerationSettings = {
 			...effectiveGenerationSettings,
@@ -1894,7 +2099,7 @@ var WorkflowAgent = class {
 			const startTime = Date.now();
 			let result;
 			try {
-				const execute = () => executeTool(toolCall, tools, messages, resolvedContext, effectiveAbortSignal, download, stepSandbox);
+				const execute = () => executeTool(toolCall, tools, messages, resolvedContext, effectiveAbortSignal, workflowDownload, stepSandbox);
 				result = telemetryDispatcher.executeTool != null ? await telemetryDispatcher.executeTool({
 					callId: "workflow-agent",
 					toolCallId: toolCall.toolCallId,
@@ -2029,6 +2234,7 @@ var WorkflowAgent = class {
 			includeRawChunks: options.includeRawChunks ?? false,
 			timeoutAt,
 			repairToolCall: options.repairToolCall ?? options.experimental_repairToolCall ?? this.repairToolCall,
+			download,
 			responseFormat: await (options.output ?? this.output)?.responseFormat,
 			experimental_transform: options.experimental_transform,
 			experimental_sandbox: sandbox
@@ -2106,7 +2312,7 @@ var WorkflowAgent = class {
 						const executableResults = await Promise.all(executableToolCalls.map((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, download)
+							result: await resolveProviderToolResult(toolCall, capturedProviderToolResults, stepTools, workflowDownload)
 						})));
 						await Promise.all(providerResultEntries.flatMap(({ toolCall, result }) => result == null ? [] : [recordProviderExecutedToolTelemetry(toolCall, result, iterMessages, currentStepNumber)]));
 						const providerResults = providerResultEntries.flatMap(({ result }) => result == null ? [] : [result]);
@@ -2204,7 +2410,7 @@ var WorkflowAgent = class {
 					const clientToolResults = await Promise.all(nonProviderToolCalls.map((toolCall) => executeToolWithCallbacks(toolCall, stepTools, iterMessages, toolsContext, currentStepNumber, toolExecutionSandbox)));
 					const providerToolResultEntries = await Promise.all(providerToolCallsForResults.map(async (toolCall) => ({
 						toolCall,
-						result: await resolveProviderToolResult(toolCall, capturedProviderToolResults, stepTools, download)
+						result: await resolveProviderToolResult(toolCall, capturedProviderToolResults, stepTools, workflowDownload)
 					})));
 					await Promise.all(providerToolResultEntries.flatMap(({ toolCall, result }) => result == null ? [] : [recordProviderExecutedToolTelemetry(toolCall, result, iterMessages, currentStepNumber)]));
 					const providerToolResults = providerToolResultEntries.flatMap(({ result }) => result == null ? [] : [result]);