@librechat/agents 3.4.0 → 3.4.1

package/dist/esm/tools/ToolNode.mjs

@@ -1,3 +1,4 @@
+import { SUBAGENT_PARENT_BATCH_CONFIG_KEY, SUBAGENT_REPLAY_CONTROLLER, attachSubagentResumeManifest } from "./subagent/SubagentReplay.mjs";
 import { composeAbortSignals } from "../utils/misc.mjs";
 import { resolveLangfuseRuntimeScope, withLangfuseRuntimeScope } from "../langfuseRuntimeScope.mjs";
 import { CODE_EXECUTION_TOOLS } from "../common/enum.mjs";
@@ -14,12 +15,13 @@ import { RunnableCallable } from "../utils/run.mjs";
 import "../utils/index.mjs";
 import { stripCodeSessionFileSummary } from "./CodeSessionFileSummary.mjs";
 import { executeHooks } from "../hooks/executeHooks.mjs";
+import { TOOL_APPROVAL_EXECUTION_SCOPE_CONFIG_KEY } from "../hooks/types.mjs";
 import "../hooks/index.mjs";
 import { resolveLocalExecutionTools, resolveLocalToolRegistry } from "./local/resolveLocalExecutionTools.mjs";
 import "./local/index.mjs";
 import { nanoid } from "nanoid";
 import { AIMessage, HumanMessage, ToolMessage, isAIMessage, isBaseMessage } from "@langchain/core/messages";
-import { Command, END, Send, interrupt, isCommand, isGraphInterrupt } from "@langchain/langgraph";
+import { Command, END, GraphInterrupt, Send, interrupt, isCommand, isGraphInterrupt } from "@langchain/langgraph";
 import { AsyncLocalStorageProviderSingleton } from "@langchain/core/singletons";
 //#region src/tools/ToolNode.ts
 /** Host-facing batch requests must not carry the batch's breaker scope —
@@ -29,6 +31,22 @@ function stripRunBreakerScope(configurable) {
 	const { [RUN_BREAKER_SCOPE_CONFIG_KEY]: _scope, ...rest } = configurable;
 	return rest;
 }
+function createToolApprovalReplayKey(config, agentId, toolUseId) {
+	const configuredScope = config.configurable?.[TOOL_APPROVAL_EXECUTION_SCOPE_CONFIG_KEY];
+	const threadId = config.configurable?.thread_id;
+	let executionScope = "";
+	if (typeof configuredScope === "string") executionScope = configuredScope;
+	else if (typeof threadId === "string") executionScope = threadId;
+	return {
+		executionScope,
+		agentId,
+		toolUseId
+	};
+}
+function getToolApprovalReplaySessionId(config, hookSessionId) {
+	const configuredScope = config.configurable?.[TOOL_APPROVAL_EXECUTION_SCOPE_CONFIG_KEY];
+	return typeof configuredScope === "string" && configuredScope.length > 0 ? configuredScope : hookSessionId;
+}
 function createToolErrorOwnership() {
 	return {
 		handlerOwned: /* @__PURE__ */ new Set(),
@@ -99,6 +117,25 @@ function describeOfferedShape(value) {
 	if (Array.isArray(value)) return "array";
 	return typeof value;
 }
+function findAssistantBatch(messages) {
+	for (let i = messages.length - 1; i >= 0; i--) {
+		const message = messages[i];
+		if (isAIMessage(message)) return {
+			message,
+			index: i,
+			messageCount: messages.length
+		};
+	}
+}
+function getAssistantBatchReplayKey(batch, runId, threadId) {
+	return JSON.stringify([
+		runId ?? null,
+		threadId ?? null,
+		batch.message.id ?? null,
+		batch.index,
+		batch.messageCount
+	]);
+}
 /**
 * Build the `tool_approval` interrupt payload from the set of pending
 * `ask`-decision entries collected during PreToolUse hook handling.
@@ -106,9 +143,10 @@ function describeOfferedShape(value) {
 * scope. The interrupt itself is raised by the caller (which still
 * needs `interrupt()` plus the AsyncLocalStorage anchoring shim).
 */
