@tanstack/ai 0.61.0 → 0.63.0

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

@@ -163,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;
@@ -330,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 });
@@ -355,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;
@@ -391,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;
@@ -885,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()) {
@@ -900,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";
 		}
@@ -977,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";
@@ -997,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;
 		}
@@ -1230,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);
@@ -1311,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) {
@@ -1319,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)
 			}
 		};
 	}
@@ -1419,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))];
@@ -1439,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;
@@ -1449,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() {
@@ -1482,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
@@ -1553,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;
@@ -1563,18 +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,
-				...result.state === "output-error" && { error: toolResultErrorText(parseToolOutput(wireContent)) }
+				...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;
@@ -1586,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) {
@@ -1828,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;
 			{
@@ -1873,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;
@@ -1967,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
 				};
 			}
 		}
@@ -2029,6 +2088,7 @@ var TextEngine = class {
 			resumeToolState: {
 				approvals: this.resumeApprovals,
 				clientToolResults: this.resumeClientToolResults,
+				clientToolErrors: this.resumeClientToolErrors,
 				deniedToolResults: this.resumeDeniedToolResults,
 				cancelledToolCallIds: this.resumeCancelledToolCallIds
 			},
@@ -2108,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,
@@ -2124,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);
@@ -2144,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) {
@@ -2216,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);
@@ -2240,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);
@@ -2577,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 ?? [];
@@ -2889,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();