@librechat/agents 3.8.1 → 3.8.3

package/dist/esm/tools/ToolNode.mjs

@@ -1,19 +1,21 @@
-import { calculateMaxToolResultChars, truncateToolResultContent } from "../utils/truncation.mjs";
 import { CODE_EXECUTION_TOOLS } from "../common/enum.mjs";
 import "../common/index.mjs";
+import { calculateMaxToolResultChars, truncateToolResultContent } from "../utils/truncation.mjs";
 import { attachRunStepResumeState } from "./runStepResume.mjs";
 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 { cloneToolMessageWithContent, compactToolContent, hasComputerCallOutputMarker, isComputerCallOutputContent, isComputerCallOutputMessage, serializeStructuredValueBounded, serializeToolContentBounded } from "../utils/toolContent.mjs";
 import { stampSyntheticProviderMessage } from "../messages/provenance.mjs";
+import { buildToolExecutionRequestPlan, coerceArgsForSchema, coerceRecordArgs, recordArgsEqual, resolveRuntimeSessionHint, stableStringify } from "./eagerEventExecution.mjs";
+import { TOOL_APPROVAL_REVIEW_CONFIG_KEY, getReviewedToolApproval, getToolApprovalReviewEvidence, toolApprovalPayloadMatches, toolApprovalProposalMatches } from "../hitl/approvalReview.mjs";
 import { TOOL_APPROVAL_EXECUTION_SCOPE_CONFIG_KEY } from "../hooks/types.mjs";
+import { TOOL_BATCH_REPLAY_KEY, attachToolBatchReplayState, getToolBatchReplayOwner, getToolBatchReplayScope, getToolBatchReplayState, isChildToolReplayOwner, isToolReplayResume, restoreToolBatchReplayState } from "./toolBatchReplay.mjs";
 import { executeHooks } from "../hooks/executeHooks.mjs";
 import "../hooks/index.mjs";
 import { convertInjectedMessages } from "../messages/injected.mjs";
 import { safeDispatchCustomEvent } from "../utils/events.mjs";
 import { RUN_BREAKER_SCOPE_CONFIG_KEY, StreamLimitExceededError } from "../llm/streamLimits.mjs";
-import { buildToolExecutionRequestPlan, coerceArgsForSchema, coerceRecordArgs, recordArgsEqual, resolveRuntimeSessionHint } from "./eagerEventExecution.mjs";
 import { INTENT_ARG, isIntentLabelProperty, outcomeFieldsFromResult, readOutcomeFields, resolveToolOutcome } from "./intentArg.mjs";
 import { ToolOutputReferenceRegistry, buildReferenceKey } from "./toolOutputReferences.mjs";
 import { PreparedSubagentError } from "./preparedSubagents.mjs";
@@ -28,10 +30,17 @@ import { RunnableLambda } from "@langchain/core/runnables";
 import { AIMessage, HumanMessage, ToolMessage, isAIMessage, isBaseMessage } from "@langchain/core/messages";
 import { Command, END, GraphInterrupt, Send, interrupt, isCommand, isGraphInterrupt } from "@langchain/langgraph";
 import { AsyncLocalStorageProviderSingleton } from "@langchain/core/singletons";
+import { createHash } from "crypto";
 //#region src/tools/ToolNode.ts
-function stripRunBreakerScope(configurable) {
-	if (configurable == null || !("lc_run_breaker_scope" in configurable)) return configurable;
-	const { [RUN_BREAKER_SCOPE_CONFIG_KEY]: _scope, ...rest } = configurable;
+function stripToolApprovalReviewConfig(configurable) {
+	if (configurable == null || !("__librechat_tool_approval_review" in configurable) && !("__librechat_tool_batch_replay" in configurable)) return configurable;
+	const { [TOOL_APPROVAL_REVIEW_CONFIG_KEY]: _review, [TOOL_BATCH_REPLAY_KEY]: _replay, ...rest } = configurable;
+	return rest;
+}
+function stripHostExecutionConfig(configurable) {
+	const withoutReview = stripToolApprovalReviewConfig(configurable);
+	if (withoutReview == null || !("lc_run_breaker_scope" in withoutReview)) return withoutReview;
+	const { [RUN_BREAKER_SCOPE_CONFIG_KEY]: _scope, ...rest } = withoutReview;
 	return rest;
 }
 function createToolApprovalReplayKey(config, agentId, toolUseId) {
@@ -60,6 +69,9 @@ function withSubagentReplayBatch(config, replayBatchKey) {
 		}
 	};
 }
+function directReplayKey(call, batchIndex) {
+	return call.id == null || call.id === "" ? JSON.stringify(["position", batchIndex]) : JSON.stringify(["id", call.id]);
+}
 function createToolErrorOwnership() {
 	return {
 		handlerOwned: /* @__PURE__ */ new Set(),
@@ -113,20 +125,14 @@ function describeOfferedShape(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
-		};
+		if (isAIMessage(message)) return { message };
 	}
 }
