@ai-sdk/workflow 2.0.58 → 2.0.60

package/dist/index.js

@@ -1,7 +1,7 @@
 import { n as normalizeUIMessageStreamParts, t as WorkflowChatTransport } from "./workflow-chat-transport-Bduf4ZDx.js";
-import { asArray, asSchema, getErrorMessage, isAbortError, jsonSchema, validateTypes, withUserAgentSuffix } from "@ai-sdk/provider-utils";
-import { DefaultGeneratedFile, InvalidToolApprovalSignatureError, Output, dynamicTool, experimental_filterActiveTools, experimental_streamLanguageModelCall, gateway, tool, wrapLanguageModel } from "ai";
-import { collectToolApprovals, convertToLanguageModelPrompt, createDefaultDownloadFunction, createRestrictedTelemetryDispatcher, createToolModelOutput, createToolSearchState, downloadAssets, mapToolResultOutput, mergeAbortSignals, mergeCallbacks, prepareRetries, signToolApproval, standardizePrompt, validateApprovedToolApprovals, verifyToolApprovalSignature } from "ai/internal";
+import { asArray, asSchema, convertUint8ArrayToBase64, 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 { getWorkflowMetadata } from "workflow";
 import Ajv from "ajv";
 //#region src/add-tool-results-to-conversation.ts
@@ -118,6 +118,265 @@ async function resolveToolContext({ toolName, tool, toolsContext }) {
 	});
 }
 //#endregion
