@ai-sdk/workflow 2.0.69 → 2.0.70

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # @ai-sdk/workflow
 
+## 2.0.70
+
+### Patch Changes
+
+- 1506ee1: Fix `WorkflowChatTransport` retrying indefinitely when successful reconnect responses contain no UI message chunks. Empty streams now count toward `maxConsecutiveErrors`, while streams that receive chunks continue to advance the resume cursor and reset the error count.
+- 7400215: fix(workflow): retain streamed terminal assistant responses in conversation messages
+- 9aef724: fix(workflow): report incomplete no-output model streams as errors
+- 507cd9d: fix(workflow): include actionable details in tool input validation errors
+- a155baa: fix(workflow): dispatch WorkflowAgent model call telemetry to globally registered integrations from the model step
+- 7c0410d: fix(workflow): preserve provider-executed tool results and invalid local tool call error results on length completion
+- Updated dependencies [eab278a]
+- Updated dependencies [26d64e9]
+- Updated dependencies [9667bf2]
+- Updated dependencies [75b3ea2]
+- Updated dependencies [69f4b82]
+- Updated dependencies [e57803c]
+- Updated dependencies [4c705d9]
+- Updated dependencies [81663cc]
+- Updated dependencies [5150d50]
+- Updated dependencies [9aef724]
+- Updated dependencies [7d0458b]
+  - ai@7.0.138
+  - @ai-sdk/provider-utils@5.0.59
+  - @ai-sdk/provider@4.0.27
+
 ## 2.0.69
 
 ### Patch Changes

package/dist/client.d.ts

@@ -1,2 +1,2 @@
-import { i as WorkflowChatTransportOptions, n as SendMessagesOptions, r as WorkflowChatTransport, t as ReconnectToStreamOptions } from "./workflow-chat-transport-DwOgX7dK.js";
+import { i as WorkflowChatTransportOptions, n as SendMessagesOptions, r as WorkflowChatTransport, t as ReconnectToStreamOptions } from "./workflow-chat-transport-Bw-K44A5.js";
 export { type ReconnectToStreamOptions, type SendMessagesOptions, WorkflowChatTransport, type WorkflowChatTransportOptions };

package/dist/client.js

@@ -1,2 +1,2 @@
-import { t as WorkflowChatTransport } from "./workflow-chat-transport-Bduf4ZDx.js";
+import { t as WorkflowChatTransport } from "./workflow-chat-transport-Dj1poviu.js";
 export { WorkflowChatTransport };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { i as WorkflowChatTransportOptions, n as SendMessagesOptions, r as WorkflowChatTransport, t as ReconnectToStreamOptions } from "./workflow-chat-transport-DwOgX7dK.js";
+import { i as WorkflowChatTransportOptions, n as SendMessagesOptions, r as WorkflowChatTransport, t as ReconnectToStreamOptions } from "./workflow-chat-transport-Bw-K44A5.js";
 import { Context, HasRequiredKey, InferToolContext, InferToolInput, InferToolOutput, InferToolSetContext } from "@ai-sdk/provider-utils";
 import { ActiveTools, Experimental_LanguageModelStreamPart, Experimental_SandboxSession, FinishReason, GenerateTextOnStepEndCallback, GenerateTextResult, InferUITools, Instructions, LanguageModel, LanguageModelResponseMetadata, LanguageModelUsage, ModelMessage, Output, StepResult, StopCondition, TelemetryOptions as TelemetryOptions$1, ToolCallRepairFunction, ToolCallRepairFunction as ToolCallRepairFunction$1, ToolChoice, ToolSet, UIMessage, UIMessageChunk } from "ai";
 import { LanguageModelV4, LanguageModelV4CallOptions, LanguageModelV4Prompt, LanguageModelV4StreamPart, SharedV4ProviderOptions } from "@ai-sdk/provider";

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",
@@ -424,6 +424,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 +443,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 +458,7 @@ function resolveSerializableTools(tools) {
 			};
 			return {
 				success: false,
-				error: new Error(schemaAjv.errorsText(validateFn.errors))
+				error: new Error(validateFn.errors.map(formatAjvError).join(", "))
 			};
 		} });
 	};
@@ -494,26 +504,149 @@ 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");
@@ -527,23 +660,49 @@ 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: [...prompt],
+				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,
@@ -627,6 +786,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)]);
@@ -691,7 +861,8 @@ async function doStreamStep(conversationPrompt, modelInit, writable, serializedT
 				frequencyPenalty: options?.frequencyPenalty,
 				stopSequences: options?.stopSequences,
 				seed: options?.seed,
-				repairToolCall: options?.repairToolCall
+				repairToolCall: options?.repairToolCall,
+				...languageModelCallTelemetry
 			}));
 			return stream;
 		} catch (error) {
@@ -712,11 +883,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 +1075,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 +1094,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;
@@ -1032,6 +1208,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();
@@ -1135,7 +1312,13 @@ async function* modelCallIterator({ prompt, mode = "stream", include, initialIns
 				repairToolCall,
 				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 +1365,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 +1376,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 +1389,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 +1407,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));