-function getAssistantBatchReplayKey(batch, runId, threadId) {
+function getAssistantBatchReplayKey(batch, threadId) {
 	return JSON.stringify([
-		runId ?? null,
 		threadId ?? null,
-		batch.message.id ?? null,
-		batch.index,
-		batch.messageCount
+		batch.message.id == null || batch.message.id === "" ? null : batch.message.id,
+		createHash("sha256").update(stableStringify(batch.message.tool_calls ?? [])).digest("hex")
 	]);
 }
 function buildToolApprovalInterruptPayload(askEntries, hookSessionId) {
@@ -244,7 +250,7 @@ var ToolNode = class extends RunnableCallable {
 	toolUsageCount;
 	toolCallTurns = /* @__PURE__ */ new Map();
 	directPathTurns = /* @__PURE__ */ new Map();
-	settledInterruptingResults = /* @__PURE__ */ new Map();
+	settledDirectResultsByBatch = /* @__PURE__ */ new Map();
 	toolRegistry;
 	toolDefinitions;
 	localImplementationNames = /* @__PURE__ */ new Set();
@@ -279,16 +285,59 @@ var ToolNode = class extends RunnableCallable {
 			name: name ?? TOOL_NODE_RUN_NAME,
 			tags,
 			func: async (input, config) => {
+				const messages = Array.isArray(input) ? input : input.messages;
+				const assistantBatch = messages == null ? void 0 : findAssistantBatch(messages);
+				const activeReplayKey = assistantBatch == null || getToolBatchReplayScope(config) == null ? void 0 : getAssistantBatchReplayKey(assistantBatch, getToolBatchReplayScope(config));
+				const replayOwner = getToolBatchReplayOwner(config, this.executingAgentId ?? this.agentId ?? "");
+				let reviewEvidence = getToolApprovalReviewEvidence(config);
+				const replayState = getToolBatchReplayState(config.configurable);
+				const ownsParentBatch = replayState?.records.some((record) => record.owner === replayOwner && record.batch === activeReplayKey) === true;
+				let isChildReplay = false;
+				if (ownsParentBatch) {
+					const calls = this.isSendInput(input) ? [input.lg_tool_call] : assistantBatch?.message.tool_calls ?? [];
+					const trustedParentCallIds = new Set(calls.filter((call) => call.name === "subagent" && this.toolMap.get(call.name)?.[SUBAGENT_REPLAY_CONTROLLER] != null).map((call) => call.id ?? ""));
+					isChildReplay = reviewEvidence?.owner != null ? isChildToolReplayOwner(config, reviewEvidence.owner, trustedParentCallIds) : replayState.records.some((record) => isChildToolReplayOwner(config, record.owner, trustedParentCallIds));
+				}
+				if ((reviewEvidence?.owner != null || replayState != null) && !isToolReplayResume(config, reviewEvidence?.interruptId ?? replayState?.interruptId, isChildReplay)) {
+					config = {
+						...config,
+						configurable: {
+							...config.configurable,
+							[TOOL_APPROVAL_REVIEW_CONFIG_KEY]: void 0,
+							[TOOL_BATCH_REPLAY_KEY]: void 0
+						}
+					};
+					reviewEvidence = void 0;
+				}
+				if (reviewEvidence?.owner != null && reviewEvidence.owner !== replayOwner && !isChildReplay) throw new Error("Tool approval execution owner changed before resume — failing closed");
+				const referenceReplay = {};
+				const restoredBatches = await restoreToolBatchReplayState(config, replayOwner);
+				if (restoredBatches.length > 0 && !restoredBatches.some(({ batch }) => batch === activeReplayKey)) throw new Error("Tool batch proposal changed before approval replay — failing closed");
+				if (activeReplayKey != null && getToolBatchReplayState(config.configurable) != null) this.settledDirectResultsByBatch.delete(activeReplayKey);
+				for (const { batch, results, turnState, referenceState } of restoredBatches) {
+					if (batch !== activeReplayKey) continue;
+					this.settledDirectResultsByBatch.set(batch, new Map(results));
+					if (turnState != null) this.restoreSubagentResumeState(turnState);
+					referenceReplay.state = referenceState;
+				}
 				restoreRunStepResumeState?.(input.runStepState, config);
 				let result;
 				try {
-					result = await this.run(input, config);
+					result = await this.run(input, config, referenceReplay);
 				} catch (error) {
-					if (!isGraphInterrupt(error) || createRunStepResumeState == null) throw error;
-					const resumeState = createRunStepResumeState();
-					throw new GraphInterrupt(error.interrupts.map((pendingInterrupt) => ({
-						...pendingInterrupt,
-						value: attachRunStepResumeState(pendingInterrupt.value, resumeState)
+					if (!isGraphInterrupt(error)) throw error;
+					const resumeState = createRunStepResumeState?.();
+					const activeResults = activeReplayKey == null ? void 0 : this.settledDirectResultsByBatch.get(activeReplayKey);
+					const activeBatches = activeReplayKey == null ? /* @__PURE__ */ new Map() : new Map([[activeReplayKey, activeResults ?? /* @__PURE__ */ new Map()]]);
+					const turnState = this.createSubagentResumeState();
+					const activeCallIds = new Set(assistantBatch?.message.tool_calls?.map((call) => call.id));
+					turnState.directPathTurns = turnState.directPathTurns.filter(({ toolCallId }) => activeCallIds.has(toolCallId));
+					throw new GraphInterrupt(await Promise.all(error.interrupts.map(async (pendingInterrupt) => {
+						const value = await attachToolBatchReplayState(pendingInterrupt.value, replayOwner, activeBatches, turnState, referenceReplay.state);
+						return {
+							...pendingInterrupt,
+							value: resumeState == null ? value : attachRunStepResumeState(value, resumeState)
+						};
 					})));
 				}
 				if (createRunStepResumeState == null) return result;
@@ -416,7 +465,7 @@ var ToolNode = class extends RunnableCallable {
 	}
 	clearDirectPathTurns() {
 		this.directPathTurns.clear();
-		this.settledInterruptingResults.clear();
+		this.settledDirectResultsByBatch.clear();
 	}
 	getCallerCapabilityProjection() {
 		const discoveredToolNames = new Set(this.getDiscoveredToolNames?.() ?? []);
@@ -486,11 +535,16 @@ var ToolNode = class extends RunnableCallable {
 	}
 	invokeWithRuntime(tool, invokeParams, call, config, runInput) {
 		const lgConfig = config;
-		const runtime = {
+		const isTrustedSubagentHop = call.name === "subagent" && tool[SUBAGENT_REPLAY_CONTROLLER] != null;
+		const toolConfig = {
 			...config,
+			configurable: isTrustedSubagentHop ? config.configurable : stripToolApprovalReviewConfig(config.configurable)
+		};
+		const runtime = {
+			...toolConfig,
 			state: runInput,
 			toolCallId: call.id ?? "",
-			config,
+			config: toolConfig,
 			context: lgConfig.context,
 			store: lgConfig.store ?? null,
 			writer: lgConfig.writer ?? config.configurable?.writer ?? null
@@ -576,6 +630,8 @@ var ToolNode = class extends RunnableCallable {
 				if (call.id != null && call.id !== "") this.toolCallTurns.set(call.id, next);
 				return next;
 			})();
+			this.recordToolUsageTurn(call.name, usageCount, call.id);
+			if (batchContext.replayBatchKey != null && call.id != null && call.id !== "") this.directPathTurns.set(call.id, usageCount);
 			let args = call.args;
 			if (resolveFn != null) {
 				const { resolved, unresolved } = resolveFn(runId, args);
@@ -724,6 +780,7 @@ var ToolNode = class extends RunnableCallable {
 			throw new PreparedSubagentError("Tool hooks changed after a subagent started.");
 		}
 		const replayController = this.toolMap.get(call.name)?.[SUBAGENT_REPLAY_CONTROLLER];
+		const isTrustedSubagentReviewHop = call.name === "subagent" && replayController != null;
 		const replayConfig = replayController == null ? config : withSubagentReplayBatch(config, batchContext.replayBatchKey);
 		const settledOutput = await replayController?.getSettledOutput(call, replayConfig);
 		if (settledOutput != null) {
@@ -754,9 +811,12 @@ var ToolNode = class extends RunnableCallable {
 		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 approvalReviewEvidence = getToolApprovalReviewEvidence(config, getToolBatchReplayOwner(config, this.executingAgentId ?? this.agentId ?? ""));
+		const reviewedApproval = getReviewedToolApproval(approvalReviewEvidence?.payload, call.id);
+		const approvalEvidenceAppliesToBatch = approvalReviewEvidence?.payload.action_requests.some((request) => batchContext.approvalScopeCallIds == null ? request.tool_call_id === call.id : batchContext.approvalScopeCallIds.has(request.tool_call_id)) === true;
 		const hasPostHook = hookRegistry?.hasHookFor("PostToolUse", runId) === true;
 		const hasFailureHook = hookRegistry?.hasHookFor("PostToolUseFailure", runId) === true;
-		if (hookRegistry == null || !hasPreHook && pendingApproval == null && !hasPostHook && !hasFailureHook) {
+		if (!hasPreHook && pendingApproval == null && reviewedApproval == null && approvalReviewEvidence == null && !hasPostHook && !hasFailureHook) {
 			const output = await this.runTool(call, replayConfig, batchContext);
 			return output instanceof ToolMessage ? persistOutput(output) : output;
 		}
@@ -774,18 +834,21 @@ var ToolNode = class extends RunnableCallable {
 		}
 		const turn = usageCount;
 		const stepId = this.toolCallStepIds?.get(call.id ?? "") ?? "";
-		let resolvedArgs = call.args;
 		const hookResolveOptions = { substituteIntentKey: this.toolDeclaresBusinessIntent(call.name) };
-		if (batchContext.preBatchSnapshot != null) {
-			const { resolved } = batchContext.preBatchSnapshot.resolve(call.args, hookResolveOptions);
-			resolvedArgs = resolved;
-		} else if (this.toolOutputRegistry != null) {
-			const { resolved } = this.toolOutputRegistry.resolve(registryRunId, call.args, hookResolveOptions);
-			resolvedArgs = resolved;
-		}
+		const resolveDirectArgs = (args) => {
+			if (batchContext.preBatchSnapshot != null) return batchContext.preBatchSnapshot.resolve(args, hookResolveOptions).resolved;
+			if (this.toolOutputRegistry != null) return this.toolOutputRegistry.resolve(registryRunId, args, hookResolveOptions).resolved;
+			return args;
+		};
+		const originalResolvedArgs = resolveDirectArgs(call.args);
+		let resolvedArgs = hasPreHook || pendingApproval != null ? originalResolvedArgs : reviewedApproval?.request.arguments ?? originalResolvedArgs;
 		let effectiveCall = call;
-		if (hasPreHook || pendingApproval != null) {
-			const preResult = await executeHooks({
+		if (hasPreHook || pendingApproval != null || reviewedApproval != null || approvalReviewEvidence != null) {
+			const preResult = hookRegistry == null ? {
+				additionalContexts: [],
+				injectedMessages: [],
+				errors: []
+			} : await executeHooks({
 				registry: hookRegistry,
 				input: {
 					hook_event_name: "PreToolUse",
@@ -803,16 +866,31 @@ var ToolNode = class extends RunnableCallable {
 				matchQuery: call.name,
 				onceReplayKey: approvalReplayKey,
 				onceReplaySessionId: approvalReplaySessionId
-			}).catch(() => void 0);
+			}).catch(() => approvalReviewEvidence == null ? void 0 : {
+				decision: "deny",
+				reason: "Approval policy could not be evaluated on resume",
+				additionalContexts: [],
+				injectedMessages: [],
+				errors: []
+			});
 			if (preResult != null) {
 				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.updatedInput != null) {
+					resolvedArgs = resolveDirectArgs(preResult.updatedInput);
+					effectiveCall = {
+						...call,
+						args: resolvedArgs
+					};
+				} else if (reviewedApproval != null) {
+					resolvedArgs = reviewedApproval.request.arguments;
+					effectiveCall = {
+						...call,
+						args: resolvedArgs
+					};
+				}
 				if (preResult.decision === "deny") return persistOutput(this.blockDirectCall({
 					call,
 					resolvedArgs,
@@ -821,7 +899,15 @@ var ToolNode = class extends RunnableCallable {
 					runId,
 					threadId
 				}), effectiveCall.args);
-				if (preResult.decision === "ask") {
+				if (approvalEvidenceAppliesToBatch && reviewedApproval == null && !isTrustedSubagentReviewHop && preResult.decision !== "ask") return persistOutput(this.blockDirectCall({
+					call,
+					resolvedArgs,
+					reason: "Tool call was not included in the restored approval batch — failing closed",
+					hookRegistry,
+					runId,
+					threadId
+				}), resolvedArgs);
+				if (preResult.decision === "ask" || reviewedApproval != null) {
 					if (this.humanInTheLoop?.enabled !== true) {
 						const reason = this.resolveAskDecisionForDirectTool(preResult.reason, call.name);
 						return persistOutput(this.blockDirectCall({
@@ -842,26 +928,41 @@ var ToolNode = class extends RunnableCallable {
 						runId,
 						threadId
 					}), effectiveCall.args);
+					const allowedDecisions = preResult.decision === "ask" ? preResult.allowedDecisions : reviewedApproval?.reviewConfig.allowed_decisions;
+					const askReason = preResult.decision === "ask" ? preResult.reason : reviewedApproval?.request.description;
+					if (effectiveCall === call) effectiveCall = {
+						...call,
+						args: resolvedArgs
+					};
 					const payload = buildToolApprovalInterruptPayload([{
 						entry: {
 							call: effectiveCall,
 							args: effectiveCall.args,
 							stepId
 						},
-						reason: preResult.reason,
-						allowedDecisions: preResult.allowedDecisions
+						reason: askReason,
+						allowedDecisions
 					}], runId);
 					const resumeValue = AsyncLocalStorageProviderSingleton.runWithConfig(config, () => interrupt(payload));
-					hookRegistry.clearPendingToolApproval(approvalReplaySessionId, approvalReplayKey);
+					hookRegistry?.clearPendingToolApproval(approvalReplaySessionId, approvalReplayKey);
+					const currentApproval = getReviewedToolApproval(payload, toolCallId);
+					if (reviewedApproval != null && (currentApproval == null || !toolApprovalProposalMatches(currentApproval, reviewedApproval))) return persistOutput(this.blockDirectCall({
+						call,
+						resolvedArgs,
+						reason: "Reviewed tool proposal changed before resume; retry approval",
+						hookRegistry,
+						runId,
+						threadId
+					}), effectiveCall.args);
 					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 persistOutput(this.blockDirectCall({
+					if (allowedDecisions != null && (typeof declaredType !== "string" || !allowedDecisions.includes(declaredType))) return persistOutput(this.blockDirectCall({
 						call,
 						resolvedArgs,
-						reason: `Decision "${typeof declaredType === "string" ? declaredType : "<missing>"}" not in allowedDecisions [${preResult.allowedDecisions.join(", ")}] — failing closed`,
+						reason: `Decision "${typeof declaredType === "string" ? declaredType : "<missing>"}" not in allowedDecisions [${allowedDecisions.join(", ")}] — failing closed`,
 						hookRegistry,
 						runId,
 						threadId
@@ -869,7 +970,7 @@ var ToolNode = class extends RunnableCallable {
 					if (decision.type === "reject") return persistOutput(this.blockDirectCall({
 						call,
 						resolvedArgs,
-						reason: decision.reason ?? preResult.reason ?? "Rejected by user",
+						reason: decision.reason ?? askReason ?? "Rejected by user",
 						hookRegistry,
 						runId,
 						threadId
@@ -997,7 +1098,7 @@ var ToolNode = class extends RunnableCallable {
 	}
 	blockDirectCall(args) {
 		const { call, resolvedArgs, reason, hookRegistry, runId, threadId } = args;
-		if (hookRegistry.hasHookFor("PermissionDenied", runId) === true) executeHooks({
+		if (hookRegistry?.hasHookFor("PermissionDenied", runId) === true) executeHooks({
 			registry: hookRegistry,
 			input: {
 				hook_event_name: "PermissionDenied",
@@ -1125,7 +1226,8 @@ var ToolNode = class extends RunnableCallable {
 				resolvedArgs = pre.resolved;
 				if (pre.unresolved.length > 0 && call.id != null) unresolvedByCallId.set(call.id, pre.unresolved);
 			} else if (registry != null) {
-				const { resolved, unresolved } = registry.resolve(registryRunId, originalArgs, { substituteIntentKey: this.toolDeclaresBusinessIntent(call.name) });
+				const options = { substituteIntentKey: this.toolDeclaresBusinessIntent(call.name) };
+				const { resolved, unresolved } = preBatchSnapshot != null ? preBatchSnapshot.resolve(originalArgs, options) : registry.resolve(registryRunId, originalArgs, options);
 				resolvedArgs = resolved;
 				if (unresolved.length > 0 && call.id != null) unresolvedByCallId.set(call.id, unresolved);
 			}
@@ -1147,8 +1249,9 @@ var ToolNode = class extends RunnableCallable {
 		});
 		const hookRegistry = this.hookRegistry;
 		const approvalReplaySessionId = getToolApprovalReplaySessionId(config, runId);
+		const approvalReviewEvidence = getToolApprovalReviewEvidence(config, getToolBatchReplayOwner(config, this.executingAgentId ?? this.agentId ?? ""));
 		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)) {
+		if (hookRegistry?.hasHookFor("PreToolUse", runId) === true || hasPendingApproval || approvalReviewEvidence != null) {
 			const preemptedEagerRecords = /* @__PURE__ */ new Map();
 			if (this.eagerEventToolExecutions != null) for (const entry of preToolCalls) {
 				const callId = entry.call.id;
@@ -1159,7 +1262,7 @@ var ToolNode = class extends RunnableCallable {
 					this.eagerEventToolExecutions.delete(callId);
 				}
 			}
-			const preResults = await Promise.all(preToolCalls.map((entry) => {
+			const preResults = hookRegistry == null ? preToolCalls.map(() => HOOK_FALLBACK) : 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({
@@ -1212,7 +1315,7 @@ var ToolNode = class extends RunnableCallable {
 			const flushDeferredBlockedSideEffects = async () => {
 				for (const item of deferredBlockedSideEffects) {
 					await this.dispatchStepCompleted(item.callId, item.toolName, item.args, item.contentString, config);
-					if (hookRegistry.hasHookFor("PermissionDenied", runId)) executeHooks({
+					if (hookRegistry?.hasHookFor("PermissionDenied", runId) === true) executeHooks({
 						registry: hookRegistry,
 						input: {
 							hook_event_name: "PermissionDenied",
@@ -1256,6 +1359,13 @@ var ToolNode = class extends RunnableCallable {
 						continue;
 					}
 					if (hookResult.updatedInput != null) applyInputOverride(entry, hookResult.updatedInput);
+					else {
+						const reviewed = getReviewedToolApproval(approvalReviewEvidence?.payload, entry.call.id);
+						if (reviewed != null) {
+							entry.args = this.coerceEventToolArgs(entry.call.name, reviewed.request.arguments);
+							if (entry.call.id != null) unresolvedByCallId.delete(entry.call.id);
+						}
+					}
 					askEntries.push({
 						entry,
 						reason: hookResult.reason,
@@ -1264,6 +1374,19 @@ var ToolNode = class extends RunnableCallable {
 					continue;
 				}
 				if (hookResult.updatedInput != null) applyInputOverride(entry, hookResult.updatedInput);
+				const reviewedApproval = getReviewedToolApproval(approvalReviewEvidence?.payload, entry.call.id);
+				if (reviewedApproval != null) {
+					if (hookResult.updatedInput == null) {
+						entry.args = this.coerceEventToolArgs(entry.call.name, reviewedApproval.request.arguments);
+						if (entry.call.id != null) unresolvedByCallId.delete(entry.call.id);
+					}
+					askEntries.push({
+						entry,
+						reason: reviewedApproval.request.description,
+						allowedDecisions: reviewedApproval.reviewConfig.allowed_decisions
+					});
+					continue;
+				}
 				if (entry.call.id != null) {
 					const preempted = preemptedEagerRecords.get(entry.call.id);
 					if (preempted != null) this.eagerEventToolExecutions?.set(entry.call.id, preempted);
@@ -1273,9 +1396,12 @@ var ToolNode = class extends RunnableCallable {
 			if (askEntries.length > 0) {
 				const payload = buildToolApprovalInterruptPayload(askEntries, runId);
 				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) {
+				for (const { entry } of askEntries) hookRegistry?.clearPendingToolApproval(approvalReplaySessionId, createToolApprovalReplayKey(config, this.executingAgentId ?? this.agentId ?? "", entry.call.id));
+				const proposalMatches = approvalReviewEvidence == null || toolApprovalPayloadMatches(payload, approvalReviewEvidence.payload);
+				if (!proposalMatches) for (const { entry } of askEntries) blockEntry(entry, "Reviewed tool proposal changed before resume; retry approval");
+				const decisionEntries = proposalMatches ? askEntries : [];
+				const decisionByCallId = normalizeApprovalDecisions(decisionEntries.map(({ entry }) => entry.call.id), resumeValue);
+				for (const { entry, reason: askReason, allowedDecisions } of decisionEntries) {
 					const decision = decisionByCallId.get(entry.call.id) ?? {
 						type: "reject",
 						reason: "No decision provided for tool approval"
@@ -1401,7 +1527,7 @@ var ToolNode = class extends RunnableCallable {
 					userId: config.configurable?.user_id,
 					agentId: this.executingAgentId,
 					callerCapabilityProjection: this.getCallerCapabilityProjectionSnapshot(),
-					configurable: stripRunBreakerScope(config.configurable),
+					configurable: stripHostExecutionConfig(config.configurable),
 					metadata: config.metadata,
 					signal: config.signal,
 					resolve: (results) => {
@@ -1659,15 +1785,39 @@ var ToolNode = class extends RunnableCallable {
 		return this.dispatchStepCompleted(result.toolCallId, request.name, request.args, output, config, request.turn, resolveToolOutcome(request.args, outcomeFieldsFromResult(result), { isError: result.status === "error" }));
 	}
 	async runDirectBatchInterruptSafe(directCalls, batchIndices, config, baseContext) {
-		const settledBatchResults = baseContext.replayBatchKey == null ? void 0 : this.settledInterruptingResults.get(baseContext.replayBatchKey);
+		const settledBatchResults = baseContext.replayBatchKey == null ? void 0 : this.settledDirectResultsByBatch.get(baseContext.replayBatchKey) ?? /* @__PURE__ */ new Map();
+		const cacheResult = (call, position, result) => {
+			if (baseContext.replayBatchKey == null || settledBatchResults == null) return;
+			settledBatchResults.set(directReplayKey(call, baseContext.replayCallPositions?.get(call) ?? batchIndices[position]), result);
+			this.settledDirectResultsByBatch.set(baseContext.replayBatchKey, settledBatchResults);
+		};
 		const restoreResult = (call, result) => {
 			baseContext.additionalContextsSink?.push(...result.additionalContexts);
+			const turn = result.turn;
+			if (turn != null) this.recordToolUsageTurn(call.name, turn, call.id);
+			const refMeta = isBaseMessage(result.output) ? result.output.additional_kwargs : void 0;
+			if (refMeta?._refKey != null && result.referenceContent != null) {
+				this.toolOutputRegistry?.set(baseContext.batchScopeId, refMeta._refKey, result.referenceContent);
+				if (isBaseMessage(result.output)) result = {
+					...result,
+					output: new ToolMessage({
+						...result.output,
+						additional_kwargs: {
+							...result.output.additional_kwargs,
+							_refScope: baseContext.batchScopeId
+						}
+					})
+				};
+			}
 			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 cachedResult = settledBatchResults?.get(directReplayKey(call, baseContext.replayCallPositions?.get(call) ?? batchIndices[position]));
+			if (cachedResult != null) {
+				if (cachedResult.proposal.name !== call.name || !recordArgsEqual(cachedResult.proposal.args, call.args)) throw new Error("Cannot change an already completed tool call during approval replay");
+				return restoreResult(call, cachedResult);
+			}
 			const additionalContexts = [];
 			const output = await this.runDirectToolWithLifecycleHooks(call, config, {
 				...baseContext,
@@ -1675,14 +1825,32 @@ var ToolNode = class extends RunnableCallable {
 				additionalContextsSink: additionalContexts
 			});
 			const resolvedArgs = call.id == null ? void 0 : baseContext.resolvedArgsByCallId?.get(call.id);
-			return restoreResult(call, {
+			const result = {
+				proposal: structuredClone({
+					name: call.name,
+					args: call.args
+				}),
+				turn: call.id == null ? void 0 : this.toolCallTurns.get(call.id) ?? this.directPathTurns.get(call.id),
 				output,
 				additionalContexts,
 				...resolvedArgs == null ? {} : { resolvedArgs }
-			});
+			};
+			const refMeta = isBaseMessage(output) ? output.additional_kwargs : void 0;
+			if (refMeta?._refKey != null) result.referenceContent = this.toolOutputRegistry?.get(refMeta._refScope, refMeta._refKey);
+			cacheResult(call, position, result);
+			return restoreResult(call, result);
 		};
 		const interrupting = this.interruptingToolNames;
-		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);
+		if (!(interrupting != null && directCalls.some((call) => interrupting.has(call.name)))) {
+			const results = await Promise.allSettled(directCalls.map((call, i) => runOne(call, i)));
+			this.throwIfBreakerTripped(config);
+			const failed = results.find((result) => result.status === "rejected" && !isGraphInterrupt(result.reason)) ?? results.find((result) => result.status === "rejected");
+			if (failed?.status === "rejected") throw failed.reason;
+			return results.map((result) => {
+				if (result.status === "rejected") throw result.reason;
+				return result.value.output;
+			});
+		}
 		const outputs = new Array(directCalls.length);
 		const interruptingPositions = [];
 		const regularPositions = [];
@@ -1703,12 +1871,6 @@ var ToolNode = class extends RunnableCallable {
 			}
 			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)) {
@@ -1750,7 +1912,7 @@ var ToolNode = class extends RunnableCallable {
 		const outputs = [...toolMessages, ...injected];
 		return Array.isArray(input) ? outputs : { messages: outputs };
 	}
-	async run(input, config) {
+	async run(input, config, referenceReplay = {}) {
 		const breakerSignal = this.getBreakerSignal?.();
 		const composedSignal = composeAbortSignals(config.signal, breakerSignal);
 		const batchRunScope = this.getRunScope?.();
@@ -1766,10 +1928,11 @@ var ToolNode = class extends RunnableCallable {
 		this.toolCallTurns.clear();
 		const resolvedArgsByCallId = /* @__PURE__ */ new Map();
 		const errorOwnership = createToolErrorOwnership();
-		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;
+		const batchScopeId = config.configurable?.run_id ?? `\0anon-${this.anonBatchCounter++}`;
+		const resumedReferenceState = referenceReplay.state;
+		const replayInputSnapshot = resumedReferenceState == null ? void 0 : this.toolOutputRegistry?.resumeBatch(batchScopeId, resumedReferenceState);
+		referenceReplay.state = resumedReferenceState ?? this.toolOutputRegistry?.snapshotState(batchScopeId);
+		const turn = resumedReferenceState?.turnCounter ?? this.toolOutputRegistry?.nextTurn(batchScopeId) ?? 0;
 		let outputs;
 		let replayBatchKey;
 		let promotedAiMessage;
@@ -1779,17 +1942,19 @@ var ToolNode = class extends RunnableCallable {
 			if (this.eventDrivenMode && !isLocalTool) return this.executeViaEvent([input.lg_tool_call], config, input, {
 				batchIndices: [0],
 				turn,
-				batchScopeId
+				batchScopeId,
+				preBatchSnapshot: replayInputSnapshot
 			});
 			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 sendReplayBatchKey = sendAssistantBatch == null || getToolBatchReplayScope(config) == null ? void 0 : getAssistantBatchReplayKey(sendAssistantBatch, getToolBatchReplayScope(config));
 			const sendOutput = await this.runDirectToolWithLifecycleHooks(input.lg_tool_call, config, {
 				batchIndex: 0,
 				turn,
 				batchScopeId,
+				preBatchSnapshot: replayInputSnapshot,
 				resolvedArgsByCallId,
 				errorOwnership,
 				additionalContextsSink: directAdditionalContexts,
@@ -1813,14 +1978,15 @@ var ToolNode = class extends RunnableCallable {
 			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);
+			replayBatchKey = getToolBatchReplayScope(config) == null ? void 0 : getAssistantBatchReplayKey(assistantBatch, getToolBatchReplayScope(config));
 			if (this.loadRuntimeTools) {
 				const { tools, toolMap } = this.loadRuntimeTools(aiMessage.tool_calls ?? []);
 				this.toolMap = toolMap ?? new Map(tools.map((tool) => [tool.name, tool]));
 				this.applyToolExecutionOverrides();
 			}
+			const replayCallPositions = new Map((aiMessage.tool_calls ?? []).map((call, i) => [call, i]));
 			const filteredCalls = aiMessage.tool_calls?.filter((call) => {
-				return (call.id == null || !toolMessageIds.has(call.id)) && !(call.id?.startsWith("srvtoolu_") ?? false);
+				return (call.id == null || call.id === "" || !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_"));
 			invalidCallResults = attributableInvalidCalls.map((call) => new ToolMessage({
@@ -1862,14 +2028,16 @@ var ToolNode = class extends RunnableCallable {
 				if (directEntries.length === 0 && invalidCallResults.length === 0) return this.executeViaEvent(filteredCalls, config, input, {
 					batchIndices: eventEntries.map((entry) => entry.batchIndex),
 					turn,
-					batchScopeId
+					batchScopeId,
+					preBatchSnapshot: replayInputSnapshot
 				});
 				const directCalls = directEntries.map((e) => e.call);
 				const directIndices = directEntries.map((e) => e.batchIndex);
 				const eventCalls = eventEntries.map((e) => e.call);
 				const eventIndices = eventEntries.map((e) => e.batchIndex);
+				const approvalScopeCallIds = new Set(filteredCalls.flatMap((call) => call.id == null ? [] : [call.id]));
 				const preResolvedEventArgs = /* @__PURE__ */ new Map();
-				const preBatchSnapshot = this.toolOutputRegistry?.snapshot(batchScopeId);
+				const preBatchSnapshot = replayInputSnapshot ?? this.toolOutputRegistry?.snapshot(batchScopeId);
 				if (preBatchSnapshot != null) {
 					for (const entry of eventEntries) if (entry.call.id != null) {
 						const { resolved, unresolved } = preBatchSnapshot.resolve(entry.call.args, { substituteIntentKey: this.toolDeclaresBusinessIntent(entry.call.name) });
@@ -1888,9 +2056,25 @@ var ToolNode = class extends RunnableCallable {
 					preBatchSnapshot,
 					additionalContextsSink: directAdditionalContexts,
 					replayBatchKey,
+					replayCallPositions,
+					approvalScopeCallIds,
 					runInput: input
 				}) : [];
-				if (directCalls.length > 0 && directOutputs.length > 0) await this.handleRunToolCompletions(directCalls, directOutputs, config, resolvedArgsByCallId, errorOwnership);
+				const settledDirectResults = replayBatchKey == null ? void 0 : this.settledDirectResultsByBatch.get(replayBatchKey);
+				const unhandledDirectCalls = [];
+				const unhandledDirectOutputs = [];
+				for (let i = 0; i < directCalls.length; i++) {
+					if ((settledDirectResults?.get(directReplayKey(directCalls[i], replayCallPositions.get(directCalls[i]))))?.completionHandled === true) continue;
+					unhandledDirectCalls.push(directCalls[i]);
+					unhandledDirectOutputs.push(directOutputs[i]);
+				}
+				if (unhandledDirectCalls.length > 0) {
+					await this.handleRunToolCompletions(unhandledDirectCalls, unhandledDirectOutputs, config, resolvedArgsByCallId, errorOwnership);
+					for (let i = 0; i < directCalls.length; i++) {
+						const settled = settledDirectResults?.get(directReplayKey(directCalls[i], replayCallPositions.get(directCalls[i])));
+						if (settled != null) settled.completionHandled = true;
+					}
+				}
 				const eventResult = eventCalls.length > 0 ? await this.dispatchToolEvents(eventCalls, config, {
 					batchIndices: eventIndices,
 					turn,
@@ -1917,8 +2101,9 @@ var ToolNode = class extends RunnableCallable {
 					...eventResult.injected
 				];
 			} else {
-				const preBatchSnapshot = this.toolOutputRegistry?.snapshot(batchScopeId);
+				const preBatchSnapshot = replayInputSnapshot ?? this.toolOutputRegistry?.snapshot(batchScopeId);
 				const directAdditionalContexts = [];
+				const approvalScopeCallIds = new Set(filteredCalls.flatMap((call) => call.id == null ? [] : [call.id]));
 				const toolOutputs = await this.runDirectBatchInterruptSafe(filteredCalls, filteredCalls.map((_call, i) => i), config, {
 					turn,
 					batchScopeId,
@@ -1927,6 +2112,8 @@ var ToolNode = class extends RunnableCallable {
 					preBatchSnapshot,
 					additionalContextsSink: directAdditionalContexts,
 					replayBatchKey,
+					replayCallPositions,
+					approvalScopeCallIds,
 					runInput: input
 				});
 				await this.handleRunToolCompletions(filteredCalls, toolOutputs, config, resolvedArgsByCallId, errorOwnership);
@@ -1955,7 +2142,7 @@ var ToolNode = class extends RunnableCallable {
 			}
 		}
 		if (!outputs.some(isCommand)) {
-			if (replayBatchKey != null) this.settledInterruptingResults.delete(replayBatchKey);
+			if (replayBatchKey != null) this.settledDirectResultsByBatch.delete(replayBatchKey);
 			return Array.isArray(input) ? outputs : { messages: outputs };
 		}
 		if (promotedAiMessage != null) outputs = outputs.map((output) => isCommand(output) ? patchCommandUpdateForPromotedInvalidCalls(output, promotedAiMessage, invalidCallResults) : output);
@@ -2005,7 +2192,7 @@ var ToolNode = class extends RunnableCallable {
 			combinedOutputs.push(parallelCommand);
 		} else if (handoffCommands.length === 1) combinedOutputs.push(handoffCommands[0]);
 		if (parentCommand) combinedOutputs.push(parentCommand);
-		if (replayBatchKey != null) this.settledInterruptingResults.delete(replayBatchKey);
+		if (replayBatchKey != null) this.settledDirectResultsByBatch.delete(replayBatchKey);
 		return combinedOutputs;
 	}
 	isSendInput(input) {