agents 0.12.3 → 0.13.0

package/dist/index.js

@@ -1,8 +1,8 @@
 import { __DO_NOT_USE_WILL_BREAK__agentContext } from "./internal_context.js";
 import { MessageType } from "./types.js";
-import { camelCaseToKebabCase } from "./utils.js";
+import { camelCaseToKebabCase, isInternalJsStubProp } from "./utils.js";
 import { createHeaderBasedEmailResolver, signAgentHeaders } from "./email.js";
-import { i as _classPrivateFieldInitSpec, n as _classPrivateFieldSet2, t as _classPrivateFieldGet2 } from "./classPrivateFieldGet2-Bqby-AHD.js";
+import { i as _classPrivateFieldInitSpec, n as _classPrivateFieldSet2, t as _classPrivateFieldGet2 } from "./classPrivateFieldGet2-Evpt0SEr.js";
 import { SUB_PREFIX, getSubAgentByName, parseSubAgentPath, routeSubAgentRequest } from "./sub-routing.js";
 import { isErrorRetryable, tryN, validateRetryOptions } from "./retries.js";
 import { o as RPC_DO_PREFIX, r as MCPConnectionState, s as DisposableStore, t as MCPClientManager } from "./client-D1kFXo80.js";
@@ -12,7 +12,7 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { parseCronExpression } from "cron-schedule";
 import { nanoid } from "nanoid";
 import { EmailMessage } from "cloudflare:email";
-import { RpcTarget } from "cloudflare:workers";
+import { RpcTarget, exports } from "cloudflare:workers";
 import { Server, getServerByName, routePartykitRequest } from "partyserver";
 //#region src/index.ts
 let _Symbol$dispose;
@@ -587,6 +587,7 @@ var Agent = class Agent extends Server {
 		this._persistenceHookMode = "none";
 		this._isFacet = false;
 		this._suppressProtocolBroadcasts = false;
+		this._protocolBroadcastExcludeIds = /* @__PURE__ */ new Set();
 		this._cf_virtualSubAgentConnections = /* @__PURE__ */ new Map();
 		this._parentPath = [];
 		this._insideOnStart = false;
@@ -770,8 +771,16 @@ var Agent = class Agent extends Server {
 							type: "cf_agent_identity"
 						}));
 					}
