@tanstack/ai 0.57.0 → 0.59.0

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

@@ -6,6 +6,7 @@ import { publishRunDisconnectHandler } from "../../delivery-disconnect.js";
 import { EventType } from "../../types.js";
 import { rebuildTokenUsage } from "../../utilities/ag-ui-usage.js";
 import { tanstackMetadata, withTanstackMetadata } from "../../utilities/merge-metadata.js";
+import { withDurabilityBatchHint } from "../../utilities/durability-batch.js";
 import { normalizeStreamChunk } from "../../utilities/normalize-stream-chunk.js";
 import { resolveDebugOption } from "../../logger/resolve.js";
 import { streamToText } from "../../stream-to-response.js";
@@ -17,6 +18,7 @@ import { INTERRUPT_BINDING_METADATA_KEY, InterruptResumeValidationError, readInt
 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 { appendUiResourceToModelMessages, convertMessagesToModelMessages, generateMessageId, modelMessagesToUIMessages, safeJsonStringify, uiResourcePartFromCustomValue } from "./messages.js";
 import { uiMessagesToWire } from "../../utilities/ag-ui-wire.js";
@@ -24,6 +26,8 @@ import { restorePublicUsage } from "../../utilities/restore-inbound-chunk.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";
+import { collectNamedText, createSubagentSink, createSyntheticSubagentTools, normalizeRouterPick, rebindInterrupts, spawnNamedAgents, subagentCallMessages, withChildUsage } from "./agents/spawn.js";
+import { SUBAGENT_PLAN_KEY, readSubagentTurn } from "./agents/turn.js";
 import { maxIterations } from "./agent-loop-strategies.js";
 import { MiddlewareRunner } from "./middleware/compose.js";
 import { provideSandboxRuntime } from "./middleware/sandbox-runtime.js";
@@ -44,6 +48,14 @@ import { undoNullWidening } from "@tanstack/ai-utils";
 /** The adapter kind this activity handles */
 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;
@@ -154,6 +166,7 @@ var TextEngine = class {
 	threadId;
 	runIdOverride;
 	parentRunIdOverride;
+	subagentRunIdOverride;
 	middlewareRunner;
 	middlewareCtx;
 	sandboxFileQueue = [];
@@ -209,6 +222,7 @@ var TextEngine = class {
 		this.threadId = config.params.threadId || config.params.conversationId || this.createId("thread");
 		this.runIdOverride = config.params.runId;
 		this.parentRunIdOverride = config.params.parentRunId;
+		this.subagentRunIdOverride = config.params.subagentRunId;
 		const allMiddleware = [devtoolsMiddleware(), ...config.middleware || []];
 		this.middlewareRunner = new MiddlewareRunner(allMiddleware, logger);
 		this.middlewareAbortController = new AbortController();
@@ -218,6 +232,7 @@ var TextEngine = class {
 			streamId: this.streamId,
 			runId: this.runIdOverride ?? this.requestId,
 			parentRunId: this.parentRunIdOverride,
+			subagentRunId: this.subagentRunIdOverride,
 			threadId: this.threadId,
 			conversationId: this.threadId,
 			phase: "init",
@@ -228,8 +243,8 @@ var TextEngine = class {
 				this.abortReason = reason;
 				this.middlewareAbortController?.abort(reason);
 			},
-			emitCustomEvent: (name, value) => {
-				this.middlewareCustomQueue.push(this.createCustomEventChunk(name, value));
+			emitCustomEvent: (name, value, options) => {
+				this.middlewareCustomQueue.push(this.createCustomEventChunk(name, value, options));
 				const waiters = this.middlewareCustomWaiters;
 				this.middlewareCustomWaiters = [];
 				for (const waiter of waiters) waiter();
@@ -516,6 +531,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);
 		for await (const raw of this.adapter.chatStream({
 			model: this.params.model,
 			messages: this.providerMessages,
@@ -796,7 +812,7 @@ var TextEngine = class {
 			return "wait";
 		}
 		const { approvals, clientToolResults } = this.collectClientState();
-		const generator = executeToolCalls(executablePendingCalls, this.resolveExecutableTools(executablePendingCalls), approvals, clientToolResults, (eventName, data) => this.createCustomEventChunk(eventName, data), {
+		const generator = executeToolCalls(executablePendingCalls, this.resolveExecutableTools(executablePendingCalls), approvals, clientToolResults, (eventName, data, options) => this.createCustomEventChunk(eventName, data, options), {
 			onBeforeToolCall: async (toolCall, tool, args) => {
 				this.logger.tools(`phase=before name=${toolCall.function.name}`, {
 					name: toolCall.function.name,
@@ -834,10 +850,10 @@ var TextEngine = class {
 			needsApproval: executionResult.needsApproval,
 			needsClientExecution: executionResult.needsClientExecution
 		}));
-		if (executionResult.needsApproval.length > 0 || executionResult.needsClientExecution.length > 0) {
+		if (executionResult.needsApproval.length > 0 || executionResult.needsClientExecution.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);
+			const emitted = yield* this.emitActionableInterruptBoundary(finishEvent, executionResult.needsApproval, executionResult.needsClientExecution, [], executionResult.subagentInterrupts);
 			this.setToolPhase(emitted ? "wait" : "stop");
 			return emitted ? "wait" : "stop";
 		}
@@ -888,7 +904,7 @@ var TextEngine = class {
 			return;
 		}
 		const { approvals, clientToolResults } = this.collectClientState();
-		const generator = executeToolCalls(executableToolCalls, this.resolveExecutableTools(executableToolCalls), approvals, clientToolResults, (eventName, data) => this.createCustomEventChunk(eventName, data), {
+		const generator = executeToolCalls(executableToolCalls, this.resolveExecutableTools(executableToolCalls), approvals, clientToolResults, (eventName, data, options) => this.createCustomEventChunk(eventName, data, options), {
 			onBeforeToolCall: async (toolCall, tool, args) => {
 				this.logger.tools(`phase=before name=${toolCall.function.name}`, {
 					name: toolCall.function.name,
@@ -935,9 +951,9 @@ var TextEngine = class {
 			this.setToolPhase("wait");
 			return;
 		}
-		if (executionResult.needsApproval.length > 0 || executionResult.needsClientExecution.length > 0) {
+		if (executionResult.needsApproval.length > 0 || executionResult.needsClientExecution.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);
+			const emitted = yield* this.emitActionableInterruptBoundary(finishEvent, executionResult.needsApproval, executionResult.needsClientExecution, [], executionResult.subagentInterrupts);
 			this.setToolPhase(emitted ? "wait" : "stop");
 			return;
 		}
@@ -1109,7 +1125,7 @@ var TextEngine = class {
 	genericInterruptId() {
 		return this.createId("interrupt");
 	}
-	buildActionableInterrupts(approvals, clientRequests, genericRequests = [], genericInterruptIds = []) {
+	buildActionableInterrupts(approvals, clientRequests, genericRequests = [], genericInterruptIds = [], childInterrupts = []) {
 		const interrupts = [];
 		for (const approval of approvals) {
 			const tool = this.tools.find((candidate) => candidate.name === approval.toolName);
@@ -1190,6 +1206,7 @@ var TextEngine = class {
 				}
 			});
 		}
+		interrupts.push(...childInterrupts);
 		const ids = /* @__PURE__ */ new Set();
 		for (const interrupt of interrupts) {
 			if (ids.has(interrupt.id)) throw new Error(`Duplicate interrupt id in final batch: ${interrupt.id}`);
@@ -1197,13 +1214,13 @@ var TextEngine = class {
 		}
 		return interrupts;
 	}
-	buildInterruptFinishedChunk(finishEvent, approvals, clientRequests, genericRequests = [], genericInterruptIds) {
+	buildInterruptFinishedChunk(finishEvent, approvals, clientRequests, genericRequests = [], genericInterruptIds, childInterrupts) {
 		return {
 			...finishEvent,
 			timestamp: Date.now(),
 			outcome: {
 				type: "interrupt",
-				interrupts: this.buildActionableInterrupts(approvals, clientRequests, genericRequests, genericInterruptIds)
+				interrupts: this.buildActionableInterrupts(approvals, clientRequests, genericRequests, genericInterruptIds, childInterrupts)
 			}
 		};
 	}
@@ -1297,10 +1314,10 @@ var TextEngine = class {
 		};
 		yield* this.pipeThroughMiddleware(this.buildInterruptRunErrorChunk(error));
 	}
-	async *emitActionableInterruptBoundary(finishEvent, approvals, clientRequests, genericRequests = []) {
+	async *emitActionableInterruptBoundary(finishEvent, approvals, clientRequests, genericRequests = [], childInterrupts = []) {
 		yield* this.emitSyntheticRunStarted(finishEvent);
 		const genericInterruptIds = genericRequests.map(() => this.genericInterruptId());
-		const terminal = this.completeEphemeralInterruptBindings(this.buildInterruptFinishedChunk(finishEvent, approvals, clientRequests, genericRequests, genericInterruptIds));
+		const terminal = this.completeEphemeralInterruptBindings(this.buildInterruptFinishedChunk(finishEvent, approvals, clientRequests, genericRequests, genericInterruptIds, childInterrupts));
 		let terminalOutputs;
 		try {
 			terminalOutputs = [...this.emitPublicChunks(await this.middlewareRunner.runOnChunk(this.middlewareCtx, terminal))];
@@ -1665,6 +1682,7 @@ var TextEngine = class {
 			tools: baseConfig.tools
 		}));
 		this.applyMiddlewareConfig(postOnConfig);
+		assertNoFileSources(this.adapter.name, this.messages);
 		const structuredCallOptions = {
 			chatOptions: {
 				model: this.params.model,
@@ -1906,7 +1924,16 @@ var TextEngine = class {
 			modelOptions: this.params.modelOptions
 		};
 	}
-	async applyEphemeralInterruptResume(config) {
+	/** Resume entries this run answers itself. A subagent tool owns the rest. */
+	ownResume(resume) {
+		const childIds = this.params[CHILD_RESUME_IDS];
+		return childIds ? resume?.filter((entry) => !childIds.has(entry.interruptId)) : resume;
+	}
+	async applyEphemeralInterruptResume(middlewareConfig) {
+		const config = {
+			...middlewareConfig,
+			resume: this.ownResume(middlewareConfig.resume)
+		};
 		if ((config.resume?.length ?? 0) === 0) return;
 		const interruptedRunId = this.parentRunIdOverride;
 		if (!interruptedRunId) throw new InterruptResumeValidationError([{
@@ -2025,7 +2052,7 @@ var TextEngine = class {
 		const pending = [];
 		const ids = /* @__PURE__ */ new Set();
 		const batchIndexes = /* @__PURE__ */ new Set();
-		for (const resumeItem of this.params.resume ?? []) {
+		for (const resumeItem of this.ownResume(this.params.resume) ?? []) {
 			const parsed = readGenericInterruptContinuation(resumeItem.metadata);
 			if (parsed.status === "absent") continue;
 			if (parsed.status === "invalid") return fail(parsed.message);
@@ -2220,13 +2247,14 @@ var TextEngine = class {
 			pending = generator.next();
 		}
 	}
-	createCustomEventChunk(eventName, value) {
-		return {
+	createCustomEventChunk(eventName, value, options) {
+		const chunk = {
 			type: EventType.CUSTOM,
 			timestamp: Date.now(),
 			name: eventName,
 			value
 		};
+		return options?.batch ? withDurabilityBatchHint(chunk) : chunk;
 	}
 	createId(prefix) {
 		return `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
@@ -2298,6 +2326,7 @@ function chat(options) {
 	validateCapabilities(readRuntimeMiddleware(options.middleware) ?? [], options.adapter);
 	if (options.tools) assertUniqueToolNames(options.tools);
 	const { outputSchema, stream } = options;
+	if (outputSchema && (options.subagents?.agents.length ?? 0) > 0) throw new Error("chat() does not support subagents together with outputSchema. Put outputSchema on a child chat() instead.");
 	if (outputSchema && stream === true) return runStreamingStructuredOutput(toRuntimeTextActivityOptions(options, {
 		outputSchema,
 		stream: true
@@ -2366,8 +2395,8 @@ function runStreamingText(options) {
 	publishDeliverySeams(stream, engineRef);
 	return stream;
 }
-async function* streamTextChunks(options, engineRef) {
-	const { adapter, middleware, context, debug, mcp, ...textOptions } = options;
+async function* runChatEngine(options, engineRef) {
+	const { adapter, middleware, context, debug, mcp, subagents: _subagents, ...textOptions } = options;
 	const model = adapter.model;
 	const logger = resolveDebugOption(debug);
 	const mcpManager = MCPManager.from(mcp);
@@ -2390,6 +2419,303 @@ async function* streamTextChunks(options, engineRef) {
 		await mcpManager.dispose();
 	}
 }
+async function* streamTextChunks(options, engineRef) {
+	const bag = options.subagents;
+	const agents = bag?.agents ?? [];
+	if (bag && agents.length > 0 && bag.router) {
+		yield* runRoutedSubagents(options, engineRef);
+		return;
+	}
+	if (bag && agents.length > 0) {
+		const threadId = options.threadId ?? `thread-${Date.now()}`;
+		const runId = options.runId ?? `run-${Date.now()}`;
+		const messages = options.messages ?? [];
+		const turn = readSubagentTurn(messages, options.resume);
+		const sink = createSubagentSink();
+		const calls = subagentCallMessages(new Set(bag.agents.map((agent) => agent.name)));
+		const synthetic = createSyntheticSubagentTools(bag, {
+			messages: turn?.before ?? messages,
+			messagesFor: calls.messagesFor,
+			threadId,
+			runId,
+			...options.parentRunId !== void 0 && { interruptedRunId: options.parentRunId },
+			...options.abortController && { abortSignal: options.abortController.signal },
+			...turn && { turn },
+			sink
+		});
+		yield* streamWithChildUsage(runChatEngine({
+			...options,
+			threadId,
+			runId,
+			...turn && { [CHILD_RESUME_IDS]: new Set(turn.children.flatMap((child) => child.resume.map((entry) => entry.interruptId))) },
+			tools: [...options.tools ?? [], ...synthetic],
+			middleware: [...options.middleware ?? [], calls.middleware]
+		}, engineRef), sink);
+		return;
+	}
+	yield* runChatEngine(options, engineRef);
+}
+/** Add child usage to the next RUN_FINISHED of the parent. */
+async function* streamWithChildUsage(stream, sink) {
+	for await (const chunk of stream) yield chunk.type === EventType.RUN_FINISHED ? withChildUsage(chunk, sink) : chunk;
+}
+async function* runRoutedSubagents(options, engineRef) {
+	const bag = options.subagents;
+	if (!bag?.router) {
+		yield* runChatEngine(options, engineRef);
+		return;
+	}
+	const threadId = options.threadId ?? `thread-${Date.now()}`;
+	const runId = options.runId ?? `run-${Date.now()}`;
+	const messages = options.messages ?? [];
+	const turn = readSubagentTurn(messages, options.resume);
+	if (!turn && (options.resume?.length ?? 0) > 0) {
+		yield* runChatEngine({
+			...options,
+			threadId,
+			runId,
+			subagents: void 0
+		}, engineRef);
+		return;
+	}
+	const abortSignal = options.abortController?.signal;
+	const turnMessages = turn?.before ?? messages;
+	const subagentPersistence = readRoutedSubagentPersistence(options.middleware);
+	await subagentPersistence?.start({
+		threadId,
+		runId,
+		messages,
+		...options.resume && { resume: options.resume }
+	});
+	try {
+		const plan = savedPlan(turn?.plan, bag.agents, {
+			threadId,
+			interruptedRunId: options.parentRunId ?? runId,
+			interruptIds: options.resume?.map((entry) => entry.interruptId) ?? []
+		}) ?? normalizeRouterPick(await bag.router({
+			messages: turnMessages,
+			agents: bag.agents,
+			...abortSignal && { abortSignal }
+		}), bag.agents);
+		if (abortSignal?.aborted) {
+			const error = /* @__PURE__ */ new Error("Aborted");
+			error.name = "AbortError";
+			await subagentPersistence?.abort({
+				threadId,
+				runId,
+				error
+			});
+			return;
+		}
+		const onlyStep = plan.steps.length === 1 ? plan.steps[0] : void 0;
+		if (onlyStep?.names.length === 1 && onlyStep.names[0] === "main") {
+			if (turn) await subagentPersistence?.finish({
+				threadId,
+				runId
+			});
+			yield* runChatEngine({
+				...options,
+				threadId,
+				runId,
+				subagents: void 0,
+				...turn && { resume: turn.rest }
+			}, engineRef);
+			return;
+		}
+		yield {
+			type: EventType.RUN_STARTED,
+			threadId,
+			runId,
+			timestamp: Date.now()
+		};
+		const earlier = [...turn?.children ?? []];
+		const takeEarlier = (name) => {
+			const index = earlier.findIndex((child) => child.name === name);
+			return index === -1 ? void 0 : earlier.splice(index, 1)[0];
+		};
+		const sink = createSubagentSink();
+		const stepTexts = [];
+		let stepMessages = turnMessages;
+		let failure;
+		for (const step of plan.steps) {
+			const entries = [];
+			const textByName = /* @__PURE__ */ new Map();
+			for (const name of step.names) {
+				const prior = takeEarlier(name);
+				if (prior?.status === "finished") {
+					textByName.set(name, prior.text);
+					continue;
+				}
+				entries.push(prior?.status === "suspended" ? {
+					name,
+					resume: {
+						subagentRunId: prior.subagentRunId,
+						messages: prior.messages,
+						entries: prior.resume,
+						text: prior.text
+					}
+				} : { name });
+			}
+			const stepChunks = [];
+			if (entries.length > 0) for await (const chunk of spawnNamedAgents(entries, {
+				...bag,
+				order: step.order ?? bag.order
+			}, {
+				messages: stepMessages,
+				...abortSignal && { abortSignal },
+				threadId,
+				parentRunId: runId,
+				...options.parentRunId !== void 0 && { interruptedRunId: options.parentRunId }
+			}, sink)) {
+				const tagged = withPlan(chunk, plan);
+				stepChunks.push(tagged);
+				await subagentPersistence?.chunk({
+					threadId,
+					runId,
+					chunk: tagged
+				});
+				yield tagged;
+			}
+			failure = stepChunks.find((chunk) => chunk.type === EventType.SUBAGENT_ERROR);
+			if (failure) break;
+			if (sink.interrupts.length > 0) break;
+			for (const entry of entries) {
+				const text = collectNamedText(stepChunks, [entry.name]);
+				textByName.set(entry.name, [entry.resume?.text, text].filter(Boolean).join("\n\n"));
+			}
+			const text = step.names.map((name) => textByName.get(name)?.trim() ?? "").filter((block) => block !== "").join("\n\n");
+			if (text) {
+				stepTexts.push(text);
+				stepMessages = [...stepMessages, {
+					role: "assistant",
+					content: text
+				}];
+			}
+		}
+		if (abortSignal?.aborted) {
+			const error = /* @__PURE__ */ new Error("Aborted");
+			error.name = "AbortError";
+			await subagentPersistence?.abort({
+				threadId,
+				runId,
+				error
+			});
+			yield withChildUsage({
+				type: EventType.RUN_FINISHED,
+				threadId,
+				runId,
+				outcome: { type: "cancelled" },
+				timestamp: Date.now()
+			}, sink);
+			return;
+		}
+		if (failure) {
+			const message = failure.message || "A subagent failed";
+			await subagentPersistence?.abort({
+				threadId,
+				runId,
+				error: new Error(message)
+			});
+			yield withChildUsage({
+				type: EventType.RUN_ERROR,
+				threadId,
+				runId,
+				message,
+				...failure.code !== void 0 ? { code: failure.code } : {},
+				timestamp: Date.now()
+			}, sink);
+			return;
+		}
+		if (sink.interrupts.length > 0) {
+			const interrupts = rebindInterrupts(sink.interrupts, runId);
+			await subagentPersistence?.suspend?.({
+				threadId,
+				runId,
+				interrupts
+			});
+			yield withChildUsage({
+				type: EventType.RUN_FINISHED,
+				threadId,
+				runId,
+				outcome: {
+					type: "interrupt",
+					interrupts
+				},
+				timestamp: Date.now()
+			}, sink);
+			return;
+		}
+		if ((bag.strategy ?? "exclusive") === "handoff") {
+			const childText = stepTexts.join("\n\n");
+			await subagentPersistence?.finish({
+				threadId,
+				runId
+			});
+			yield* streamWithChildUsage(runChatEngine({
+				...options,
+				threadId,
+				runId,
+				subagents: void 0,
+				...turn && { resume: turn.rest },
+				messages: [...turnMessages, {
+					id: subagentHostMessageId(runId),
+					role: "assistant",
+					content: childText || "Subagent finished.",
+					metadata: { tanstack: { runId } }
+				}]
+			}, engineRef), sink);
+			return;
+		}
+		await subagentPersistence?.finish({
+			threadId,
+			runId
+		});
+		yield withChildUsage({
+			type: EventType.RUN_FINISHED,
+			threadId,
+			runId,
+			timestamp: Date.now()
+		}, sink);
+	} catch (error) {
+		await subagentPersistence?.abort({
+			threadId,
+			runId,
+			error
+		});
+		throw error;
+	}
+}
+/**
+* The plan from a resumed turn, or undefined when it is absent. A plan that
+* names agents this chat does not have is stale: re-routing would strand the
+* suspended child that owns the answers, so fail the resume instead.
+*/
+function savedPlan(plan, agents, run) {
+	if (typeof plan !== "object" || plan === null || !("steps" in plan)) return;
+	try {
+		return normalizeRouterPick(plan, agents);
+	} catch (error) {
+		throw new InterruptResumeValidationError([{
+			scope: "batch",
+			threadId: run.threadId,
+			interruptedRunId: run.interruptedRunId,
+			generation: 0,
+			interruptIds: run.interruptIds,
+			code: "stale",
+			message: `The saved subagent plan does not match the agents of this chat. ${error instanceof Error ? error.message : String(error)}`,
+			source: "server",
+			retryable: false
+		}]);
+	}
+}
+/** Put the router plan on a direct child's SUBAGENT_STARTED metadata. */
+function withPlan(chunk, plan) {
+	if (chunk.type !== EventType.SUBAGENT_STARTED || chunk.parentSubagentRunId !== void 0) return chunk;
+	return withTanstackMetadata(chunk, { [SUBAGENT_PLAN_KEY]: plan });
+}
+function readRoutedSubagentPersistence(middleware) {
+	for (const item of middleware ?? []) if (item.routedSubagentPersistence) return item.routedSubagentPersistence;
+}
 /**
 * Run non-streaming text - collects all content and returns as a string.
 * Runs the full agentic loop (if tools are provided) but returns collected text.