-function buildToolApprovalInterruptPayload(askEntries) {
+function buildToolApprovalInterruptPayload(askEntries, hookSessionId) {
 	return {
 		type: "tool_approval",
+		...hookSessionId == null || hookSessionId === "" ? {} : { hook_session_id: hookSessionId },
 		action_requests: askEntries.map(({ entry, reason }) => {
 			const request = {
 				tool_call_id: entry.call.id,
@@ -287,6 +325,10 @@ var ToolNode = class extends RunnableCallable {
 	* 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) */
@@ -520,16 +562,16 @@ var ToolNode = class extends RunnableCallable {
 		return `Tool "${callName}" not found. Did you mean "${suggestion}"? Handoff tool names must match exactly.`;
 	}
 	/**
-	* Flush the per-Run direct-path turn cache. Called by the Graph at
-	* end-of-Run via `clearHeavyState`. The map intentionally survives
-	* `run()` re-entry so an interrupt + resume reuses the original
-	* slot (Codex P2 #30), but it would otherwise grow linearly with
-	* tool calls and could collide across Runs if a provider reused
-	* call IDs (Codex P2 #33). Hosts can also call this directly if
+	* 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.
@@ -559,6 +601,29 @@ var ToolNode = class extends RunnableCallable {
 	getToolUsageCounts() {
 		return new Map(this.toolUsageCount);
 	}
+	createSubagentResumeState() {
+		return {
+			stateKey: JSON.stringify([
+				this.executingAgentId ?? "",
+				this.agentId ?? "",
+				this.name
+			]),
+			toolUsageCounts: [...this.toolUsageCount].map(([toolName, count]) => ({
+				toolName,
+				count
+			})),
+			directPathTurns: [...this.directPathTurns].map(([toolCallId, turn]) => ({
+				toolCallId,
+				turn
+			}))
+		};
+	}
+	restoreSubagentResumeState(state) {
+		this.toolUsageCount.clear();
+		for (const { toolName, count } of state.toolUsageCounts) this.toolUsageCount.set(toolName, count);
+		this.directPathTurns.clear();
+		for (const { toolCallId, turn } of state.directPathTurns) this.directPathTurns.set(toolCallId, turn);
+	}
 	recordToolUsageTurn(toolName, turn, callId) {
 		this.toolUsageCount.set(toolName, Math.max(this.toolUsageCount.get(toolName) ?? 0, turn + 1));
 		if (callId != null && callId !== "") this.toolCallTurns.set(callId, turn);
@@ -860,9 +925,9 @@ var ToolNode = class extends RunnableCallable {
 	*       `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; the hook fires
-	*       again and the resume value distinguishes "first ask" from
-	*       "second pass with decision".
+	*       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.
@@ -882,13 +947,49 @@ var ToolNode = class extends RunnableCallable {
 	* 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 || batchContext.replayBatchKey == null ? config : {
+			...config,
+			configurable: {
+				...config.configurable,
+				[SUBAGENT_PARENT_BATCH_CONFIG_KEY]: batchContext.replayBatchKey
+			}
+		};
+		const settledOutput = await replayController?.getSettledOutput(call, replayConfig);
+		if (settledOutput != null) {
+			if (batchContext.additionalContextsSink != null && settledOutput.additionalContexts.length > 0) batchContext.additionalContextsSink.push(...settledOutput.additionalContexts);
+			if (batchContext.resolvedArgsByCallId != null && call.id != null && settledOutput.resolvedArgs != null) batchContext.resolvedArgsByCallId.set(call.id, settledOutput.resolvedArgs);
+			const refMeta = settledOutput.output.additional_kwargs;
+			if (this.toolOutputRegistry != null && refMeta?._refKey != null && settledOutput.referenceContent != null) this.toolOutputRegistry.set(refMeta._refScope, refMeta._refKey, settledOutput.referenceContent);
+			return settledOutput.output;
+		}
+		const replayAdditionalContexts = [];
+		const persistOutput = async (output, terminalArgs) => {
+			const refMeta = output.additional_kwargs;
+			if (terminalArgs != null && call.id != null && batchContext.resolvedArgsByCallId != null) batchContext.resolvedArgsByCallId.set(call.id, terminalArgs);
+			const resolvedArgs = terminalArgs ?? (call.id == null ? void 0 : batchContext.resolvedArgsByCallId?.get(call.id));
+			const referenceContent = this.toolOutputRegistry == null || refMeta?._refKey == null ? void 0 : this.toolOutputRegistry.get(refMeta._refScope, refMeta._refKey);
+			await replayController?.persistSettledOutput(call, replayConfig, {
+				output,
+				additionalContexts: replayAdditionalContexts,
+				...resolvedArgs == null ? {} : { resolvedArgs },
+				...referenceContent == null ? {} : { referenceContent }
+			});
+			return output;
+		};
 		const runId = config.configurable?.run_id ?? "";
+		const threadId = config.configurable?.thread_id;
 		const hookRegistry = this.hookRegistry;
 		const hasPreHook = hookRegistry?.hasHookFor("PreToolUse", runId) === true;
+		const approvalReplayKey = call.id == null || call.id === "" ? void 0 : createToolApprovalReplayKey(config, this.executingAgentId ?? this.agentId ?? "", call.id);
+		const approvalReplaySessionId = getToolApprovalReplaySessionId(config, runId);
+		const pendingApproval = approvalReplayKey == null ? void 0 : hookRegistry?.getPendingToolApproval(approvalReplaySessionId, approvalReplayKey);
 		const hasPostHook = hookRegistry?.hasHookFor("PostToolUse", runId) === true;
 		const hasFailureHook = hookRegistry?.hasHookFor("PostToolUseFailure", runId) === true;
-		if (hookRegistry == null || !hasPreHook && !hasPostHook && !hasFailureHook) return this.runTool(call, config, batchContext);
-		const threadId = config.configurable?.thread_id;
+		if (hookRegistry == null || !hasPreHook && pendingApproval == null && !hasPostHook && !hasFailureHook) {
+			const output = await this.runTool(call, replayConfig, batchContext);
+			return output instanceof ToolMessage ? persistOutput(output) : output;
+		}
 		const registryRunId = batchContext.batchScopeId ?? config.configurable?.run_id;
 		let usageCount;
 		const cachedTurn = call.id != null && call.id !== "" ? this.directPathTurns.get(call.id) ?? this.toolCallTurns.get(call.id) : void 0;
@@ -913,7 +1014,7 @@ var ToolNode = class extends RunnableCallable {
 			resolvedArgs = resolved;
 		}
 		let effectiveCall = call;
-		if (hasPreHook) {
+		if (hasPreHook || pendingApproval != null) {
 			const preResult = await executeHooks({
 				registry: hookRegistry,
 				input: {
@@ -929,34 +1030,48 @@ var ToolNode = class extends RunnableCallable {
 					turn
 				},
 				sessionId: runId,
-				matchQuery: call.name
+				matchQuery: call.name,
+				onceReplayKey: approvalReplayKey,
+				onceReplaySessionId: approvalReplaySessionId
 			}).catch(() => void 0);
 			if (preResult != null) {
-				if (batchContext.additionalContextsSink != null && preResult.additionalContexts.length > 0) batchContext.additionalContextsSink.push(...preResult.additionalContexts);
+				if (preResult.additionalContexts.length > 0) {
+					replayAdditionalContexts.push(...preResult.additionalContexts);
+					batchContext.additionalContextsSink?.push(...preResult.additionalContexts);
+				}
 				if (preResult.updatedInput != null) effectiveCall = {
 					...call,
 					args: preResult.updatedInput
 				};
-				if (preResult.decision === "deny") return this.blockDirectCall({
+				if (preResult.decision === "deny") return persistOutput(this.blockDirectCall({
 					call,
 					resolvedArgs,
 					reason: preResult.reason ?? "Blocked by hook",
 					hookRegistry,
 					runId,
 					threadId
-				});
+				}), effectiveCall.args);
 				if (preResult.decision === "ask") {
 					if (this.humanInTheLoop?.enabled !== true) {
 						const reason = this.resolveAskDecisionForDirectTool(preResult.reason, call.name);
-						return this.blockDirectCall({
+						return persistOutput(this.blockDirectCall({
 							call,
 							resolvedArgs,
 							reason,
 							hookRegistry,
 							runId,
 							threadId
-						});
+						}), effectiveCall.args);
 					}
+					const toolCallId = call.id;
+					if (toolCallId == null || toolCallId === "" || approvalReplayKey == null) return persistOutput(this.blockDirectCall({
+						call,
+						resolvedArgs,
+						reason: "Tool approval requires a non-empty tool call ID — failing closed",
+						hookRegistry,
+						runId,
+						threadId
+					}), effectiveCall.args);
 					const payload = buildToolApprovalInterruptPayload([{
 						entry: {
 							call: effectiveCall,
@@ -965,59 +1080,71 @@ var ToolNode = class extends RunnableCallable {
 						},
 						reason: preResult.reason,
 						allowedDecisions: preResult.allowedDecisions
-					}]);
+					}], runId);
 					const resumeValue = AsyncLocalStorageProviderSingleton.runWithConfig(config, () => interrupt(payload));
-					const decision = normalizeApprovalDecisions([call.id], resumeValue).get(call.id) ?? {
+					hookRegistry.clearPendingToolApproval(approvalReplaySessionId, approvalReplayKey);
+					const decision = normalizeApprovalDecisions([toolCallId], resumeValue).get(toolCallId) ?? {
 						type: "reject",
 						reason: "No decision provided for tool approval"
 					};
 					const declaredType = decision.type;
-					if (preResult.allowedDecisions != null && (typeof declaredType !== "string" || !preResult.allowedDecisions.includes(declaredType))) return this.blockDirectCall({
+					if (preResult.allowedDecisions != null && (typeof declaredType !== "string" || !preResult.allowedDecisions.includes(declaredType))) return persistOutput(this.blockDirectCall({
 						call,
 						resolvedArgs,
 						reason: `Decision "${typeof declaredType === "string" ? declaredType : "<missing>"}" not in allowedDecisions [${preResult.allowedDecisions.join(", ")}] — failing closed`,
 						hookRegistry,
 						runId,
 						threadId
-					});
-					if (decision.type === "reject") return this.blockDirectCall({
+					}), effectiveCall.args);
+					if (decision.type === "reject") return persistOutput(this.blockDirectCall({
 						call,
 						resolvedArgs,
 						reason: decision.reason ?? preResult.reason ?? "Rejected by user",
 						hookRegistry,
 						runId,
 						threadId
-					});
+					}), effectiveCall.args);
 					if (decision.type === "respond") {
 						const responseText = decision.responseText;
-						if (typeof responseText !== "string") return this.blockDirectCall({
+						if (typeof responseText !== "string") return persistOutput(this.blockDirectCall({
 							call,
 							resolvedArgs,
 							reason: "Approval payload `respond` was missing a string `responseText`",
 							hookRegistry,
 							runId,
 							threadId
-						});
-						return new ToolMessage({
+						}), effectiveCall.args);
+						return persistOutput(new ToolMessage({
 							status: "success",
-							content: responseText,
+							content: truncateToolResultContent(responseText, this.maxToolResultChars),
 							name: call.name,
 							tool_call_id: call.id ?? ""
-						});
+						}), effectiveCall.args);
 					}
 					if (decision.type === "edit") {
 						const updatedInput = decision.updatedInput;
-						if (updatedInput === null || typeof updatedInput !== "object" || Array.isArray(updatedInput)) return new ToolMessage({
+						if (updatedInput === null || typeof updatedInput !== "object" || Array.isArray(updatedInput)) return persistOutput(new ToolMessage({
 							status: "error",
 							content: "Decision \"edit\" missing object updatedInput — failing closed.",
 							name: call.name,
 							tool_call_id: call.id ?? ""
-						});
+						}), effectiveCall.args);
 						effectiveCall = {
 							...call,
 							args: updatedInput
 						};
 					}
+					if (declaredType !== "approve" && declaredType !== "edit") {
+						const unknownType = typeof declaredType === "string" ? declaredType : "<missing>";
+						return persistOutput(this.blockDirectCall({
+							call,
+							resolvedArgs,
+							reason: `Unknown approval decision type "${unknownType}" — failing closed`,
+							hookRegistry,
+							runId,
+							threadId
+						}), effectiveCall.args);
+					}
 				}
 			}
 		}
@@ -1031,7 +1158,7 @@ var ToolNode = class extends RunnableCallable {
 		* 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, config, {
+		const output = await this.runTool(effectiveCall, replayConfig, {
 			...batchContext,
 			usageCount
 		});
@@ -1055,8 +1182,11 @@ var ToolNode = class extends RunnableCallable {
 				sessionId: runId,
 				matchQuery: call.name
 			}).catch(() => void 0);
-			if (failureResult != null && batchContext.additionalContextsSink != null && failureResult.additionalContexts.length > 0) batchContext.additionalContextsSink.push(...failureResult.additionalContexts);
-			return output;
+			if (failureResult != null && failureResult.additionalContexts.length > 0) {
+				replayAdditionalContexts.push(...failureResult.additionalContexts);
+				batchContext.additionalContextsSink?.push(...failureResult.additionalContexts);
+			}
+			return persistOutput(output);
 		}
 		if (output.status !== "error" && hasPostHook) {
 			const postResult = await executeHooks({
@@ -1077,21 +1207,24 @@ var ToolNode = class extends RunnableCallable {
 				sessionId: runId,
 				matchQuery: call.name
 			}).catch(() => void 0);
-			if (postResult != null && batchContext.additionalContextsSink != null && postResult.additionalContexts.length > 0) batchContext.additionalContextsSink.push(...postResult.additionalContexts);
+			if (postResult != null && postResult.additionalContexts.length > 0) {
+				replayAdditionalContexts.push(...postResult.additionalContexts);
+				batchContext.additionalContextsSink?.push(...postResult.additionalContexts);
+			}
 			if (postResult?.updatedOutput != null) {
 				if (hasComputerCallOutputMarker(output)) {
 					if (!isComputerCallOutputContent(postResult.updatedOutput)) throw new Error("PostToolUse updatedOutput for a computer call must be a valid screenshot URL or screenshot content block.");
-					return cloneToolMessageWithContent(output, postResult.updatedOutput);
+					return persistOutput(cloneToolMessageWithContent(output, postResult.updatedOutput));
 				}
 				const refMeta = output.additional_kwargs;
 				const refKey = refMeta?._refKey;
 				const refScope = refMeta?._refScope;
 				const replaced = serializeToolOutputWithinLimits(postResult.updatedOutput, this.maxToolResultChars, this.toolOutputRegistry != null && refKey != null ? this.toolOutputRegistry.perOutputLimit : 0);
 				if (this.toolOutputRegistry != null && refKey != null) this.toolOutputRegistry.set(refScope, refKey, replaced.registryContent);
-				return cloneToolMessageWithContent(output, replaced.content);
+				return persistOutput(cloneToolMessageWithContent(output, replaced.content));
 			}
 		}
-		return output;
+		return persistOutput(output);
 	}
 	/**
 	* `ask` decisions on direct-path tools collapse to fail-closed deny
@@ -1382,13 +1515,10 @@ var ToolNode = class extends RunnableCallable {
 			injectedMessages: [],
 			errors: []
 		});
-		if (this.hookRegistry?.hasHookFor("PreToolUse", runId) === true) {
-			/**
-			* Capture as a non-null local so the inner `blockEntry` closure
-			* doesn't lose narrowing on `this.hookRegistry` and we don't have
-			* to defensively `?.` it across every reference inside.
-			*/
-			const hookRegistry = this.hookRegistry;
+		const hookRegistry = this.hookRegistry;
+		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
@@ -1408,23 +1538,29 @@ var ToolNode = class extends RunnableCallable {
 					this.eagerEventToolExecutions.delete(callId);
 				}
 			}
-			const preResults = await Promise.all(preToolCalls.map((entry) => executeHooks({
-				registry: hookRegistry,
-				input: {
-					hook_event_name: "PreToolUse",
-					runId,
-					threadId,
-					agentId: this.agentId,
-					executingAgentId: this.executingAgentId,
-					toolName: entry.call.name,
-					toolInput: entry.args,
-					toolUseId: entry.call.id,
-					stepId: entry.stepId,
-					turn: this.toolUsageCount.get(entry.call.name) ?? 0
-				},
-				sessionId: runId,
-				matchQuery: entry.call.name
-			}).catch(() => HOOK_FALLBACK)));
+			const preResults = await Promise.all(preToolCalls.map((entry) => {
+				const toolUseId = entry.call.id;
+				const approvalReplayKey = toolUseId == null ? void 0 : createToolApprovalReplayKey(config, this.executingAgentId ?? this.agentId ?? "", toolUseId);
+				return executeHooks({
+					registry: hookRegistry,
+					input: {
+						hook_event_name: "PreToolUse",
+						runId,
+						threadId,
+						agentId: this.agentId,
+						executingAgentId: this.executingAgentId,
+						toolName: entry.call.name,
+						toolInput: entry.args,
+						toolUseId: entry.call.id,
+						stepId: entry.stepId,
+						turn: this.toolUsageCount.get(entry.call.name) ?? 0
+					},
+					sessionId: runId,
+					matchQuery: entry.call.name,
+					onceReplayKey: approvalReplayKey,
+					onceReplaySessionId: approvalReplaySessionId
+				}).catch(() => HOOK_FALLBACK);
+			}));
 			/**
 			* Side effects deferred from `blockEntry` until after any pending
 			* `interrupt()` resolves. Without deferral, a batch that mixes a
@@ -1581,12 +1717,11 @@ var ToolNode = class extends RunnableCallable {
 			* 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, so the loop above re-runs and the same
-			* `askEntries` list is rebuilt deterministically (assuming hooks
-			* are pure — see `humanInTheLoop` docs).
+			* 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);
+				const payload = buildToolApprovalInterruptPayload(askEntries, runId);
 				/**
 				* `interrupt()` reads the current `RunnableConfig` from
 				* AsyncLocalStorage. ToolNode usually runs with tracing disabled
@@ -1597,6 +1732,7 @@ var ToolNode = class extends RunnableCallable {
 				* 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);
 				for (const { entry, reason: askReason, allowedDecisions } of askEntries) {
 					const decision = decisionByCallId.get(entry.call.id) ?? {
@@ -2187,16 +2323,16 @@ var ToolNode = class extends RunnableCallable {
 	* 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. On the resume pass LangGraph re-runs the batch from the
-	* top; the interrupting tool resolves with the host's answer instead of
-	* throwing, and the siblings execute for the FIRST time, exactly once.
+	* 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. Interrupting tools
-	* are expected to be side-effect-free (they only suspend), so running them
-	* as a group and re-running them on resume is harmless.
+	* 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
@@ -2205,28 +2341,95 @@ var ToolNode = class extends RunnableCallable {
 	* per-call here.
 	*/
 	async runDirectBatchInterruptSafe(directCalls, batchIndices, config, baseContext) {
-		const runOne = (call, position) => this.runDirectToolWithLifecycleHooks(call, config, {
-			...baseContext,
-			batchIndex: batchIndices[position]
-		});
+		const settledBatchResults = baseContext.replayBatchKey == null ? void 0 : this.settledInterruptingResults.get(baseContext.replayBatchKey);
+		const restoreResult = (call, result) => {
+			baseContext.additionalContextsSink?.push(...result.additionalContexts);
+			if (call.id != null && result.resolvedArgs != null && baseContext.resolvedArgsByCallId != null) baseContext.resolvedArgsByCallId.set(call.id, result.resolvedArgs);
+			return result;
+		};
+		const runOne = async (call, position) => {
+			const cachedResult = typeof call.id === "string" ? settledBatchResults?.get(call.id) : void 0;
+			if (cachedResult != null) return restoreResult(call, cachedResult);
+			const additionalContexts = [];
+			const output = await this.runDirectToolWithLifecycleHooks(call, config, {
+				...baseContext,
+				batchIndex: batchIndices[position],
+				additionalContextsSink: additionalContexts
+			});
+			const resolvedArgs = call.id == null ? void 0 : baseContext.resolvedArgsByCallId?.get(call.id);
+			return restoreResult(call, {
+				output,
+				additionalContexts,
+				...resolvedArgs == null ? {} : { resolvedArgs }
+			});
+		};
 		const interrupting = this.interruptingToolNames;
-		if (!(interrupting != null && directCalls.some((call) => interrupting.has(call.name)))) return Promise.all(directCalls.map((call, i) => runOne(call, i)));
+		if (!(interrupting != null && directCalls.some((call) => interrupting.has(call.name)))) return (await Promise.all(directCalls.map((call, i) => runOne(call, i)))).map((result) => result.output);
 		const outputs = new Array(directCalls.length);
 		const interruptingPositions = [];
 		const regularPositions = [];
 		for (let i = 0; i < directCalls.length; i++) if (interrupting.has(directCalls[i].name)) interruptingPositions.push(i);
 		else regularPositions.push(i);
-		const interruptingOutputs = await Promise.all(interruptingPositions.map((i) => runOne(directCalls[i], i)));
-		interruptingPositions.forEach((i, k) => {
-			outputs[i] = interruptingOutputs[k];
-		});
+		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;
+		for (let i = 0; i < interruptingResults.length; i++) {
+			const result = interruptingResults[i];
+			if (result.status === "rejected") {
+				if (!hasInterruptingError) {
+					hasInterruptingError = true;
+					interruptingError = result.reason;
+				}
+				continue;
+			}
+			const position = interruptingPositions[i];
+			outputs[position] = result.value.output;
+			const callId = directCalls[position].id;
+			if (baseContext.replayBatchKey != null && typeof callId === "string" && callId !== "") {
+				const batchResults = this.settledInterruptingResults.get(baseContext.replayBatchKey) ?? /* @__PURE__ */ new Map();
+				batchResults.set(callId, result.value);
+				this.settledInterruptingResults.set(baseContext.replayBatchKey, batchResults);
+			}
+		}
+		if (hasInterruptingError) {
+			if (isGraphInterrupt(interruptingError)) {
+				const controllers = /* @__PURE__ */ new Set();
+				const parentToolCallIds = /* @__PURE__ */ new Set();
+				for (const call of directCalls) {
+					const controller = this.toolMap.get(call.name)?.[SUBAGENT_REPLAY_CONTROLLER];
+					if (controller?.getResumeManifest != null) controllers.add(controller);
+					if (call.id != null && call.id !== "") parentToolCallIds.add(call.id);
+				}
+				const executionsByParentCall = /* @__PURE__ */ new Map();
+				for (const controller of controllers) {
+					const manifest = await controller.getResumeManifest?.(parentToolCallIds);
+					if (manifest != null) for (const execution of manifest.executions) executionsByParentCall.set(execution.parentToolCallId, execution);
+				}
+				const executions = [...executionsByParentCall.values()];
+				if (executions.length > 0) {
+					const manifest = {
+						version: 1,
+						executions
+					};
+					throw new GraphInterrupt(interruptingError.interrupts.map((pendingInterrupt) => ({
+						...pendingInterrupt,
+						value: attachSubagentResumeManifest(pendingInterrupt.value, manifest)
+					})));
+				}
+			}
+			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) => {
-			outputs[i] = regularOutputs[k];
+			outputs[i] = regularOutputs[k].output;
 		});
 		return outputs;
 	}
@@ -2282,9 +2485,23 @@ var ToolNode = class extends RunnableCallable {
 		const resolvedArgsByCallId = /* @__PURE__ */ new Map();
 		/** Per-invocation error-completion ownership — see `ToolErrorOwnership`. */
 		const errorOwnership = createToolErrorOwnership();
-		const batchScopeId = config.configurable?.run_id ?? `\0anon-${this.anonBatchCounter++}`;
+		/**
+		* 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). */
@@ -2299,6 +2516,9 @@ var ToolNode = class extends RunnableCallable {
 			});
 			const directAdditionalContexts = [];
 			const { lg_tool_call: _sendToolCall, ...sendState } = input;
+			const sendMessages = sendState.messages;
+			const sendAssistantBatch = Array.isArray(sendMessages) ? findAssistantBatch(sendMessages) : void 0;
+			const sendReplayBatchKey = sendAssistantBatch == null ? void 0 : getAssistantBatchReplayKey(sendAssistantBatch, incomingRunId, incomingThreadId);
 			const sendOutput = await this.runDirectToolWithLifecycleHooks(input.lg_tool_call, config, {
 				batchIndex: 0,
 				turn,
@@ -2306,6 +2526,7 @@ var ToolNode = class extends RunnableCallable {
 				resolvedArgsByCallId,
 				errorOwnership,
 				additionalContextsSink: directAdditionalContexts,
+				replayBatchKey: sendReplayBatchKey,
 				runInput: sendState
 			});
 			outputs = directAdditionalContexts.length > 0 ? [sendOutput, new HumanMessage({
@@ -2322,15 +2543,10 @@ var ToolNode = class extends RunnableCallable {
 			else if (this.isMessagesState(input)) messages = input.messages;
 			else throw new Error("ToolNode only accepts BaseMessage[] or { messages: BaseMessage[] } as input.");
 			const toolMessageIds = new Set(messages.filter((msg) => msg._getType() === "tool").map((msg) => msg.tool_call_id));
-			let aiMessage;
-			for (let i = messages.length - 1; i >= 0; i--) {
-				const message = messages[i];
-				if (isAIMessage(message)) {
-					aiMessage = message;
-					break;
-				}
-			}
-			if (aiMessage == null || !isAIMessage(aiMessage)) throw new Error("ToolNode only accepts AIMessages as input.");
+			const assistantBatch = findAssistantBatch(messages);
+			if (assistantBatch == null) throw new Error("ToolNode only accepts AIMessages as input.");
+			const aiMessage = assistantBatch.message;
+			replayBatchKey = getAssistantBatchReplayKey(assistantBatch, incomingRunId, incomingThreadId);
 			if (this.loadRuntimeTools) {
 				const { tools, toolMap } = this.loadRuntimeTools(aiMessage.tool_calls ?? []);
 				this.toolMap = toolMap ?? new Map(tools.map((tool) => [tool.name, tool]));
@@ -2445,6 +2661,7 @@ var ToolNode = class extends RunnableCallable {
 					errorOwnership,
 					preBatchSnapshot,
 					additionalContextsSink: directAdditionalContexts,
+					replayBatchKey,
 					runInput: input
 				}) : [];
 				if (directCalls.length > 0 && directOutputs.length > 0) await this.handleRunToolCompletions(directCalls, directOutputs, config, resolvedArgsByCallId, errorOwnership);
@@ -2483,6 +2700,7 @@ var ToolNode = class extends RunnableCallable {
 					errorOwnership,
 					preBatchSnapshot,
 					additionalContextsSink: directAdditionalContexts,
+					replayBatchKey,
 					runInput: input
 				});
 				await this.handleRunToolCompletions(filteredCalls, toolOutputs, config, resolvedArgsByCallId, errorOwnership);
@@ -2519,7 +2737,10 @@ var ToolNode = class extends RunnableCallable {
 				await this.dispatchStepCompleted(result.tool_call_id, result.name ?? "unknown", {}, typeof result.content === "string" ? result.content : "", config);
 			}
 		}
-		if (!outputs.some(isCommand)) return Array.isArray(input) ? outputs : { messages: outputs };
+		if (!outputs.some(isCommand)) {
+			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
@@ -2606,6 +2827,7 @@ var ToolNode = class extends RunnableCallable {
  /** Single handoff - pass through as-is */
 		combinedOutputs.push(handoffCommands[0]);
 		if (parentCommand) combinedOutputs.push(parentCommand);
+		if (replayBatchKey != null) this.settledInterruptingResults.delete(replayBatchKey);
 		return combinedOutputs;
 	}
 	isSendInput(input) {