-					if (this.state) connection.send(JSON.stringify({
-						state: this.state,
+					const wasExcludedFromStateInitBroadcast = this._protocolBroadcastExcludeIds.has(connection.id);
+					let currentState;
+					this._protocolBroadcastExcludeIds.add(connection.id);
+					try {
+						currentState = this.state;
+					} finally {
+						if (!wasExcludedFromStateInitBroadcast) this._protocolBroadcastExcludeIds.delete(connection.id);
+					}
+					if (currentState !== void 0) connection.send(JSON.stringify({
+						state: currentState,
 						type: "cf_agent_state"
 					}));
 					connection.send(JSON.stringify({
@@ -823,14 +832,17 @@ var Agent = class Agent extends Server {
 					this.broadcastMcpServers();
 					this._checkOrphanedWorkflows();
 					await this._checkRunFibers();
-					await this._reconcileAgentToolRuns();
+					const recoveredAgentToolFinishes = await this._reconcileAgentToolRuns({ deferFinishHooks: true });
 					this._insideOnStart = true;
 					this._warnedScheduleInOnStart.clear();
+					let result;
 					try {
-						return await _onStart(props);
+						result = await _onStart(props);
 					} finally {
 						this._insideOnStart = false;
 					}
+					await this._runDeferredAgentToolFinishHooks(recoveredAgentToolFinishes);
+					return result;
 				});
 			});
 		};
@@ -866,7 +878,7 @@ var Agent = class Agent extends Server {
 	*/
 	_broadcastProtocol(msg, excludeIds = []) {
 		if (this._suppressProtocolBroadcasts) return;
-		const exclude = [...excludeIds];
+		const exclude = [...excludeIds, ...this._protocolBroadcastExcludeIds];
 		for (const conn of this.getConnections()) if (!this.isConnectionProtocolEnabled(conn)) exclude.push(conn.id);
 		this.broadcast(msg, exclude);
 	}
@@ -1101,7 +1113,7 @@ var Agent = class Agent extends Server {
 	*
 	* IMPORTANT: This hook must be synchronous.
 	*/
-	validateStateChange(nextState, source) {}
+	validateStateChange(_nextState, _source) {}
 	/**
 	* Called after the Agent's state has been persisted and broadcast to all clients.
 	* This is a notification hook — errors here are routed to onError and do not
@@ -1110,7 +1122,7 @@ var Agent = class Agent extends Server {
 	* @param state Updated state
 	* @param source Source of the state update ("server" or a client connection)
 	*/
-	onStateChanged(state, source) {}
+	onStateChanged(_state, _source) {}
 	/**
 	* @deprecated Renamed to `onStateChanged` — the behavior is identical.
 	* `onStateUpdate` will be removed in the next major version.
@@ -1122,7 +1134,7 @@ var Agent = class Agent extends Server {
 	* @param state Updated state
 	* @param source Source of the state update ("server" or a client connection)
 	*/
-	onStateUpdate(state, source) {}
+	onStateUpdate(_state, _source) {}
 	/**
 	* Dispatch to the appropriate persistence hook based on the mode
 	* cached in the constructor. No prototype walks at call time.
@@ -2398,11 +2410,16 @@ var Agent = class Agent extends Server {
 		if (!this._isSameAgentPathPrefix(selfPath, ownerPath)) throw new Error(`Schedule owner path does not descend from ${JSON.stringify(selfPath)}.`);
 		if (selfPath.length === ownerPath.length) {
 			await this._executeScheduleCallback(row);
-			return;
+			return true;
 		}
 		const next = ownerPath[selfPath.length];
-		if (!this.hasSubAgent(next.className, next.name)) throw new Error(`Scheduled sub-agent ${next.className} "${next.name}" no longer exists.`);
-		await (await this._cf_resolveSubAgent(next.className, next.name))._cf_dispatchScheduledCallback(ownerPath, row);
+		if (!this.hasSubAgent(next.className, next.name)) {
+			const stalePath = ownerPath.slice(0, selfPath.length + 1);
+			if (this._isFacet) await (await this._rootAlarmOwner())._cf_cleanupFacetPrefix(stalePath);
+			else await this._cf_cleanupFacetPrefix(stalePath);
+			return false;
+		}
+		return (await this._cf_resolveSubAgent(next.className, next.name))._cf_dispatchScheduledCallback(ownerPath, row);
 	}
 	/**
 	* Recursively destroy a descendant facet identified by
@@ -2586,7 +2603,7 @@ var Agent = class Agent extends Server {
 				if (row.type === "interval") this.sql`UPDATE cf_agents_schedules SET running = 1, execution_started_at = ${now} WHERE id = ${row.id}`;
 				if (row.owner_path) try {
 					const ownerPath = JSON.parse(row.owner_path);
-					await this._cf_dispatchScheduledCallback(ownerPath, row);
+					executed = await this._cf_dispatchScheduledCallback(ownerPath, row);
 				} catch (e) {
 					console.error(`error dispatching scheduled callback "${row.callback}"`, e);
 					this._emit("schedule:error", {
@@ -2603,8 +2620,10 @@ var Agent = class Agent extends Server {
               `;
 					continue;
 				}
-				else await this._executeScheduleCallback(row);
-				executed = true;
+				else {
+					await this._executeScheduleCallback(row);
+					executed = true;
+				}
 				if (this._destroyed) return;
 				if (!executed) continue;
 				if (row.type === "cron") {
@@ -3073,7 +3092,29 @@ var Agent = class Agent extends Server {
 	* @internal
 	*/
 	async _cf_invokeSubAgent(className, name, method, args) {
-		const handle = await this._cf_resolveSubAgent(className, name);
+		const stub = await this._cf_resolveSubAgent(className, name);
+		return await this._cf_invokeStubMethod(stub, className, method, args);
+	}
+	/**
+	* Bridge method used by `parentAgent()` when the requested parent is
+	* itself a facet (and therefore has no top-level env namespace).
+	* The root receives the full root-first target path, then each hop
+	* delegates to the next facet using that facet's own `ctx.facets`.
+	*
+	* @internal
+	*/
+	async _cf_invokeSubAgentPath(path, method, args) {
+		const [self, next, ...rest] = path;
+		if (!self) throw new Error(`Sub-agent path invocation requires a non-empty path.`);
+		const ownClassName = this.constructor.name;
+		if (self.className !== ownClassName || self.name !== this.name) throw new Error(`Sub-agent path invocation reached ${ownClassName}("${this.name}") but expected ${self.className}("${self.name}").`);
+		if (!next) return await this._cf_invokeStubMethod(this, this.constructor.name, method, args);
+		const child = await this._cf_resolveSubAgent(next.className, next.name);
+		if (rest.length === 0) return await this._cf_invokeStubMethod(child, next.className, method, args);
+		return await child._cf_invokeSubAgentPath([next, ...rest], method, args);
+	}
+	async _cf_invokeStubMethod(stub, className, method, args) {
+		const handle = stub;
 		if (typeof handle[method] !== "function") throw new Error(`Method "${method}" not found on ${className}.`);
 		return await handle[method](...args);
 	}
@@ -3097,11 +3138,11 @@ var Agent = class Agent extends Server {
 	*
 	* The facet's name (and `this.name` getter) is handled entirely by
 	* partyserver via `ctx.id.name`, which is populated because the
-	* parent passed an explicit `id: parentNs.idFromName(name)` to
+	* parent passed an explicit named Durable Object id to
 	* `ctx.facets.get()` — see {@link _cf_resolveSubAgent}. No
 	* `setName()` call or `__ps_name` storage write is needed; the
-	* facet's name survives cold wake automatically because the
-	* factory re-runs and `idFromName` is deterministic.
+	* facet's name survives cold wake automatically because the factory
+	* re-runs and `idFromName` is deterministic.
 	*
 	* @internal Called by {@link subAgent}.
 	*/
@@ -3148,26 +3189,33 @@ var Agent = class Agent extends Server {
 		}];
 	}
 	/**
-	* Resolve a typed RPC stub for this facet's **immediate** parent
+	* Resolve a typed parent stub for this facet's **immediate** parent
 	* agent.
 	*
 	* Symmetric with `subAgent(Cls, name)`: while `subAgent` opens a
 	* stub from parent to child, `parentAgent` opens one from child
 	* to parent. Pass the direct parent's class reference — the
 	* framework verifies it matches the last entry of
-	* `this.parentPath` at runtime, then looks up `env[Cls.name]` to
-	* find the namespace binding.
+	* `this.parentPath` at runtime. If the parent is a top-level
+	* Durable Object, the framework returns the normal namespace stub.
+	* If the parent is itself a facet, the framework returns a bridge
+	* proxy that routes method calls through the root/supervisor and
+	* then down the recorded facet path.
 	*
 	* `this.parentPath` is root-first, so the direct parent is the
 	* **last** entry: `this.parentPath.at(-1)`. For grandparents and
 	* further ancestors, iterate `this.parentPath` and use
 	* `getAgentByName(env.X, this.parentPath[i].name)` directly.
 	*
-	* Assumes the standard "binding name matches class name" convention.
-	* If your `wrangler.jsonc` binds the parent under a different name
-	* (e.g. `{ class_name: "Inbox", name: "MY_INBOX" }`), call
-	* `getAgentByName(env.MY_INBOX, this.parentPath.at(-1)!.name)`
-	* directly instead.
+	* For top-level parents, the framework first checks `env[Cls.name]`,
+	* then falls back to the Worker `exports` object. This supports
+	* custom binding names as long as the parent class is exported under
+	* its class name.
+	*
+	* Facet-parent stubs route normal HTTP `.fetch()` calls through the
+	* same root bridge as RPC methods. WebSocket upgrade requests are
+	* not supported yet because WebSocket handles cannot be serialized
+	* over RPC.
 	*
 	* @experimental The API surface may change before stabilizing.
 	*
@@ -3175,7 +3223,8 @@ var Agent = class Agent extends Server {
 	* @throws If `Cls.name` doesn't match the recorded direct-parent
 	*         class (guards against accidentally reaching the wrong
 	*         DO, especially in nested Root → Mid → Leaf chains).
-	* @throws If no env binding named `Cls.name` is found.
+	* @throws If no namespace is found for a top-level parent, or no
+	*         root namespace is available for a facet parent bridge.
 	*
 	* @example
 	* ```ts
@@ -3192,10 +3241,46 @@ var Agent = class Agent extends Server {
 		const parent = this._parentPath[this._parentPath.length - 1];
 		if (!parent) throw new Error(`parentAgent(): ${this.constructor.name} is not a facet — only sub-agents (spawned via \`subAgent()\`) have a parent.`);
 		if (cls.name !== parent.className) throw new Error(`parentAgent(${cls.name}): this facet's recorded parent class is "${parent.className}", not "${cls.name}". Pass the class whose constructor actually spawned this facet.`);
-		const binding = this.env[cls.name];
-		if (!binding) throw new Error(`parentAgent(${cls.name}): no top-level binding "${cls.name}" found in env. If the parent is bound under a different name (e.g. "MY_${cls.name.toUpperCase()}"), use \`getAgentByName(env.MY_${cls.name.toUpperCase()}, this.parentPath.at(-1)!.name)\` directly.`);
+		if (this._parentPath.length > 1) return await this._cf_parentAgentFacetProxy(cls.name, this._parentPath);
+		const binding = this._cf_getTopLevelNamespaceByClassName(cls.name);
+		if (!binding) throw new Error(`parentAgent(${cls.name}): no top-level namespace for "${cls.name}" was found in env or worker exports. Make sure the parent class is exported under that class name and registered as a Durable Object binding.`);
 		return await getServerByName(binding, parent.name);
 	}
+	_cf_getTopLevelNamespaceByClassName(className) {
+		return this._cf_asDurableObjectNamespace(this.env[className]) ?? this._cf_asDurableObjectNamespace(exports[className]);
+	}
+	_cf_asDurableObjectNamespace(candidate) {
+		const binding = candidate;
+		return binding?.idFromName ? binding : void 0;
+	}
+	async _cf_parentAgentFacetProxy(className, parentPath) {
+		const [root] = parentPath;
+		if (!root) throw new Error(`parentAgent(${className}): parent path is empty.`);
+		const rootBinding = this._cf_getTopLevelNamespaceByClassName(root.className);
+		if (!rootBinding) throw new Error(`parentAgent(${className}): direct parent is a facet, but no top-level root namespace "${root.className}" was found in env or worker exports to bridge the call.`);
+		const rootStubPromise = getServerByName(rootBinding, root.name);
+		const targetPath = parentPath.map((step) => ({ ...step }));
+		const invokeBridge = async (method, args) => {
+			return await (await rootStubPromise)._cf_invokeSubAgentPath(targetPath, method, args);
+		};
+		const owner = this;
+		return new Proxy({}, { get(_target, prop) {
+			if (isInternalJsStubProp(prop)) return void 0;
+			if (typeof prop !== "string") return void 0;
+			if (prop === "fetch") return async (input, init) => {
+				if (owner._cf_isWebSocketUpgradeRequest(input, init)) throw new Error(`parentAgent(${className}).fetch() does not support WebSocket upgrade requests yet. Use externally routed sub-agent URLs for WebSocket connections.`);
+				return await invokeBridge(prop, [input, init]);
+			};
+			return async (...args) => {
+				return await invokeBridge(prop, args);
+			};
+		} });
+	}
+	_cf_isWebSocketUpgradeRequest(input, init) {
+		const initHeaders = init?.headers ? new Headers(init.headers) : void 0;
+		const requestHeaders = input instanceof Request ? new Headers(input.headers) : void 0;
+		return initHeaders?.get("Upgrade")?.toLowerCase() === "websocket" || requestHeaders?.get("Upgrade")?.toLowerCase() === "websocket";
+	}
 	/**
 	* Get or create a named sub-agent — a child Durable Object (facet)
 	* with its own isolated SQLite storage running on the same machine.
@@ -3238,7 +3323,7 @@ var Agent = class Agent extends Server {
 				} catch {}
 				return this._resultFromAgentToolRow(existing);
 			}
-			return await this._replayAndInterruptAgentToolRun(cls, existing, "Agent tool run was still running, but live-tail reattachment is not supported in this runtime.");
+			return await this._replayAndInterruptAgentToolRun(existing, "Agent tool run was still running, but live-tail reattachment is not supported in this runtime.");
 		}
 		const displayOrder = options.displayOrder ?? 0;
 		const inputPreview = options.inputPreview ?? this._defaultAgentToolPreview(options.input);
@@ -3321,13 +3406,7 @@ var Agent = class Agent extends Server {
 				status: "aborted",
 				error: options.signal.reason instanceof Error ? options.signal.reason.message : String(options.signal.reason ?? "cancelled")
 			};
-			this._updateAgentToolTerminal(runId, result);
-			this._broadcastAgentToolTerminal(options.parentToolCallId, sequence, result);
-			await this.onAgentToolFinish({
-				...runInfo,
-				status: "aborted",
-				completedAt: Date.now()
-			}, result);
+			await this._finishAgentToolRun(runInfo, result, { sequence });
 			return result;
 		} else {
 			parentAbortListener = () => {
@@ -3351,24 +3430,15 @@ var Agent = class Agent extends Server {
 					status: "aborted",
 					error: options.signal.reason instanceof Error ? options.signal.reason.message : String(options.signal.reason ?? "cancelled")
 				};
-				this._updateAgentToolTerminal(runId, result);
-				this._broadcastAgentToolTerminal(options.parentToolCallId, sequence, result);
-				await this.onAgentToolFinish({
-					...runInfo,
-					status: "aborted",
-					completedAt: Date.now()
-				}, result);
+				await this._finishAgentToolRun(runInfo, result, { sequence });
 				return result;
 			}
 			const inspection = await adapter.inspectAgentToolRun(runId) ?? childStart;
 			const result = this._terminalResultFromInspection(agentType, inspection);
-			this._updateAgentToolTerminal(runId, result, inspection.completedAt);
-			this._broadcastAgentToolTerminal(options.parentToolCallId, sequence, result);
-			await this.onAgentToolFinish({
-				...runInfo,
-				status: result.status,
-				completedAt: Date.now()
-			}, result);
+			await this._finishAgentToolRun(runInfo, result, {
+				sequence,
+				completedAt: inspection.completedAt
+			});
 			return result;
 		} catch (error) {
 			if (options.signal?.aborted) {
@@ -3379,13 +3449,7 @@ var Agent = class Agent extends Server {
 					status: "aborted",
 					error: options.signal.reason instanceof Error ? options.signal.reason.message : String(options.signal.reason ?? "cancelled")
 				};
-				this._updateAgentToolTerminal(runId, result);
-				this._broadcastAgentToolTerminal(options.parentToolCallId, sequence, result);
-				await this.onAgentToolFinish({
-					...runInfo,
-					status: "aborted",
-					completedAt: Date.now()
-				}, result);
+				await this._finishAgentToolRun(runInfo, result, { sequence });
 				return result;
 			}
 			const result = {
@@ -3394,13 +3458,7 @@ var Agent = class Agent extends Server {
 				status: "error",
 				error: error instanceof Error ? error.message : String(error)
 			};
-			this._updateAgentToolTerminal(runId, result);
-			this._broadcastAgentToolTerminal(options.parentToolCallId, sequence, result);
-			await this.onAgentToolFinish({
-				...runInfo,
-				status: "error",
-				completedAt: Date.now()
-			}, result);
+			await this._finishAgentToolRun(runInfo, result, { sequence });
 			return result;
 		} finally {
 			if (parentAbortListener && options.signal) options.signal.removeEventListener("abort", parentAbortListener);
@@ -3481,6 +3539,19 @@ var Agent = class Agent extends Server {
 			...row.error_message !== null ? { error: row.error_message } : {}
 		};
 	}
+	_agentToolRunInfoFromRow(row, status = row.status, completedAt = row.completed_at ?? void 0) {
+		return {
+			runId: row.run_id,
+			parentToolCallId: row.parent_tool_call_id ?? void 0,
+			agentType: row.agent_type,
+			inputPreview: this._parseAgentToolJson(row.input_preview),
+			status,
+			display: this._parseAgentToolJson(row.display_metadata),
+			displayOrder: row.display_order,
+			startedAt: row.started_at,
+			completedAt
+		};
+	}
 	_terminalResultFromInspection(agentType, inspection) {
 		if (inspection.status === "completed") return {
 			runId: inspection.runId,
@@ -3502,6 +3573,27 @@ var Agent = class Agent extends Server {
 			error: inspection.error ?? "Agent tool run failed"
 		};
 	}
+	async _finishAgentToolRun(run, result, options) {
+		const completedAt = options?.completedAt ?? Date.now();
+		this._updateAgentToolTerminal(run.runId, result, completedAt);
+		if (options?.sequence !== void 0) this._broadcastAgentToolTerminal(run.parentToolCallId, options.sequence, result);
+		const finish = () => this.onAgentToolFinish({
+			...run,
+			status: result.status,
+			completedAt
+		}, result);
+		if (options?.deferFinishHook) return finish;
+		await finish();
+	}
+	async _runDeferredAgentToolFinishHooks(hooks) {
+		for (const hook of hooks) try {
+			await hook();
+		} catch (error) {
+			try {
+				await this.onError(error);
+			} catch {}
+		}
+	}
 	_updateAgentToolTerminal(runId, result, completedAt = Date.now()) {
 		this.sql`
       UPDATE cf_agent_tool_runs
@@ -3561,6 +3653,11 @@ var Agent = class Agent extends Server {
 		}, replay, connection);
 		return next;
 	}
+	async _broadcastAgentToolStoredChunks(row, sequence, replay, connection) {
+		const child = await this._cf_resolveSubAgent(row.agent_type, row.run_id);
+		const chunks = await this._asAgentToolChildAdapter(child).getAgentToolChunks(row.run_id);
+		return this._broadcastAgentToolChunks(row.parent_tool_call_id ?? void 0, row.run_id, chunks, sequence, replay, connection);
+	}
 	async _forwardAgentToolStream(stream, parentToolCallId, runId, sequence, signal) {
 		let next = sequence;
 		if (signal?.aborted) return next;
@@ -3656,13 +3753,10 @@ var Agent = class Agent extends Server {
 		if (!cls) throw new Error(`Agent tool class "${className}" is not exported.`);
 		return cls;
 	}
-	async _replayAndInterruptAgentToolRun(cls, row, message) {
-		const parentToolCallId = row.parent_tool_call_id ?? void 0;
+	async _replayAndInterruptAgentToolRun(row, message) {
 		let sequence = 1;
 		try {
-			const child = await this.subAgent(cls, row.run_id);
-			const chunks = await this._asAgentToolChildAdapter(child).getAgentToolChunks(row.run_id);
-			sequence = this._broadcastAgentToolChunks(parentToolCallId, row.run_id, chunks, sequence);
+			sequence = await this._broadcastAgentToolStoredChunks(row, sequence);
 		} catch {}
 		const result = {
 			runId: row.run_id,
@@ -3670,8 +3764,7 @@ var Agent = class Agent extends Server {
 			status: "interrupted",
 			error: message
 		};
-		this._updateAgentToolTerminal(row.run_id, result);
-		this._broadcastAgentToolTerminal(parentToolCallId, sequence, result);
+		await this._finishAgentToolRun(this._agentToolRunInfoFromRow(row), result, { sequence });
 		return result;
 	}
 	async _replayAgentToolRuns(connection) {
@@ -3693,9 +3786,7 @@ var Agent = class Agent extends Server {
 				display: this._parseAgentToolJson(row.display_metadata)
 			}, true, connection);
 			try {
-				const child = await this.subAgent(this._agentToolClassByName(row.agent_type), row.run_id);
-				const chunks = await this._asAgentToolChildAdapter(child).getAgentToolChunks(row.run_id);
-				sequence = this._broadcastAgentToolChunks(parentToolCallId, row.run_id, chunks, sequence, true, connection);
+				sequence = await this._broadcastAgentToolStoredChunks(row, sequence, true, connection);
 			} catch {}
 			if (this._isAgentToolTerminal(row.status)) this._broadcastAgentToolTerminal(parentToolCallId, sequence, {
 				runId: row.run_id,
@@ -3707,40 +3798,52 @@ var Agent = class Agent extends Server {
 			}, true, connection);
 		}
 	}
-	async _reconcileAgentToolRuns() {
+	async _reconcileAgentToolRuns(options) {
+		const deferredFinishes = [];
 		const rows = this.sql`
-      SELECT run_id, agent_type FROM cf_agent_tool_runs
+      SELECT run_id, parent_tool_call_id, agent_type, input_preview, status,
+             summary, output_json, error_message, display_metadata, display_order,
+             started_at, completed_at
+      FROM cf_agent_tool_runs
       WHERE status IN ('starting', 'running')
       ORDER BY started_at ASC
     `;
-		for (const row of rows) try {
-			const cls = this._agentToolClassByName(row.agent_type);
-			if (!this.hasSubAgent(cls, row.run_id)) {
-				this._updateAgentToolTerminal(row.run_id, {
+		for (const row of rows) {
+			let sequence = 1;
+			let completedAt;
+			let result;
+			try {
+				const child = await this._cf_resolveSubAgent(row.agent_type, row.run_id);
+				const inspection = await this._asAgentToolChildAdapter(child).inspectAgentToolRun(row.run_id);
+				try {
+					sequence = await this._broadcastAgentToolStoredChunks(row, sequence);
+				} catch {}
+				if (!inspection || inspection.status === "running" || inspection.status === "starting") result = {
 					runId: row.run_id,
 					agentType: row.agent_type,
 					status: "interrupted",
-					error: "Agent tool child was not found during parent recovery."
-				});
-				continue;
+					error: "Agent tool run was still running, but live-tail reattachment is not supported in this runtime."
+				};
+				else {
+					result = this._terminalResultFromInspection(row.agent_type, inspection);
+					completedAt = inspection.completedAt;
+				}
+			} catch {
+				result = {
+					runId: row.run_id,
+					agentType: row.agent_type,
+					status: "interrupted",
+					error: "Agent tool run could not be inspected during parent recovery."
+				};
 			}
-			const child = await this.subAgent(cls, row.run_id);
-			const inspection = await this._asAgentToolChildAdapter(child).inspectAgentToolRun(row.run_id);
-			if (!inspection || inspection.status === "running" || inspection.status === "starting") this._updateAgentToolTerminal(row.run_id, {
-				runId: row.run_id,
-				agentType: row.agent_type,
-				status: "interrupted",
-				error: "Agent tool run was still running, but live-tail reattachment is not supported in this runtime."
-			});
-			else this._updateAgentToolTerminal(row.run_id, this._terminalResultFromInspection(row.agent_type, inspection), inspection.completedAt);
-		} catch {
-			this._updateAgentToolTerminal(row.run_id, {
-				runId: row.run_id,
-				agentType: row.agent_type,
-				status: "interrupted",
-				error: "Agent tool run could not be inspected during parent recovery."
+			const deferredFinish = await this._finishAgentToolRun(this._agentToolRunInfoFromRow(row), result, {
+				sequence,
+				completedAt,
+				deferFinishHook: options?.deferFinishHooks
 			});
+			if (deferredFinish) deferredFinishes.push(deferredFinish);
 		}
+		return deferredFinishes;
 	}
 	/**
 	* Shared facet resolution — takes a CamelCase class name string
@@ -3759,13 +3862,13 @@ var Agent = class Agent extends Server {
 		if (!Cls) throw new Error(`Sub-agent class "${className}" not found in worker exports. Make sure the class is exported from your worker entry point and that the export name matches the class name.`);
 		if (name.includes("\0")) throw new Error(`Sub-agent name contains null character (\\0), which is reserved.`);
 		const facetKey = `${className}\0${name}`;
-		const parentClassName = this.constructor.name;
-		const parentNs = ctx.exports[parentClassName];
-		if (!parentNs?.idFromName) {
-			const minificationHint = /^_*[a-z][a-z0-9]{0,2}$/.test(parentClassName) ? ` The class name "${parentClassName}" looks minified — make sure your bundler preserves class names (e.g. esbuild's \`keepNames: true\`).` : "";
-			throw new Error(`Sub-agent bootstrap requires the parent class "${parentClassName}" to be bound as a Durable Object namespace, but ctx.exports["${parentClassName}"] is missing or doesn't expose idFromName.${minificationHint} Make sure the parent agent class is registered in your wrangler.jsonc durable_objects.bindings under its class name.`);
+		const rootClassName = this._parentPath[0]?.className ?? this.constructor.name;
+		const rootNs = ctx.exports[rootClassName];
+		if (!rootNs?.idFromName) {
+			const minificationHint = /^_*[a-z][a-z0-9]{0,2}$/.test(rootClassName) ? ` The class name "${rootClassName}" looks minified — make sure your bundler preserves class names (e.g. esbuild's \`keepNames: true\`).` : "";
+			throw new Error(`Sub-agent bootstrap requires the root agent class "${rootClassName}" to be available as a Durable Object namespace, but ctx.exports["${rootClassName}"] is missing or doesn't expose idFromName.${minificationHint} Make sure the root agent class is exported under that class name and registered in your wrangler.jsonc durable_objects.bindings.`);
 		}
-		const facetId = parentNs.idFromName(name);
+		const facetId = rootNs.idFromName(name);
 		const stub = ctx.facets.get(facetKey, () => ({
 			class: Cls,
 			id: facetId