@tanstack/ai 0.59.0 → 0.63.0

package/dist/esm/activities/chat/index.js

@@ -17,12 +17,13 @@ import { hashSchemaInput, normalizeApprovalSchema } from "./tools/approval-schem
 import { INTERRUPT_BINDING_METADATA_KEY, InterruptResumeValidationError, readInterruptBinding, readUnopenedInterruptBinding, validateInterruptResumeBatch } from "../../interrupt-resume.js";
 import { INTERRUPT_PAYLOAD_METADATA_KEY, createInterruptBinding, rehydrateInterruptRequest } from "../../interrupt-definition.js";
 import { readGenericInterruptContinuation } from "../../generic-interrupt-continuation.js";
-import { normalizeToolResult } from "../../utilities/tool-result.js";
-import { subagentHostMessageId } from "../../utilities/subagent-wire.js";
 import { isProviderExecutedToolCall } from "../../utilities/provider-executed.js";
+import { normalizeToolResult, parseToolOutput, toolResultErrorText } from "../../utilities/tool-result.js";
+import { subagentHostMessageId } from "../../utilities/subagent-wire.js";
 import { appendUiResourceToModelMessages, convertMessagesToModelMessages, generateMessageId, modelMessagesToUIMessages, safeJsonStringify, uiResourcePartFromCustomValue } from "./messages.js";
 import { uiMessagesToWire } from "../../utilities/ag-ui-wire.js";
 import { restorePublicUsage } from "../../utilities/restore-inbound-chunk.js";
+import { assertMessagesFileSourceSupport } from "../../utilities/content-source.js";
 import { LazyToolManager } from "./tools/lazy-tool-manager.js";
 import { assertUniqueToolNames } from "./tools/unique-tool-names.js";
 import { MiddlewareAbortError, ToolCallManager, executeToolCalls } from "./tools/tool-calls.js";
@@ -50,12 +51,6 @@ var kind = "text";
 var interruptBindingMetadataKey = INTERRUPT_BINDING_METADATA_KEY;
 /** Resume entries a subagent tool call owns. The parent run skips them. */
 var CHILD_RESUME_IDS = Symbol("tanstack.ai.childResumeIds");
