@librechat/agents 3.2.32 → 3.2.33

package/dist/esm/tools/subagent/SubagentExecutor.mjs

@@ -1,829 +1,673 @@
-import { nanoid } from 'nanoid';
-import { HumanMessage } from '@langchain/core/messages';
-import { BaseCallbackHandler } from '@langchain/core/callbacks/base';
-import { GraphEvents, Callback, StepTypes } from '../../common/enum.mjs';
-import { executeHooks } from '../../hooks/executeHooks.mjs';
-import '../../hooks/createWorkspacePolicyHook.mjs';
-
+import "../../common/enum.mjs";
+import "../../common/index.mjs";
+import { executeHooks } from "../../hooks/executeHooks.mjs";
+import "../../hooks/index.mjs";
+import { HumanMessage } from "@langchain/core/messages";
+import { BaseCallbackHandler } from "@langchain/core/callbacks/base";
+import { nanoid } from "nanoid";
+//#region src/tools/subagent/SubagentExecutor.ts
 const DEFAULT_MAX_TURNS = 25;
 const RECURSION_MULTIPLIER = 3;
 const ERROR_MESSAGE_MAX_CHARS = 200;
 const MAX_PENDING_SUBAGENT_UPDATES = 64;
 const HOOK_FALLBACK = Object.freeze({
-    additionalContexts: [],
-    errors: [],
+	additionalContexts: [],
+	errors: []
 });
-const LANGGRAPH_RUNTIME_CONFIG_PREFIX = '__pregel_';
+const LANGGRAPH_RUNTIME_CONFIG_PREFIX = "__pregel_";
 const LANGGRAPH_CHECKPOINT_CONFIG_KEYS = new Set([
-    'checkpoint_id',
-    'checkpoint_map',
-    'checkpoint_ns',
+	"checkpoint_id",
+	"checkpoint_map",
+	"checkpoint_ns"
 ]);
