@librechat/agents 3.4.6 → 3.5.0

package/dist/esm/tools/ToolNode.mjs

@@ -24,8 +24,6 @@ import { Command, END, GraphInterrupt, Send, interrupt, isCommand, isGraphInterr
 import { AIMessage, HumanMessage, ToolMessage, isAIMessage, isBaseMessage } from "@langchain/core/messages";
 import { AsyncLocalStorageProviderSingleton } from "@langchain/core/singletons";
 //#region src/tools/ToolNode.ts
-/** Host-facing batch requests must not carry the batch's breaker scope —
-* hosts spread `configurable` into their own run configs. */
 function stripRunBreakerScope(configurable) {
 	if (configurable == null || !("lc_run_breaker_scope" in configurable)) return configurable;
 	const { [RUN_BREAKER_SCOPE_CONFIG_KEY]: _scope, ...rest } = configurable;
@@ -63,12 +61,6 @@ function createToolErrorOwnership() {
 		undispatched: /* @__PURE__ */ new Set()
 	};
 }
-/**
-* Produces the provider preview and, when requested, the exact registry prefix
-* in one bounded traversal. String outputs already exist in memory when a tool
-* returns them; structured outputs must never be fully JSON-materialized before
-* either limit applies.
-*/
 function serializeToolOutputWithinLimits(output, maxToolResultChars, registryPrefixChars = 0) {
 	if (typeof output === "string") return {
 		content: truncateToolResultContent(output, maxToolResultChars),
@@ -83,19 +75,12 @@ function serializeToolOutputWithinLimits(output, maxToolResultChars, registryPre
 const TOOL_NODE_RUN_NAME = "tool_batch";
 const NANOID_URL_ALPHABET = "_-0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
 const RUNTIME_HANDOFF_GROUP_OFFSET = 2 ** 48;
-/**
-* Helper to check if a value is a Send object
-*/
 function isSend(value) {
 	return value instanceof Send;
 }
 function isHandoffToolName(name) {
 	return name.startsWith("lc_transfer_to_");
 }
-/**
-* Encodes 48 random bits from the persisted batch key into a safe integer.
-* The high offset keeps runtime groups disjoint from low, structural group IDs.
-*/
 function getRuntimeHandoffGroupId(batch) {
 	let value = 0;
 	for (const char of batch.slice(0, 8)) {
@@ -114,13 +99,6 @@ function findHandoffMessage(messages, destination) {
 		if (isStandardHandoff || isConditionalHandoff) return toolMessage;
 	}
 }
-/**
-* Format a fail-closed diagnostic for malformed approval-decision
-* fields. Hosts deserialize resume payloads from untyped JSON, so
-* `responseText` and `updatedInput` can land here as anything; the
-* blocking ToolMessage carries this string so the host can debug the
-* exact wire shape that was rejected.
-*/
 function describeOfferedShape(value) {
 	if (value === void 0) return "<missing>";
 	if (value === null) return "null";
@@ -146,13 +124,6 @@ function getAssistantBatchReplayKey(batch, runId, threadId) {
 		batch.messageCount
 	]);
 }
-/**
-* Build the `tool_approval` interrupt payload from the set of pending
-* `ask`-decision entries collected during PreToolUse hook handling.
-* Pure function — doesn't touch ToolNode state — so it lives at module
-* scope. The interrupt itself is raised by the caller (which still
-* needs `interrupt()` plus the AsyncLocalStorage anchoring shim).
-*/
 function buildToolApprovalInterruptPayload(askEntries, hookSessionId) {
 	return {
 		type: "tool_approval",
@@ -178,14 +149,6 @@ function buildToolApprovalInterruptPayload(askEntries, hookSessionId) {
 		}))
 	};
 }
-/**
-* Build a `tool_call_id → ToolApprovalDecision` map from the host's
-* resume value. Hosts may return decisions either as an array (one per
-* action_request, in order) or as a record keyed by `tool_call_id`. Any
-* unrecognized shape (or a decision missing for a given call id) is
-* treated as "no decision" by callers — typically rejected so the run
-* doesn't silently invoke a tool the human never approved.
-*/
 function normalizeApprovalDecisions(callIds, resumeValue) {
 	const map = /* @__PURE__ */ new Map();
 	if (resumeValue == null) return map;
@@ -200,48 +163,6 @@ function normalizeApprovalDecisions(callIds, resumeValue) {
 	}
 	return map;
 }
-/**
-* Merges code execution session context into the sessions map.
-*
-* The codeapi worker reports two distinct ids on a code-execution result:
-*  - `artifact.session_id` (the `sessionId` arg here) is the EXEC session
-*    — the sandbox VM that ran the code. It's transient and torn down
-*    post-execution; subsequent calls cannot reuse it as a sandbox.
-*  - `file.storage_session_id` on each `artifact.files[i]` is the STORAGE
-*    session — the file-server bucket prefix where the artifact actually
-*    lives and is served from.
-*
-* Per-file `storage_session_id` is preserved (not overwritten with the
-* exec id) because `_injected_files` are looked up against the
-* file-server's storage path on subsequent tool calls. Stomping the
-* storage id with the exec id silently 404s every follow-up tool call
-* within the same run — `cat /mnt/data/foo.txt` reports "No such file
-* or directory" because the worker can't mount a file at a path the
-* storage doesn't know about. Fall back to the exec id only when the
-* per-file id is absent (e.g. inline `content` files have no persistent
-* storage location).
-*/
-/**
-* Builds a `CodeEnvFile` ref from an arbitrary `FileRef`-like input,
-* narrowing onto the discriminated union: `kind: 'skill'` requires
-* `version`, other kinds forbid it.
-*
-* Defaults `kind` to `'user'` when unset — most ad-hoc files are
-* user-private; shared resources (skills/agents) populate their kind
-* upstream. A skill ref missing `version` falls back to `'user'` so
-* the upstream contract bug surfaces as a degraded sessionKey rather
-* than a runtime crash; primeSkillFiles is the only writer, and it
-* always sets `version` — see LC packages/api/src/agents/skillFiles.ts.
-*
-* `resource_id` carries the entity-that-owns-this-file's-session
-* identity (skill `_id` etc.); falls back to `id` (the storage
-* file_id) for inputs that haven't been updated to send the field
-* explicitly. The fallback degrades sessionKey resolution on the
-* codeapi side for shared kinds (it'll match the storage nanoid
-* against a skill _id and 403) — but won't crash, so an unmigrated
-* client still produces a diagnosable error instead of a stack
-* trace.
-*/
 function toInjectedFileRef(file, execSessionId) {
 	const base = {
 		id: file.id,
@@ -314,121 +235,32 @@ var ToolNode = class extends RunnableCallable {
 	agentLangfuse;
 	toolCallStepIds;
 	errorHandler;
-	/**
-	* Fallback error-completion ownership for calls that reach `runTool`
-	* outside a batch context (direct `runTool` use in tests / embedders).
-	* Batch-scoped ownership is threaded via `RunToolBatchContext` instead —
-	* see {@link ToolErrorOwnership} for why per-invocation scoping matters.
-	*/
 	looseErrorOwnership = createToolErrorOwnership();
 	toolUsageCount;
-	/** Maps toolCallId → turn captured in runTool, used by handleRunToolCompletions */
 	toolCallTurns = /* @__PURE__ */ new Map();
-	/**
-	* `call.id → turn` map dedicated to the direct-path lifecycle so the
-	* turn assigned on first entry is REUSED on LangGraph resume.
-	* Distinct from `toolCallTurns` (which is cleared at the start of
-	* every `run()` to keep per-batch event-dispatch metadata fresh) —
-	* the direct path needs stability across re-entries triggered by
-	* `interrupt()` resumes (Codex P2 #30). Cleared with the rest of
-	* the per-Run state in `clearHeavyState`-equivalent flushes when
-	* the Run ends.
-	*/
 	directPathTurns = /* @__PURE__ */ new Map();
-	/** Terminal results from interrupting siblings that must survive a
-	* LangGraph replay of the containing ToolNode. Includes the sidecar data
-	* the fresh batch needs for hook-context injection and completion events. */
 	settledInterruptingResults = /* @__PURE__ */ new Map();
-	/** Tool registry for filtering (lazy computation of programmatic maps) */
 	toolRegistry;
-	/** Cached programmatic tools (computed once on first PTC call) */
 	programmaticCache;
-	/** Reference to Graph's sessions map for automatic session injection */
 	sessions;
-	/** When true, dispatches ON_TOOL_EXECUTE events instead of invoking tools directly */
 	eventDrivenMode = false;
-	/** Opt-in stream-layer prestart config for event-driven tools. */
 	eagerEventToolExecution;
-	/** Host tools that write to the code sandbox and share its exec session. */
 	codeSessionToolNames;
-	/** Shared per-run prestarted tool registry populated by ChatModelStreamHandler. */
 	eagerEventToolExecutions;
-	/** Shared per-run per-tool turn counter used by eager and normal event dispatch. */
 	eagerEventToolUsageCount;
-	/**
-	* Shared per-run eager prestart circuit breaker. Tool names added here
-	* (when a prestarted execution's args mismatch the final request) are no
-	* longer prestarted by the stream handler for the rest of the run.
-	*/
 	eagerEventToolSuppressions;
-	/** Agent ID for event-driven mode */
 	agentId;
-	/**
-	* ID of the agent that owns this tool node, whenever the graph knows it
-	* (including top-level agents in a multi-agent graph). Surfaced to hooks as
-	* `executingAgentId` so they can attribute a tool batch to a specific agent
-	* even where `agentId` (the subagent-scope marker) is undefined.
-	*/
 	executingAgentId;
-	/** Tool names that bypass event dispatch and execute directly (e.g., graph-managed handoff tools) */
 	directToolNames;
-	/**
-	* Tool names whose in-process body may raise a LangGraph `interrupt()`
-	* mid-execution (e.g. `ask_user_question`). Used only to REORDER within
-	* the direct group: a tool named here that is *already* direct (a real
-	* in-process graphTool — the only kind whose body can reach
-	* `interrupt()`) is scheduled ahead of its non-interrupting direct
-	* siblings, so a mid-body interrupt unwinds the ToolNode before a
-	* non-idempotent sibling executes and LangGraph's resume-time batch
-	* re-execution can't double it. This set is deliberately NOT folded
-	* into direct classification: a name that resolves to a schema-only
-	* event stub (an inherited `toolDefinition` with no executable
-	* instance) stays event-dispatched — forcing it direct would invoke
-	* the stub, which throws. See {@link t.ToolNodeOptions.interruptingToolNames}.
-	*/
 	interruptingToolNames;
-	/**
-	* File checkpointer extracted from the local coding tool bundle when
-	* `toolExecution.local.fileCheckpointing === true`. Exposed via
-	* {@link getFileCheckpointer}. Undefined when checkpointing is off
-	* or the local coding suite isn't bound to this node.
-	*/
 	fileCheckpointer;
-	/** Maximum characters allowed in a single tool result before truncation. */
 	maxToolResultChars;
-	/** Hook registry for PreToolUse/PostToolUse lifecycle hooks */
 	hookRegistry;
-	/**
-	* Run-scoped HITL config. When `enabled`, `ask` decisions from
-	* PreToolUse hooks raise a LangGraph `interrupt()` instead of being
-	* treated as fail-closed denies.
-	*/
 	humanInTheLoop;
-	/**
-	* Registry of tool outputs keyed by `tool<idx>turn<turn>`.
-	*
-	* Populated only when `toolOutputReferences.enabled` is true. The
-	* registry owns the run-scoped state (turn counter, last-seen runId,
-	* warn-once memo, stored outputs), so sharing a single instance
-	* across multiple ToolNodes in a run lets cross-agent `{{…}}`
-	* references resolve — which is why multi-agent graphs pass the
-	* *same* instance to every ToolNode they compile rather than each
-	* ToolNode building its own.
-	*/
 	toolOutputRegistry;
-	/** Run-scoped selection for swapping remote code tools to local executors. */
 	toolExecution;
-	/** Owning graph's run-scoped breaker signal, composed into each batch's config. */
 	getBreakerSignal;
-	/** Owning graph's immutable run scope; captured once per batch. */
 	getRunScope;
-	/**
-	* Monotonic counter used to mint a unique scope id for anonymous
-	* batches (ones invoked without a `run_id` in
-	* `config.configurable`). Each such batch gets its own registry
-	* partition so concurrent anonymous invocations can't delete each
-	* other's in-flight state.
-	*/
 	anonBatchCounter = 0;
 	constructor({ tools, toolMap, name, tags, trace, runLangfuse, agentLangfuse, errorHandler, toolCallStepIds, handleToolErrors, loadRuntimeTools, toolRegistry, sessions, eventDrivenMode, eagerEventToolExecution, eagerEventToolExecutions, eagerEventToolUsageCount, eagerEventToolSuppressions, agentId, executingAgentId, directToolNames, interruptingToolNames, codeSessionToolNames, maxContextTokens, maxToolResultChars, hookRegistry, humanInTheLoop, toolOutputReferences, toolOutputRegistry, toolExecution, fileCheckpointer, getBreakerSignal, getRunScope }) {
 		super({
@@ -468,17 +300,6 @@ var ToolNode = class extends RunnableCallable {
 		this.getRunScope = getRunScope;
 		this.fileCheckpointer = fileCheckpointer;
 		this.applyToolExecutionOverrides();
-		/**
-		* Precedence: an explicitly passed `toolOutputRegistry` instance
-		* wins over a config object so a host (`Graph`) can share one
-		* registry across many ToolNodes. When only the config is
-		* provided (direct ToolNode usage), build a local registry so
-		* the feature still works without graph-level plumbing. Registry
-		* caps are intentionally decoupled from `maxToolResultChars`:
-		* the registry stores the raw untruncated output so a later
-		* `{{…}}` substitution pipes the full payload into the next
-		* tool, even when the LLM saw a truncated preview.
-		*/
 		if (toolOutputRegistry != null) this.toolOutputRegistry = toolOutputRegistry;
 		else if (toolOutputReferences?.enabled === true) this.toolOutputRegistry = new ToolOutputReferenceRegistry({
 			maxOutputSize: toolOutputReferences.maxOutputSize,
@@ -499,24 +320,9 @@ var ToolNode = class extends RunnableCallable {
 			agentId: this.executingAgentId
 		}), () => super.invoke(input, scopedOptions));
 	}
-	/**
-	* Returns the run-scoped tool output registry, or `undefined` when
-	* the feature is disabled.
-	*
-	* @internal Exposed for test observation only. Host code should rely
-	* on `{{tool<i>turn<n>}}` substitution at tool-invocation time and
-	* not mutate the registry directly.
-	*/
 	_unsafeGetToolOutputRegistry() {
 		return this.toolOutputRegistry;
 	}
-	/**
-	* Replaces known remote Code API tools with local-process tools when
-	* `RunConfig.toolExecution.engine === 'local'`. In event-driven mode those
-	* names are also marked direct so the SDK executes them locally instead of
-	* dispatching the batch to a host-side remote sandbox handler. When the
-	* local coding suite is enabled, this also injects file/search/edit tools.
-	*/
 	applyToolExecutionOverrides() {
 		const resolved = resolveLocalExecutionTools({
 			toolMap: this.toolMap,
@@ -529,16 +335,6 @@ var ToolNode = class extends RunnableCallable {
 		this.directToolNames = new Set([...this.directToolNames ?? /* @__PURE__ */ new Set(), ...resolved.directToolNames]);
 		this.programmaticCache = void 0;
 	}
-	/**
-	* Returns the per-Run file checkpointer when
-	* `toolExecution.local.fileCheckpointing === true`. Hosts call
-	* `rewind()` on the returned object to restore captured pre-write
-	* file contents — the standard "undo a tool batch" pattern. Returns
-	* undefined when checkpointing is disabled or the local coding suite
-	* isn't bound. Manual review (finding E): without this getter, the
-	* config flag was a silent no-op outside of direct
-	* `createLocalCodingToolBundle()` use.
-	*/
 	getFileCheckpointer() {
 		return this.fileCheckpointer;
 	}
@@ -571,22 +367,10 @@ var ToolNode = class extends RunnableCallable {
 		if (suggestion == null) return `Tool "${callName}" not found.`;
 		return `Tool "${callName}" not found. Did you mean "${suggestion}"? Handoff tool names must match exactly.`;
 	}
-	/**
-	* Flush per-Run direct replay state. Called by the Graph at end-of-Run via
-	* `clearHeavyState`. The state intentionally survives `run()` re-entry so
-	* interrupt + resume keeps both original turn slots and terminal sibling
-	* outputs, but it would otherwise grow linearly and could collide across
-	* Runs if a provider reused call IDs. Hosts can also call this directly if
-	* they reuse a ToolNode across batches outside of a Graph.
-	*/
 	clearDirectPathTurns() {
 		this.directPathTurns.clear();
 		this.settledInterruptingResults.clear();
 	}
-	/**
-	* Returns cached programmatic tools, computing once on first access.
-	* Single iteration builds both toolMap and toolDefs simultaneously.
-	*/
 	getProgrammaticTools() {
 		if (this.programmaticCache) return this.programmaticCache;
 		const toolMap = /* @__PURE__ */ new Map();
@@ -604,10 +388,6 @@ var ToolNode = class extends RunnableCallable {
 		};
 		return this.programmaticCache;
 	}
-	/**
-	* Returns a snapshot of the current tool usage counts.
-	* @returns A ReadonlyMap where keys are tool names and values are their usage counts.
-	*/
 	getToolUsageCounts() {
 		return new Map(this.toolUsageCount);
 	}
@@ -642,14 +422,6 @@ var ToolNode = class extends RunnableCallable {
 		this.recordToolUsageTurn(toolName, turn, callId);
 		if (this.canConsumeEagerEventExecution(runId)) this.eagerEventToolUsageCount?.set(toolName, Math.max(this.eagerEventToolUsageCount.get(toolName) ?? 0, turn + 1));
 	}
-	/**
-	* Runs a single tool call with error handling.
-	*
-	* `batchIndex` is the tool's position within the current ToolNode
-	* batch and, together with `this.currentTurn`, forms the key used to
-	* register the output for future `{{tool<idx>turn<turn>}}`
-	* substitutions. Omit when no registration should occur.
-	*/
 	async runTool(call, config, batchContext = {}) {
 		const { batchIndex, turn, batchScopeId, resolvedArgsByCallId, preBatchSnapshot, runInput } = batchContext;
 		const tool = this.toolMap.get(call.name);
@@ -658,42 +430,11 @@ var ToolNode = class extends RunnableCallable {
 		const resolveOptions = { substituteIntentKey: this.toolDeclaresBusinessIntent(call.name) };
 		if (preBatchSnapshot != null) resolveFn = (_runId, args) => preBatchSnapshot.resolve(args, resolveOptions);
 		else if (registry != null) resolveFn = (runIdArg, args) => registry.resolve(runIdArg, args, resolveOptions);
-		/**
-		* Precompute the reference key once per call — captured locally
-		* so concurrent `invoke()` calls on the same ToolNode cannot race
-		* on a shared turn field.
-		*/
 		const refKey = registry != null && batchIndex != null && turn != null ? buildReferenceKey(batchIndex, turn) : void 0;
-		/**
-		* Hoisted outside the try so the catch branch can append
-		* `[unresolved refs: …]` to error messages — otherwise the LLM
-		* only sees a generic error when it references a bad key, losing
-		* the self-correction signal this feature is meant to provide.
-		*/
 		let unresolvedRefs = [];
-		/**
-		* Use the caller-provided `batchScopeId` when threaded from
-		* `run()` (so anonymous batches get their own unique scope).
-		* Fall back to the config's `run_id` when runTool is invoked
-		* from a context that doesn't thread it — that still preserves
-		* the runId-based partitioning for named runs.
-		*/
 		const runId = batchScopeId ?? config.configurable?.run_id;
 		try {
 			if (tool === void 0) throw new Error(this.getUnknownToolErrorMessage(call.name));
-			/**
-			* `usageCount` is the per-tool-name invocation index that
-			* web-search and other tools observe via `invokeParams.turn`.
-			* It is intentionally distinct from the outer `turn` parameter
-			* (the batch turn used for ref keys); the latter is captured
-			* before the try block when constructing `refKey`.
-			*
-			* Prefer the value `runDirectToolWithLifecycleHooks` already
-			* incremented (Codex P2 #27) — its hook wants the SAME turn
-			* the tool will execute under. When called from a path that
-			* doesn't pre-increment (event dispatch, the no-hooks
-			* shortcut), do the read+increment here.
-			*/
 			const usageCount = batchContext.usageCount ?? (() => {
 				const next = this.toolUsageCount.get(call.name) ?? 0;
 				this.toolUsageCount.set(call.name, next + 1);
@@ -705,12 +446,6 @@ var ToolNode = class extends RunnableCallable {
 				const { resolved, unresolved } = resolveFn(runId, args);
 				args = resolved;
 				unresolvedRefs = unresolved;
-				/**
-				* Expose the post-substitution args to downstream completion
-				* events so audit logs / host-side `ON_RUN_STEP_COMPLETED`
-				* handlers observe what actually ran, not the `{{…}}`
-				* template. Only string/object args are worth recording.
-				*/
 				if (resolvedArgsByCallId != null && call.id != null && call.id !== "" && resolved !== call.args && typeof resolved === "object") resolvedArgsByCallId.set(call.id, resolved);
 			}
 			const stepId = this.toolCallStepIds?.get(call.id);
@@ -739,16 +474,6 @@ var ToolNode = class extends RunnableCallable {
 				...invokeParams,
 				toolRegistry: this.toolRegistry
 			};
-			/**
-			* Inject session context for code execution tools when available.
-			* Each file uses its own session_id (supporting multi-session file tracking).
-			* Both session_id and _injected_files are injected directly to invokeParams
-			* (not inside args) so they bypass Zod schema validation and reach config.toolCall.
-			*
-			* session_id is always injected when available, but concrete file refs
-			* still need to travel through `_injected_files`; the legacy
-			* `/files/<session_id>` fallback was removed from the executors.
-			*/
 			if (this.participatesInCodeSession(call.name)) {
 				const codeSession = this.sessions?.get("execute_code");
 				const execSessionId = codeSession?.session_id;
@@ -759,25 +484,12 @@ var ToolNode = class extends RunnableCallable {
 					};
 					if (codeSession?.files != null && codeSession.files.length > 0) invokeParams._injected_files = codeSession.files.map((file) => toInjectedFileRef(file, execSessionId));
 				}
-				/**
-				* Stateful runtime session hint — orthogonal to the transient
-				* exec-session above, and injected independently (a first call has a
-				* hint but no exec session yet). Explicit host hint wins; otherwise
-				* fall back to the conversation's thread_id.
-				*/
 				const runtimeSessionHint = this.resolveRuntimeSessionHint(config);
 				if (runtimeSessionHint != null) invokeParams = {
 					...invokeParams,
 					_runtime_session_hint: runtimeSessionHint
 				};
 			}
-			/**
-			* Forward the graph state as langgraph 1.4's `runtime.state` so
-			* tools can read it off their second argument instead of the
-			* deprecated `getCurrentTaskInput()` (which relies on
-			* `node:async_hooks` and is browser-incompatible). Shape mirrors
-			* langgraph's prebuilt ToolNode runtime exactly.
-			*/
 			const lgConfig = config;
 			const runtime = {
 				...config,
@@ -788,9 +500,6 @@ var ToolNode = class extends RunnableCallable {
 				store: lgConfig.store ?? null,
 				writer: lgConfig.writer ?? config.configurable?.writer ?? null
 			};
-			/** A sibling can trip the breaker while the PreToolUse hooks above
-			* are awaited; a tool that never inspects its runtime signal would
-			* still run. Recheck at the last moment before execution. */
 			this.throwIfBreakerTripped(config);
 			const output = await tool.invoke(invokeParams, runtime);
 			if (isCommand(output)) return output;
@@ -801,13 +510,6 @@ var ToolNode = class extends RunnableCallable {
 				const compacted = compactToolContent(originalContent, this.maxToolResultChars);
 				if (compacted.changed) toolMsg.content = compacted.content;
 				if (toolMsg.status === "error") {
-					/**
-					* Error ToolMessages bypass registration but still stamp the
-					* unresolved-refs hint into `additional_kwargs` so the lazy
-					* annotation transform surfaces it to the LLM, letting the
-					* model self-correct when its reference key caused the
-					* failure. Persisted `content` stays clean.
-					*/
 					if (unresolvedRefs.length > 0) toolMsg.additional_kwargs = {
 						...toolMsg.additional_kwargs,
 						_unresolvedRefs: unresolvedRefs
@@ -822,16 +524,6 @@ var ToolNode = class extends RunnableCallable {
 						...refMeta
 					};
 				} else {
-					/**
-					* Non-string content (multi-part content blocks — text +
-					* image). It is now bounded for the LLM, but cannot register under a
-					* reference key because there's no canonical serialized
-					* form. Warn once per tool per run when the caller
-					* intended to register. The unresolved-refs hint is still
-					* stamped as metadata; the lazy transform prepends a text
-					* block at request time so the LLM gets the self-correction
-					* signal.
-					*/
 					if (unresolvedRefs.length > 0) toolMsg.additional_kwargs = {
 						...toolMsg.additional_kwargs,
 						_unresolvedRefs: unresolvedRefs
@@ -853,11 +545,6 @@ var ToolNode = class extends RunnableCallable {
 			const e = _e;
 			if (!this.handleToolErrors) throw e;
 			if (isGraphInterrupt(e)) throw e;
-			/**
-			* A stream circuit breaker tripped by a child run (subagent) is a
-			* safety abort, not a tool failure to report back to the model. It
-			* passes through like an interrupt so the whole run rejects.
-			*/
 			if (e instanceof StreamLimitExceededError) throw e;
 			if (this.errorHandler) try {
 				const dispatched = await this.errorHandler({
@@ -867,15 +554,7 @@ var ToolNode = class extends RunnableCallable {
 					input: call.args
 				}, config.metadata);
 				const ownership = batchContext.errorOwnership ?? this.looseErrorOwnership;
-				if (call.id != null && call.id !== "") if (dispatched === false)
- /**
-				* The handler could not dispatch the error completion (typically
-				* a resume pass, where a fast-failing tool errors before the
-				* step replay registers its run step). Remember the call so the
-				* output loop dispatches the completion itself instead of
-				* assuming the handler covered it.
-				*/
-				ownership.undispatched.add(call.id);
+				if (call.id != null && call.id !== "") if (dispatched === false) ownership.undispatched.add(call.id);
 				else ownership.handlerOwned.add(call.id);
 			} catch (handlerError) {
 				if (call.id != null && call.id !== "") (batchContext.errorOwnership ?? this.looseErrorOwnership).handlerOwned.add(call.id);
@@ -909,53 +588,6 @@ var ToolNode = class extends RunnableCallable {
 			});
 		}
 	}
-	/**
-	* Runs a single in-process tool call with the same lifecycle hooks
-	* the event-dispatch path fires (`PreToolUse`, `PermissionDenied`,
-	* `PostToolUse`, `PostToolUseFailure`). Used for any tool whose
-	* implementation lives in the SDK process — i.e. every entry in
-	* `directToolNames` — so host-supplied policy hooks gate
-	* direct-invoked tools the same way they gate dispatched ones.
-	*
-	* Fast path: when the registry has none of the relevant events
-	* registered for this run, falls through to `runTool` with zero
-	* extra work. The hook list is also checked via
-	* `hasHookFor(event, runId)`, which performs the registry's own
-	* O(1) shortcut.
-	*
-	* Hook semantics intentionally mirror `dispatchToolEvents` for the
-	* single-call case:
-	*   - `PreToolUse` returning `decision: 'deny'` synthesizes an error
-	*     `ToolMessage` and fires `PermissionDenied` (observational).
-	*   - `PreToolUse` returning `decision: 'ask'`:
-	*     • When `humanInTheLoop.enabled === true`: raises a real
-	*       `tool_approval` interrupt for this single tool call (the
-	*       same payload shape the event path produces). On resume:
-	*       `approve` runs the tool, `reject` blocks via
-	*       `blockDirectCall`, `respond` returns the host-supplied
-	*       `responseText` as a synthetic success ToolMessage,
-	*       `edit` re-runs with edited args. LangGraph re-enters
-	*       ToolNode.run from the start on resume. Reusable hooks fire
-	*       again; a consumed one-shot hook replays its pending approval
-	*       result. In both cases `interrupt()` consumes the resume value.
-	*     • When HITL is off: collapses to a fail-closed deny (matches
-	*       the rest of the SDK's HITL-disabled default). One-time
-	*       warning logged so hosts notice the gap.
-	*   - `PreToolUse.updatedInput` is applied to the call before
-	*     `runTool` runs; placeholder resolution inside `runTool` is
-	*     idempotent on already-resolved args.
-	*   - `PostToolUse.updatedOutput` replaces the returned
-	*     `ToolMessage` content (preserving id/name/status).
-	*   - `PostToolUseFailure` fires when `runTool` returns a
-	*     `ToolMessage` whose `status === 'error'`. Observational only;
-	*     the error message stays the source of truth.
-	*
-	* `PostToolBatch` aggregation across direct + dispatched outcomes is
-	* a separate concern: `dispatchToolEvents` accumulates batch entries
-	* locally and fires `PostToolBatch` at the end of its scope. Wiring
-	* direct-call entries into that aggregation crosses the two paths'
-	* scopes and is left to a follow-up.
-	*/
 	async runDirectToolWithLifecycleHooks(call, config, batchContext = {}) {
 		const replayController = this.toolMap.get(call.name)?.[SUBAGENT_REPLAY_CONTROLLER];
 		const replayConfig = replayController == null ? config : withSubagentReplayBatch(config, batchContext.replayBatchKey);
@@ -1152,15 +784,6 @@ var ToolNode = class extends RunnableCallable {
 				}
 			}
 		}
-		/**
-		* A hook (`PreToolUse.updatedInput`) or HITL `edit` decision rewrote the
-		* args: expose the EFFECTIVE args to downstream completion handling
-		* (`handleRunToolCompletions` reads this sink), so the emitted
-		* `tool_call.args` — and any intent/outcome label resolved from them —
-		* reflect what the tool actually ran with. `runTool`'s own placeholder
-		* substitution may overwrite this entry with the post-substitution args,
-		* which is strictly more accurate.
-		*/
 		if (effectiveCall !== call && batchContext.resolvedArgsByCallId != null && call.id != null && call.id !== "") batchContext.resolvedArgsByCallId.set(call.id, effectiveCall.args);
 		const output = await this.runTool(effectiveCall, replayConfig, {
 			...batchContext,
@@ -1230,13 +853,6 @@ var ToolNode = class extends RunnableCallable {
 		}
 		return persistOutput(output);
 	}
-	/**
-	* `ask` decisions on direct-path tools collapse to fail-closed deny
-	* only when `humanInTheLoop.enabled !== true` (i.e. there's no host
-	* UI configured to actually prompt the user). Logged once per process
-	* so the gap is visible. When HITL IS enabled, `ask` raises a real
-	* LangGraph `interrupt()` instead — see `runDirectToolWithLifecycleHooks`.
-	*/
 	askDirectWarningEmitted = false;
 	resolveAskDecisionForDirectTool(reason, toolName) {
 		if (!this.askDirectWarningEmitted) {
@@ -1245,12 +861,6 @@ var ToolNode = class extends RunnableCallable {
 		}
 		return reason ?? "Blocked by hook";
 	}
-	/**
-	* Synthesize a Blocked ToolMessage AND fire `PermissionDenied`
-	* (observational) for a direct-path tool call. Centralised so the
-	* deny path looks identical whether the block came from `'deny'` or
-	* from a fail-closed/`'reject'`/policy-violation path.
-	*/
 	blockDirectCall(args) {
 		const { call, resolvedArgs, reason, hookRegistry, runId, threadId } = args;
 		if (hookRegistry.hasHookFor("PermissionDenied", runId) === true) executeHooks({
@@ -1276,49 +886,17 @@ var ToolNode = class extends RunnableCallable {
 			tool_call_id: call.id ?? ""
 		});
 	}
-	/**
-	* Registers the full, raw output under `refKey` (when provided) and
-	* builds the per-message ref metadata stamped onto the resulting
-	* `ToolMessage.additional_kwargs`. The metadata is read at LLM-
-	* request time by `annotateMessagesForLLM` to produce a transient
-	* annotated copy of the message — the persisted `content` itself
-	* stays clean.
-	*
-	* @param registryContent  The full, untruncated output to store in
-	*   the registry so `{{tool<i>turn<n>}}` substitutions deliver the
-	*   complete payload. Ignored when `refKey` is undefined.
-	* @param refKey  Precomputed `tool<i>turn<n>` key, or undefined when
-	*   the output is not to be registered (errors, disabled feature,
-	*   unavailable batch/turn).
-	* @param unresolved  Placeholder keys that did not resolve; surfaced
-	*   to the LLM lazily so it can self-correct.
-	* @returns A `ToolMessageRefMetadata` object when there is anything
-	*   to stamp, otherwise `undefined`.
-	*/
 	recordOutputReference(runId, registryContent, refKey, unresolved) {
 		if (this.toolOutputRegistry != null && refKey != null) this.toolOutputRegistry.set(runId, refKey, registryContent);
 		if (refKey == null && unresolved.length === 0) return void 0;
 		const meta = {};
 		if (refKey != null) {
 			meta._refKey = refKey;
-			/**
-			* Stamp the registry scope alongside the key so the lazy
-			* annotation transform can look up the right bucket. Anonymous
-			* invocations get a synthetic per-batch scope (`\0anon-<n>`)
-			* that `attemptInvoke` cannot derive from
-			* `config.configurable.run_id` — without this, anonymous-run
-			* refs would silently fail registry lookup and the LLM would
-			* never see `[ref: …]` markers for outputs that were registered.
-			*/
 			if (runId != null) meta._refScope = runId;
 		}
 		if (unresolved.length > 0) meta._unresolvedRefs = unresolved;
 		return meta;
 	}
-	/**
-	* Builds code session context for injection into event-driven tool calls.
-	* Mirrors the session injection logic in runTool() for direct execution.
-	*/
 	getCodeSessionContext() {
 		if (!this.sessions) return;
 		const codeSession = this.sessions.get("execute_code");
@@ -1328,23 +906,10 @@ var ToolNode = class extends RunnableCallable {
 		if (codeSession.files && codeSession.files.length > 0) context.files = codeSession.files.map((file) => toInjectedFileRef(file, execSessionId));
 		return context;
 	}
-	/**
-	* Extracts code execution session context from tool results and stores in Graph.sessions.
-	* Mirrors the session storage logic in handleRunToolCompletions for direct execution.
-	*/
-	/**
-	* True when a tool's successful result should fold its returned exec
-	* `session_id` into the shared code session: built-in `CODE_EXECUTION_TOOLS`,
-	* plus host-declared sandbox-writing tools (`codeSessionToolNames`, e.g.
-	* create_file/edit_file). Kept name-scoped rather than a blanket artifact
-	* opt-in so only host-declared tools can influence the shared session.
-	*/
 	participatesInCodeSession(name) {
 		if (name === "") return false;
 		return CODE_EXECUTION_TOOLS.has(name) || this.codeSessionToolNames?.has(name) === true;
 	}
-	/** Delegates to the shared resolver so the direct and event-driven planning
-	*  paths derive the runtime session hint identically. */
 	resolveRuntimeSessionHint(config) {
 		return resolveRuntimeSessionHint(this.toolExecution, config.configurable?.thread_id);
 	}
@@ -1361,19 +926,6 @@ var ToolNode = class extends RunnableCallable {
 			updateCodeSession(this.sessions, execSessionId, artifact?.files);
 		}
 	}
-	/**
-	* Post-processes standard runTool outputs: dispatches ON_RUN_STEP_COMPLETED
-	* and stores code session context. Mirrors the completion handling in
-	* dispatchToolEvents for the event-driven path.
-	*
-	* By handling completions here in graph context (rather than in the
-	* stream consumer via ToolEndHandler), the race between the stream
-	* consumer and graph execution is eliminated.
-	*
-	* @param resolvedArgsByCallId  Per-batch resolved-args sink populated
-	*   by `runTool`. Threaded as a local map (instead of instance state)
-	*   so concurrent batches cannot read each other's entries.
-	*/
 	async handleRunToolCompletions(calls, outputs, config, resolvedArgsByCallId, errorOwnership) {
 		const ownership = errorOwnership ?? this.looseErrorOwnership;
 		for (let i = 0; i < calls.length; i++) {
@@ -1401,15 +953,7 @@ var ToolNode = class extends RunnableCallable {
 			if (isComputerCallOutputMessage(toolMessage)) contentString = truncateToolResultContent("[Computer screenshot omitted from completion event]", this.maxToolResultChars);
 			else if (typeof toolMessage.content === "string") contentString = toolMessage.content;
 			else contentString = serializeStructuredValueBounded(toolMessage.content, this.maxToolResultChars).content;
-			/**
-			* Prefer the post-substitution args when a `{{…}}` placeholder
-			* was resolved in `runTool`. This keeps
-			* `ON_RUN_STEP_COMPLETED.tool_call.args` consistent with what
-			* the tool actually received rather than leaking the template.
-			*/
 			const effectiveArgs = resolvedArgsByCallId?.get(toolCallId) ?? call.args;
-			/** Authored outcomes apply to failed calls too (“Search failed for…”);
-			*  without one, an error call simply stays unlabeled. */
 			const outcome = resolveToolOutcome(effectiveArgs, readOutcomeFields(toolMessage.artifact), { isError: toolMessage.status === "error" });
 			await safeDispatchCustomEvent("on_run_step_completed", { result: {
 				id: stepId,
@@ -1427,25 +971,6 @@ var ToolNode = class extends RunnableCallable {
 			} }, config);
 		}
 	}
-	/**
-	* Dispatches tool calls to the host via ON_TOOL_EXECUTE event and returns raw ToolMessages.
-	* Core logic for event-driven execution, separated from output shaping.
-	*
-	* Hook lifecycle (when `hookRegistry` is set):
-	* 1. **PreToolUse** fires per call in parallel before dispatch. Denied
-	*    calls produce error ToolMessages and fire **PermissionDenied**;
-	*    surviving calls proceed with optional `updatedInput`.
-	* 2. Surviving calls are dispatched to the host via `ON_TOOL_EXECUTE`.
-	* 3. **PostToolUse** / **PostToolUseFailure** fire per result. Post hooks
-	*    can replace tool output via `updatedOutput`.
-	* 4. Injected messages from results are collected and returned alongside
-	*    ToolMessages (appended AFTER to respect provider ordering).
-	*/
-	/** Rethrows a stream-limit trip carried on the batch config's composed
-	* signal. Rechecked at each later execution/dispatch stage because a tool
-	* that ignores cancellation can complete normally across the trip, and
-	* the next stage would otherwise start fresh side effects on a failed
-	* run. */
 	throwIfBreakerTripped(config) {
 		const signal = config.signal;
 		if (signal?.aborted === true && signal.reason instanceof StreamLimitExceededError) throw signal.reason;
@@ -1454,13 +979,6 @@ var ToolNode = class extends RunnableCallable {
 		this.throwIfBreakerTripped(config);
 		const { batchIndices, turn, batchScopeId, preResolvedArgs, preBatchSnapshot } = batchContext;
 		const runId = config.configurable?.run_id ?? "";
-		/**
-		* Registry-facing scope id — prefers the caller-threaded
-		* `batchScopeId` so anonymous batches target their own unique
-		* bucket and don't step on concurrent anonymous invocations.
-		* Hooks and event payloads keep using the empty-string coerced
-		* `runId` for backward compat.
-		*/
 		const registryRunId = batchScopeId ?? config.configurable?.run_id;
 		const threadId = config.configurable?.thread_id;
 		const registry = this.toolOutputRegistry;
@@ -1468,14 +986,6 @@ var ToolNode = class extends RunnableCallable {
 		const preToolCalls = toolCalls.map((call, i) => {
 			const originalArgs = call.args;
 			let resolvedArgs = originalArgs;
-			/**
-			* When the caller provided a pre-resolved map (the mixed
-			* direct+event path snapshots event args synchronously before
-			* awaiting directs so they can't accidentally resolve
-			* same-turn direct outputs), use those entries verbatim instead
-			* of re-resolving against a registry that may have changed
-			* since the batch started.
-			*/
 			const pre = call.id != null ? preResolvedArgs?.get(call.id) : void 0;
 			if (pre != null) {
 				resolvedArgs = pre.resolved;
@@ -1494,26 +1004,7 @@ var ToolNode = class extends RunnableCallable {
 		});
 		const messageByCallId = /* @__PURE__ */ new Map();
 		const approvedEntries = [];
-		/**
-		* Batch-level accumulator for `additionalContext` strings returned
-		* by any PreToolUse / PostToolUse / PostToolUseFailure hook in this
-		* dispatch. We emit one consolidated `HumanMessage` after all tool
-		* results land so the next model turn sees the injected context
-		* exactly once, ordered after the ToolMessages.
-		*/
 		const batchAdditionalContexts = [];
-		/**
-		* Batch-level outcome record keyed by `tool_call_id`. Captures
-		* every tool call's final result (success / error from the host,
-		* blocked from HITL deny / reject, substituted from HITL respond)
-		* across the three call sites that touch it. We materialize the
-		* `PostToolBatch` entry array in `toolCalls` order at dispatch
-		* time so hooks correlating outcomes by position see exactly the
-		* same sequence the model emitted — independent of when each
-		* outcome was recorded (deny entries land synchronously in the
-		* hook loop, approved entries land after host execution, respond
-		* entries land in the resume branch).
-		*/
 		const postToolBatchEntryByCallId = /* @__PURE__ */ new Map();
 		const HOOK_FALLBACK = Object.freeze({
 			additionalContexts: [],
@@ -1524,15 +1015,6 @@ var ToolNode = class extends RunnableCallable {
 		const approvalReplaySessionId = getToolApprovalReplaySessionId(config, runId);
 		const hasPendingApproval = preToolCalls.some((entry) => entry.call.id != null && hookRegistry?.getPendingToolApproval(approvalReplaySessionId, createToolApprovalReplayKey(config, this.executingAgentId ?? this.agentId ?? "", entry.call.id)) != null);
 		if (hookRegistry != null && (hookRegistry.hasHookFor("PreToolUse", runId) || hasPendingApproval)) {
-			/**
-			* Pull each call's prestarted eager record BEFORE awaiting the hooks:
-			* an async deny must never race the eager host promise into emitting a
-			* successful completion (`dispatchEagerToolCompletions`' map-identity
-			* check skips deleted records). Allowed entries get their record
-			* restored in the decision loop below so consumption still works;
-			* denied entries stay deleted. Ask/interrupt configs never have eager
-			* records (HITL disables the reservation gate).
-			*/
 			const preemptedEagerRecords = /* @__PURE__ */ new Map();
 			if (this.eagerEventToolExecutions != null) for (const entry of preToolCalls) {
 				const callId = entry.call.id;
@@ -1566,20 +1048,6 @@ var ToolNode = class extends RunnableCallable {
 					onceReplaySessionId: approvalReplaySessionId
 				}).catch(() => HOOK_FALLBACK);
 			}));
-			/**
-			* Side effects deferred from `blockEntry` until after any pending
-			* `interrupt()` resolves. Without deferral, a batch that mixes a
-			* `deny` decision with an `ask` decision would dispatch
-			* `ON_RUN_STEP_COMPLETED` for the denied tool on the FIRST node
-			* execution (before `interrupt()` throws), then dispatch the
-			* same event AGAIN on the resume re-execution — hosts would
-			* observe two completion events for one logical denial. By
-			* queueing the dispatch + PermissionDenied hook here and
-			* flushing after the interrupt block, we ensure each side effect
-			* fires exactly once: never on the first pass when interrupt
-			* throws (the flush is unreachable), once on resume / no-ask
-			* passes when control reaches the flush.
-			*/
 			const deferredBlockedSideEffects = [];
 			const blockEntry = (entry, reason) => {
 				const contentString = `Blocked: ${reason}`;
@@ -1594,15 +1062,6 @@ var ToolNode = class extends RunnableCallable {
 					toolInput: entry.args,
 					toolUseId: entry.call.id,
 					stepId: entry.stepId,
-					/**
-					* Records the pre-invocation turn count — the same value the
-					* executed path captures before incrementing `toolUsageCount`.
-					* For a blocked tool the counter is never incremented (no
-					* invocation happened), so this is always the count of prior
-					* successful invocations of this tool name in earlier batches.
-					* Surfaces in the `PostToolBatch` entry so batch hooks see
-					* a uniform shape regardless of outcome.
-					*/
 					turn: this.toolUsageCount.get(entry.call.name) ?? 0,
 					status: "error",
 					error: contentString
@@ -1614,13 +1073,6 @@ var ToolNode = class extends RunnableCallable {
 					contentString,
 					reason
 				});
-				/**
-				* A prestarted eager execution for a now-blocked call must neither be
-				* consumed nor emit its completion — the run reports this call as
-				* blocked. Deleting the record makes `dispatchEagerToolCompletions`'
-				* map-identity check skip the pending emission (same pattern as the
-				* rejected-results cleanup below).
-				*/
 				this.eagerEventToolExecutions?.delete(entry.call.id);
 			};
 			const flushDeferredBlockedSideEffects = async () => {
@@ -1645,19 +1097,6 @@ var ToolNode = class extends RunnableCallable {
 				}
 				deferredBlockedSideEffects.length = 0;
 			};
-			/**
-			* Apply a hook-supplied or host-supplied input override to a pending
-			* entry, re-running the `{{tool<i>turn<n>}}` resolver so any new
-			* placeholders introduced by the override are substituted (and any
-			* formerly-unresolved refs cleared from the unresolved set).
-			*
-			* Mixed direct+event batches must use the pre-batch snapshot so a
-			* hook-introduced placeholder cannot accidentally resolve to a
-			* same-turn direct output that has just registered. Pure event
-			* batches don't have a snapshot and resolve against the live
-			* registry — safe because no event-side registrations have happened
-			* yet.
-			*/
 			const applyInputOverride = (entry, nextArgs) => {
 				if (registry != null) {
 					const { resolved, unresolved } = (preBatchSnapshot ?? { resolve: (args, options) => registry.resolve(registryRunId, args, options) }).resolve(nextArgs, { substituteIntentKey: this.toolDeclaresBusinessIntent(entry.call.name) });
@@ -1678,29 +1117,10 @@ var ToolNode = class extends RunnableCallable {
 					continue;
 				}
 				if (hookResult.decision === "ask") {
-					/**
-					* HITL is OFF by default — hosts must explicitly opt in via
-					* `humanInTheLoop: { enabled: true }` to engage the
-					* `interrupt()` path. When opted out (or omitted), `ask`
-					* collapses into the pre-HITL fail-closed path: a blocked
-					* tool with an error `ToolMessage`. The default stays
-					* conservative until host UIs are ready to render
-					* `tool_approval` interrupts; see `HumanInTheLoopConfig`
-					* JSDoc for the full rationale and the migration plan.
-					*/
 					if (this.humanInTheLoop?.enabled !== true) {
 						blockEntry(entry, hookResult.reason ?? "Blocked by hook");
 						continue;
 					}
-					/**
-					* Apply `updatedInput` BEFORE queuing into `askEntries` —
-					* a hook is allowed to return both a sanitization rewrite
-					* and an `ask` decision (e.g. one matcher redacts secrets,
-					* another matcher requires approval). Without this, the
-					* interrupt payload would surface the original args to the
-					* reviewer AND the post-approve execution would run with
-					* the original args, silently dropping the hook's rewrite.
-					*/
 					if (hookResult.updatedInput != null) applyInputOverride(entry, hookResult.updatedInput);
 					askEntries.push({
 						entry,
@@ -1716,26 +1136,8 @@ var ToolNode = class extends RunnableCallable {
 				}
 				approvedEntries.push(entry);
 			}
-			/**
-			* If any entries asked for approval, raise a single LangGraph
-			* `interrupt()` carrying every pending request together. The host
-			* pauses, gathers human input, and resumes the run with one
-			* decision per request. On resume LangGraph re-executes this node
-			* from the start; `interrupt()` then returns the resume value
-			* instead of throwing. Reusable hooks rebuild their entries, while
-			* consumed one-shot hooks replay their pending approval aggregate.
-			*/
 			if (askEntries.length > 0) {
 				const payload = buildToolApprovalInterruptPayload(askEntries, runId);
-				/**
-				* `interrupt()` reads the current `RunnableConfig` from
-				* AsyncLocalStorage. ToolNode usually runs with tracing disabled
-				* (unless Langfuse explicitly enables it), so the upstream
-				* `runWithConfig` frame may not exist. Re-anchor here using the
-				* node's own `config` — Pregel hands us a config that already
-				* carries every checkpoint/scratchpad key `interrupt()` needs to
-				* suspend and resume.
-				*/
 				const resumeValue = AsyncLocalStorageProviderSingleton.runWithConfig(config, () => interrupt(payload));
 				for (const { entry } of askEntries) hookRegistry.clearPendingToolApproval(approvalReplaySessionId, createToolApprovalReplayKey(config, this.executingAgentId ?? this.agentId ?? "", entry.call.id));
 				const decisionByCallId = normalizeApprovalDecisions(askEntries.map(({ entry }) => entry.call.id), resumeValue);
@@ -1744,27 +1146,7 @@ var ToolNode = class extends RunnableCallable {
 						type: "reject",
 						reason: "No decision provided for tool approval"
 					};
-					/**
-					* Read `decision.type` through a widened view once: hosts
-					* deserialize resume payloads from untyped JSON, so the
-					* runtime value can be a typo, the wrong type, or missing
-					* entirely. Both the `allowedDecisions` enforcement
-					* immediately below and the unknown-type fallthrough at the
-					* end of this loop body share this single read so the
-					* fail-closed checks compare against the same source.
-					*/
 					const declaredType = decision.type;
-					/**
-					* Enforce the per-tool `allowedDecisions` allowlist that the
-					* `PreToolUse` hook surfaced in `review_configs`. The host
-					* UI is supposed to honor this when collecting the user's
-					* decision, but the wire is untrusted: a buggy or hostile
-					* host could submit a decision type the policy explicitly
-					* forbids (e.g. `'edit'` when the hook restricted to
-					* `['approve', 'reject']`), bypassing argument-mutation /
-					* response-substitution safeguards. Fail closed when the
-					* declared type isn't in the allowlist.
-					*/
 					if (allowedDecisions != null && (typeof declaredType !== "string" || !allowedDecisions.includes(declaredType))) {
 						blockEntry(entry, `Decision "${typeof declaredType === "string" ? declaredType : "<missing>"}" not in allowedDecisions [${allowedDecisions.join(", ")}] — failing closed`);
 						continue;
@@ -1773,38 +1155,12 @@ var ToolNode = class extends RunnableCallable {
 						blockEntry(entry, decision.reason ?? askReason ?? "Rejected by user");
 						continue;
 					}
-					/**
-					* `respond` short-circuits tool execution: the human supplies
-					* the result the model should see in place of running the
-					* tool. We emit a successful `ToolMessage` directly and skip
-					* dispatch — no host event fires, no real tool side effect
-					* occurs. Mirrors LangChain HITL middleware semantics.
-					*/
 					if (decision.type === "respond") {
-						/**
-						* Validate the wire shape before touching it: hosts
-						* deserialize resume payloads from untyped JSON, so a
-						* malformed `{ type: 'respond' }` (no `responseText`) or
-						* `{ type: 'respond', responseText: 42 }` would crash
-						* `truncateToolResultContent` (which calls
-						* `content.length`) and turn a fail-closed approval path
-						* into a hard run failure. Route bad shapes through
-						* `blockEntry` like any other unusable decision.
-						*/
 						const responseText = decision.responseText;
 						if (typeof responseText !== "string") {
 							blockEntry(entry, `Decision "respond" missing string responseText (got ${describeOfferedShape(responseText)}) — failing closed`);
 							continue;
 						}
-						/**
-						* Truncate the human-supplied text just like the success
-						* path does for real tool output. Without this, a user
-						* pasting a large document as a manual response bypasses
-						* `maxToolResultChars` and can blow past the model's
-						* context window. The PostToolBatch entry surfaces the
-						* truncated text too so batch hooks see what the model
-						* will actually see.
-						*/
 						const truncatedResponse = truncateToolResultContent(responseText, this.maxToolResultChars);
 						messageByCallId.set(entry.call.id, new ToolMessage({
 							status: "success",
@@ -1821,30 +1177,10 @@ var ToolNode = class extends RunnableCallable {
 							status: "success",
 							toolOutput: truncatedResponse
 						});
-						/**
-						* Safe to dispatch immediately — unlike `blockEntry` which
-						* defers, `respond` only executes inside the decision-
-						* processing loop, which is reachable only AFTER
-						* `interrupt()` has returned (the resume pass). There is
-						* no risk of being rolled back by a subsequent throw, so
-						* no risk of a duplicate `ON_RUN_STEP_COMPLETED` event.
-						*/
 						await this.dispatchStepCompleted(entry.call.id, entry.call.name, entry.args, truncatedResponse, config);
 						continue;
 					}
 					if (decision.type === "edit") {
-						/**
-						* Validate the wire shape before touching it: hosts
-						* deserialize resume payloads from untyped JSON, so a
-						* malformed `{ type: 'edit' }` (no `updatedInput`),
-						* `{ type: 'edit', updatedInput: 'string' }` (non-object),
-						* or `{ type: 'edit', updatedInput: [...] }` (array, not a
-						* plain object) would feed garbage into
-						* `applyInputOverride` and silently approve a tool with
-						* undefined / wrong-shape args. Same trust boundary as
-						* the `respond` validation above — fail closed via
-						* `blockEntry` with a diagnostic.
-						*/
 						const updatedInput = decision.updatedInput;
 						if (updatedInput === null || typeof updatedInput !== "object" || Array.isArray(updatedInput)) {
 							blockEntry(entry, `Decision "edit" missing object updatedInput (got ${describeOfferedShape(updatedInput)}) — failing closed`);
@@ -1854,19 +1190,6 @@ var ToolNode = class extends RunnableCallable {
 						approvedEntries.push(entry);
 						continue;
 					}
-					/**
-					* Defensive type widening: hosts deserialize resume payloads
-					* from untyped JSON, so the `decision.type` value at runtime
-					* is whatever string the wire sent — not necessarily one of
-					* the four union variants TS knows about. We compare against
-					* the literal `'approve'` through the widened `declaredType`
-					* captured at the top of this iteration, so a typo or schema
-					* drift (`'aproved'`, `null`, `undefined`) hits the fail-
-					* closed branch below instead of silently approving the
-					* tool. Without this widening, TS narrows the union after
-					* the three earlier branches and treats `=== 'approve'` as
-					* trivially true.
-					*/
 					if (declaredType === "approve") {
 						approvedEntries.push(entry);
 						continue;
@@ -1874,18 +1197,6 @@ var ToolNode = class extends RunnableCallable {
 					blockEntry(entry, `Unknown approval decision type "${typeof declaredType === "string" ? declaredType : "<missing>"}" — failing closed`);
 				}
 			}
-			/**
-			* Flush deferred denial side effects exactly once. On the FIRST
-			* pass through a batch that contains an `ask`, `interrupt()`
-			* threw above and we never reach this line — so no
-			* `ON_RUN_STEP_COMPLETED` / `PermissionDenied` events fire
-			* for blocked tools yet. On resume the node re-executes from
-			* scratch, `blockEntry` re-queues the same entries, and the
-			* flush below dispatches them once. For batches without any
-			* `ask` (deny-only or empty), the flush still runs here and
-			* dispatches in the same relative position as the pre-deferral
-			* code did (after hook processing, before tool execution).
-			*/
 			await flushDeferredBlockedSideEffects();
 		} else approvedEntries.push(...preToolCalls);
 		const injected = [];
@@ -1925,33 +1236,13 @@ var ToolNode = class extends RunnableCallable {
 				});
 				else dispatchRequests.push(request);
 			}
-			/**
-			* Per-call completion fast-path: when the host reports a result
-			* through `onResult` before the batch resolves, emit that call's
-			* completed run step immediately instead of waiting for the slowest
-			* call in the batch. Safe only when nothing can change the result
-			* after execution — post-tool hooks may rewrite output and HITL may
-			* deny a call, so those configurations keep batch-time emission.
-			* Ids are claimed synchronously before the async dispatch and
-			* released if the dispatch fails, letting the batch path re-emit.
-			*/
 			const canEmitEarlyCompletions = this.hookRegistry?.hasResultAlteringHooks(runId) !== true && this.humanInTheLoop?.enabled !== true;
-			/**
-			* Snapshot the post-hook gates at the same instant as the early-emission
-			* gate: a result-altering hook registered while this batch is in flight
-			* applies from the NEXT batch. Evaluating these after results settle
-			* would let a late hook rewrite the ToolMessage AFTER an early
-			* completion already emitted the pre-hook output — two views of the
-			* same call.
-			*/
 			const hasPostHook = this.hookRegistry?.hasHookFor("PostToolUse", runId) === true;
 			const hasFailureHook = this.hookRegistry?.hasHookFor("PostToolUseFailure", runId) === true;
 			const earlyCompletionDispatchedIds = /* @__PURE__ */ new Set();
 			const earlyCompletionDispatches = [];
 			const dispatchRequestById = new Map(dispatchRequests.map((request) => [request.id, request]));
 			const onResult = (result) => {
-				/** Runtime-honest widening: hosts may omit the id despite the
-				* field type. */
 				const resultToolCallId = result.toolCallId;
 				const request = resultToolCallId != null ? dispatchRequestById.get(resultToolCallId) : void 0;
 				if (request == null || earlyCompletionDispatchedIds.has(result.toolCallId)) return;
@@ -1962,9 +1253,6 @@ var ToolNode = class extends RunnableCallable {
 					earlyCompletionDispatchedIds.delete(result.toolCallId);
 				}));
 			};
-			/** The approval hooks above are awaited; a sibling's trip during them
-			* must stop the approved batch before it reaches a host handler that
-			* may never inspect the request signal. */
 			if (dispatchRequests.length > 0) this.throwIfBreakerTripped(config);
 			const dispatchPromise = dispatchRequests.length === 0 ? Promise.resolve([]) : new Promise((resolve, reject) => {
 				let dispatchSettled = false;
@@ -2019,24 +1307,9 @@ var ToolNode = class extends RunnableCallable {
 				const toolName = request?.name ?? "unknown";
 				let contentString;
 				let toolMessage;
-				/**
-				* Tracks the post-PostToolUse-hook output so the
-				* `PostToolBatch` entry below sees the final transformed value
-				* even when a hook replaced the original via `updatedOutput`.
-				* Lives at the loop-iteration scope so the success branch can
-				* mutate it; the error branch leaves it unset (and the batch
-				* entry uses `error` instead of `toolOutput` in that case).
-				*/
 				let finalToolOutput = result.content;
 				if (result.status === "error") {
 					contentString = truncateToolResultContent(`Error: ${result.errorMessage ?? "Unknown error"}\n Please fix your mistakes.`, this.maxToolResultChars);
-					/**
-					* Error results bypass registration but stamp the
-					* unresolved-refs hint into `additional_kwargs` so the lazy
-					* annotation transform surfaces it to the LLM at request
-					* time, letting the model self-correct when its reference
-					* key caused the failure. Persisted `content` stays clean.
-					*/
 					const unresolved = unresolvedByCallId.get(result.toolCallId) ?? [];
 					const errorRefMeta = unresolved.length > 0 ? this.recordOutputReference(registryRunId, contentString, void 0, unresolved) : void 0;
 					toolMessage = new ToolMessage({
@@ -2065,15 +1338,6 @@ var ToolNode = class extends RunnableCallable {
 							sessionId: runId,
 							matchQuery: toolName
 						}).catch(() => void 0);
-						/**
-						* Collect `additionalContext` from failure hooks too. Without
-						* this, recovery guidance returned on tool errors (e.g.
-						* "if this tool errors with X, suggest Y to the user") is
-						* silently dropped even though the API surface advertises
-						* `additionalContext` for this event. PostToolUseFailure
-						* remains observational for errors thrown by the hook
-						* itself, but a successfully-returned result is honored.
-						*/
 						if (failureHookResult != null) for (const ctx of failureHookResult.additionalContexts) batchAdditionalContexts.push(ctx);
 					}
 				} else {
@@ -2107,14 +1371,6 @@ var ToolNode = class extends RunnableCallable {
 							registryRaw = serialized.registryContent;
 							contentString = serialized.content;
 							finalToolOutput = hookResult.updatedOutput;
-							/**
-							* The hook ACTUALLY rewrote this output: any completion the
-							* stream already emitted for the consumed eager result showed
-							* the raw content, so un-mark it and let the dispatch below
-							* re-emit the corrected version. Hooks that merely observe or
-							* add context leave the original emission final — no
-							* duplicates.
-							*/
 							eagerCompletionDispatchedIds.delete(result.toolCallId);
 						}
 					}
@@ -2156,7 +1412,6 @@ var ToolNode = class extends RunnableCallable {
 			injected
 		};
 	}
-	/** Run-scoped so another run's session hooks can't flip this run's gate. */
 	canConsumeEagerEventExecution(runId) {
 		return this.eventDrivenMode && this.eagerEventToolExecution?.enabled === true && this.hookRegistry?.hasResultAlteringHooks(runId) !== true && this.humanInTheLoop?.enabled !== true;
 	}
@@ -2196,24 +1451,6 @@ var ToolNode = class extends RunnableCallable {
 			errorMessage: "Tool execution completed without a result for this tool call"
 		}];
 	}
-	/**
-	* Fires the `PostToolBatch` hook (if registered) and appends the
-	* accumulated batch-level `additionalContext` strings to `injected`
-	* as a single `HumanMessage`. Entries are materialized in the
-	* original `toolCalls` order so hooks correlating outcomes by
-	* position (as the type docs promise) see exactly the sequence
-	* the model emitted, regardless of when each individual outcome
-	* was recorded into the map (deny synchronous, approved
-	* post-execution, respond on resume).
-	*
-	* The PostToolBatch hook's `additionalContexts` flow into the same
-	* batch accumulator per-tool hooks already use, so a single
-	* batch-level convention message can be injected through one path.
-	*
-	* Mutates `batchAdditionalContexts` (push from batch hook) and
-	* `injected` (push the consolidated HumanMessage). The caller owns
-	* those arrays and consumes them right after this returns.
-	*/
 	async dispatchPostToolBatchAndInjectContext(args) {
 		const { toolCalls, entriesByCallId, batchAdditionalContexts, injected, runId, threadId } = args;
 		const orderedBatchEntries = [];
@@ -2242,40 +1479,19 @@ var ToolNode = class extends RunnableCallable {
 				for (const msg of batchHookResult.injectedMessages) hookInjectedMessages.push(msg);
 			}
 		}
-		if (batchAdditionalContexts.length > 0)
- /**
-		* `HumanMessage` carrying a metadata `role: 'system'` marker —
-		* see `convertInjectedMessages` for the wider rationale. Anthropic
-		* and Google reject mid-conversation `SystemMessage`s, so we use
-		* a user-role message and surface the system intent through
-		* `additional_kwargs` for hosts inspecting state. The model sees
-		* a user message; `role` is metadata only.
-		*/
-		injected.push(new HumanMessage({
+		if (batchAdditionalContexts.length > 0) injected.push(new HumanMessage({
 			content: batchAdditionalContexts.join("\n\n"),
 			additional_kwargs: {
 				role: "system",
 				source: "hook"
 			}
 		}));
-		/**
-		* Hook-returned `injectedMessages` land AFTER the consolidated context
-		* message: one converted `HumanMessage` per entry (role/source kept in
-		* `additional_kwargs`), preserving per-message identity so verbatim
-		* user speech (e.g. steering) sits closest to the next model call.
-		*/
 		if (hookInjectedMessages.length > 0) try {
 			injected.push(...convertInjectedMessages(hookInjectedMessages));
 		} catch (e) {
 			console.warn("[ToolNode] Failed to convert PostToolBatch injectedMessages:", e instanceof Error ? e.message : e);
 		}
 	}
-	/**
-	* Whether `name`'s own schema declares a BUSINESS parameter called
-	* `intent` (declared, and not the injected label contract — see
-	* `isIntentLabelProperty`). Such a parameter must keep participating in
-	* `{{tool…}}` placeholder substitution; only the display label is exempt.
-	*/
 	toolDeclaresBusinessIntent(name) {
 		const instance = this.toolMap.get(name);
 		const instanceProp = instance?.schema?.properties?.["intent"] ?? instance?.schema?.shape?.["intent"];
@@ -2302,50 +1518,10 @@ var ToolNode = class extends RunnableCallable {
 			completed_at: Date.now()
 		} }, config) !== false;
 	}
-	/**
-	* Emits the completed run step for a single host-reported result before
-	* the batch resolves. Mirrors the batch loop's output formatting exactly;
-	* callers gate on the no-hooks/no-HITL configuration, so the raw result
-	* content here is also the final content. Returns whether the event was
-	* actually dispatched so the caller can fall back to batch-time emission.
-	*/
 	async dispatchEarlyToolCompletion(result, request, config) {
 		const output = result.status === "error" ? truncateToolResultContent(`Error: ${result.errorMessage ?? "Unknown error"}\n Please fix your mistakes.`, this.maxToolResultChars) : serializeToolOutputWithinLimits(result.content, this.maxToolResultChars).content;
 		return this.dispatchStepCompleted(result.toolCallId, request.name, request.args, output, config, request.turn, resolveToolOutcome(request.args, outcomeFieldsFromResult(result), { isError: result.status === "error" }));
 	}
-	/**
-	* Execute a group of direct (in-process) tool calls with interrupt-safe
-	* ordering, returning outputs aligned 1:1 with `directCalls`.
-	*
-	* Fast path (the common case): when no call in the group is in
-	* `interruptingToolNames`, this is a single `Promise.all` — byte-for-byte
-	* the prior behavior, so ordinary batches are unaffected.
-	*
-	* Interrupt-safe path: when the group contains an interrupting tool (e.g.
-	* `ask_user_question`, whose body raises a LangGraph `interrupt()` to
-	* collect a human answer), the interrupting calls run as their own awaited
-	* group **first**; only after they all settle without interrupting do the
-	* remaining (potentially non-idempotent) siblings run. If an interrupting
-	* call throws a `GraphInterrupt`, the `await` below rejects and unwinds the
-	* whole ToolNode *before* any non-interrupting sibling has started — so a
-	* sibling with real side effects (send_email, billing) never executes on
-	* the first pass. Terminal interrupting siblings are cached by call id, so
-	* LangGraph replay reuses their complete lifecycle output instead of
-	* repeating model calls, hooks, or side effects.
-	*
-	* Without this ordering, a flat `Promise.all` starts every sibling
-	* concurrently, so a non-idempotent sibling can complete its side effect
-	* before the interrupt unwinds and then run a SECOND time on resume — the
-	* duplicate side effect this method exists to prevent. A tool that actually
-	* suspends re-enters until it reaches a terminal result; siblings that
-	* already settled do not re-enter.
-	*
-	* `batchIndices[i]` is `directCalls[i]`'s position within the parent
-	* ToolNode batch (used for `{{tool<i>turn<n>}}` registration); it is
-	* preserved regardless of execution order. `baseContext` carries the
-	* batch-scoped fields every call shares; `batchIndex` is filled in
-	* per-call here.
-	*/
 	async runDirectBatchInterruptSafe(directCalls, batchIndices, config, baseContext) {
 		const settledBatchResults = baseContext.replayBatchKey == null ? void 0 : this.settledInterruptingResults.get(baseContext.replayBatchKey);
 		const restoreResult = (call, result) => {
@@ -2377,9 +1553,6 @@ var ToolNode = class extends RunnableCallable {
 		for (let i = 0; i < directCalls.length; i++) if (interrupting.has(directCalls[i].name)) interruptingPositions.push(i);
 		else regularPositions.push(i);
 		const interruptingResults = await Promise.allSettled(interruptingPositions.map((i) => runOne(directCalls[i], i)));
-		/** A sibling may have tripped the run-wide breaker while another raised
-		* a GraphInterrupt. Safety failures take precedence over approval pauses
-		* regardless of input order. */
 		this.throwIfBreakerTripped(config);
 		let hasInterruptingError = false;
 		let interruptingError;
@@ -2429,9 +1602,6 @@ var ToolNode = class extends RunnableCallable {
 			}
 			throw interruptingError;
 		}
-		/** The breaker can trip while the interrupting group is awaited — e.g.
-		* a tool that ignores cancellation and completes normally. Recheck
-		* before starting the non-idempotent siblings. */
 		this.throwIfBreakerTripped(config);
 		const regularOutputs = await Promise.all(regularPositions.map((i) => runOne(directCalls[i], i)));
 		regularPositions.forEach((i, k) => {
@@ -2439,34 +1609,14 @@ var ToolNode = class extends RunnableCallable {
 		});
 		return outputs;
 	}
-	/**
-	* Execute all tool calls via ON_TOOL_EXECUTE event dispatch.
-	* Injected messages are placed AFTER ToolMessages to respect provider
-	* message ordering (AIMessage tool_calls must be immediately followed
-	* by their ToolMessage results).
-	*
-	* `batchIndices` mirrors `toolCalls` and carries each call's position
-	* within the parent batch. `turn` is the per-`run()` batch index
-	* captured locally by the caller. Both are threaded so concurrent
-	* invocations cannot race on shared mutable state.
-	*/
 	async executeViaEvent(toolCalls, config, input, batchContext = {}) {
 		const { toolMessages, injected } = await this.dispatchToolEvents(toolCalls, config, batchContext);
 		const outputs = [...toolMessages, ...injected];
 		return Array.isArray(input) ? outputs : { messages: outputs };
 	}
 	async run(input, config) {
-		/**
-		* Breaker read once at batch entry: every downstream path (direct
-		* `tool.invoke` runtimes and the ON_TOOL_EXECUTE dispatch) inherits this
-		* config, and a graph reset mid-batch must not detach in-flight tools
-		* from an already-tripped signal.
-		*/
 		const breakerSignal = this.getBreakerSignal?.();
 		const composedSignal = composeAbortSignals(config.signal, breakerSignal);
-		/** Immutable batch scope, captured with the signal BEFORE hooks: tools
-		* that spawn runs (subagents) bind their child to this controller, so a
-		* reset during a PreToolUse hook cannot hand them the new run's one. */
 		const batchRunScope = this.getRunScope?.();
 		if (composedSignal !== config.signal || batchRunScope != null) config = {
 			...config,
@@ -2476,41 +1626,16 @@ var ToolNode = class extends RunnableCallable {
 				["lc_run_breaker_scope"]: batchRunScope
 			} }
 		};
-		/** Already-tripped-at-entry: a parallel sibling's breach failed the run
-		* before this batch was scheduled. Rethrow before hooks, direct
-		* `tool.invoke` calls, or ON_TOOL_EXECUTE dispatch — a tool or host
-		* handler that doesn't synchronously inspect an aborted signal would
-		* otherwise perform side effects on a failed run. */
 		if (composedSignal?.aborted === true && composedSignal.reason instanceof StreamLimitExceededError) throw composedSignal.reason;
 		this.toolCallTurns.clear();
-		/**
-		* Per-batch local map for resolved (post-substitution) args.
-		* Lives on the stack so concurrent `run()` calls on the same
-		* ToolNode cannot read or wipe each other's entries.
-		*/
 		const resolvedArgsByCallId = /* @__PURE__ */ new Map();
-		/** Per-invocation error-completion ownership — see `ToolErrorOwnership`. */
 		const errorOwnership = createToolErrorOwnership();
-		/**
-		* Claim this batch's turn synchronously from the registry (or
-		* fall back to 0 when the feature is disabled). The registry is
-		* partitioned by scope id so overlapping batches cannot
-		* overwrite each other's state even under a shared registry.
-		*
-		* For anonymous callers (no `run_id` in config), mint a unique
-		* per-batch scope id so two concurrent anonymous invocations
-		* don't target the same bucket. The scope is threaded down to
-		* every subsequent registry call on this batch.
-		*/
 		const incomingRunId = config.configurable?.run_id;
 		const incomingThreadId = config.configurable?.thread_id;
 		const batchScopeId = incomingRunId ?? `\0anon-${this.anonBatchCounter++}`;
 		const turn = this.toolOutputRegistry?.nextTurn(batchScopeId) ?? 0;
 		let outputs;
 		let replayBatchKey;
-		/** Hoisted from the messages-state branch so the Command tail can carry
-		*  the promotion into handoff updates (same-id state copies there would
-		*  otherwise overwrite the replacement message). */
 		let promotedAiMessage;
 		let invalidCallResults = [];
 		if (this.isSendInput(input)) {
@@ -2560,12 +1685,6 @@ var ToolNode = class extends RunnableCallable {
 				this.programmaticCache = void 0;
 			}
 			const filteredCalls = aiMessage.tool_calls?.filter((call) => {
-				/**
-				* Filter out:
-				* 1. Already processed tool calls (present in toolMessageIds)
-				* 2. Server tool calls (e.g., web_search with IDs starting with 'srvtoolu_')
-				*    which are executed by the provider's API and don't require invocation
-				*/
 				return (call.id == null || !toolMessageIds.has(call.id)) && !(call.id?.startsWith("srvtoolu_") ?? false);
 			}) ?? [];
 			const attributableInvalidCalls = !(!Array.isArray(input) && typeof aiMessage.id === "string" && aiMessage.id.length > 0) ? [] : (aiMessage.invalid_tool_calls ?? []).filter((call) => call.id != null && call.id !== "" && !toolMessageIds.has(call.id) && !call.id.startsWith("srvtoolu_"));
@@ -2576,20 +1695,6 @@ var ToolNode = class extends RunnableCallable {
 				name: normalizeInvalidCallName(call.name),
 				tool_call_id: call.id
 			}));
-			/**
-			* Promote the answered invalid calls into well-formed `tool_calls` on a
-			* REPLACEMENT copy of the AI message (`messagesStateReducer` upserts by
-			* id). Without this, provider converters that rebuild the call side of
-			* the wire from `tool_calls` — OpenAI Completions `tool_calls`, OpenAI
-			* Responses `function_call` items, Gemini/Bedrock function-call parts —
-			* drop the invalid call while the synthesized result above still
-			* references it, inverting the dangling-pair rejection (an output whose
-			* call is missing). Promoting at this single seam keeps the call and
-			* result sides agreeing for EVERY provider; args become `{}` (the raw
-			* string never parsed — the paired error result tells the model why).
-			* Skipped when the message has no id: the reducer would append a
-			* duplicate instead of replacing, which is worse than the dangle.
-			*/
 			promotedAiMessage = attributableInvalidCalls.length > 0 ? new AIMessage({
 				id: aiMessage.id,
 				content: sanitizeInvalidToolUseBlocks(aiMessage.content, attributableInvalidCalls),
@@ -2628,27 +1733,7 @@ var ToolNode = class extends RunnableCallable {
 				const directIndices = directEntries.map((e) => e.batchIndex);
 				const eventCalls = eventEntries.map((e) => e.call);
 				const eventIndices = eventEntries.map((e) => e.batchIndex);
-				/**
-				* Snapshot the event calls' args against the *pre-batch*
-				* registry state synchronously, before any await runs. The
-				* directs are then awaited first (preserving fail-fast
-				* semantics — a thrown error in a direct tool, e.g. with
-				* `handleToolErrors=false` or a `GraphInterrupt`, aborts
-				* before we dispatch any event-driven tools to the host).
-				* Because the event args were captured pre-await, they stay
-				* isolated from same-turn direct outputs that register
-				* during the await.
-				*/
 				const preResolvedEventArgs = /* @__PURE__ */ new Map();
-				/**
-				* Take a frozen snapshot of the registry state before any
-				* direct registrations land. The snapshot resolves
-				* placeholders against this point-in-time view, so a
-				* `PreToolUse` hook later rewriting event args via
-				* `updatedInput` can introduce placeholders that resolve
-				* cross-batch (against prior runs) without ever picking up
-				* same-turn direct outputs.
-				*/
 				const preBatchSnapshot = this.toolOutputRegistry?.snapshot(batchScopeId);
 				if (preBatchSnapshot != null) {
 					for (const entry of eventEntries) if (entry.call.id != null) {
@@ -2728,15 +1813,6 @@ var ToolNode = class extends RunnableCallable {
 					...invalidCallResults
 				];
 			}
-			/**
-			* Resolve the streamed tool-call cards for invalid calls, best-effort.
-			* Runs AFTER the direct batch settled: on an interrupting first pass
-			* this line is unreachable (the node unwound), so interrupt/resume
-			* flows emit the completion exactly once — same reasoning as the
-			* deferred blocked-call side effects. Skipped when the stream never
-			* registered a step for the call (non-streaming providers), where a
-			* completion could not be routed to a card anyway.
-			*/
 			for (const result of invalidCallResults) {
 				const invalidStepId = this.toolCallStepIds?.get(result.tool_call_id);
 				if (invalidStepId == null || invalidStepId === "") continue;
@@ -2747,64 +1823,28 @@ var ToolNode = class extends RunnableCallable {
 			if (replayBatchKey != null) this.settledInterruptingResults.delete(replayBatchKey);
 			return Array.isArray(input) ? outputs : { messages: outputs };
 		}
-		/**
-		* Carry the invalid-call promotion into handoff commands. A handoff
-		* tool's Command snapshots `update.messages` from the PRE-promotion
-		* state (MultiAgentGraph builds a filtered same-id copy of the original
-		* AI message), and commands apply after the sibling reducer updates —
-		* so the stale copy would overwrite the replacement message, and a
-		* Send handoff's child state could omit the synthesized results
-		* entirely. Patch each command's same-id AI message with the promotion
-		* and append any missing synthesized results.
-		*/
 		if (promotedAiMessage != null) outputs = outputs.map((output) => isCommand(output) ? patchCommandUpdateForPromotedInvalidCalls(output, promotedAiMessage, invalidCallResults) : output);
 		const combinedOutputs = [];
 		let parentCommand = null;
-		/**
-		* Collect handoff commands (Commands with string goto and Command.PARENT)
-		* for potential parallel handoff aggregation
-		*/
 		const handoffCommands = [];
 		const nonCommandOutputs = [];
-		for (const output of outputs) if (isCommand(output)) if (output.graph === Command.PARENT && Array.isArray(output.goto) && output.goto.every((send) => isSend(send)))
- /** Aggregate Send-based commands */
-		if (parentCommand) parentCommand.goto.push(...output.goto);
+		for (const output of outputs) if (isCommand(output)) if (output.graph === Command.PARENT && Array.isArray(output.goto) && output.goto.every((send) => isSend(send))) if (parentCommand) parentCommand.goto.push(...output.goto);
 		else parentCommand = new Command({
 			graph: Command.PARENT,
 			goto: output.goto
 		});
 		else if (output.graph === Command.PARENT) {
-			/**
-			* Handoff Command with destination.
-			* Handle both string ('agent') and array (['agent']) formats.
-			* Collect for potential parallel aggregation.
-			*/
 			const goto = output.goto;
 			const isSingleStringDest = typeof goto === "string";
 			const isSingleArrayDest = Array.isArray(goto) && goto.length === 1 && typeof goto[0] === "string";
 			if (isSingleStringDest || isSingleArrayDest) handoffCommands.push(output);
-			else
- /** Multi-destination or other command - pass through */
-			combinedOutputs.push(output);
-		} else
- /** Other commands - pass through */
-		combinedOutputs.push(output);
+			else combinedOutputs.push(output);
+		} else combinedOutputs.push(output);
 		else {
 			nonCommandOutputs.push(output);
 			combinedOutputs.push(Array.isArray(input) ? [output] : { messages: [output] });
 		}
-		/**
-		* Handle handoff commands - convert to Send objects for parallel execution
-		* when multiple handoffs are requested
-		*/
 		if (handoffCommands.length > 1) {
-			/**
-			* Multiple parallel handoffs - convert to Send objects.
-			* Each Send carries its own state with the appropriate messages.
-			* This enables LLM-initiated parallel execution when calling multiple
-			* transfer tools simultaneously.
-			*/
-			/** Collect all destinations for sibling tracking */
 			const allDestinations = handoffCommands.map((cmd) => {
 				const goto = cmd.goto;
 				return typeof goto === "string" ? goto : goto[0];
@@ -2813,7 +1853,6 @@ var ToolNode = class extends RunnableCallable {
 			const parallelGroupId = getRuntimeHandoffGroupId(parallelBatch);
 			const sends = handoffCommands.map((cmd, idx) => {
 				const destination = allDestinations[idx];
-				/** Get siblings (other destinations, not this one) */
 				const siblings = allDestinations.filter((d) => d !== destination);
 				const update = cmd.update;
 				const handoffMessage = update?.messages ? findHandoffMessage(update.messages, destination) : void 0;
@@ -2829,9 +1868,7 @@ var ToolNode = class extends RunnableCallable {
 				goto: sends
 			});
 			combinedOutputs.push(parallelCommand);
-		} else if (handoffCommands.length === 1)
- /** Single handoff - pass through as-is */
-		combinedOutputs.push(handoffCommands[0]);
+		} else if (handoffCommands.length === 1) combinedOutputs.push(handoffCommands[0]);
 		if (parentCommand) combinedOutputs.push(parentCommand);
 		if (replayBatchKey != null) this.settledInterruptingResults.delete(replayBatchKey);
 		return combinedOutputs;
@@ -2847,17 +1884,6 @@ function areToolCallsInvoked(message, invokedToolIds) {
 	if (!invokedToolIds || invokedToolIds.size === 0) return false;
 	return message.tool_calls?.every((toolCall) => toolCall.id != null && invokedToolIds.has(toolCall.id)) ?? false;
 }
-/**
-* Normalize the `tool_use` content blocks of promoted invalid calls so the
-* replacement AI message is valid on EVERY provider surface, not just
-* `tool_calls`. Anthropic formats an array-content AI message from its blocks
-* verbatim, and a call whose streamed `input_json` never parsed leaves the
-* block's `input` as the raw accumulated STRING — replayed as-is, the API
-* rejects it with `tool_use.input: Input should be an object` before pairing
-* is even checked. Blocks matching a promoted call id get `input: {}`
-* (mirroring the promoted args); everything else passes through untouched.
-* String content (OpenAI-style) is returned as-is.
-*/
 function sanitizeInvalidToolUseBlocks(content, promotedCalls) {
 	if (!Array.isArray(content)) return content;
 	const promotedNamesById = new Map(promotedCalls.filter((call) => call.id != null).map((call) => [call.id, normalizeInvalidCallName(call.name)]));
@@ -2866,9 +1892,6 @@ function sanitizeInvalidToolUseBlocks(content, promotedCalls) {
 		const toolUse = block;
 		if (toolUse.id == null || !promotedNamesById.has(toolUse.id)) return block;
 		const inputIsObject = typeof toolUse.input === "object" && toolUse.input != null && !Array.isArray(toolUse.input);
-		/** `name` normalizes with the SAME fallback the promoted `tool_calls`
-		*  entry uses — a nameless block would fail provider validation on its
-		*  own even with a valid input. */
 		const nameIsValid = typeof toolUse.name === "string" && toolUse.name !== "";
 		if (inputIsObject && nameIsValid) return block;
 		return {
@@ -2878,41 +1901,9 @@ function sanitizeInvalidToolUseBlocks(content, promotedCalls) {
 		};
 	});
 }
-/**
-* Name fallback for attributable invalid calls, shared by every surface that
-* materializes them (synthesized result, promoted tool_calls entry, sanitized
-* block, handoff patch): `''` is normalized like `undefined` — providers
-* reject nameless calls, so an empty string would defeat the promotion.
-*
-* INVARIANT MAP — a tool call lives in several parallel representations, and
-* any surface that materializes, copies, filters, routes on, or reports one
-* must keep ALL of them agreeing (`tool_calls`, `invalid_tool_calls`,
-* provider content blocks, paired results). The attribution predicate is:
-* id-bearing (non-empty), non-server (`srvtoolu_`), unanswered
-* (`toolMessageIds`), messages-state input, id-bearing AI message. Surfaces
-* that apply it today — extend this list when adding another:
-*   - `run()`'s `canPromoteInvalidCalls` gate + attributable filter
-*   - `toolsCondition`'s invalid-only / server-mix routing branch
-*   - `sanitizeInvalidToolUseBlocks` (block input AND name)
-*   - `patchCommandUpdateForPromotedInvalidCalls` (handoff snapshots)
-*   - `processHandoffReception`'s transfer-block filtering (MultiAgentGraph)
-*   - `findPendingToolCalls` in langfuseTraceShaping (span claims)
-*   - `serializeMessage`/`deserializeMessage` (session round-trip keeps
-*     `invalid_tool_calls` with the content blocks they repair)
-*/
 function normalizeInvalidCallName(name) {
 	return name != null && name !== "" ? name : "unknown";
 }
-/**
-* Rewrite a handoff Command's `update.messages` so the invalid-call promotion
-* survives into the child state: the same-id AI message copy (snapshotted
-* pre-promotion by the handoff tool) gets the sanitized content, the promoted
-* `tool_calls` entries for the answered invalid calls, and the leftover
-* `invalid_tool_calls`; synthesized results missing from the update are
-* appended so the child's history keeps every call/result pair. The update
-* copy's own `tool_calls` narrowing (parallel handoffs filter to a single
-* call) is preserved. Commands without a same-id AI message pass through.
-*/
 function patchCommandUpdateForPromotedInvalidCalls(command, promoted, invalidResults) {
 	const update = command.update;
 	const messages = update?.messages;
@@ -2950,13 +1941,6 @@ function patchCommandUpdateForPromotedInvalidCalls(command, promoted, invalidRes
 		}
 	});
 }
-/**
-* Whether the message carries an `invalid_tool_calls` entry ToolNode can pair a
-* synthesized error result with (id-bearing, non-server). Shared by the routing
-* condition below so an invalid-only turn still enters ToolNode — otherwise the
-* malformed `tool_use` block is committed with no `tool_result` and the next
-* model call is rejected by pairing-strict providers.
-*/
 function hasAttributableInvalidToolCalls(message) {
 	return message.invalid_tool_calls?.some((call) => call.id != null && call.id !== "" && !call.id.startsWith("srvtoolu_")) ?? false;
 }
@@ -2964,22 +1948,6 @@ function toolsCondition(state, toolNode, invokedToolIds) {
 	const messages = Array.isArray(state) ? state : state.messages;
 	const message = messages[messages.length - 1];
 	if (message && "tool_calls" in message && (message.tool_calls?.length ?? 0) > 0 && !areToolCallsInvoked(message, invokedToolIds)) return toolNode;
-	/**
-	* The valid calls (if any) did not route above, but ToolNode still owes any
-	* malformed calls their synthesized error results. Route when EVERY valid
-	* call is provider-server-executed (`srvtoolu_` — ToolNode's batch filter
-	* excludes those before execution, so nothing re-runs): that covers both the
-	* invalid-only turn and the Anthropic server-call + malformed-client-call
-	* mix, where `handleAnthropicSearchResults` marks the server call invoked
-	* and the first branch declines. A valid NON-server call that was invoked
-	* externally stays conservative (no routing) — ToolNode does not filter on
-	* `invokedToolIds`, so entering it would re-execute that call.
-	*
-	* Mirrors ToolNode's own gating exactly, or the routed turn would no-op and
-	* bounce back to the model with the dangle intact: array-state graphs get a
-	* plain output list (no reducer upsert — ToolNode skips invalid handling
-	* there), and an id-less message cannot take the replacement upsert either.
-	*/
 	if (!Array.isArray(state) && message && typeof message.id === "string" && message.id.length > 0 && hasAttributableInvalidToolCalls(message) && (message.tool_calls ?? []).every((call) => call.id?.startsWith("srvtoolu_") === true)) return toolNode;
 	return END;
 }