-function assertNoFileSources(adapterName, messages) {
-	for (const message of messages) {
-		if (!Array.isArray(message.content)) continue;
-		for (const part of message.content) if ("source" in part && part.source.type === "file") throw new Error(`${adapterName} does not support provider file-handle sources ({ type: 'file' }). Pass a data or url source.`);
-	}
-}
 function isInterruptSubmissionError(value) {
 	if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
 	if (!("scope" in value) || !("code" in value) || !("message" in value) || !("source" in value) || !("retryable" in value) || !("threadId" in value) || !("interruptedRunId" in value) || !("generation" in value) || typeof value.code !== "string" || typeof value.message !== "string" || typeof value.retryable !== "boolean" || typeof value.threadId !== "string" || typeof value.interruptedRunId !== "string" || typeof value.generation !== "number") return false;
@@ -143,6 +138,15 @@ var TextEngine = class {
 	streamIdentityCaptured = false;
 	accumulatedContent = "";
 	accumulatedThinking = [];
+	/**
+	* Arrival order of this iteration's thinking steps, text and tool calls.
+	* A ModelMessage keeps `thinking` apart from `content`/`toolCalls`, so a
+	* provider turn that thinks between provider-executed tools would otherwise
+	* be recorded as "all thinking, then text, then tools" and the provider
+	* rejects the replay (signed thinking must keep its position). `null` once
+	* the order could no longer be tracked (callers fall back to one message).
+	*/
+	turnParts = [];
 	currentThinkingContent = "";
 	currentThinkingSignature = "";
 	eventOptions;
@@ -159,8 +163,10 @@ var TextEngine = class {
 	initialClientToolResults;
 	resumeApprovals = /* @__PURE__ */ new Map();
 	resumeClientToolResults = /* @__PURE__ */ new Map();
+	resumeClientToolErrors = /* @__PURE__ */ new Map();
 	resumeDeniedToolResults = /* @__PURE__ */ new Map();
 	resumeCancelledToolCallIds = /* @__PURE__ */ new Set();
+	resumeInputResponses = /* @__PURE__ */ new Map();
 	resumeGenericInterrupts = /* @__PURE__ */ new Map();
 	resumeGenericInterruptRequests = /* @__PURE__ */ new Map();
 	threadId;
@@ -326,6 +332,33 @@ var TextEngine = class {
 	getFinalizationError() {
 		return this.finalizationError;
 	}
+	async runTerminalHook() {
+		if (this.terminalHookCalled || this.isCancelled()) return;
+		this.terminalHookCalled = true;
+		if (this.finalizationError) {
+			const errForHook = new Error(this.finalizationError.message, this.finalizationError.cause !== void 0 ? { cause: this.finalizationError.cause } : void 0);
+			if (this.finalizationError.code !== void 0) Object.defineProperty(errForHook, "code", {
+				value: this.finalizationError.code,
+				enumerable: true
+			});
+			if (this.finalizationError.rawText !== void 0) Object.defineProperty(errForHook, "rawText", {
+				value: this.finalizationError.rawText,
+				enumerable: true
+			});
+			await this.middlewareRunner.runOnError(this.middlewareCtx, {
+				error: errForHook,
+				duration: Date.now() - this.streamStartTime
+			});
+			return;
+		}
+		this.addTerminalAssistantMessages();
+		await this.middlewareRunner.runOnFinish(this.middlewareCtx, {
+			finishReason: this.lastFinishReason,
+			duration: Date.now() - this.streamStartTime,
+			content: this.accumulatedContent,
+			usage: rebuildTokenUsage(this.finishedEvent?.usage, tanstackMetadata(this.finishedEvent ?? void 0)?.usage)
+		});
+	}
 	async *run() {
 		this.beforeRun();
 		this.logger.agentLoop("run started", { threadId: this.middlewareCtx.threadId });
@@ -351,7 +384,11 @@ var TextEngine = class {
 				}
 				return;
 			}
-			if ((yield* this.checkForPendingToolCalls()) === "wait") return;
+			const pendingPhase = yield* this.checkForPendingToolCalls();
+			if (pendingPhase === "stop" || pendingPhase === "wait") {
+				await this.runTerminalHook();
+				return;
+			}
 			if (!(!!this.finalStructuredOutput && this.tools.length === 0 && this.finalStructuredOutput.nativeCombined !== true)) do {
 				if (this.earlyTermination) break;
 				if (this.isCancelled()) return;
@@ -387,29 +424,7 @@ var TextEngine = class {
 					if (!this.finalizationError && !this.isCancelled()) yield* this.flushDeferredModelRunFinishedChunks();
 				} else yield* this.runStructuredFinalization();
 			}
-			if (!this.terminalHookCalled && this.toolPhase !== "wait" && !this.isCancelled()) {
-				if (this.finalizationError) {
-					this.terminalHookCalled = true;
-					const errForHook = new Error(this.finalizationError.message, this.finalizationError.cause !== void 0 ? { cause: this.finalizationError.cause } : void 0);
-					if (this.finalizationError.code !== void 0) Object.defineProperty(errForHook, "code", {
-						value: this.finalizationError.code,
-						enumerable: true
-					});
-					await this.middlewareRunner.runOnError(this.middlewareCtx, {
-						error: errForHook,
-						duration: Date.now() - this.streamStartTime
-					});
-				} else {
-					this.addTerminalAssistantMessages();
-					this.terminalHookCalled = true;
-					await this.middlewareRunner.runOnFinish(this.middlewareCtx, {
-						finishReason: this.lastFinishReason,
-						duration: Date.now() - this.streamStartTime,
-						content: this.accumulatedContent,
-						usage: rebuildTokenUsage(this.finishedEvent?.usage, tanstackMetadata(this.finishedEvent ?? void 0)?.usage)
-					});
-				}
-			}
+			await this.runTerminalHook();
 		} catch (error) {
 			if (error instanceof Error && error.name === "InterruptReplaySignal" && "continuationRunId" in error && typeof error.continuationRunId === "string") {
 				this.terminalHookCalled = true;
@@ -501,6 +516,7 @@ var TextEngine = class {
 		this.streamIdentityCaptured = false;
 		this.accumulatedContent = "";
 		this.accumulatedThinking = [];
+		this.turnParts = [];
 		this.currentThinkingContent = "";
 		this.currentThinkingSignature = "";
 		this.finishedEvent = null;
@@ -531,7 +547,7 @@ var TextEngine = class {
 		const { approvals } = this.collectClientState();
 		const adapterApprovals = /* @__PURE__ */ new Map();
 		for (const [approvalId, resolution] of approvals) adapterApprovals.set(approvalId, typeof resolution === "boolean" ? resolution : resolution.approved);
-		assertNoFileSources(this.adapter.name, this.messages);
+		assertMessagesFileSourceSupport(this.adapter, this.messages);
 		for await (const raw of this.adapter.chatStream({
 			model: this.params.model,
 			messages: this.providerMessages,
@@ -666,9 +682,23 @@ var TextEngine = class {
 	}
 	handleTextMessageContentEvent(chunk) {
 		const extra = chunk;
+		const before = this.accumulatedContent;
 		if (typeof extra.content === "string" && extra.content !== "") this.accumulatedContent = extra.content;
 		else this.accumulatedContent += chunk.delta;
 		this.middlewareCtx.accumulatedContent = this.accumulatedContent;
+		if (!this.turnParts) return;
+		if (!this.accumulatedContent.startsWith(before)) {
+			this.turnParts = null;
+			return;
+		}
+		const delta = this.accumulatedContent.slice(before.length);
+		if (delta === "") return;
+		const last = this.turnParts[this.turnParts.length - 1];
+		if (last && last.type === "text") last.content += delta;
+		else this.turnParts.push({
+			type: "text",
+			content: delta
+		});
 	}
 	captureStreamMessageIdentity(messageId) {
 		this.currentMessageId = messageId;
@@ -685,6 +715,11 @@ var TextEngine = class {
 	handleToolCallStartEvent(chunk) {
 		if (typeof chunk.parentMessageId === "string" && chunk.parentMessageId !== "") this.captureStreamMessageIdentity(chunk.parentMessageId);
 		this.toolCallManager.addToolCallStartEvent(chunk);
+		if (this.turnParts && !this.turnParts.some((part) => part.type === "call" && part.id === chunk.toolCallId)) this.turnParts.push({
+			type: "call",
+			id: chunk.toolCallId,
+			providerExecuted: isProviderExecutedToolCall({ metadata: chunk.metadata })
+		});
 		const metadata = chunk.metadata;
 		const thoughtSignature = metadata != null && typeof metadata === "object" && "thoughtSignature" in metadata && typeof metadata.thoughtSignature === "string" && metadata.thoughtSignature !== "" ? metadata.thoughtSignature : void 0;
 		if (thoughtSignature === void 0) return;
@@ -746,17 +781,42 @@ var TextEngine = class {
 				content: this.currentThinkingContent,
 				...this.currentThinkingSignature && { signature: this.currentThinkingSignature }
 			});
+			if (this.turnParts) {
+				const placeholder = [...this.turnParts].reverse().find((part) => part.type === "thinking" && part.index === -1);
+				const index = this.accumulatedThinking.length - 1;
+				if (placeholder) placeholder.index = index;
+				else this.turnParts.push({
+					type: "thinking",
+					index
+				});
+			}
 			this.currentThinkingContent = "";
 			this.currentThinkingSignature = "";
 		}
 	}
+	/**
+	* Record where the current thinking step sits among this turn's parts. A
+	* step is finalized only when the next step starts (or the turn ends), by
+	* which time later tool calls have already arrived, so the position has to
+	* be noted when the step's first content or signature shows up.
+	*/
+	noteThinkingStepPosition() {
+		if (this.turnParts && this.currentThinkingContent === "" && this.currentThinkingSignature === "") this.turnParts.push({
+			type: "thinking",
+			index: -1
+		});
+	}
 	handleStepStartedEvent() {
 		this.finalizeCurrentThinkingStep();
 	}
 	handleStepFinishedEvent(chunk) {
-		if (typeof chunk.signature === "string" && chunk.signature !== "") this.currentThinkingSignature = chunk.signature;
+		if (typeof chunk.signature === "string" && chunk.signature !== "") {
+			this.noteThinkingStepPosition();
+			this.currentThinkingSignature = chunk.signature;
+		}
 	}
 	handleReasoningMessageContentEvent(chunk) {
+		this.noteThinkingStepPosition();
 		this.currentThinkingContent += chunk.delta;
 	}
 	handleReasoningEncryptedValueEvent(chunk) {
@@ -768,6 +828,7 @@ var TextEngine = class {
 			};
 			return;
 		}
+		this.noteThinkingStepPosition();
 		this.currentThinkingSignature = chunk.encryptedValue;
 	}
 	/**
@@ -835,8 +896,10 @@ var TextEngine = class {
 				await this.middlewareRunner.runOnAfterToolCall(this.middlewareCtx, info);
 			}
 		}, this.middlewareCtx.context, this.toolAbortSignal, {
+			clientToolErrors: this.resumeClientToolErrors,
 			deniedToolResults: this.resumeDeniedToolResults,
-			cancelledToolCallIds: this.resumeCancelledToolCallIds
+			cancelledToolCallIds: this.resumeCancelledToolCallIds,
+			inputResponses: this.resumeInputResponses
 		});
 		const executionResult = yield* this.drainToolCallGenerator(generator);
 		if (this.isMiddlewareAborted()) {
@@ -850,10 +913,10 @@ var TextEngine = class {
 			needsApproval: executionResult.needsApproval,
 			needsClientExecution: executionResult.needsClientExecution
 		}));
-		if (executionResult.needsApproval.length > 0 || executionResult.needsClientExecution.length > 0 || executionResult.subagentInterrupts.length > 0) {
+		if (executionResult.needsApproval.length > 0 || executionResult.needsClientExecution.length > 0 || executionResult.inputRequired.length > 0 || executionResult.subagentInterrupts.length > 0) {
 			this.discardDeferredToolCallRunFinishedChunks();
 			if (allResults.length > 0) for (const chunk of this.buildToolResultChunks(allResults, finishEvent)) yield* this.pipeThroughMiddleware(chunk);
-			const emitted = yield* this.emitActionableInterruptBoundary(finishEvent, executionResult.needsApproval, executionResult.needsClientExecution, [], executionResult.subagentInterrupts);
+			const emitted = yield* this.emitActionableInterruptBoundary(finishEvent, executionResult.needsApproval, executionResult.needsClientExecution, [], executionResult.inputRequired, executionResult.subagentInterrupts);
 			this.setToolPhase(emitted ? "wait" : "stop");
 			return emitted ? "wait" : "stop";
 		}
@@ -927,8 +990,10 @@ var TextEngine = class {
 				await this.middlewareRunner.runOnAfterToolCall(this.middlewareCtx, info);
 			}
 		}, this.middlewareCtx.context, this.toolAbortSignal, {
+			clientToolErrors: this.resumeClientToolErrors,
 			deniedToolResults: this.resumeDeniedToolResults,
-			cancelledToolCallIds: this.resumeCancelledToolCallIds
+			cancelledToolCallIds: this.resumeCancelledToolCallIds,
+			inputResponses: this.resumeInputResponses
 		});
 		const executionResult = yield* this.drainToolCallGenerator(generator);
 		this.middlewareCtx.phase = "afterTools";
@@ -947,13 +1012,13 @@ var TextEngine = class {
 		const afterToolRequests = yield* this.runWhileYielding(this.middlewareRunner.runOnInterruptBoundary(this.middlewareCtx));
 		if (afterToolRequests.length > 0) {
 			for (const chunk of afterToolBoundaryChunks) yield* this.pipeThroughMiddleware(chunk);
-			yield* this.emitBoundaryInterrupts("afterTools", finishEvent, toolCalls, afterToolRequests);
+			yield* this.emitBoundaryInterrupts("afterTools", finishEvent, toolCalls, afterToolRequests, executionResult.inputRequired);
 			this.setToolPhase("wait");
 			return;
 		}
-		if (executionResult.needsApproval.length > 0 || executionResult.needsClientExecution.length > 0 || executionResult.subagentInterrupts.length > 0) {
+		if (executionResult.needsApproval.length > 0 || executionResult.needsClientExecution.length > 0 || executionResult.inputRequired.length > 0 || executionResult.subagentInterrupts.length > 0) {
 			if (allResults.length > 0) for (const chunk of afterToolBoundaryChunks) yield* this.pipeThroughMiddleware(chunk);
-			const emitted = yield* this.emitActionableInterruptBoundary(finishEvent, executionResult.needsApproval, executionResult.needsClientExecution, [], executionResult.subagentInterrupts);
+			const emitted = yield* this.emitActionableInterruptBoundary(finishEvent, executionResult.needsApproval, executionResult.needsClientExecution, [], executionResult.inputRequired, executionResult.subagentInterrupts);
 			this.setToolPhase(emitted ? "wait" : "stop");
 			return;
 		}
@@ -1013,16 +1078,67 @@ var TextEngine = class {
 	shouldExecuteToolPhase() {
 		return this.lastFinishReason === "tool_calls" && this.tools.length > 0 && this.toolCallManager.hasToolCalls();
 	}
+	/**
+	* Split this iteration into assistant ModelMessages that keep the provider's
+	* block order: a new segment starts at every thinking step that follows a
+	* provider-executed tool call (the rule buildAssistantMessages applies to
+	* UIMessages). Segments after the first get `${id}-segment-${n}` ids.
+	* Returns null when no split is needed or the order could not be tracked,
+	* so callers fall back to the single-message shape.
+	*/
+	buildOrderedAssistantSegments(toolCalls, id, createdAt) {
+		const parts = this.turnParts;
+		if (!parts) return null;
+		const providerCallIds = new Set(parts.flatMap((part) => part.type === "call" && part.providerExecuted ? [part.id] : []));
+		let current = {
+			thinking: [],
+			text: "",
+			callIds: []
+		};
+		const segments = [current];
+		let split = false;
+		for (const part of parts) if (part.type === "thinking") {
+			const thinking = this.accumulatedThinking[part.index];
+			if (!thinking) return null;
+			if (current.callIds.some((callId) => providerCallIds.has(callId))) {
+				current = {
+					thinking: [thinking],
+					text: "",
+					callIds: []
+				};
+				segments.push(current);
+				split = true;
+			} else current.thinking.push(thinking);
+		} else if (part.type === "text") current.text += part.content;
+		else current.callIds.push(part.id);
+		if (!split) return null;
+		if (segments.map((segment) => segment.text).join("") !== this.accumulatedContent) return null;
+		if (segments.reduce((n, segment) => n + segment.thinking.length, 0) !== this.accumulatedThinking.length) return null;
+		const placed = new Set(segments.flatMap((segment) => segment.callIds));
+		for (const toolCall of toolCalls) if (!placed.has(toolCall.id)) current.callIds.push(toolCall.id);
+		return segments.map((segment, index) => {
+			const segmentCalls = toolCalls.filter((toolCall) => segment.callIds.includes(toolCall.id));
+			return {
+				role: "assistant",
+				content: segment.text || null,
+				...segmentCalls.length > 0 && { toolCalls: segmentCalls },
+				id: id === void 0 ? void 0 : index === 0 ? id : `${id}-segment-${index}`,
+				createdAt,
+				...segment.thinking.length > 0 && { thinking: segment.thinking }
+			};
+		});
+	}
 	addAssistantToolCallMessage(toolCalls) {
 		this.finalizeCurrentThinkingStep();
-		this.messages = [...this.messages, {
+		const segments = this.buildOrderedAssistantSegments(toolCalls, this.currentMessageId ?? void 0, this.currentMessageCreatedAt ?? void 0);
+		this.messages = [...this.messages, ...segments ?? [{
 			role: "assistant",
 			content: this.accumulatedContent || null,
 			toolCalls,
 			id: this.currentMessageId ?? void 0,
 			createdAt: this.currentMessageCreatedAt ?? void 0,
 			...this.accumulatedThinking.length > 0 && { thinking: this.accumulatedThinking }
-		}];
+		}]];
 		this.middlewareCtx.messages = this.messages;
 	}
 	addTerminalAssistantMessages() {
@@ -1063,13 +1179,17 @@ var TextEngine = class {
 				...thinking ? { thinking } : {}
 			});
 		} else {
-			if (!currentTurnAlreadyRecorded && (this.accumulatedContent !== "" || thinking)) messages.push({
-				role: "assistant",
-				content: this.accumulatedContent || null,
-				id: this.currentMessageId ?? this.createId("msg"),
-				createdAt: this.currentMessageCreatedAt ?? /* @__PURE__ */ new Date(),
-				...thinking ? { thinking } : {}
-			});
+			if (!currentTurnAlreadyRecorded && (this.accumulatedContent !== "" || thinking)) {
+				const id = this.currentMessageId ?? this.createId("msg");
+				const createdAt = this.currentMessageCreatedAt ?? /* @__PURE__ */ new Date();
+				messages.push(...this.buildOrderedAssistantSegments(this.toolCallManager.getToolCalls(), id, createdAt) ?? [{
+					role: "assistant",
+					content: this.accumulatedContent || null,
+					id,
+					createdAt,
+					...thinking ? { thinking } : {}
+				}]);
+			}
 			if (structuredOutput) messages.push({
 				role: "assistant",
 				content: raw || null,
@@ -1125,7 +1245,7 @@ var TextEngine = class {
 	genericInterruptId() {
 		return this.createId("interrupt");
 	}
-	buildActionableInterrupts(approvals, clientRequests, genericRequests = [], genericInterruptIds = [], childInterrupts = []) {
+	buildActionableInterrupts(approvals, clientRequests, genericRequests = [], genericInterruptIds = [], inputRequired = [], childInterrupts = []) {
 		const interrupts = [];
 		for (const approval of approvals) {
 			const tool = this.tools.find((candidate) => candidate.name === approval.toolName);
@@ -1206,6 +1326,27 @@ var TextEngine = class {
 				}
 			});
 		}
+		for (const pendingInput of inputRequired) {
+			const id = `mcp_input_${pendingInput.toolCallId}`;
+			interrupts.push({
+				id,
+				reason: "mcp_input",
+				message: `Input required to run ${pendingInput.toolName}`,
+				toolCallId: pendingInput.toolCallId,
+				metadata: {
+					toolName: pendingInput.toolName,
+					[interruptBindingMetadataKey]: {
+						v: 1,
+						kind: "generic",
+						interruptId: id
+					},
+					[INTERRUPT_PAYLOAD_METADATA_KEY]: {
+						kind: pendingInput.kind,
+						request: pendingInput.request
+					}
+				}
+			});
+		}
 		interrupts.push(...childInterrupts);
 		const ids = /* @__PURE__ */ new Set();
 		for (const interrupt of interrupts) {
@@ -1214,13 +1355,13 @@ var TextEngine = class {
 		}
 		return interrupts;
 	}
-	buildInterruptFinishedChunk(finishEvent, approvals, clientRequests, genericRequests = [], genericInterruptIds, childInterrupts) {
+	buildInterruptFinishedChunk(finishEvent, approvals, clientRequests, genericRequests = [], genericInterruptIds, inputRequired = [], childInterrupts) {
 		return {
 			...finishEvent,
 			timestamp: Date.now(),
 			outcome: {
 				type: "interrupt",
-				interrupts: this.buildActionableInterrupts(approvals, clientRequests, genericRequests, genericInterruptIds, childInterrupts)
+				interrupts: this.buildActionableInterrupts(approvals, clientRequests, genericRequests, genericInterruptIds, inputRequired, childInterrupts)
 			}
 		};
 	}
@@ -1314,10 +1455,10 @@ var TextEngine = class {
 		};
 		yield* this.pipeThroughMiddleware(this.buildInterruptRunErrorChunk(error));
 	}
-	async *emitActionableInterruptBoundary(finishEvent, approvals, clientRequests, genericRequests = [], childInterrupts = []) {
+	async *emitActionableInterruptBoundary(finishEvent, approvals, clientRequests, genericRequests = [], inputRequired = [], childInterrupts = []) {
 		yield* this.emitSyntheticRunStarted(finishEvent);
 		const genericInterruptIds = genericRequests.map(() => this.genericInterruptId());
-		const terminal = this.completeEphemeralInterruptBindings(this.buildInterruptFinishedChunk(finishEvent, approvals, clientRequests, genericRequests, genericInterruptIds, childInterrupts));
+		const terminal = this.completeEphemeralInterruptBindings(this.buildInterruptFinishedChunk(finishEvent, approvals, clientRequests, genericRequests, genericInterruptIds, inputRequired, childInterrupts));
 		let terminalOutputs;
 		try {
 			terminalOutputs = [...this.emitPublicChunks(await this.middlewareRunner.runOnChunk(this.middlewareCtx, terminal))];
@@ -1334,7 +1475,7 @@ var TextEngine = class {
 		for (const output of terminalOutputs) yield this.publicInterruptTerminal(output);
 		return true;
 	}
-	async *emitBoundaryInterrupts(phase, finishEvent, toolCalls = [], requests) {
+	async *emitBoundaryInterrupts(phase, finishEvent, toolCalls = [], requests, inputRequired = []) {
 		this.middlewareCtx.phase = phase;
 		const boundaryRequests = requests ?? (yield* this.runWhileYielding(this.middlewareRunner.runOnInterruptBoundary(this.middlewareCtx)));
 		if (boundaryRequests.length === 0) return false;
@@ -1344,7 +1485,7 @@ var TextEngine = class {
 			else this.addAssistantTextMessageForInterrupt();
 		}
 		const actionable = this.getBoundaryActionableToolRequests(toolCalls);
-		yield* this.emitActionableInterruptBoundary(finishEvent, actionable.approvals, actionable.clientRequests, boundaryRequests);
+		yield* this.emitActionableInterruptBoundary(finishEvent, actionable.approvals, actionable.clientRequests, boundaryRequests, inputRequired);
 		return true;
 	}
 	addAssistantTextMessageForInterrupt() {
@@ -1360,6 +1501,7 @@ var TextEngine = class {
 		const approvalRequests = [];
 		const clientRequests = [];
 		for (const toolCall of toolCalls) {
+			if (isProviderExecutedToolCall(toolCall)) continue;
 			const tool = this.resolveExecutableTools([toolCall]).find((candidate) => candidate.name === toolCall.function.name);
 			if (!tool) continue;
 			let input = {};
@@ -1376,7 +1518,7 @@ var TextEngine = class {
 				input,
 				approvalId
 			});
-			else if (!tool.execute && !clientToolResults.has(toolCall.id) && !this.resumeCancelledToolCallIds.has(toolCall.id)) clientRequests.push({
+			else if (!tool.execute && !clientToolResults.has(toolCall.id) && !this.resumeClientToolErrors.has(toolCall.id) && !this.resumeCancelledToolCallIds.has(toolCall.id)) clientRequests.push({
 				toolCallId: toolCall.id,
 				toolName: toolCall.function.name,
 				input
@@ -1447,7 +1589,10 @@ var TextEngine = class {
 				content: wireContent,
 				role: "tool"
 			};
-			chunks.push(result.state === "output-error" ? withTanstackMetadata(resultChunk, { state: result.state }) : resultChunk);
+			chunks.push(result.state === "output-error" ? withTanstackMetadata(resultChunk, {
+				state: result.state,
+				...result.outcome !== void 0 && { toolResultOutcome: result.outcome }
+			}) : resultChunk);
 			const placeholderIdx = this.messages.findIndex((m) => {
 				if (m.role !== "tool" || m.toolCallId !== result.toolCallId) return false;
 				if (typeof m.content !== "string") return false;
@@ -1457,17 +1602,31 @@ var TextEngine = class {
 					return false;
 				}
 			});
-			const newToolMessage = {
+			const isDeniedResult = result.outcome === "denied";
+			const existingToolResultIdx = isDeniedResult ? this.messages.findIndex((message) => message.role === "tool" && message.toolCallId === result.toolCallId) : -1;
+			const resultMessageIdx = existingToolResultIdx >= 0 ? existingToolResultIdx : placeholderIdx;
+			const existingToolMessage = existingToolResultIdx >= 0 ? this.messages[existingToolResultIdx] : void 0;
+			const errorField = result.state === "output-error" && { error: toolResultErrorText(parseToolOutput(wireContent)) };
+			const replacementMessage = existingToolMessage?.role === "tool" ? {
+				...existingToolMessage,
+				content,
+				toolCallId: result.toolCallId,
+				...errorField
+			} : {
 				role: "tool",
 				content,
-				toolCallId: result.toolCallId
+				toolCallId: result.toolCallId,
+				...errorField
 			};
-			if (placeholderIdx >= 0) this.messages = [
-				...this.messages.slice(0, placeholderIdx),
-				newToolMessage,
-				...this.messages.slice(placeholderIdx + 1)
-			];
-			else this.messages = [...this.messages, newToolMessage];
+			const newToolMessage = result.outcome !== void 0 ? withTanstackMetadata(replacementMessage, { toolResultOutcome: result.outcome }) : replacementMessage;
+			if (resultMessageIdx >= 0) {
+				const replacedMessages = [
+					...this.messages.slice(0, resultMessageIdx),
+					newToolMessage,
+					...this.messages.slice(resultMessageIdx + 1)
+				];
+				this.messages = isDeniedResult ? replacedMessages.filter((message, index) => index === resultMessageIdx || !(message.role === "tool" && message.toolCallId === result.toolCallId)) : replacedMessages;
+			} else this.messages = [...this.messages, newToolMessage];
 			this.middlewareCtx.messages = this.messages;
 		}
 		return chunks;
@@ -1479,7 +1638,7 @@ var TextEngine = class {
 			if (typeof message.content === "string") try {
 				if (JSON.parse(message.content).pendingExecution === true) hasPendingExecution = true;
 			} catch {}
-			if (!hasPendingExecution) completedToolIds.add(message.toolCallId);
+			if (!hasPendingExecution && !this.resumeDeniedToolResults.has(message.toolCallId)) completedToolIds.add(message.toolCallId);
 		}
 		const pending = [];
 		for (const message of this.messages) if (message.role === "assistant" && message.toolCalls) for (const toolCall of message.toolCalls) {
@@ -1682,7 +1841,7 @@ var TextEngine = class {
 			tools: baseConfig.tools
 		}));
 		this.applyMiddlewareConfig(postOnConfig);
-		assertNoFileSources(this.adapter.name, this.messages);
+		assertMessagesFileSourceSupport(this.adapter, this.messages);
 		const structuredCallOptions = {
 			chatOptions: {
 				model: this.params.model,
@@ -1721,6 +1880,7 @@ var TextEngine = class {
 		};
 		const runChunkMiddleware = (synthChunk) => this.middlewareRunner.runOnChunk(this.middlewareCtx, synthChunk);
 		let runErrorYielded = false;
+		let rawText = "";
 		for await (const raw of providerStream) {
 			if (this.isCancelled()) break;
 			{
@@ -1766,11 +1926,16 @@ var TextEngine = class {
 					}
 				}
 				if (chunk.type === EventType.RUN_FINISHED) await this.runOnUsageFromChunk(chunk);
-				if (chunk.type === EventType.RUN_ERROR) this.finalizationError = {
-					message: chunk.message,
-					...chunk.code ? { code: chunk.code } : {},
-					...fallbackAdapterError !== void 0 ? { cause: fallbackAdapterError } : {}
-				};
+				if (chunk.type === EventType.TEXT_MESSAGE_CONTENT) rawText += chunk.delta;
+				if (chunk.type === EventType.RUN_ERROR) {
+					const cause = fallbackAdapterError ?? chunk.rawEvent;
+					this.finalizationError = {
+						message: chunk.message,
+						...chunk.code ? { code: chunk.code } : {},
+						...cause !== void 0 ? { cause } : {},
+						...rawText ? { rawText } : {}
+					};
+				}
 				const outputChunks = await this.middlewareRunner.runOnChunk(this.middlewareCtx, outboundChunk);
 				if (this.finalStructuredOutput.yieldChunks) for (const spec of this.emitPublicChunks(outputChunks)) {
 					if (spec.type === EventType.RUN_ERROR) runErrorYielded = true;
@@ -1832,7 +1997,12 @@ var TextEngine = class {
 	async *harvestCombinedStructuredOutput() {
 		if (!this.finalStructuredOutput) throw new Error("harvestCombinedStructuredOutput called without finalStructuredOutput config");
 		const yieldChunks = this.finalStructuredOutput.yieldChunks;
-		if ((this.finalStructuredOutput.source ?? "text") === "event") {
+		const source = this.finalStructuredOutput.source ?? "text";
+		if (this.lastFinishReason === "length") this.finalizationError = {
+			message: "The response was cut off because the maximum token limit was reached (finish_reason=length); raise the output token limit.",
+			code: "max_tokens"
+		};
+		else if (source === "event") {
 			if (!this.structuredOutputResult) this.finalizationError = {
 				message: "missing structured result",
 				code: "structured-output-missing-result"
@@ -1855,7 +2025,8 @@ var TextEngine = class {
 				this.finalizationError = {
 					message: `Failed to parse structured output as JSON. Content: ${detail}`,
 					code: "structured-output-parse-failed",
-					cause: err
+					cause: err,
+					rawText
 				};
 			}
 		}
@@ -1917,6 +2088,7 @@ var TextEngine = class {
 			resumeToolState: {
 				approvals: this.resumeApprovals,
 				clientToolResults: this.resumeClientToolResults,
+				clientToolErrors: this.resumeClientToolErrors,
 				deniedToolResults: this.resumeDeniedToolResults,
 				cancelledToolCallIds: this.resumeCancelledToolCallIds
 			},
@@ -1996,6 +2168,24 @@ var TextEngine = class {
 			}] : [];
 		});
 		pending.push(...genericPending);
+		const mcpInputCallIds = /* @__PURE__ */ new Map();
+		for (const toolCall of pendingToolCalls) {
+			const interruptId = `mcp_input_${toolCall.id}`;
+			if (!resumeInterruptIds.has(interruptId)) continue;
+			if (!toolsByCallId.get(toolCall.id)?.execute) continue;
+			mcpInputCallIds.set(interruptId, toolCall.id);
+			pending.push({
+				interruptId,
+				payload: { id: interruptId },
+				binding: {
+					v: 1,
+					kind: "generic",
+					interruptId,
+					interruptedRunId,
+					generation: 0
+				}
+			});
+		}
 		const validated = await validateInterruptResumeBatch({
 			threadId: this.threadId,
 			interruptedRunId,
@@ -2012,6 +2202,14 @@ var TextEngine = class {
 			approvals
 		});
 		const genericResolutions = validated.resumeToolState.genericInterrupts;
+		for (const [interruptId, toolCallId] of mcpInputCallIds) {
+			const resolution = genericResolutions?.get(interruptId);
+			if (!resolution) continue;
+			this.resumeInputResponses.set(toolCallId, resolution.status === "resolved" ? {
+				status: "resolved",
+				payload: resolution.payload
+			} : { status: "cancelled" });
+		}
 		if (genericPending.length > 0 && genericResolutions) {
 			const resolutions = genericPending.sort((left, right) => {
 				return (left.binding.kind === "generic" ? left.binding.batchIndex ?? 0 : 0) - (right.binding.kind === "generic" ? right.binding.batchIndex ?? 0 : 0);
@@ -2032,7 +2230,10 @@ var TextEngine = class {
 				all: (...definitions) => definitions.length === 0 ? resolutions : resolutions.filter((resolution) => definitions.includes(resolution.request.definition))
 			});
 			if (policy.toolResume === "stop") this.earlyTermination = true;
-			else if (policy.toolResume === "cancel") for (const request of pendingToolCalls) this.resumeCancelledToolCallIds.add(request.id);
+			else if (policy.toolResume === "cancel") for (const request of pendingToolCalls) {
+				if (this.resumeDeniedToolResults.has(request.id)) continue;
+				this.resumeCancelledToolCallIds.add(request.id);
+			}
 		}
 	}
 	getGenericContinuationPending(interruptedRunId) {
@@ -2104,6 +2305,7 @@ var TextEngine = class {
 	applyResumeToolState(state) {
 		if (state?.approvals) for (const [approvalId, resolution] of state.approvals) this.resumeApprovals.set(approvalId, resolution);
 		if (state?.clientToolResults) for (const [toolCallId, result] of state.clientToolResults) this.resumeClientToolResults.set(toolCallId, result);
+		if (state?.clientToolErrors) for (const [toolCallId, errorText] of state.clientToolErrors) this.resumeClientToolErrors.set(toolCallId, errorText);
 		if (state?.deniedToolResults) for (const [toolCallId, result] of state.deniedToolResults) this.resumeDeniedToolResults.set(toolCallId, result);
 		if (state?.cancelledToolCallIds) for (const toolCallId of state.cancelledToolCallIds) this.resumeCancelledToolCallIds.add(toolCallId);
 		if (state?.genericInterrupts) for (const [interruptId, resolution] of state.genericInterrupts) this.resumeGenericInterrupts.set(interruptId, resolution);
@@ -2128,7 +2330,10 @@ var TextEngine = class {
 			all: (...definitions) => definitions.length === 0 ? resolutions : resolutions.filter((resolution) => definitions.includes(resolution.request.definition))
 		});
 		if (policy.toolResume === "stop") this.earlyTermination = true;
-		else if (policy.toolResume === "cancel") for (const toolCall of this.getPendingToolCallsFromMessages()) this.resumeCancelledToolCallIds.add(toolCall.id);
+		else if (policy.toolResume === "cancel") for (const toolCall of this.getPendingToolCallsFromMessages()) {
+			if (this.resumeDeniedToolResults.has(toolCall.id)) continue;
+			this.resumeCancelledToolCallIds.add(toolCall.id);
+		}
 	}
 	applyMiddlewareConfig(config) {
 		this.applyResumeToolState(config.resumeToolState);
@@ -2465,6 +2670,8 @@ async function* runRoutedSubagents(options, engineRef) {
 		yield* runChatEngine(options, engineRef);
 		return;
 	}
+	const withInput = bag.agents.find((agent) => agent.inputSchema !== void 0);
+	if (withInput) throw new Error(`Subagent "${withInput.name}" has an inputSchema. inputSchema needs tool mode: remove subagents.router so the model writes the input.`);
 	const threadId = options.threadId ?? `thread-${Date.now()}`;
 	const runId = options.runId ?? `run-${Date.now()}`;
 	const messages = options.messages ?? [];
@@ -2777,6 +2984,10 @@ async function runAgenticStructuredOutput(options) {
 			value: finalizationError.code,
 			enumerable: true
 		});
+		if (finalizationError.rawText !== void 0) Object.defineProperty(err, "rawText", {
+			value: finalizationError.rawText,
+			enumerable: true
+		});
 		throw err;
 	}
 	const validated = engine.getValidatedStructuredOutput();