-class SubagentExecutor {
-    configs;
-    parentSignal;
-    hookRegistry;
-    parentRunId;
-    parentAgentId;
-    langfuse;
-    tokenCounter;
-    maxDepth;
-    createChildGraph;
-    resolveParentHandlerRegistry;
-    constructor(options) {
-        this.configs = options.configs;
-        this.parentSignal = options.parentSignal;
-        this.hookRegistry = options.hookRegistry;
-        this.parentRunId = options.parentRunId;
-        this.parentAgentId = options.parentAgentId;
-        this.langfuse = options.langfuse;
-        this.tokenCounter = options.tokenCounter;
-        this.maxDepth = options.maxDepth ?? 1;
-        this.createChildGraph = options.createChildGraph;
-        const rawRegistry = options.parentHandlerRegistry;
-        if (typeof rawRegistry === 'function') {
-            this.resolveParentHandlerRegistry = rawRegistry;
-        }
-        else if (rawRegistry != null) {
-            this.resolveParentHandlerRegistry = () => rawRegistry;
-        }
-    }
-    /** Snapshot of the parent's registry at the moment a subagent is dispatched. */
-    getParentHandlerRegistry() {
-        return this.resolveParentHandlerRegistry?.();
-    }
-    async execute(params) {
-        const { description, subagentType, threadId, parentToolCallId } = params;
-        const config = this.configs.get(subagentType);
-        if (!config) {
-            const available = [...this.configs.keys()].join(', ');
-            return {
-                content: `Error: Unknown subagent type "${subagentType}". Available types: ${available}`,
-                messages: [],
-            };
-        }
-        if (this.maxDepth <= 0) {
-            return {
-                content: 'Error: Maximum subagent nesting depth exceeded.',
-                messages: [],
-            };
-        }
-        const childAgentId = config.agentInputs.agentId ||
-            `${this.parentAgentId ?? 'agent'}_sub_${nanoid(8)}`;
-        if (this.hookRegistry?.hasHookFor('SubagentStart', this.parentRunId) === true) {
-            const hookResult = await executeHooks({
-                registry: this.hookRegistry,
-                input: {
-                    hook_event_name: 'SubagentStart',
-                    runId: this.parentRunId,
-                    threadId,
-                    parentAgentId: this.parentAgentId,
-                    agentId: childAgentId,
-                    agentType: subagentType,
-                    inputs: [new HumanMessage(description)],
-                },
-                sessionId: this.parentRunId,
-                matchQuery: subagentType,
-            }).catch(() => HOOK_FALLBACK);
-            /**
-             * `ask` is treated identically to `deny` in the subagent context:
-             * subagents are non-interactive, so there is no prompt path for `ask`.
-             * Both decisions block execution and return a "Blocked" tool result.
-             */
-            if (hookResult.decision === 'deny' || hookResult.decision === 'ask') {
-                return {
-                    content: `Blocked: ${hookResult.reason ?? 'Blocked by hook'}`,
-                    messages: [],
-                };
-            }
-        }
-        const parentRegistry = this.getParentHandlerRegistry();
-        const forwardingEnabled = parentRegistry != null;
-        /**
-         * Keep `toolDefinitions` only when the host has actually wired an
-         * `ON_TOOL_EXECUTE` handler. `Run` always constructs a `HandlerRegistry`,
-         * so treating any registry as "forwarding enabled" would leak
-         * `toolDefinitions` into children whose hosts cannot execute them — the
-         * child's `ToolNode` batch promise would hang forever with no handler to
-         * resolve/reject. Gating on the tool-execute handler preserves the
-         * recoverable "no tools" path for registry-but-no-handler configs.
-         */
-        const hasToolExecuteHandler = parentRegistry?.getHandler(GraphEvents.ON_TOOL_EXECUTE) != null;
-        const childInputs = buildChildInputs(config, childAgentId, this.maxDepth, 
-        /* keepToolDefinitions */ hasToolExecuteHandler);
-        const childRunId = `${this.parentRunId}_sub_${nanoid(8)}`;
-        const maxTurns = config.maxTurns ?? DEFAULT_MAX_TURNS;
-        const childGraph = this.createChildGraph({
-            runId: childRunId,
-            signal: this.parentSignal,
-            agents: [childInputs],
-            langfuse: this.langfuse,
-            tokenCounter: this.tokenCounter,
-        });
-        let forwarding;
-        if (forwardingEnabled) {
-            forwarding = this.createForwarderCallback({
-                parentRegistry: parentRegistry,
-                subagentType,
-                subagentAgentId: childAgentId,
-                childRunId,
-                parentToolCallId,
-            });
-        }
-        const forwarder = forwarding?.handler;
-        if (forwarder) {
-            await this.emitSubagentUpdate(parentRegistry, {
-                childRunId,
-                subagentType,
-                subagentAgentId: childAgentId,
-                parentToolCallId,
-                phase: 'start',
-                label: `Subagent "${subagentType}" started`,
-            });
-        }
-        let result;
-        try {
-            const workflow = childGraph.createWorkflow();
-            /**
-             * When `parentHandlerRegistry` is provided (forwarding mode), attach a
-             * lightweight callback that intercepts the child's `on_custom_event`
-             * dispatches and routes them to the parent's registry — either as
-             * operational events (ON_TOOL_EXECUTE) or wrapped ON_SUBAGENT_UPDATE
-             * envelopes. Native LangChain streaming events (on_chat_model_stream,
-             * etc.) still do NOT propagate to the parent's outer streamEvents
-             * iterator — the `callbacks` array REPLACES the inherited chain, so
-             * parent handlers won't receive child stream chunks and raise "No
-             * agent context found" lookups on the parent's agentContexts map.
-             *
-             * When no registry is provided (legacy isolation), `callbacks: []`
-             * fully detaches the child.
-             *
-             * `runName` gives the child a distinct LangSmith trace root (avoids
-             * nested trace pollution).
-             */
-            const callbacks = forwarder ? [forwarder] : [];
-            /**
-             * Inherit the parent's host `configurable` — host-set fields
-             * (`requestBody`, `user`, `userMCPAuthMap`, etc.) AND the run-
-             * identity fields (`run_id`, `parent_run_id`, `thread_id`) all
-             * propagate. LangGraph's own runtime keys are excluded because the
-             * child graph creates its own scratchpad/checkpoint/abort plumbing.
-             *
-             * Run-identity propagation is intentional and matches the
-             * convention this executor itself already uses for `SubagentStart`
-             * / `SubagentStop` hooks (`sessionId: this.parentRunId`): the
-             * subagent runs under the parent's session scope, not its own.
-             * Forwarding `run_id` / `parent_run_id` / `thread_id` makes
-             * `ToolNode`'s hook lookups (`hasHookFor(eventName, runId)`),
-             * `ToolOutputReferenceRegistry` keying, and trace lineage all
-             * resolve to the parent's session for tools dispatched from the
-             * subagent — so `PreToolUse` / `PostToolUse` hooks the host
-             * registered against the parent's run fire for subagent tool
-             * calls too. "Same run" matches the user-perceptual mental model.
-             *
-             * `thread_id` falls back to `childRunId` only when the parent
-             * didn't supply one (legacy behavior preserved for hosts that
-             * never set thread_id).
-             *
-             * NOTE: a future revision will likely make this configurable per
-             * spawn type — e.g. a background / async subagent that runs after
-             * the parent's run completes wants isolation, not inheritance.
-             * For now the inheritance path matches LibreChat's primary use
-             * case (synchronous subagents within a single user turn).
-             */
-            const inheritedConfigurable = sanitizeChildConfigurable(params.parentConfigurable);
-            result = await workflow.invoke({ messages: [new HumanMessage(description)] }, {
-                recursionLimit: maxTurns * RECURSION_MULTIPLIER,
-                signal: this.parentSignal,
-                callbacks,
-                runName: `subagent:${subagentType}`,
-                configurable: {
-                    thread_id: childRunId,
-                    ...inheritedConfigurable,
-                },
-            });
-        }
-        catch (error) {
-            const errorMessage = truncateErrorMessage(error);
-            if (forwarding) {
-                await forwarding.drain();
-                await this.emitSubagentUpdate(parentRegistry, {
-                    childRunId,
-                    subagentType,
-                    subagentAgentId: childAgentId,
-                    parentToolCallId,
-                    phase: 'error',
-                    label: `Subagent "${subagentType}" errored: ${errorMessage}`,
-                    data: { message: errorMessage },
-                });
-            }
-            childGraph.clearHeavyState();
-            return {
-                content: `Subagent error: ${errorMessage}`,
-                messages: [],
-            };
-        }
-        const filteredContent = filterSubagentResult(result.messages);
-        if (this.hookRegistry?.hasHookFor('SubagentStop', this.parentRunId) === true) {
-            /**
-             * Awaited (not fire-and-forget) for deterministic test synchronization
-             * and consistency with PostCompact. The parent is already waiting on the
-             * tool result, so the small extra latency is acceptable. Errors are
-             * swallowed — SubagentStop is observational.
-             */
-            await executeHooks({
-                registry: this.hookRegistry,
-                input: {
-                    hook_event_name: 'SubagentStop',
-                    runId: this.parentRunId,
-                    threadId,
-                    agentId: childAgentId,
-                    agentType: subagentType,
-                    messages: result.messages,
-                },
-                sessionId: this.parentRunId,
-                matchQuery: subagentType,
-            }).catch(() => {
-                /* SubagentStop is observational — swallow errors */
-            });
-        }
-        if (forwarding) {
-            await forwarding.drain();
-            await this.emitSubagentUpdate(parentRegistry, {
-                childRunId,
-                subagentType,
-                subagentAgentId: childAgentId,
-                parentToolCallId,
-                phase: 'stop',
-                label: `Subagent "${subagentType}" finished`,
-            });
-        }
-        childGraph.clearHeavyState();
-        return { content: filteredContent, messages: result.messages };
-    }
-    /**
-     * Emits a single {@link GraphEvents.ON_SUBAGENT_UPDATE} envelope through the
-     * parent's handler registry. Silent no-op when no parent registry is set.
-     * Errors are swallowed — update events are observational.
-     */
-    async emitSubagentUpdate(parentRegistry, args) {
-        const handler = parentRegistry.getHandler(GraphEvents.ON_SUBAGENT_UPDATE);
-        if (!handler) {
-            return;
-        }
-        const event = {
-            runId: this.parentRunId,
-            subagentRunId: args.childRunId,
-            subagentType: args.subagentType,
-            subagentAgentId: args.subagentAgentId,
-            parentAgentId: this.parentAgentId,
-            parentToolCallId: args.parentToolCallId,
-            phase: args.phase,
-            data: args.data,
-            label: args.label,
-            timestamp: new Date().toISOString(),
-        };
-        try {
-            await handler.handle(GraphEvents.ON_SUBAGENT_UPDATE, event);
-        }
-        catch {
-            /* observational — swallow */
-        }
-    }
-    /**
-     * Builds a BaseCallbackHandler that intercepts the child graph's custom
-     * events. Routing rules:
-     *   - `ON_TOOL_EXECUTE` → forwarded as-is to the parent's ON_TOOL_EXECUTE
-     *     handler (so event-driven tools work identically for child and parent).
-     *   - `ON_RUN_STEP` / `ON_RUN_STEP_DELTA` / `ON_RUN_STEP_COMPLETED` /
-     *     `ON_MESSAGE_DELTA` / `ON_REASONING_DELTA` → wrapped in a
-     *     {@link GraphEvents.ON_SUBAGENT_UPDATE} envelope with a human-readable
-     *     label, delivered to the parent's subagent-update handler.
-     *   - Everything else → ignored (keeps parent's UI scoped to the events it
-     *     cares about; host apps can extend by registering more phases).
-     */
-    createForwarderCallback(args) {
-        const { parentRegistry, subagentType, subagentAgentId, childRunId, parentToolCallId, } = args;
-        const parentRunId = this.parentRunId;
-        const parentAgentId = this.parentAgentId;
-        const wrap = async (eventName, phase, data) => {
-            const handler = parentRegistry.getHandler(GraphEvents.ON_SUBAGENT_UPDATE);
-            if (!handler) {
-                return;
-            }
-            try {
-                const event = {
-                    runId: parentRunId,
-                    subagentRunId: childRunId,
-                    subagentType,
-                    subagentAgentId,
-                    parentAgentId,
-                    parentToolCallId,
-                    phase,
-                    data: sanitizeForwardedSubagentUpdateData(eventName, data),
-                    label: summarizeEvent(eventName, data),
-                    timestamp: new Date().toISOString(),
-                };
-                await handler.handle(GraphEvents.ON_SUBAGENT_UPDATE, event);
-            }
-            catch {
-                /* observational — swallow */
-            }
-        };
-        const queuedUpdates = [];
-        let drainPromise;
-        const enqueue = (update) => {
-            if (queuedUpdates.length >= MAX_PENDING_SUBAGENT_UPDATES) {
-                const dropIndex = queuedUpdates.findIndex((queued) => isDroppableSubagentUpdatePhase(queued.phase));
-                if (dropIndex >= 0) {
-                    queuedUpdates.splice(dropIndex, 1);
-                }
-                else if (isDroppableSubagentUpdatePhase(update.phase)) {
-                    return;
-                }
-            }
-            queuedUpdates.push(update);
-        };
-        const drain = async () => {
-            if (drainPromise != null) {
-                await drainPromise;
-                return;
-            }
-            drainPromise = (async () => {
-                while (queuedUpdates.length > 0) {
-                    const update = queuedUpdates.shift();
-                    if (update == null) {
-                        continue;
-                    }
-                    await wrap(update.eventName, update.phase, update.data);
-                }
-            })();
-            try {
-                await drainPromise;
-            }
-            finally {
-                drainPromise = undefined;
-                if (queuedUpdates.length > 0) {
-                    await drain();
-                }
-            }
-        };
-        const scheduleWrap = (eventName, phase, data) => {
-            enqueue({ eventName, phase, data });
-            void drain();
-        };
-        const handler = BaseCallbackHandler.fromMethods({
-            [Callback.CUSTOM_EVENT]: async (eventName, data) => {
-                if (eventName === GraphEvents.ON_TOOL_EXECUTE) {
-                    const toolHandler = parentRegistry.getHandler(GraphEvents.ON_TOOL_EXECUTE);
-                    if (toolHandler) {
-                        await toolHandler.handle(GraphEvents.ON_TOOL_EXECUTE, data);
-                    }
-                    /**
-                     * We also surface a short notice in the subagent-update stream so
-                     * the UI can show "calling <tool>" for each tool the child spawns.
-                     */
-                    scheduleWrap(eventName, 'run_step', data);
-                    return;
-                }
-                if (eventName === GraphEvents.ON_RUN_STEP) {
-                    scheduleWrap(eventName, 'run_step', data);
-                    return;
-                }
-                if (eventName === GraphEvents.ON_RUN_STEP_DELTA) {
-                    scheduleWrap(eventName, 'run_step_delta', data);
-                    return;
-                }
-                if (eventName === GraphEvents.ON_RUN_STEP_COMPLETED) {
-                    scheduleWrap(eventName, 'run_step_completed', data);
-                    return;
-                }
-                if (eventName === GraphEvents.ON_MESSAGE_DELTA) {
-                    scheduleWrap(eventName, 'message_delta', data);
-                    return;
-                }
-                if (eventName === GraphEvents.ON_REASONING_DELTA) {
-                    scheduleWrap(eventName, 'reasoning_delta', data);
-                    return;
-                }
-            },
-        });
-        /**
-         * `awaitHandlers = true` is required so the child's `ToolNode` actually
-         * blocks on the parent's `ON_TOOL_EXECUTE` handler until it resolves
-         * the batch request. Observational `ON_SUBAGENT_UPDATE` calls are queued
-         * behind a bounded sequential dispatcher so host UI publication cannot
-         * backpressure each child emission or run unbounded concurrent publishes.
-         * The executor drains this queue before terminal stop/error envelopes to
-         * preserve phase ordering.
-         */
-        handler.awaitHandlers = true;
-        return { handler, drain };
-    }
-}
+var SubagentExecutor = class {
+	configs;
+	parentSignal;
+	hookRegistry;
+	parentRunId;
+	parentAgentId;
+	langfuse;
+	tokenCounter;
+	maxDepth;
+	createChildGraph;
+	resolveParentHandlerRegistry;
+	constructor(options) {
+		this.configs = options.configs;
+		this.parentSignal = options.parentSignal;
+		this.hookRegistry = options.hookRegistry;
+		this.parentRunId = options.parentRunId;
+		this.parentAgentId = options.parentAgentId;
+		this.langfuse = options.langfuse;
+		this.tokenCounter = options.tokenCounter;
+		this.maxDepth = options.maxDepth ?? 1;
+		this.createChildGraph = options.createChildGraph;
+		const rawRegistry = options.parentHandlerRegistry;
+		if (typeof rawRegistry === "function") this.resolveParentHandlerRegistry = rawRegistry;
+		else if (rawRegistry != null) this.resolveParentHandlerRegistry = () => rawRegistry;
+	}
+	/** Snapshot of the parent's registry at the moment a subagent is dispatched. */
+	getParentHandlerRegistry() {
+		return this.resolveParentHandlerRegistry?.();
+	}
+	async execute(params) {
+		const { description, subagentType, threadId, parentToolCallId } = params;
+		const config = this.configs.get(subagentType);
+		if (!config) return {
+			content: `Error: Unknown subagent type "${subagentType}". Available types: ${[...this.configs.keys()].join(", ")}`,
+			messages: []
+		};
+		if (this.maxDepth <= 0) return {
+			content: "Error: Maximum subagent nesting depth exceeded.",
+			messages: []
+		};
+		const childAgentId = config.agentInputs.agentId || `${this.parentAgentId ?? "agent"}_sub_${nanoid(8)}`;
+		if (this.hookRegistry?.hasHookFor("SubagentStart", this.parentRunId) === true) {
+			const hookResult = await executeHooks({
+				registry: this.hookRegistry,
+				input: {
+					hook_event_name: "SubagentStart",
+					runId: this.parentRunId,
+					threadId,
+					parentAgentId: this.parentAgentId,
+					agentId: childAgentId,
+					agentType: subagentType,
+					inputs: [new HumanMessage(description)]
+				},
+				sessionId: this.parentRunId,
+				matchQuery: subagentType
+			}).catch(() => HOOK_FALLBACK);
+			/**
+			* `ask` is treated identically to `deny` in the subagent context:
+			* subagents are non-interactive, so there is no prompt path for `ask`.
+			* Both decisions block execution and return a "Blocked" tool result.
+			*/
+			if (hookResult.decision === "deny" || hookResult.decision === "ask") return {
+				content: `Blocked: ${hookResult.reason ?? "Blocked by hook"}`,
+				messages: []
+			};
+		}
+		const parentRegistry = this.getParentHandlerRegistry();
+		const forwardingEnabled = parentRegistry != null;
+		/**
+		* Keep `toolDefinitions` only when the host has actually wired an
+		* `ON_TOOL_EXECUTE` handler. `Run` always constructs a `HandlerRegistry`,
+		* so treating any registry as "forwarding enabled" would leak
+		* `toolDefinitions` into children whose hosts cannot execute them — the
+		* child's `ToolNode` batch promise would hang forever with no handler to
+		* resolve/reject. Gating on the tool-execute handler preserves the
+		* recoverable "no tools" path for registry-but-no-handler configs.
+		*/
+		const hasToolExecuteHandler = parentRegistry?.getHandler("on_tool_execute") != null;
+		const childInputs = buildChildInputs(config, childAgentId, this.maxDepth, hasToolExecuteHandler);
+		const childRunId = `${this.parentRunId}_sub_${nanoid(8)}`;
+		const maxTurns = config.maxTurns ?? DEFAULT_MAX_TURNS;
+		const childGraph = this.createChildGraph({
+			runId: childRunId,
+			signal: this.parentSignal,
+			agents: [childInputs],
+			langfuse: this.langfuse,
+			tokenCounter: this.tokenCounter
+		});
+		let forwarding;
+		if (forwardingEnabled) forwarding = this.createForwarderCallback({
+			parentRegistry,
+			subagentType,
+			subagentAgentId: childAgentId,
+			childRunId,
+			parentToolCallId
+		});
+		const forwarder = forwarding?.handler;
+		if (forwarder) await this.emitSubagentUpdate(parentRegistry, {
+			childRunId,
+			subagentType,
+			subagentAgentId: childAgentId,
+			parentToolCallId,
+			phase: "start",
+			label: `Subagent "${subagentType}" started`
+		});
+		let result;
+		try {
+			const workflow = childGraph.createWorkflow();
+			/**
+			* When `parentHandlerRegistry` is provided (forwarding mode), attach a
+			* lightweight callback that intercepts the child's `on_custom_event`
+			* dispatches and routes them to the parent's registry — either as
+			* operational events (ON_TOOL_EXECUTE) or wrapped ON_SUBAGENT_UPDATE
+			* envelopes. Native LangChain streaming events (on_chat_model_stream,
+			* etc.) still do NOT propagate to the parent's outer streamEvents
+			* iterator — the `callbacks` array REPLACES the inherited chain, so
+			* parent handlers won't receive child stream chunks and raise "No
+			* agent context found" lookups on the parent's agentContexts map.
+			*
+			* When no registry is provided (legacy isolation), `callbacks: []`
+			* fully detaches the child.
+			*
+			* `runName` gives the child a distinct LangSmith trace root (avoids
+			* nested trace pollution).
+			*/
+			const callbacks = forwarder ? [forwarder] : [];
+			/**
+			* Inherit the parent's host `configurable` — host-set fields
+			* (`requestBody`, `user`, `userMCPAuthMap`, etc.) AND the run-
+			* identity fields (`run_id`, `parent_run_id`, `thread_id`) all
+			* propagate. LangGraph's own runtime keys are excluded because the
+			* child graph creates its own scratchpad/checkpoint/abort plumbing.
+			*
+			* Run-identity propagation is intentional and matches the
+			* convention this executor itself already uses for `SubagentStart`
+			* / `SubagentStop` hooks (`sessionId: this.parentRunId`): the
+			* subagent runs under the parent's session scope, not its own.
+			* Forwarding `run_id` / `parent_run_id` / `thread_id` makes
+			* `ToolNode`'s hook lookups (`hasHookFor(eventName, runId)`),
+			* `ToolOutputReferenceRegistry` keying, and trace lineage all
+			* resolve to the parent's session for tools dispatched from the
+			* subagent — so `PreToolUse` / `PostToolUse` hooks the host
+			* registered against the parent's run fire for subagent tool
+			* calls too. "Same run" matches the user-perceptual mental model.
+			*
+			* `thread_id` falls back to `childRunId` only when the parent
+			* didn't supply one (legacy behavior preserved for hosts that
+			* never set thread_id).
+			*
+			* NOTE: a future revision will likely make this configurable per
+			* spawn type — e.g. a background / async subagent that runs after
+			* the parent's run completes wants isolation, not inheritance.
+			* For now the inheritance path matches LibreChat's primary use
+			* case (synchronous subagents within a single user turn).
+			*/
+			const inheritedConfigurable = sanitizeChildConfigurable(params.parentConfigurable);
+			result = await workflow.invoke({ messages: [new HumanMessage(description)] }, {
+				recursionLimit: maxTurns * RECURSION_MULTIPLIER,
+				signal: this.parentSignal,
+				callbacks,
+				runName: `subagent:${subagentType}`,
+				configurable: {
+					thread_id: childRunId,
+					...inheritedConfigurable
+				}
+			});
+		} catch (error) {
+			const errorMessage = truncateErrorMessage(error);
+			if (forwarding) {
+				await forwarding.drain();
+				await this.emitSubagentUpdate(parentRegistry, {
+					childRunId,
+					subagentType,
+					subagentAgentId: childAgentId,
+					parentToolCallId,
+					phase: "error",
+					label: `Subagent "${subagentType}" errored: ${errorMessage}`,
+					data: { message: errorMessage }
+				});
+			}
+			childGraph.clearHeavyState();
+			return {
+				content: `Subagent error: ${errorMessage}`,
+				messages: []
+			};
+		}
+		const filteredContent = filterSubagentResult(result.messages);
+		if (this.hookRegistry?.hasHookFor("SubagentStop", this.parentRunId) === true)
+ /**
+		* Awaited (not fire-and-forget) for deterministic test synchronization
+		* and consistency with PostCompact. The parent is already waiting on the
+		* tool result, so the small extra latency is acceptable. Errors are
+		* swallowed — SubagentStop is observational.
+		*/
+		await executeHooks({
+			registry: this.hookRegistry,
+			input: {
+				hook_event_name: "SubagentStop",
+				runId: this.parentRunId,
+				threadId,
+				agentId: childAgentId,
+				agentType: subagentType,
+				messages: result.messages
+			},
+			sessionId: this.parentRunId,
+			matchQuery: subagentType
+		}).catch(() => {});
+		if (forwarding) {
+			await forwarding.drain();
+			await this.emitSubagentUpdate(parentRegistry, {
+				childRunId,
+				subagentType,
+				subagentAgentId: childAgentId,
+				parentToolCallId,
+				phase: "stop",
+				label: `Subagent "${subagentType}" finished`
+			});
+		}
+		childGraph.clearHeavyState();
+		return {
+			content: filteredContent,
+			messages: result.messages
+		};
+	}
+	/**
+	* Emits a single {@link GraphEvents.ON_SUBAGENT_UPDATE} envelope through the
+	* parent's handler registry. Silent no-op when no parent registry is set.
+	* Errors are swallowed — update events are observational.
+	*/
+	async emitSubagentUpdate(parentRegistry, args) {
+		const handler = parentRegistry.getHandler("on_subagent_update");
+		if (!handler) return;
+		const event = {
+			runId: this.parentRunId,
+			subagentRunId: args.childRunId,
+			subagentType: args.subagentType,
+			subagentAgentId: args.subagentAgentId,
+			parentAgentId: this.parentAgentId,
+			parentToolCallId: args.parentToolCallId,
+			phase: args.phase,
+			data: args.data,
+			label: args.label,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		try {
+			await handler.handle("on_subagent_update", event);
+		} catch {}
+	}
+	/**
+	* Builds a BaseCallbackHandler that intercepts the child graph's custom
+	* events. Routing rules:
+	*   - `ON_TOOL_EXECUTE` → forwarded as-is to the parent's ON_TOOL_EXECUTE
+	*     handler (so event-driven tools work identically for child and parent).
+	*   - `ON_RUN_STEP` / `ON_RUN_STEP_DELTA` / `ON_RUN_STEP_COMPLETED` /
+	*     `ON_MESSAGE_DELTA` / `ON_REASONING_DELTA` → wrapped in a
+	*     {@link GraphEvents.ON_SUBAGENT_UPDATE} envelope with a human-readable
+	*     label, delivered to the parent's subagent-update handler.
+	*   - Everything else → ignored (keeps parent's UI scoped to the events it
+	*     cares about; host apps can extend by registering more phases).
+	*/
+	createForwarderCallback(args) {
+		const { parentRegistry, subagentType, subagentAgentId, childRunId, parentToolCallId } = args;
+		const parentRunId = this.parentRunId;
+		const parentAgentId = this.parentAgentId;
+		const wrap = async (eventName, phase, data) => {
+			const handler = parentRegistry.getHandler("on_subagent_update");
+			if (!handler) return;
+			try {
+				const event = {
+					runId: parentRunId,
+					subagentRunId: childRunId,
+					subagentType,
+					subagentAgentId,
+					parentAgentId,
+					parentToolCallId,
+					phase,
+					data: sanitizeForwardedSubagentUpdateData(eventName, data),
+					label: summarizeEvent(eventName, data),
+					timestamp: (/* @__PURE__ */ new Date()).toISOString()
+				};
+				await handler.handle("on_subagent_update", event);
+			} catch {}
+		};
+		const queuedUpdates = [];
+		let drainPromise;
+		const enqueue = (update) => {
+			if (queuedUpdates.length >= MAX_PENDING_SUBAGENT_UPDATES) {
+				const dropIndex = queuedUpdates.findIndex((queued) => isDroppableSubagentUpdatePhase(queued.phase));
+				if (dropIndex >= 0) queuedUpdates.splice(dropIndex, 1);
+				else if (isDroppableSubagentUpdatePhase(update.phase)) return;
+			}
+			queuedUpdates.push(update);
+		};
+		const drain = async () => {
+			if (drainPromise != null) {
+				await drainPromise;
+				return;
+			}
+			drainPromise = (async () => {
+				while (queuedUpdates.length > 0) {
+					const update = queuedUpdates.shift();
+					if (update == null) continue;
+					await wrap(update.eventName, update.phase, update.data);
+				}
+			})();
+			try {
+				await drainPromise;
+			} finally {
+				drainPromise = void 0;
+				if (queuedUpdates.length > 0) await drain();
+			}
+		};
+		const scheduleWrap = (eventName, phase, data) => {
+			enqueue({
+				eventName,
+				phase,
+				data
+			});
+			drain();
+		};
+		const handler = BaseCallbackHandler.fromMethods({ ["handleCustomEvent"]: async (eventName, data) => {
+			if (eventName === "on_tool_execute") {
+				const toolHandler = parentRegistry.getHandler("on_tool_execute");
+				if (toolHandler) await toolHandler.handle("on_tool_execute", data);
+				/**
+				* We also surface a short notice in the subagent-update stream so
+				* the UI can show "calling <tool>" for each tool the child spawns.
+				*/
+				scheduleWrap(eventName, "run_step", data);
+				return;
+			}
+			if (eventName === "on_run_step") {
+				scheduleWrap(eventName, "run_step", data);
+				return;
+			}
+			if (eventName === "on_run_step_delta") {
+				scheduleWrap(eventName, "run_step_delta", data);
+				return;
+			}
+			if (eventName === "on_run_step_completed") {
+				scheduleWrap(eventName, "run_step_completed", data);
+				return;
+			}
+			if (eventName === "on_message_delta") {
+				scheduleWrap(eventName, "message_delta", data);
+				return;
+			}
+			if (eventName === "on_reasoning_delta") {
+				scheduleWrap(eventName, "reasoning_delta", data);
+				return;
+			}
+		} });
+		/**
+		* `awaitHandlers = true` is required so the child's `ToolNode` actually
+		* blocks on the parent's `ON_TOOL_EXECUTE` handler until it resolves
+		* the batch request. Observational `ON_SUBAGENT_UPDATE` calls are queued
+		* behind a bounded sequential dispatcher so host UI publication cannot
+		* backpressure each child emission or run unbounded concurrent publishes.
+		* The executor drains this queue before terminal stop/error envelopes to
+		* preserve phase ordering.
+		*/
+		handler.awaitHandlers = true;
+		return {
+			handler,
+			drain
+		};
+	}
+};
 function sanitizeChildConfigurable(parentConfigurable) {
-    if (parentConfigurable == null) {
-        return {};
-    }
-    return Object.fromEntries(Object.entries(parentConfigurable).filter(([key]) => !isLangGraphRuntimeConfigKey(key)));
+	if (parentConfigurable == null) return {};
+	return Object.fromEntries(Object.entries(parentConfigurable).filter(([key]) => !isLangGraphRuntimeConfigKey(key)));
 }
 function isLangGraphRuntimeConfigKey(key) {
-    return (key.startsWith(LANGGRAPH_RUNTIME_CONFIG_PREFIX) ||
-        LANGGRAPH_CHECKPOINT_CONFIG_KEYS.has(key));
+	return key.startsWith(LANGGRAPH_RUNTIME_CONFIG_PREFIX) || LANGGRAPH_CHECKPOINT_CONFIG_KEYS.has(key);
 }
 function sanitizeForwardedSubagentUpdateData(eventName, data) {
-    if (eventName === GraphEvents.ON_TOOL_EXECUTE) {
-        return sanitizeToolExecuteUpdateData(data);
-    }
-    if (eventName === GraphEvents.ON_RUN_STEP) {
-        return sanitizeRunStepUpdateData(data);
-    }
-    if (eventName === GraphEvents.ON_RUN_STEP_DELTA) {
-        return sanitizeRunStepDeltaUpdateData(data);
-    }
-    if (eventName === GraphEvents.ON_RUN_STEP_COMPLETED) {
-        return sanitizeRunStepCompletedUpdateData(data);
-    }
-    if (eventName === GraphEvents.ON_MESSAGE_DELTA) {
-        return sanitizeMessageDeltaUpdateData(data);
-    }
-    if (eventName === GraphEvents.ON_REASONING_DELTA) {
-        return sanitizeReasoningDeltaUpdateData(data);
-    }
-    return undefined;
+	if (eventName === "on_tool_execute") return sanitizeToolExecuteUpdateData(data);
+	if (eventName === "on_run_step") return sanitizeRunStepUpdateData(data);
+	if (eventName === "on_run_step_delta") return sanitizeRunStepDeltaUpdateData(data);
+	if (eventName === "on_run_step_completed") return sanitizeRunStepCompletedUpdateData(data);
+	if (eventName === "on_message_delta") return sanitizeMessageDeltaUpdateData(data);
+	if (eventName === "on_reasoning_delta") return sanitizeReasoningDeltaUpdateData(data);
 }
 function isDroppableSubagentUpdatePhase(phase) {
-    return (phase === 'message_delta' ||
-        phase === 'reasoning_delta' ||
-        phase === 'run_step_delta');
+	return phase === "message_delta" || phase === "reasoning_delta" || phase === "run_step_delta";
 }
 function sanitizeToolExecuteUpdateData(data) {
-    const request = data;
-    const toolCalls = Array.isArray(request.toolCalls)
-        ? request.toolCalls.map(sanitizeToolCallForUpdate)
-        : [];
-    const sanitized = { toolCalls };
-    if (typeof request.agentId === 'string') {
-        sanitized.agentId = request.agentId;
-    }
-    return sanitized;
+	const request = data;
+	const sanitized = { toolCalls: Array.isArray(request.toolCalls) ? request.toolCalls.map(sanitizeToolCallForUpdate) : [] };
+	if (typeof request.agentId === "string") sanitized.agentId = request.agentId;
+	return sanitized;
 }
 function sanitizeToolCallForUpdate(call) {
-    const sanitized = {
-        id: call.id,
-        name: call.name,
-        args: call.args,
-    };
-    return sanitized;
+	return {
+		id: call.id,
+		name: call.name,
+		args: call.args
+	};
 }
 function sanitizeRunStepUpdateData(data) {
-    if (!isObjectLike(data)) {
-        return undefined;
-    }
-    const step = data;
-    const sanitized = {};
-    assignString(sanitized, 'agentId', step.agentId);
-    assignNumber(sanitized, 'groupId', step.groupId);
-    assignString(sanitized, 'id', step.id);
-    assignNumber(sanitized, 'index', step.index);
-    assignString(sanitized, 'runId', step.runId);
-    assignNumber(sanitized, 'stepIndex', step.stepIndex);
-    assignString(sanitized, 'type', step.type);
-    if (step.summary !== undefined) {
-        sanitized.summary = step.summary;
-    }
-    if (step.usage !== undefined) {
-        sanitized.usage = step.usage;
-    }
-    sanitized.stepDetails = sanitizeStepDetails(step.stepDetails);
-    return sanitized;
+	if (!isObjectLike(data)) return;
+	const step = data;
+	const sanitized = {};
+	assignString(sanitized, "agentId", step.agentId);
+	assignNumber(sanitized, "groupId", step.groupId);
+	assignString(sanitized, "id", step.id);
+	assignNumber(sanitized, "index", step.index);
+	assignString(sanitized, "runId", step.runId);
+	assignNumber(sanitized, "stepIndex", step.stepIndex);
+	assignString(sanitized, "type", step.type);
+	if (step.summary !== void 0) sanitized.summary = step.summary;
+	if (step.usage !== void 0) sanitized.usage = step.usage;
+	sanitized.stepDetails = sanitizeStepDetails(step.stepDetails);
+	return sanitized;
 }
 function sanitizeRunStepDeltaUpdateData(data) {
-    if (!isObjectLike(data)) {
-        return undefined;
-    }
-    const event = data;
-    const sanitized = {};
-    assignString(sanitized, 'id', event.id);
-    sanitized.delta = sanitizeToolCallDelta(event.delta);
-    return sanitized;
+	if (!isObjectLike(data)) return;
+	const event = data;
+	const sanitized = {};
+	assignString(sanitized, "id", event.id);
+	sanitized.delta = sanitizeToolCallDelta(event.delta);
+	return sanitized;
 }
 function sanitizeRunStepCompletedUpdateData(data) {
-    if (!isObjectLike(data)) {
-        return undefined;
-    }
-    const event = data;
-    return { result: sanitizeStepCompleted(event.result) };
+	if (!isObjectLike(data)) return;
+	return { result: sanitizeStepCompleted(data.result) };
 }
 function sanitizeMessageDeltaUpdateData(data) {
-    if (!isObjectLike(data)) {
-        return undefined;
-    }
-    const event = data;
-    const sanitized = {};
-    assignString(sanitized, 'id', event.id);
-    if (event.delta != null) {
-        sanitized.delta = {};
-        if (event.delta.content !== undefined) {
-            sanitized.delta.content = event.delta.content;
-        }
-        if (event.delta.tool_call_ids !== undefined) {
-            sanitized.delta.tool_call_ids = event.delta.tool_call_ids;
-        }
-    }
-    return sanitized;
+	if (!isObjectLike(data)) return;
+	const event = data;
+	const sanitized = {};
+	assignString(sanitized, "id", event.id);
+	if (event.delta != null) {
+		sanitized.delta = {};
+		if (event.delta.content !== void 0) sanitized.delta.content = event.delta.content;
+		if (event.delta.tool_call_ids !== void 0) sanitized.delta.tool_call_ids = event.delta.tool_call_ids;
+	}
+	return sanitized;
 }
 function sanitizeReasoningDeltaUpdateData(data) {
-    if (!isObjectLike(data)) {
-        return undefined;
-    }
-    const event = data;
-    const sanitized = {};
-    assignString(sanitized, 'id', event.id);
-    if (event.delta?.content !== undefined) {
-        sanitized.delta = { content: event.delta.content };
-    }
-    return sanitized;
+	if (!isObjectLike(data)) return;
+	const event = data;
+	const sanitized = {};
+	assignString(sanitized, "id", event.id);
+	if (event.delta?.content !== void 0) sanitized.delta = { content: event.delta.content };
+	return sanitized;
 }
 function sanitizeStepDetails(stepDetails) {
-    if (!isObjectLike(stepDetails)) {
-        return undefined;
-    }
-    const rawDetails = stepDetails;
-    if (rawDetails.type === StepTypes.MESSAGE_CREATION) {
-        const sanitized = {
-            type: StepTypes.MESSAGE_CREATION,
-        };
-        const messageId = rawDetails.message_creation?.message_id;
-        if (typeof messageId === 'string') {
-            sanitized.message_creation = { message_id: messageId };
-        }
-        return sanitized;
-    }
-    if (rawDetails.type === StepTypes.TOOL_CALLS) {
-        const sanitized = {
-            type: StepTypes.TOOL_CALLS,
-        };
-        if (Array.isArray(rawDetails.tool_calls)) {
-            sanitized.tool_calls = rawDetails.tool_calls.map(sanitizeAgentToolCall);
-        }
-        return sanitized;
-    }
-    return undefined;
+	if (!isObjectLike(stepDetails)) return;
+	const rawDetails = stepDetails;
+	if (rawDetails.type === "message_creation") {
+		const sanitized = { type: "message_creation" };
+		const messageId = rawDetails.message_creation?.message_id;
+		if (typeof messageId === "string") sanitized.message_creation = { message_id: messageId };
+		return sanitized;
+	}
+	if (rawDetails.type === "tool_calls") {
+		const sanitized = { type: "tool_calls" };
+		if (Array.isArray(rawDetails.tool_calls)) sanitized.tool_calls = rawDetails.tool_calls.map(sanitizeAgentToolCall);
+		return sanitized;
+	}
 }
 function sanitizeToolCallDelta(delta) {
-    if (!isObjectLike(delta)) {
-        return undefined;
-    }
-    const sanitized = {};
-    assignString(sanitized, 'auth', delta.auth);
-    assignNumber(sanitized, 'expires_at', delta.expires_at);
-    assignString(sanitized, 'type', delta.type);
-    if (delta.summary !== undefined) {
-        sanitized.summary = delta.summary;
-    }
-    if (Array.isArray(delta.tool_calls)) {
-        sanitized.tool_calls = delta.tool_calls.map(sanitizeAgentToolCall);
-    }
-    return sanitized;
+	if (!isObjectLike(delta)) return;
+	const sanitized = {};
+	assignString(sanitized, "auth", delta.auth);
+	assignNumber(sanitized, "expires_at", delta.expires_at);
+	assignString(sanitized, "type", delta.type);
+	if (delta.summary !== void 0) sanitized.summary = delta.summary;
+	if (Array.isArray(delta.tool_calls)) sanitized.tool_calls = delta.tool_calls.map(sanitizeAgentToolCall);
+	return sanitized;
 }
 function sanitizeStepCompleted(data) {
-    if (!isObjectLike(data)) {
-        return undefined;
-    }
-    const completed = data;
-    if (completed.type === 'summary') {
-        return {
-            type: 'summary',
-            summary: completed.summary,
-        };
-    }
-    if (completed.type !== 'tool_call') {
-        return undefined;
-    }
-    const sanitized = { type: 'tool_call' };
-    assignString(sanitized, 'id', completed.id);
-    assignNumber(sanitized, 'index', completed.index);
-    sanitized.tool_call = sanitizeProcessedToolCall(completed.tool_call);
-    return sanitized;
+	if (!isObjectLike(data)) return;
+	const completed = data;
+	if (completed.type === "summary") return {
+		type: "summary",
+		summary: completed.summary
+	};
+	if (completed.type !== "tool_call") return;
+	const sanitized = { type: "tool_call" };
+	assignString(sanitized, "id", completed.id);
+	assignNumber(sanitized, "index", completed.index);
+	sanitized.tool_call = sanitizeProcessedToolCall(completed.tool_call);
+	return sanitized;
 }
 function sanitizeProcessedToolCall(toolCall) {
-    if (!isObjectLike(toolCall)) {
-        return undefined;
-    }
-    const call = toolCall;
-    const sanitized = {};
-    assignString(sanitized, 'id', call.id);
-    assignString(sanitized, 'name', call.name);
-    if (call.args !== undefined) {
-        sanitized.args = call.args;
-    }
-    assignString(sanitized, 'output', call.output);
-    assignNumber(sanitized, 'progress', call.progress);
-    return sanitized;
+	if (!isObjectLike(toolCall)) return;
+	const call = toolCall;
+	const sanitized = {};
+	assignString(sanitized, "id", call.id);
+	assignString(sanitized, "name", call.name);
+	if (call.args !== void 0) sanitized.args = call.args;
+	assignString(sanitized, "output", call.output);
+	assignNumber(sanitized, "progress", call.progress);
+	return sanitized;
 }
 function sanitizeAgentToolCall(toolCall) {
-    if (!isObjectLike(toolCall)) {
-        return {};
-    }
-    const call = toolCall;
-    const sanitized = {};
-    assignString(sanitized, 'id', call.id);
-    assignString(sanitized, 'name', call.name);
-    assignString(sanitized, 'type', call.type);
-    if (call.args !== undefined) {
-        sanitized.args = call.args;
-    }
-    if (isObjectLike(call.function)) {
-        const fn = {};
-        assignString(fn, 'name', call.function.name);
-        if (typeof call.function.arguments === 'string' ||
-            isObjectLike(call.function.arguments)) {
-            fn.arguments = call.function.arguments;
-        }
-        sanitized.function = fn;
-    }
-    return sanitized;
+	if (!isObjectLike(toolCall)) return {};
+	const call = toolCall;
+	const sanitized = {};
+	assignString(sanitized, "id", call.id);
+	assignString(sanitized, "name", call.name);
+	assignString(sanitized, "type", call.type);
+	if (call.args !== void 0) sanitized.args = call.args;
+	if (isObjectLike(call.function)) {
+		const fn = {};
+		assignString(fn, "name", call.function.name);
+		if (typeof call.function.arguments === "string" || isObjectLike(call.function.arguments)) fn.arguments = call.function.arguments;
+		sanitized.function = fn;
+	}
+	return sanitized;
 }
 function isObjectLike(value) {
-    return value != null && typeof value === 'object' && !Array.isArray(value);
+	return value != null && typeof value === "object" && !Array.isArray(value);
 }
 function assignString(target, key, value) {
-    if (typeof value === 'string') {
-        target[key] = value;
-    }
+	if (typeof value === "string") target[key] = value;
 }
 function assignNumber(target, key, value) {
-    if (typeof value === 'number') {
-        target[key] = value;
-    }
+	if (typeof value === "number") target[key] = value;
 }
 /**
- * Produces a short single-line label for an arbitrary forwarded child event.
- * Used to populate {@link SubagentUpdateEvent.label} so the host UI can show
- * a compact status ticker without parsing the raw payload.
- */
+* Produces a short single-line label for an arbitrary forwarded child event.
+* Used to populate {@link SubagentUpdateEvent.label} so the host UI can show
+* a compact status ticker without parsing the raw payload.
+*/
 function summarizeEvent(eventName, data) {
-    if (eventName === GraphEvents.ON_TOOL_EXECUTE) {
-        const req = data;
-        const names = (req.toolCalls ?? [])
-            .map((c) => c.name)
-            .filter((n) => typeof n === 'string');
-        return names.length > 0 ? `Calling ${names.join(', ')}` : 'Calling tool';
-    }
-    if (eventName === GraphEvents.ON_RUN_STEP) {
-        const step = data;
-        const detailType = step.stepDetails?.type ?? step.type ?? 'step';
-        if (detailType === 'tool_calls') {
-            const names = (step.stepDetails?.tool_calls ?? [])
-                .map((c) => c.name)
-                .filter((n) => typeof n === 'string');
-            return names.length > 0
-                ? `Using tool: ${names.join(', ')}`
-                : 'Planning tool call';
-        }
-        if (detailType === 'message_creation') {
-            return 'Thinking…';
-        }
-        return `Step: ${detailType}`;
-    }
-    if (eventName === GraphEvents.ON_RUN_STEP_COMPLETED) {
-        const step = data;
-        const tool = step.result?.tool_call;
-        if (tool?.name != null && tool.name !== '') {
-            return `Tool ${tool.name} complete`;
-        }
-        return 'Step complete';
-    }
-    if (eventName === GraphEvents.ON_MESSAGE_DELTA) {
-        return 'Streaming…';
-    }
-    return eventName;
+	if (eventName === "on_tool_execute") {
+		const names = (data.toolCalls ?? []).map((c) => c.name).filter((n) => typeof n === "string");
+		return names.length > 0 ? `Calling ${names.join(", ")}` : "Calling tool";
+	}
+	if (eventName === "on_run_step") {
+		const step = data;
+		const detailType = step.stepDetails?.type ?? step.type ?? "step";
+		if (detailType === "tool_calls") {
+			const names = (step.stepDetails?.tool_calls ?? []).map((c) => c.name).filter((n) => typeof n === "string");
+			return names.length > 0 ? `Using tool: ${names.join(", ")}` : "Planning tool call";
+		}
+		if (detailType === "message_creation") return "Thinking…";
+		return `Step: ${detailType}`;
+	}
+	if (eventName === "on_run_step_completed") {
+		const tool = data.result?.tool_call;
+		if (tool?.name != null && tool.name !== "") return `Tool ${tool.name} complete`;
+		return "Step complete";
+	}
+	if (eventName === "on_message_delta") return "Streaming…";
+	return eventName;
 }
 /**
- * Walk messages from last to first, returning the text content of the most
- * recent AIMessage that has any. Non-text blocks (tool_use, thinking,
- * redacted_thinking, tool_result) are stripped. If the last AIMessage is
- * pure tool_use (e.g. the subagent hit `maxTurns` mid-tool-call), the walk
- * continues to earlier AIMessages so partial progress is salvaged — this
- * matches Claude Code's behavior in `agentToolUtils.finalizeAgentTool`.
- * Returns "Task completed" only when no AIMessage in the history contains
- * any text.
- */
+* Walk messages from last to first, returning the text content of the most
+* recent AIMessage that has any. Non-text blocks (tool_use, thinking,
+* redacted_thinking, tool_result) are stripped. If the last AIMessage is
+* pure tool_use (e.g. the subagent hit `maxTurns` mid-tool-call), the walk
+* continues to earlier AIMessages so partial progress is salvaged — this
+* matches Claude Code's behavior in `agentToolUtils.finalizeAgentTool`.
+* Returns "Task completed" only when no AIMessage in the history contains
+* any text.
+*/
 function filterSubagentResult(messages) {
-    for (let i = messages.length - 1; i >= 0; i--) {
-        if (messages[i]._getType() !== 'ai') {
-            continue;
-        }
-        const content = messages[i].content;
-        if (typeof content === 'string') {
-            if (content)
-                return content;
-            continue;
-        }
-        if (!Array.isArray(content)) {
-            continue;
-        }
-        const textParts = [];
-        for (const block of content) {
-            if (typeof block === 'string') {
-                textParts.push(block);
-            }
-            else if ('type' in block && block.type === 'text' && 'text' in block) {
-                textParts.push(block.text);
-            }
-        }
-        if (textParts.length > 0) {
-            return textParts.join('\n');
-        }
-    }
-    return 'Task completed';
+	for (let i = messages.length - 1; i >= 0; i--) {
+		if (messages[i]._getType() !== "ai") continue;
+		const content = messages[i].content;
+		if (typeof content === "string") {
+			if (content) return content;
+			continue;
+		}
+		if (!Array.isArray(content)) continue;
+		const textParts = [];
+		for (const block of content) if (typeof block === "string") textParts.push(block);
+		else if ("type" in block && block.type === "text" && "text" in block) textParts.push(block.text);
+		if (textParts.length > 0) return textParts.join("\n");
+	}
+	return "Task completed";
 }
 /**
- * Resolve self-spawn configs by filling in agentInputs from the parent context.
- * Returns configs with agentInputs guaranteed present. Throws on duplicate
- * `type` values to prevent silent config shadowing.
- */
+* Resolve self-spawn configs by filling in agentInputs from the parent context.
+* Returns configs with agentInputs guaranteed present. Throws on duplicate
+* `type` values to prevent silent config shadowing.
+*/
 function resolveSubagentConfigs(configs, parentContext) {
-    const resolved = configs
-        .map((config) => {
-        if (config.agentInputs != null) {
-            return config;
-        }
-        if (config.self !== true || parentContext._sourceInputs == null) {
-            return null;
-        }
-        return {
-            ...config,
-            agentInputs: { ...parentContext._sourceInputs },
-        };
-    })
-        .filter((c) => c != null);
-    const seenTypes = new Set();
-    for (const config of resolved) {
-        if (seenTypes.has(config.type)) {
-            throw new Error(`Duplicate subagent type "${config.type}". Each SubagentConfig must have a unique "type" field.`);
-        }
-        seenTypes.add(config.type);
-    }
-    return resolved;
+	const resolved = configs.map((config) => {
+		if (config.agentInputs != null) return config;
+		if (config.self !== true || parentContext._sourceInputs == null) return null;
+		return {
+			...config,
+			agentInputs: { ...parentContext._sourceInputs }
+		};
+	}).filter((c) => c != null);
+	const seenTypes = /* @__PURE__ */ new Set();
+	for (const config of resolved) {
+		if (seenTypes.has(config.type)) throw new Error(`Duplicate subagent type "${config.type}". Each SubagentConfig must have a unique "type" field.`);
+		seenTypes.add(config.type);
+	}
+	return resolved;
 }
 /**
- * Build child AgentInputs from a resolved config, stripping nesting and
- * (optionally) event-driven fields. When `allowNested: true`, the child's
- * `maxSubagentDepth` is decremented so that depth is consumed as the call
- * chain deepens across graph boundaries — the parent's executor-level check
- * alone cannot see into the child graph's separate executor.
- *
- * When `keepToolDefinitions` is `true`, the child retains the parent's
- * `toolDefinitions` so event-driven tools remain usable. This is only safe
- * when the caller has wired a forwarder for `ON_TOOL_EXECUTE` to a
- * registered handler — otherwise the child will hang on tool dispatch.
- *
- * @remarks Advanced utility: exported primarily for testing and by
- * {@link SubagentExecutor}. Host applications configuring subagents should
- * not need to call this directly — it is invoked internally when a subagent
- * tool is dispatched. The depth-countdown contract (parent's `maxDepth` in,
- * child's decremented `maxSubagentDepth` on the returned inputs) is the
- * mechanism that bounds nesting across graph boundaries; callers must
- * respect it.
- */
+* Build child AgentInputs from a resolved config, stripping nesting and
+* (optionally) event-driven fields. When `allowNested: true`, the child's
+* `maxSubagentDepth` is decremented so that depth is consumed as the call
+* chain deepens across graph boundaries — the parent's executor-level check
+* alone cannot see into the child graph's separate executor.
+*
+* When `keepToolDefinitions` is `true`, the child retains the parent's
+* `toolDefinitions` so event-driven tools remain usable. This is only safe
+* when the caller has wired a forwarder for `ON_TOOL_EXECUTE` to a
+* registered handler — otherwise the child will hang on tool dispatch.
+*
+* @remarks Advanced utility: exported primarily for testing and by
+* {@link SubagentExecutor}. Host applications configuring subagents should
+* not need to call this directly — it is invoked internally when a subagent
+* tool is dispatched. The depth-countdown contract (parent's `maxDepth` in,
+* child's decremented `maxSubagentDepth` on the returned inputs) is the
+* mechanism that bounds nesting across graph boundaries; callers must
+* respect it.
+*/
 function buildChildInputs(config, childAgentId, parentMaxDepth, keepToolDefinitions = false) {
-    const { agentInputs } = config;
-    const childInputs = {
-        ...agentInputs,
-        agentId: childAgentId,
-        toolDefinitions: keepToolDefinitions
-            ? agentInputs.toolDefinitions
-            : undefined,
-        /**
-         * Subagents run in an isolated context by contract. Parent-run-scoped
-         * fields that would otherwise survive the shallow-spread clone — the
-         * cross-run conversation summary and the prior-turn tool-discovery
-         * set — are cleared here so the child starts fresh. Host applications
-         * that want a subagent to see parent context must thread it in
-         * explicitly (e.g. via the `description` argument to the subagent
-         * tool), not via inherited state.
-         */
-        initialSummary: undefined,
-        discoveredTools: undefined,
-    };
-    if (config.allowNested === true) {
-        childInputs.maxSubagentDepth = Math.max(0, parentMaxDepth - 1);
-    }
-    else {
-        childInputs.subagentConfigs = undefined;
-        childInputs.maxSubagentDepth = undefined;
-    }
-    return childInputs;
+	const { agentInputs } = config;
+	const childInputs = {
+		...agentInputs,
+		agentId: childAgentId,
+		toolDefinitions: keepToolDefinitions ? agentInputs.toolDefinitions : void 0,
+		/**
+		* Subagents run in an isolated context by contract. Parent-run-scoped
+		* fields that would otherwise survive the shallow-spread clone — the
+		* cross-run conversation summary and the prior-turn tool-discovery
+		* set — are cleared here so the child starts fresh. Host applications
+		* that want a subagent to see parent context must thread it in
+		* explicitly (e.g. via the `description` argument to the subagent
+		* tool), not via inherited state.
+		*/
+		initialSummary: void 0,
+		discoveredTools: void 0
+	};
+	if (config.allowNested === true) childInputs.maxSubagentDepth = Math.max(0, parentMaxDepth - 1);
+	else {
+		childInputs.subagentConfigs = void 0;
+		childInputs.maxSubagentDepth = void 0;
+	}
+	return childInputs;
 }
 function truncateErrorMessage(error) {
-    const message = error instanceof Error ? error.message : String(error);
-    if (message.length <= ERROR_MESSAGE_MAX_CHARS) {
-        return message;
-    }
-    return `${message.slice(0, ERROR_MESSAGE_MAX_CHARS)}...`;
+	const message = error instanceof Error ? error.message : String(error);
+	if (message.length <= ERROR_MESSAGE_MAX_CHARS) return message;
+	return `${message.slice(0, ERROR_MESSAGE_MAX_CHARS)}...`;
 }
+//#endregion
+export { SubagentExecutor, buildChildInputs, filterSubagentResult, resolveSubagentConfigs, summarizeEvent };
 
-export { SubagentExecutor, buildChildInputs, filterSubagentResult, resolveSubagentConfigs, sanitizeForwardedSubagentUpdateData, summarizeEvent };
-//# sourceMappingURL=SubagentExecutor.mjs.map
+//# sourceMappingURL=SubagentExecutor.mjs.map