+//#region src/to-model-response-messages.ts
+/** Convert provider file references back to public message data without re-running tool output hooks. */
+function toModelResponseMessages(messages) {
+	return messages.map((message) => message.role !== "assistant" ? message : {
+		...message,
+		content: message.content.map((part) => {
+			if (part.type !== "file" && part.type !== "reasoning-file") return part;
+			return {
+				...part,
+				data: part.data.type === "data" ? part.data.data : part.data.type === "url" ? part.data.url : part.data
+			};
+		})
+	});
+}
+//#endregion
+//#region src/build-model-step-result.ts
+async function buildModelStepResult(raw, toolCalls, finish, providerExecutedToolResults, opts) {
+	if (raw.generation != null && finish != null) {
+		const providerContent = [];
+		for (const part of raw.content) switch (part.type) {
+			case "reasoning":
+				if (!("reasoningIndex" in part)) providerContent.push(part);
+				break;
+			case "tool-call": {
+				const call = toolCalls[part.toolCallIndex];
+				providerContent.push({
+					...call,
+					input: "",
+					type: "tool-call"
+				});
+				break;
+			}
+			case "provider-tool-result":
+				providerContent.push({
+					...providerExecutedToolResults.get(part.toolCallId),
+					type: "tool-result"
+				});
+				break;
+			case "file":
+				providerContent.push({
+					...part,
+					data: {
+						type: "data",
+						data: part.data
+					}
+				});
+				break;
+			default: providerContent.push(part);
+		}
+		const content = await convertLanguageModelContent({
+			content: providerContent,
+			toolCalls,
+			toolOutputs: [],
+			toolApprovalRequests: [],
+			toolApprovalResponses: [],
+			tools: opts.tools
+		});
+		const duration = raw.generation.responseTimeMs;
+		const rate = (tokens) => calculateTokensPerSecond({
+			tokens,
+			durationMs: duration
+		});
+		return new DefaultStepResult({
+			callId: "workflow-agent",
+			stepNumber: opts.stepNumber,
+			provider: raw.generation.provider,
+			modelId: raw.generation.modelId,
+			runtimeContext: opts.runtimeContext,
+			toolsContext: opts.toolsContext,
+			content,
+			finishReason: finish.finishReason,
+			rawFinishReason: finish.rawFinishReason,
+			usage: finish.usage,
+			warnings: raw.warnings,
+			request: {
+				...raw.generation.request,
+				messages: opts.requestMessages
+			},
+			response: {
+				...raw.responseMetadata,
+				messages: []
+			},
+			providerMetadata: finish.providerMetadata,
+			performance: {
+				responseTimeMs: duration,
+				stepTimeMs: duration,
+				toolExecutionMs: {},
+				effectiveOutputTokensPerSecond: rate(finish.usage.outputTokens),
+				effectiveTotalTokensPerSecond: rate(finish.usage.totalTokens),
+				outputTokensPerSecond: void 0,
+				inputTokensPerSecond: void 0,
+				timeToFirstOutputMs: void 0
+			}
+		});
+	}
+	const { content: rawContent, reasoning: reasoningParts, responseMetadata, warnings } = raw;
+	const reasoningText = reasoningParts.map((r) => r.text).join("") || void 0;
+	const validToolCallsByIndex = new Map(toolCalls.flatMap((tc, index) => tc.invalid ? [] : [[index, {
+		type: "tool-call",
+		toolCallId: tc.toolCallId,
+		toolName: tc.toolName,
+		input: tc.input,
+		...tc.providerExecuted != null ? { providerExecuted: tc.providerExecuted } : {},
+		...tc.title != null ? { title: tc.title } : {},
+		...tc.toolMetadata != null ? { toolMetadata: tc.toolMetadata } : {},
+		...tc.dynamic ? { dynamic: true } : {},
+		...tc.providerExecuted ? { providerExecuted: true } : {},
+		...tc.providerMetadata != null ? { providerMetadata: tc.providerMetadata } : {}
+	}]]));
+	const validToolCalls = [...validToolCallsByIndex.values()];
+	const content = [];
+	const files = [];
+	const sources = [];
+	let text = "";
+	for (const part of rawContent) switch (part.type) {
+		case "text":
+			text += part.text;
+			content.push({
+				type: "text",
+				text: part.text,
+				...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
+			});
+			break;
+		case "reasoning":
+			if ("reasoningIndex" in part) {
+				const reasoningPart = reasoningParts[part.reasoningIndex];
+				if (reasoningPart != null) content.push({
+					type: "reasoning",
+					text: reasoningPart.text,
+					...reasoningPart.providerMetadata != null ? { providerMetadata: reasoningPart.providerMetadata } : {}
+				});
+			}
+			break;
+		case "file": {
+			const file = new DefaultGeneratedFile({
+				data: part.data,
+				mediaType: part.mediaType,
+				providerMetadata: part.providerMetadata
+			});
+			files.push(file);
+			content.push({
+				type: "file",
+				file,
+				...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
+			});
+			break;
+		}
+		case "source":
+			sources.push(part);
+			content.push(part);
+			break;
+		case "tool-approval-request": {
+			const toolCall = validToolCalls.find((call) => call.toolCallId === part.toolCallId);
+			if (toolCall != null) content.push({
+				type: "tool-approval-request",
+				approvalId: part.approvalId,
+				toolCall
+			});
+			break;
+		}
+		case "tool-call": {
+			const toolCall = validToolCallsByIndex.get(part.toolCallIndex);
+			if (toolCall != null) content.push(toolCall);
+			break;
+		}
+		case "provider-tool-result": {
+			const result = providerExecutedToolResults.get(part.toolCallId);
+			if (result == null) break;
+			const toolCall = toolCalls.find((toolCall) => toolCall.toolCallId === result.toolCallId);
+			const common = {
+				toolCallId: result.toolCallId,
+				toolName: result.toolName,
+				input: toolCall?.input,
+				providerExecuted: true,
+				...result.dynamic === true || toolCall?.dynamic === true ? { dynamic: true } : {},
+				...result.providerMetadata != null ? { providerMetadata: result.providerMetadata } : {},
+				...toolCall?.toolMetadata != null ? { toolMetadata: toolCall.toolMetadata } : {}
+			};
+			content.push(result.isError ? {
+				type: "tool-error",
+				...common,
+				error: result.result
+			} : {
+				type: "tool-result",
+				...common,
+				output: result.result
+			});
+			break;
+		}
+	}
+	const toolResults = content.filter((part) => part.type === "tool-result");
+	return {
+		callId: "workflow-agent",
+		stepNumber: opts.stepNumber,
+		model: {
+			provider: responseMetadata?.modelId?.split(":")[0] ?? "unknown",
+			modelId: responseMetadata?.modelId ?? "unknown"
+		},
+		functionId: void 0,
+		metadata: void 0,
+		runtimeContext: opts.runtimeContext ?? {},
+		toolsContext: opts.toolsContext ?? {},
+		content,
+		text,
+		reasoning: reasoningParts.map((r) => ({
+			type: "reasoning",
+			text: r.text,
+			...r.providerMetadata != null ? { providerMetadata: r.providerMetadata } : {}
+		})),
+		reasoningText,
+		files,
+		sources,
+		toolCalls: validToolCalls,
+		staticToolCalls: validToolCalls.filter((tc) => tc.dynamic !== true),
+		dynamicToolCalls: validToolCalls.filter((tc) => tc.dynamic),
+		toolResults,
+		staticToolResults: toolResults.filter((result) => result.dynamic !== true),
+		dynamicToolResults: toolResults.filter((result) => result.dynamic === true),
+		finishReason: finish?.finishReason ?? "other",
+		rawFinishReason: finish?.rawFinishReason,
+		usage: finish?.usage ?? {
+			inputTokens: 0,
+			inputTokenDetails: {
+				noCacheTokens: void 0,
+				cacheReadTokens: void 0,
+				cacheWriteTokens: void 0
+			},
+			outputTokens: 0,
+			outputTokenDetails: {
+				textTokens: void 0,
+				reasoningTokens: void 0
+			},
+			totalTokens: 0
+		},
+		performance: {
+			effectiveOutputTokensPerSecond: 0,
+			outputTokensPerSecond: void 0,
+			inputTokensPerSecond: void 0,
+			effectiveTotalTokensPerSecond: 0,
+			stepTimeMs: 0,
+			responseTimeMs: 0,
+			toolExecutionMs: {},
+			timeToFirstOutputMs: void 0
+		},
+		warnings,
+		request: {
+			body: "",
+			messages: []
+		},
+		response: {
+			id: responseMetadata?.id ?? "unknown",
+			timestamp: responseMetadata?.timestamp ?? /* @__PURE__ */ new Date(),
+			modelId: responseMetadata?.modelId ?? "unknown",
+			messages: []
+		},
+		providerMetadata: finish?.providerMetadata ?? {}
+	};
+}
+//#endregion
 //#region src/serializable-schema.ts
 /**
 * Converts a ToolSet (with Zod/standard schemas and execute functions) to a
@@ -233,6 +492,136 @@ function resolveSerializableTools(tools) {
 	}));
 }
 //#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
+		};
+	}
+}
+async function generateModelCall(prompt, modelInit, serializedTools, options) {
+	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 tools = resolveSerializableTools(serializedTools);
+	const toolChoice = prepareToolChoice({ toolChoice: options.toolChoice });
+	const modelTools = await prepareTools({ tools });
+	const settings = prepareLanguageModelCallOptions(options);
+	const { retry } = prepareRetries({
+		maxRetries: options.maxRetries,
+		abortSignal
+	});
+	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
+		});
+	});
+	abortSignal?.throwIfAborted();
+	const responseTimeMs = Date.now() - start;
+	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,
+		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({
+		toolChoice,
+		finishReason: response.finishReason.unified,
+		provider: model.provider,
+		modelId: model.modelId,
+		content: response.content
+	});
+	const providerExecutedToolResults = /* @__PURE__ */ new Map();
+	const content = response.content.map((part) => {
+		switch (part.type) {
+			case "tool-call": return {
+				type: "tool-call",
+				toolCallIndex: toolCalls.findIndex((call) => call.toolCallId === part.toolCallId)
+			};
+			case "tool-result":
+				providerExecutedToolResults.set(part.toolCallId, part);
+				return {
+					type: "provider-tool-result",
+					toolCallId: part.toolCallId
+				};
+			case "file": return {
+				type: "file",
+				data: part.data.type === "data" ? typeof part.data.data === "string" ? part.data.data : convertUint8ArrayToBase64(part.data.data) : part.data.url.toString(),
+				mediaType: part.mediaType,
+				providerMetadata: part.providerMetadata
+			};
+			default: return part;
+		}
+	});
+	const toolInputLifecycleEvents = toolCalls.flatMap((call) => {
+		const tool = serializedTools[call.toolName];
+		if (call.invalid || tool == null) return [];
+		const events = [];
+		if (tool.hasOnInputStart || tool.hasOnInputAvailable) events.push([
+			"start",
+			call.toolCallId,
+			call.toolName
+		]);
+		if (tool.hasOnInputAvailable) events.push(["available", call.toolCallId]);
+		return events;
+	});
+	return {
+		toolCalls,
+		finish: {
+			finishReason: response.finishReason.unified,
+			rawFinishReason: response.finishReason.raw,
+			usage: asLanguageModelUsage(response.usage),
+			providerMetadata: response.providerMetadata
+		},
+		raw: {
+			content,
+			reasoning: [],
+			warnings: response.warnings,
+			responseMetadata: {
+				id: response.response?.id ?? generateId(),
+				timestamp: response.response?.timestamp ?? /* @__PURE__ */ new Date(),
+				modelId: response.response?.modelId ?? model.modelId,
+				headers: response.response?.headers,
+				...options.include?.responseBody ? { body: response.response?.body } : {}
+			},
+			generation: {
+				provider: model.provider,
+				modelId: model.modelId,
+				responseTimeMs,
+				request: options.include?.requestBody ? response.request : void 0
+			}
+		},
+		providerExecutedToolResults,
+		toolInputLifecycleEvents
+	};
+}
+doGenerateStep.maxRetries = 0;
+//#endregion
 //#region src/do-stream-step.ts
 async function doStreamStep(conversationPrompt, modelInit, writable, serializedTools, options) {
 	"use step";
@@ -276,7 +665,13 @@ async function doStreamStep(conversationPrompt, modelInit, writable, serializedT
 		try {
 			const { stream } = await retry(() => experimental_streamLanguageModelCall({
 				model: modelWithTransforms,
-				messages: conversationPrompt,
+				messages: conversationPrompt.map((message) => message.role !== "tool" ? message : {
+					...message,
+					content: message.content.map((part) => part.type === "tool-approval-response" ? {
+						...part,
+						providerExecuted: true
+					} : part)
+				}),
 				allowSystemInMessages: true,
 				tools,
 				toolChoice: options?.toolChoice,
@@ -403,6 +798,13 @@ async function doStreamStep(conversationPrompt, modelInit, writable, serializedT
 				case "source":
 					content.push(part);
 					break;
+				case "tool-approval-request":
+					content.push({
+						type: "tool-approval-request",
+						approvalId: part.approvalId,
+						toolCallId: part.toolCall.toolCallId
+					});
+					break;
 				case "tool-call": {
 					const toolCallPart = part;
 					const toolCallIndex = toolCalls.length;
@@ -576,7 +978,7 @@ function upsertReasoningContentPart({ content, reasoningParts, reasoningPartInde
 	if (providerMetadata != null) part.providerMetadata = providerMetadata;
 }
 //#endregion
-//#region src/stream-text-iterator.ts
+//#region src/model-call-iterator.ts
 const prepareStepGenerationSettingKeys = [
 	"maxOutputTokens",
 	"temperature",
@@ -599,7 +1001,7 @@ function mergePrepareStepGenerationSettings(current, overrides) {
 		...definedOverrides
 	};
 }
-async function* streamTextIterator({ prompt, 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, responseFormat, experimental_transform, experimental_sandbox: sandbox }) {
 	let conversationPrompt = [...prompt];
 	let currentModel = model;
 	let currentGenerationSettings = generationSettings ?? {};
@@ -626,7 +1028,10 @@ async function* streamTextIterator({ prompt, initialInstructions, initialMessage
 		includeToolsContext: telemetry?.includeToolsContext
 	});
 	while (!done) {
-		if (currentGenerationSettings.abortSignal?.aborted) break;
+		if (currentGenerationSettings.abortSignal?.aborted) {
+			if (mode === "generate") currentGenerationSettings.abortSignal.throwIfAborted();
+			break;
+		}
 		let stepSandbox = sandbox;
 		if (prepareStep) {
 			const prepareResult = await prepareStep({
@@ -716,25 +1121,28 @@ async function* streamTextIterator({ prompt, initialInstructions, initialMessage
 				providerOptions: currentGenerationSettings.providerOptions,
 				headers: currentGenerationSettings.headers
 			});
-			const stepInputMessages = conversationPrompt;
-			const streamStepResult = await doStreamStep(conversationPrompt, currentModel, writable, serializedTools, {
+			const stepInputMessages = mode === "generate" ? [...conversationPrompt] : conversationPrompt;
+			const callOptions = {
 				...currentGenerationSettings,
 				toolChoice: currentToolChoice,
 				includeRawChunks,
 				timeoutAt,
 				repairToolCall,
 				responseFormat,
+				include,
 				experimental_transform
-			});
-			if (streamStepResult.aborted) {
+			};
+			const modelCallResult = mode === "generate" ? await doGenerateStep(conversationPrompt, currentModel, serializedTools, callOptions) : await doStreamStep(conversationPrompt, currentModel, writable, serializedTools, callOptions);
+			if (modelCallResult.aborted) {
 				wasAborted = true;
 				break;
 			}
-			if ("terminalError" in streamStepResult) {
-				terminalError = streamStepResult.terminalError;
+			if ("terminalError" in modelCallResult) {
+				if (mode === "generate") throw modelCallResult.terminalError;
+				terminalError = modelCallResult.terminalError;
 				hasTerminalError = true;
 			}
-			const { toolCalls, finish, raw, providerExecutedToolResults, toolInputLifecycleEvents } = streamStepResult;
+			const { toolCalls, finish, raw, providerExecutedToolResults, toolInputLifecycleEvents } = modelCallResult;
 			await invokeToolInputLifecycleCallbacks({
 				events: toolInputLifecycleEvents ?? [],
 				toolCalls,
@@ -744,7 +1152,9 @@ async function* streamTextIterator({ prompt, initialInstructions, initialMessage
 				toolsContext: currentToolsContext,
 				experimental_sandbox: stepSandbox
 			});
-			const step = buildStepResult(raw, toolCalls, finish, providerExecutedToolResults, {
+			const step = await buildModelStepResult(raw, toolCalls, finish, providerExecutedToolResults, {
+				tools: effectiveTools,
+				requestMessages: mode === "generate" && include?.requestMessages ? stepInputMessages : void 0,
 				stepNumber,
 				runtimeContext: currentRuntimeContext,
 				toolsContext: currentToolsContext
@@ -771,7 +1181,7 @@ async function* streamTextIterator({ prompt, initialInstructions, initialMessage
 			if (hasTerminalError) done = true;
 			else if (shouldProcessTools) {
 				lastStepWasYielded = true;
-				const { content: assistantContent, providerExecutedToolResultPositions } = getAssistantMessageContent(step);
+				const { content: assistantContent, providerExecutedToolResultPositions } = getAssistantMessageContent(step, mode);
 				const includedToolCallIds = new Set(assistantContent.flatMap((part) => part.type === "tool-call" ? [part.toolCallId] : []));
 				conversationPrompt.push({
 					role: "assistant",
@@ -794,23 +1204,22 @@ async function* streamTextIterator({ prompt, initialInstructions, initialMessage
 					providerExecutedToolCallIds: /* @__PURE__ */ new Set([...toolCalls.flatMap((toolCall) => toolCall.providerExecuted ? [toolCall.toolCallId] : []), ...providerExecutedToolResults.keys()]),
 					providerExecutedToolResultPositions
 				});
-				step.response.messages.push(...responseMessages);
+				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 (finishReason === "stop" || finishReason === "tool-calls") {
-				const { content: assistantContent } = getAssistantMessageContent(step);
+			} else if (mode === "generate" || finishReason === "stop" || finishReason === "tool-calls" || finishReason === "length") {
+				const { content: assistantContent } = getAssistantMessageContent(step, mode);
 				if (assistantContent.length > 0) {
 					const assistantMessage = {
 						role: "assistant",
 						content: assistantContent
 					};
 					conversationPrompt.push(assistantMessage);
-					step.response.messages.push(assistantMessage);
+					step.response.messages.push(...mode === "generate" ? toModelResponseMessages([assistantMessage]) : [assistantMessage]);
 				}
 				done = true;
-			} else if (finishReason === "length") done = true;
-			else if (finishReason === "content-filter") 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;
@@ -909,193 +1318,45 @@ function normalizeStepForTelemetry$1(step) {
 		}
 	};
 }
-/**
-* Reconstruct a full `StepResult` from the minimal aggregates returned by
-* `doStreamStep`. Runs outside the step boundary so StepResult's redundant
-* fields (duplicate tool-call lists, `text`, `files`, `sources`, and
-* `reasoningText`) and the per-chunk snapshot don't cross it. Tool-result
-* arrays are initialized here and populated after execution. The shape matches
-* what the AI SDK's `streamText` exposes to callers.
-*/
-function buildStepResult(raw, toolCalls, finish, providerExecutedToolResults, opts) {
-	const { content: rawContent, reasoning: reasoningParts, responseMetadata, warnings } = raw;
-	const reasoningText = reasoningParts.map((r) => r.text).join("") || void 0;
-	const validToolCallsByIndex = new Map(toolCalls.flatMap((tc, index) => tc.invalid ? [] : [[index, {
-		type: "tool-call",
-		toolCallId: tc.toolCallId,
-		toolName: tc.toolName,
-		input: tc.input,
-		...tc.providerExecuted != null ? { providerExecuted: tc.providerExecuted } : {},
-		...tc.title != null ? { title: tc.title } : {},
-		...tc.toolMetadata != null ? { toolMetadata: tc.toolMetadata } : {},
-		...tc.dynamic ? { dynamic: true } : {},
-		...tc.providerExecuted ? { providerExecuted: true } : {},
-		...tc.providerMetadata != null ? { providerMetadata: tc.providerMetadata } : {}
-	}]]));
-	const validToolCalls = [...validToolCallsByIndex.values()];
-	const content = [];
-	const files = [];
-	const sources = [];
-	let text = "";
-	for (const part of rawContent) switch (part.type) {
-		case "text":
-			text += part.text;
-			content.push({
-				type: "text",
-				text: part.text,
-				...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
-			});
-			break;
-		case "reasoning": {
-			const reasoningPart = reasoningParts[part.reasoningIndex];
-			if (reasoningPart != null) content.push({
-				type: "reasoning",
-				text: reasoningPart.text,
-				...reasoningPart.providerMetadata != null ? { providerMetadata: reasoningPart.providerMetadata } : {}
-			});
-			break;
-		}
-		case "file": {
-			const file = new DefaultGeneratedFile({
-				data: part.data,
-				mediaType: part.mediaType,
-				providerMetadata: part.providerMetadata
-			});
-			files.push(file);
-			content.push({
-				type: "file",
-				file,
-				...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
-			});
-			break;
-		}
-		case "source":
-			sources.push(part);
-			content.push(part);
-			break;
-		case "tool-call": {
-			const toolCall = validToolCallsByIndex.get(part.toolCallIndex);
-			if (toolCall != null) content.push(toolCall);
-			break;
-		}
-		case "provider-tool-result": {
-			const result = providerExecutedToolResults.get(part.toolCallId);
-			if (result == null) break;
-			const toolCall = toolCalls.find((toolCall) => toolCall.toolCallId === result.toolCallId);
-			const common = {
-				toolCallId: result.toolCallId,
-				toolName: result.toolName,
-				input: toolCall?.input,
-				providerExecuted: true,
-				...result.dynamic === true || toolCall?.dynamic === true ? { dynamic: true } : {},
-				...result.providerMetadata != null ? { providerMetadata: result.providerMetadata } : {},
-				...toolCall?.toolMetadata != null ? { toolMetadata: toolCall.toolMetadata } : {}
-			};
-			content.push(result.isError ? {
-				type: "tool-error",
-				...common,
-				error: result.result
-			} : {
-				type: "tool-result",
-				...common,
-				output: result.result
-			});
-			break;
-		}
-	}
-	const toolResults = content.filter((part) => part.type === "tool-result");
-	return {
-		callId: "workflow-agent",
-		stepNumber: opts.stepNumber,
-		model: {
-			provider: responseMetadata?.modelId?.split(":")[0] ?? "unknown",
-			modelId: responseMetadata?.modelId ?? "unknown"
-		},
-		functionId: void 0,
-		metadata: void 0,
-		runtimeContext: opts.runtimeContext ?? {},
-		toolsContext: opts.toolsContext ?? {},
-		content,
-		text,
-		reasoning: reasoningParts.map((r) => ({
-			type: "reasoning",
-			text: r.text,
-			...r.providerMetadata != null ? { providerMetadata: r.providerMetadata } : {}
-		})),
-		reasoningText,
-		files,
-		sources,
-		toolCalls: validToolCalls,
-		staticToolCalls: validToolCalls.filter((tc) => tc.dynamic !== true),
-		dynamicToolCalls: validToolCalls.filter((tc) => tc.dynamic),
-		toolResults,
-		staticToolResults: toolResults.filter((result) => result.dynamic !== true),
-		dynamicToolResults: toolResults.filter((result) => result.dynamic === true),
-		finishReason: finish?.finishReason ?? "other",
-		rawFinishReason: finish?.rawFinishReason,
-		usage: finish?.usage ?? {
-			inputTokens: 0,
-			inputTokenDetails: {
-				noCacheTokens: void 0,
-				cacheReadTokens: void 0,
-				cacheWriteTokens: void 0
-			},
-			outputTokens: 0,
-			outputTokenDetails: {
-				textTokens: void 0,
-				reasoningTokens: void 0
-			},
-			totalTokens: 0
-		},
-		performance: {
-			effectiveOutputTokensPerSecond: 0,
-			outputTokensPerSecond: void 0,
-			inputTokensPerSecond: void 0,
-			effectiveTotalTokensPerSecond: 0,
-			stepTimeMs: 0,
-			responseTimeMs: 0,
-			toolExecutionMs: {},
-			timeToFirstOutputMs: void 0
-		},
-		warnings,
-		request: {
-			body: "",
-			messages: []
-		},
-		response: {
-			id: responseMetadata?.id ?? "unknown",
-			timestamp: responseMetadata?.timestamp ?? /* @__PURE__ */ new Date(),
-			modelId: responseMetadata?.modelId ?? "unknown",
-			messages: []
-		},
-		providerMetadata: finish?.providerMetadata ?? {}
-	};
-}
-function getAssistantMessageContent(step) {
+/** Preserve assistant ordering and positions for provider-executed results. */
+function getAssistantMessageContent(step, mode) {
 	const content = [];
 	const providerExecutedToolResultPositions = [];
 	let contentIndex = 0;
 	for (const part of step.content) switch (part.type) {
-		case "reasoning":
+		case "text":
+			if (part.text.length > 0) {
+				content.push({
+					type: "text",
+					text: part.text,
+					...part.providerMetadata != null ? { providerOptions: part.providerMetadata } : {}
+				});
+				contentIndex++;
+			}
+			break;
+		case "reasoning": {
+			const { providerMetadata, ...messagePart } = part;
 			content.push({
-				type: "reasoning",
-				text: part.text,
-				...part.providerMetadata != null ? { providerOptions: part.providerMetadata } : {}
+				...messagePart,
+				...providerMetadata != null ? { providerOptions: providerMetadata } : {}
 			});
 			contentIndex++;
 			break;
-		case "text":
-			if (part.text.length > 0) {
+		}
+		case "custom":
+			if (mode === "generate") {
+				const { providerMetadata, ...messagePart } = part;
 				content.push({
-					type: "text",
-					text: part.text
+					...messagePart,
+					providerOptions: providerMetadata
 				});
 				contentIndex++;
 			}
 			break;
+		case "reasoning-file": if (mode !== "generate") break;
 		case "file":
 			content.push({
-				type: "file",
+				type: part.type,
 				data: {
 					type: "data",
 					data: part.file.base64
@@ -1134,8 +1395,21 @@ function toAssistantToolCallContent(toolCall) {
 	};
 }
 //#endregion
+//#region src/workflow-execution-result.ts
+function resolveWorkflowStreamResult({ data, outcome }) {
+	if (outcome.status === "failed") {
+		if (outcome.source === "execution") throw outcome.error;
+		return {
+			...data,
+			error: outcome.error
+		};
+	}
+	if (outcome.status === "aborted" && outcome.rejection != null) throw outcome.rejection.value;
+	return data;
+}
+//#endregion
 //#region src/workflow-agent.ts
-function addToolResultsToStep(step, executedResults) {
+function addToolResultsToStep(step, executedResults, mode = "stream") {
 	if (step == null || executedResults.length === 0) return;
 	const existingProviderResultIds = new Set(step.content.flatMap((part) => (part.type === "tool-result" || part.type === "tool-error") && part.providerExecuted ? [part.toolCallId] : []));
 	const toolOutputs = executedResults.flatMap((result) => {
@@ -1145,6 +1419,10 @@ function addToolResultsToStep(step, executedResults) {
 			toolCallId: result.modelResult.toolCallId,
 			toolName: result.modelResult.toolName,
 			input: toolCall?.input,
+			...mode === "generate" ? {
+				dynamic: toolCall?.dynamic === true,
+				...toolCall?.toolMetadata != null ? { toolMetadata: toolCall.toolMetadata } : {}
+			} : {},
 			...toolCall?.dynamic === true ? { dynamic: true } : {},
 			...toolCall?.providerExecuted === true ? { providerExecuted: true } : {}
 		};
@@ -1159,6 +1437,7 @@ function addToolResultsToStep(step, executedResults) {
 		}];
 	});
 	step.content.push(...toolOutputs);
+	if (mode === "generate") return;
 	const toolResults = toolOutputs.filter((result) => result.type === "tool-result");
 	step.toolResults.push(...toolResults);
 	step.staticToolResults.push(...toolResults.filter((result) => result.dynamic !== true));
@@ -1234,10 +1513,34 @@ var WorkflowAgent = class {
 			providerOptions: options.providerOptions
 		};
 	}
-	generate() {
-		throw new Error("Not implemented");
+	async generate(options) {
+		const { data, outcome, abortReason, initialResponseMessages = [] } = await this.execute(options, "generate");
+		if (outcome.status === "failed") throw outcome.error;
+		if (outcome.status === "aborted") {
+			if (outcome.rejection != null) throw outcome.rejection.value;
+			if (abortReason != null) throw abortReason.value;
+			options.abortSignal?.throwIfAborted();
+			throw new DOMException("Generation aborted.", "AbortError");
+		}
+		const lastStep = data.steps.at(-1);
+		if (lastStep == null) throw new NoOutputGeneratedError();
+		let output;
+		if (lastStep.finishReason === "stop" || lastStep.finishReason !== "tool-calls" && lastStep.text.length > 0) output = await (options.output ?? this.output ?? Output.text()).parseCompleteOutput({ text: lastStep.text }, {
+			response: lastStep.response,
+			usage: lastStep.usage,
+			finishReason: lastStep.finishReason
+		});
+		return new DefaultGenerateTextResult({
+			initialResponseMessages,
+			steps: data.steps,
+			totalUsage: data.totalUsage,
+			output
+		});
 	}
 	async stream(options) {
+		return resolveWorkflowStreamResult(await this.execute(options));
+	}
+	async prepareInvocation(options, mode = "stream") {
 		const { onFinish, onEnd = onFinish } = options;
 		let effectiveModel = this.model;
 		let effectiveInstructions = options.instructions ?? options.system ?? this.instructions;
@@ -1247,7 +1550,7 @@ var WorkflowAgent = class {
 		let effectiveRuntimeContext = options.runtimeContext ?? this.runtimeContext ?? {};
 		let effectiveToolsContext = options.toolsContext ?? this.toolsContext ?? {};
 		let effectiveToolChoiceFromPrepare = options.toolChoice ?? this.toolChoice;
-		let effectiveStopWhenFromPrepare = options.stopWhen ?? this.stopWhen;
+		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;
 		const effectiveToolApprovalSecret = options.experimental_toolApprovalSecret ?? this.experimentalToolApprovalSecret;
@@ -1316,6 +1619,32 @@ var WorkflowAgent = class {
 		const timeoutAt = options.timeout == null ? void 0 : Date.now() + options.timeout;
 		const mergedOnToolExecutionStart = mergeCallbacks(this.constructorOnToolExecutionStart, options.onToolExecutionStart);
 		const mergedOnToolExecutionEnd = mergeCallbacks(this.constructorOnToolExecutionEnd, options.onToolExecutionEnd);
+		return {
+			onEnd,
+			effectiveModel,
+			effectiveInstructions,
+			effectiveGenerationSettings,
+			effectiveRuntimeContext,
+			effectiveToolsContext,
+			effectiveToolChoiceFromPrepare,
+			effectiveStopWhenFromPrepare,
+			effectiveActiveToolsFromPrepare,
+			effectiveToolApprovalSecret,
+			effectiveTelemetry,
+			telemetryDispatcher,
+			prompt,
+			download,
+			sandbox,
+			effectiveAbortSignal,
+			timeoutAt,
+			mergedOnToolExecutionStart,
+			mergedOnToolExecutionEnd
+		};
+	}
+	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 initialResponseMessages = [];
+		const abortReason = () => effectiveAbortSignal?.reason === void 0 ? void 0 : { value: effectiveAbortSignal.reason };
 		const collectedApprovals = collectToolApprovals({ messages: prompt.messages });
 		const approvedToolApprovals = collectedApprovals.approvedToolApprovals.map((collected) => ({
 			toolCallId: collected.toolCall.toolCallId,
@@ -1330,7 +1659,8 @@ var WorkflowAgent = class {
 			toolName: collected.toolCall.toolName,
 			input: collected.toolCall.input,
 			reason: collected.approvalResponse.reason,
-			providerExecuted: collected.toolCall.providerExecuted === true
+			providerExecuted: collected.toolCall.providerExecuted === true,
+			existingToolResult: collected.existingToolResult
 		}));
 		const providerExecutedApprovalIds = new Set([...collectedApprovals.approvedToolApprovals, ...collectedApprovals.deniedToolApprovals].filter((collected) => collected.toolCall.providerExecuted === true).map((collected) => collected.approvalResponse.approvalId));
 		if (approvedToolApprovals.length > 0 || deniedToolApprovals.length > 0) {
@@ -1415,7 +1745,7 @@ var WorkflowAgent = class {
 				}
 			}
 			for (const denial of deniedToolApprovals) {
-				if (denial.providerExecuted) continue;
+				if (denial.providerExecuted || denial.existingToolResult !== void 0) continue;
 				toolResultContent.push({
 					type: "tool-result",
 					toolCallId: denial.toolCallId,
@@ -1447,15 +1777,17 @@ var WorkflowAgent = class {
 					content: filtered
 				});
 			} else cleanedMessages.push(msg);
+			if (mode === "generate" && toolResultContent.length > 0) initialResponseMessages.push({
+				role: "tool",
+				content: toolResultContent
+			});
 			if (toolResultContent.length > 0) cleanedMessages.push({
 				role: "tool",
 				content: toolResultContent
 			});
 			prompt.messages = cleanedMessages;
-			if (options.writable && toolResultContent.length > 0) {
-				const deniedResults = toolResultContent.filter((r) => r.output.type === "execution-denied").map((r) => ({ toolCallId: r.toolCallId }));
-				await writeApprovalToolResults(options.writable, approvedRawResults, deniedResults);
-			}
+			const deniedResults = deniedToolApprovals.filter((denial) => !denial.providerExecuted).map((denial) => ({ toolCallId: denial.toolCallId }));
+			if (options.writable && (toolResultContent.length > 0 || deniedResults.length > 0)) await writeApprovalToolResults(options.writable, approvedRawResults, deniedResults);
 		}
 		const modelPrompt = await convertToLanguageModelPrompt({
 			prompt,
@@ -1658,16 +1990,22 @@ var WorkflowAgent = class {
 		if (mergedGenerationSettings.abortSignal?.aborted) {
 			if (options.onAbort) await options.onAbort({ steps });
 			return {
-				messages: prompt.messages,
-				steps,
-				toolCalls: [],
-				toolResults: [],
-				finishReason: "other",
-				totalUsage: aggregateUsage(steps),
-				output: void 0
+				outcome: { status: "aborted" },
+				abortReason: abortReason(),
+				data: {
+					messages: prompt.messages,
+					steps,
+					toolCalls: [],
+					toolResults: [],
+					finishReason: "other",
+					totalUsage: aggregateExecutionUsage(steps, mode),
+					output: void 0
+				}
 			};
 		}
-		const iterator = streamTextIterator({
+		const iterator = modelCallIterator({
+			mode,
+			include: options.include,
 			model: effectiveModel,
 			tools: effectiveTools,
 			writable: options.writable,
@@ -1705,6 +2043,16 @@ var WorkflowAgent = class {
 					break;
 				}
 				const { toolCalls, tools: stepTools = effectiveTools, messages: iterMessages, step, runtimeContext: yieldedRuntimeContext, toolsContext: yieldedToolsContext, experimental_sandbox: stepSandbox, providerExecutedToolResults, providerExecutedToolResultPositions } = result.value;
+				if (mode === "generate" && step != null) {
+					for (const call of toolCalls) if (call.invalid && !call.providerExecuted) step.content.push({
+						type: "tool-error",
+						toolCallId: call.toolCallId,
+						toolName: call.toolName,
+						input: call.input,
+						error: call.error,
+						dynamic: true
+					});
+				}
 				const capturedProviderToolResults = providerExecutedToolResults ?? /* @__PURE__ */ new Map();
 				const toolExecutionSandbox = stepSandbox ?? sandbox;
 				const currentStepNumber = steps.length;
@@ -1748,9 +2096,10 @@ var WorkflowAgent = class {
 						const tool = stepTools[tc.toolName];
 						return tool && typeof tool.execute !== "function" || approvalNeeded[i];
 					});
-					if (pausedToolCalls.length > 0) {
+					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 providerResultEntries = await Promise.all(providerToolCallsForResults.map(async (toolCall) => ({
+						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)
 						})));
@@ -1776,39 +2125,60 @@ var WorkflowAgent = class {
 							input: toolCalls.find((tc) => tc.toolCallId === r.modelResult.toolCallId)?.input,
 							output: r.rawOutput
 						}));
-						addToolResultsToStep(step, executedResults);
+						addToolResultsToStep(step, executedResults, mode);
+						const approvalToolCalls = pausedToolCalls.filter((tc) => approvalNeeded[nonProviderToolCalls.indexOf(tc)]);
+						const approvalRequests = await Promise.all(approvalToolCalls.map(async (tc) => {
+							const approvalId = `approval-${tc.toolCallId}`;
+							const signature = effectiveToolApprovalSecret == null ? void 0 : await signWorkflowToolApproval({
+								secret: effectiveToolApprovalSecret,
+								approvalId,
+								toolCallId: tc.toolCallId,
+								toolName: tc.toolName,
+								input: tc.input
+							});
+							return {
+								type: "tool-approval-request",
+								approvalId,
+								toolCall: {
+									...tc,
+									type: "tool-call"
+								},
+								...signature != null ? { signature } : {}
+							};
+						}));
+						step?.content.push(...approvalRequests);
+						const approvalMessages = approvalRequests.map(({ toolCall, ...request }) => ({
+							...request,
+							toolCallId: toolCall.toolCallId
+						}));
 						const responseMessages = addToolResultsToConversation({
 							messages: iterMessages,
 							toolResults: resolvedResults,
 							providerExecutedToolCallIds: new Set(providerToolCallsForResults.map((toolCall) => toolCall.toolCallId)),
 							providerExecutedToolResultPositions
 						});
-						step?.response.messages.push(...responseMessages);
-						const messages = iterMessages;
+						const publicResponseMessages = addApprovalRequestsToMessages(mode === "generate" ? toModelResponseMessages(responseMessages) : responseMessages, [...approvalMessages, ...providerApprovalRequests.map(({ toolCall, ...request }) => ({
+							...request,
+							toolCallId: toolCall.toolCallId
+						}))]);
+						step?.response.messages.push(...publicResponseMessages);
+						const messages = publicResponseMessages === responseMessages ? iterMessages : [...iterMessages.slice(0, iterMessages.length - responseMessages.length), ...publicResponseMessages];
 						const lastStep = steps[steps.length - 1];
-						const totalUsage = aggregateUsage(steps);
-						const finishReason = lastStep?.finishReason ?? "other";
-						if (mergedOnEnd && !wasAborted) await mergedOnEnd({
-							steps,
+						const totalUsage = aggregateExecutionUsage(steps, mode);
+						const data = {
 							messages,
-							text: lastStep?.text ?? "",
-							finishReason,
-							usage: totalUsage,
+							steps,
+							toolCalls: allToolCalls,
+							toolResults: allToolResults,
+							finishReason: lastStep?.finishReason ?? "other",
 							totalUsage,
-							runtimeContext,
-							toolsContext,
 							output: void 0
-						});
-						if (!wasAborted && steps.length > 0) {
-							const telemetrySteps = steps.map(normalizeStepForTelemetry);
-							const lastTelemetryStep = telemetrySteps[telemetrySteps.length - 1];
-							await telemetryDispatcher.onEnd?.({
-								...lastTelemetryStep,
-								steps: telemetrySteps,
-								usage: totalUsage,
-								totalUsage
-							});
+						};
+						if (mode === "generate" && step != null) {
+							await mergedOnStepEnd?.(step);
+							await telemetryDispatcher.onStepEnd?.(normalizeStepForTelemetry(step));
 						}
+						await notifyEnd(data, wasAborted);
 						if (options.writable) {
 							if (allToolResults.length > 0) await writeToolResults(options.writable, executedResults.map((r) => ({
 								toolCallId: r.modelResult.toolCallId,
@@ -1817,42 +2187,13 @@ var WorkflowAgent = class {
 								output: r.rawOutput,
 								isError: r.isError
 							})));
-							const approvalToolCalls = pausedToolCalls.filter((_, i) => {
-								const tcIndex = nonProviderToolCalls.indexOf(pausedToolCalls[i]);
-								return approvalNeeded[tcIndex];
-							});
-							if (approvalToolCalls.length > 0) {
-								const approvalRequests = await Promise.all(approvalToolCalls.map(async (tc) => {
-									const approvalId = `approval-${tc.toolCallId}`;
-									const signature = effectiveToolApprovalSecret == null ? void 0 : await signWorkflowToolApproval({
-										secret: effectiveToolApprovalSecret,
-										approvalId,
-										toolCallId: tc.toolCallId,
-										toolName: tc.toolName,
-										input: tc.input
-									});
-									return {
-										approvalId,
-										toolCallId: tc.toolCallId,
-										...signature != null ? { signature } : {}
-									};
-								}));
-								await writeApprovalRequests(options.writable, approvalRequests);
-							}
-						}
-						if (options.writable) {
-							const sendFinish = options.sendFinish ?? true;
-							const preventClose = options.preventClose ?? false;
-							if (sendFinish || !preventClose) await closeStream(options.writable, preventClose, sendFinish);
+							if (approvalMessages.length > 0) await writeApprovalRequests(options.writable, approvalMessages);
 						}
+						await closeOutput();
 						return {
-							messages,
-							steps,
-							toolCalls: allToolCalls,
-							toolResults: allToolResults,
-							finishReason,
-							totalUsage,
-							output: void 0
+							data,
+							outcome: { status: "completed" },
+							initialResponseMessages
 						};
 					}
 					const clientToolResults = await Promise.all(nonProviderToolCalls.map((toolCall) => executeToolWithCallbacks(toolCall, stepTools, iterMessages, toolsContext, currentStepNumber, toolExecutionSandbox)));
@@ -1900,7 +2241,7 @@ var WorkflowAgent = class {
 						input: toolCalls.find((tc) => tc.toolCallId === r.modelResult.toolCallId)?.input,
 						output: r.rawOutput
 					}));
-					addToolResultsToStep(step, executedToolResults);
+					addToolResultsToStep(step, executedToolResults, mode);
 					result = await iterator.next(continuationToolResults);
 				} else {
 					lastStepToolCalls = [];
@@ -1936,7 +2277,7 @@ var WorkflowAgent = class {
 		const messages = finalMessages ?? prompt.messages;
 		const effectiveOutput = options.output ?? this.output;
 		let experimentalOutput = void 0;
-		if (effectiveOutput && steps.length > 0) {
+		if (mode === "stream" && effectiveOutput && steps.length > 0) {
 			const lastStep = steps[steps.length - 1];
 			const text = lastStep.text;
 			if (text) try {
@@ -1953,52 +2294,67 @@ var WorkflowAgent = class {
 			}
 		}
 		const lastStep = steps[steps.length - 1];
-		const totalUsage = aggregateUsage(steps);
+		const totalUsage = aggregateExecutionUsage(steps, mode);
 		const finishReason = lastStep?.finishReason ?? "other";
-		if (mergedOnEnd && !wasAborted) await mergedOnEnd({
-			steps,
+		const data = {
 			messages,
-			text: lastStep?.text ?? "",
+			steps,
+			toolCalls: lastStepToolCalls,
+			toolResults: lastStepToolResults,
 			finishReason,
-			usage: totalUsage,
 			totalUsage,
-			runtimeContext,
-			toolsContext,
 			output: experimentalOutput
-		});
-		if (!wasAborted && steps.length > 0) {
-			const telemetrySteps = steps.map(normalizeStepForTelemetry);
-			const lastTelemetryStep = telemetrySteps[telemetrySteps.length - 1];
-			await telemetryDispatcher.onEnd?.({
-				...lastTelemetryStep,
-				steps: telemetrySteps,
-				usage: totalUsage,
-				totalUsage
+		};
+		if (mode === "stream" || !hasEncounteredError && !hasTerminalError) await notifyEnd(data, wasAborted);
+		await closeOutput();
+		const outcome = hasEncounteredError ? wasAborted ? {
+			status: "aborted",
+			rejection: { value: encounteredError }
+		} : {
+			status: "failed",
+			source: "execution",
+			error: encounteredError
+		} : hasTerminalError ? {
+			status: "failed",
+			source: "model-stream",
+			error: terminalError
+		} : wasAborted ? { status: "aborted" } : { status: "completed" };
+		return {
+			data,
+			outcome,
+			initialResponseMessages,
+			...outcome.status === "aborted" ? { abortReason: abortReason() } : {}
+		};
+		async function notifyEnd(data, aborted) {
+			if (aborted) return;
+			if (mergedOnEnd) await mergedOnEnd({
+				steps: data.steps,
+				messages: data.messages,
+				text: data.steps.at(-1)?.text ?? "",
+				finishReason: data.finishReason,
+				usage: data.totalUsage,
+				totalUsage: data.totalUsage,
+				runtimeContext,
+				toolsContext,
+				output: data.output
 			});
+			if (data.steps.length > 0) {
+				const telemetrySteps = data.steps.map(normalizeStepForTelemetry);
+				await telemetryDispatcher.onEnd?.({
+					...telemetrySteps[telemetrySteps.length - 1],
+					steps: telemetrySteps,
+					usage: data.totalUsage,
+					totalUsage: data.totalUsage
+				});
+			}
 		}
-		if (hasEncounteredError) {
+		async function closeOutput() {
 			if (options.writable) {
 				const sendFinish = options.sendFinish ?? true;
 				const preventClose = options.preventClose ?? false;
 				if (sendFinish || !preventClose) await closeStream(options.writable, preventClose, sendFinish);
 			}
-			throw encounteredError;
-		}
-		if (options.writable) {
-			const sendFinish = options.sendFinish ?? true;
-			const preventClose = options.preventClose ?? false;
-			if (sendFinish || !preventClose) await closeStream(options.writable, preventClose, sendFinish);
 		}
-		return {
-			messages,
-			steps,
-			toolCalls: lastStepToolCalls,
-			toolResults: lastStepToolResults,
-			finishReason,
-			totalUsage,
-			output: experimentalOutput,
-			...hasTerminalError ? { error: terminalError } : {}
-		};
 	}
 };
 function getModelInfo(model) {
@@ -2287,6 +2643,31 @@ async function executeTool(toolCall, tools, messages, context, abortSignal, down
 		isError: false
 	};
 }
+function aggregateExecutionUsage(steps, mode) {
+	return mode === "stream" ? aggregateUsage(steps) : steps.reduce((usage, step) => addLanguageModelUsage(usage, step.usage), createNullLanguageModelUsage());
+}
+function addApprovalRequestsToMessages(messages, requests) {
+	if (requests.length === 0) return messages;
+	const result = [...messages];
+	for (let index = result.length - 1; index >= 0; index--) {
+		const message = result[index];
+		if (message.role === "assistant") {
+			result[index] = {
+				...message,
+				content: [...typeof message.content === "string" ? [{
+					type: "text",
+					text: message.content
+				}] : message.content, ...requests]
+			};
+			return result;
+		}
+	}
+	result.unshift({
+		role: "assistant",
+		content: requests
+	});
+	return result;
+}
 //#endregion
 //#region src/to-ui-message-chunk.ts
 /**