@librechat/agents 3.3.13 → 3.4.1

package/dist/cjs/graphs/Graph.cjs

@@ -1,3 +1,4 @@
+const require_SubagentReplay = require("../tools/subagent/SubagentReplay.cjs");
 const require_misc = require("../utils/misc.cjs");
 const require_langfuseConfig = require("../langfuseConfig.cjs");
 const require_langfuseRuntimeScope = require("../langfuseRuntimeScope.cjs");
@@ -27,16 +28,16 @@ const require_handoffCue = require("../messages/handoffCue.cjs");
 const require_reducer = require("../messages/reducer.cjs");
 const require_recency = require("../messages/recency.cjs");
 require("../messages/index.cjs");
+const require_graph = require("../utils/graph.cjs");
+const require_llm = require("../utils/llm.cjs");
 const require_handlers = require("../tools/handlers.cjs");
 const require_streamLimits = require("../llm/streamLimits.cjs");
 const require_toolOutputReferences = require("../tools/toolOutputReferences.cjs");
-const require_llm = require("../utils/llm.cjs");
-const require_toolCache = require("../llm/bedrock/toolCache.cjs");
-const require_preempt = require("../llm/preempt.cjs");
-const require_graph = require("../utils/graph.cjs");
 const require_events$1 = require("../events.cjs");
 const require_run = require("../utils/run.cjs");
 require("../utils/index.cjs");
+const require_toolCache = require("../llm/bedrock/toolCache.cjs");
+const require_preempt = require("../llm/preempt.cjs");
 const require_init = require("../llm/init.cjs");
 const require_invoke = require("../llm/invoke.cjs");
 const require_contextOverflowRecovery = require("../llm/contextOverflowRecovery.cjs");
@@ -262,6 +263,7 @@ function getDispatchableFinalReasoningContent({ agentContext, responseReasoningC
 	return responseReasoningContent;
 }
 var Graph = class {
+	restoreCheckpointMessages(_messages, _pendingMessages) {}
 	/** Returns a snapshot of deferred tools discovered by this graph. */
 	getDiscoveredTools(_agentId) {
 		return [];
@@ -419,7 +421,7 @@ var Graph = class {
 		this._toolOutputRegistry?.clear();
 		this._toolOutputRegistry = void 0;
 		for (const node of this._compiledToolNodes) node.clearDirectPathTurns();
-		this._compiledToolNodes.clear();
+		for (const executor of this._subagentExecutors) executor.clearHeavyState();
 		this.sessions.clear();
 	}
 	getEagerEventToolUsageCount(agentId) {
@@ -460,6 +462,73 @@ var Graph = class {
 	registerCompiledToolNode(node) {
 		this._compiledToolNodes.add(node);
 	}
+	registerSubagentExecutor(executor) {
+		this._subagentExecutors.add(executor);
+	}
+	resetSubagentCheckpointThreadIds() {
+		for (const executor of this._subagentExecutors) executor.resetCheckpointThreadIds();
+	}
+	getChildCheckpointThreadIds() {
+		const threadIds = /* @__PURE__ */ new Set();
+		for (const executor of this._subagentExecutors) for (const threadId of executor.getChildCheckpointThreadIds()) threadIds.add(threadId);
+		return [...threadIds];
+	}
+	createSubagentResumeState(runId) {
+		return {
+			toolCallSteps: [...this.toolCallStepIds].map(([toolCallId, stepId]) => ({
+				toolCallId,
+				stepId
+			})),
+			toolSessions: [...this.sessions].map(([toolName, context]) => ({
+				toolName,
+				context: {
+					...context,
+					...context.files == null ? {} : { files: context.files.map((file) => ({ ...file })) }
+				}
+			})),
+			toolNodes: [...this._compiledToolNodes].map((node) => node.createSubagentResumeState()),
+			eagerToolUsage: [{
+				agentId: "",
+				toolUsageCounts: [...this.eagerEventToolUsageCount].map(([toolName, count]) => ({
+					toolName,
+					count
+				}))
+			}, ...[...this.eagerEventToolUsageCountsByAgentId].map(([agentId, usageCounts]) => ({
+				agentId,
+				toolUsageCounts: [...usageCounts].map(([toolName, count]) => ({
+					toolName,
+					count
+				}))
+			}))],
+			eagerToolSuppressions: [...this.eagerEventToolSuppressions],
+			...this._toolOutputRegistry == null ? {} : { toolOutputReferences: this._toolOutputRegistry.snapshotState(runId) }
+		};
+	}
+	restoreSubagentResumeState(state, runId) {
+		const toolNodesByKey = new Map([...this._compiledToolNodes].map((node) => {
+			return [node.createSubagentResumeState().stateKey, node];
+		}));
+		if (toolNodesByKey.size !== state.toolNodes.length) throw new Error("Cannot restore changed subagent tool topology.");
+		for (const nodeState of state.toolNodes) if (!toolNodesByKey.has(nodeState.stateKey)) throw new Error(`Cannot restore subagent tool state for "${nodeState.stateKey}".`);
+		const registry = state.toolOutputReferences == null ? void 0 : this.getOrCreateToolOutputRegistry();
+		if (state.toolOutputReferences != null && registry == null) throw new Error("Cannot restore disabled tool output references.");
+		this.toolCallStepIds.clear();
+		for (const { toolCallId, stepId } of state.toolCallSteps) this.toolCallStepIds.set(toolCallId, stepId);
+		this.sessions.clear();
+		for (const { toolName, context } of state.toolSessions) this.sessions.set(toolName, {
+			...context,
+			...context.files == null ? {} : { files: context.files.map((file) => ({ ...file })) }
+		});
+		for (const nodeState of state.toolNodes) toolNodesByKey.get(nodeState.stateKey).restoreSubagentResumeState(nodeState);
+		this.clearEagerEventToolUsageCounts();
+		for (const usageState of state.eagerToolUsage) {
+			const usageCounts = this.getEagerEventToolUsageCount(usageState.agentId);
+			for (const { toolName, count } of usageState.toolUsageCounts) usageCounts.set(toolName, count);
+		}
+		this.eagerEventToolSuppressions.clear();
+		for (const toolName of state.eagerToolSuppressions) this.eagerEventToolSuppressions.add(toolName);
+		if (state.toolOutputReferences != null && registry != null) registry.restoreState(runId, state.toolOutputReferences);
+	}
 	/**
 	* Returns the shared `ToolOutputReferenceRegistry` for this run,
 	* constructing it on first access. Returns `undefined` when the
@@ -501,6 +570,7 @@ var Graph = class {
 	* across Runs if a provider reuses call ids (Codex P2 #33).
 	*/
 	_compiledToolNodes = /* @__PURE__ */ new Set();
+	_subagentExecutors = /* @__PURE__ */ new Set();
 	getOrCreateFileCheckpointer() {
 		if (this._fileCheckpointer != null) return this._fileCheckpointer;
 		if (this.toolExecution?.engine === "local" && this.toolExecution.local?.fileCheckpointing === true) {
@@ -517,11 +587,14 @@ var Graph = class {
 };
 var StandardGraph = class StandardGraph extends Graph {
 	overrideModel;
+	subagentModelOverride;
 	/** Optional compile options passed into workflow.compile() */
 	compileOptions;
 	/** Whether the workflow was actually compiled with a checkpointer. */
 	hasCompiledCheckpointer = false;
 	messages = [];
+	/** Whether a rebuilt resume seeded the message baseline from its checkpoint. */
+	hasRestoredCheckpointMessages = false;
 	/** Cached run messages preserved before clearHeavyState() so getRunMessages() works after cleanup. */
 	cachedRunMessages;
 	/** Per-agent discovery snapshots preserved before contexts are reset on cleanup. */
@@ -685,7 +758,9 @@ var StandardGraph = class StandardGraph extends Graph {
 		this.defaultAgentId = agents[0].agentId;
 	}
 	resetValues(keepContent, checkpointScope) {
+		this.resetSubagentCheckpointThreadIds();
 		this.messages = [];
+		this.hasRestoredCheckpointMessages = false;
 		this.cachedRunMessages = void 0;
 		this.cachedDiscoveredTools = void 0;
 		this.config = require_graph.resetIfNotEmpty(this.config, void 0);
@@ -743,12 +818,21 @@ var StandardGraph = class StandardGraph extends Graph {
 		for (const context of this.agentContexts.values()) context.reset({ preserveOriginalToolContent });
 		this.originalToolContentCheckpointScope = hasScopedCheckpoint ? checkpointScope : void 0;
 	}
+	/** Seeds the sidecar message view that checkpoint restoration bypasses. */
+	restoreCheckpointMessages(messages, pendingMessages) {
+		if (this.messages.length > 0) return;
+		this.messages = pendingMessages == null ? [...messages] : require_reducer.messagesStateReducer(messages, pendingMessages);
+		this.startIndex = this.messages.length;
+		this.hasRestoredCheckpointMessages = true;
+		this.cachedRunMessages = void 0;
+	}
 	clearHeavyState() {
 		this.cachedRunMessages = this.messages.slice(this.startIndex);
 		this.cachedDiscoveredTools = new Map(Array.from(this.agentContexts, ([agentId, context]) => [agentId, context.getDiscoveredTools()]));
 		super.clearHeavyState();
 		this.messages = [];
 		this.overrideModel = void 0;
+		this.subagentModelOverride = void 0;
 		/** Stream-limit accounting (argument tallies, event counts, charge
 		* credits) deliberately SURVIVES cleanup: this runs in `processStream`'s
 		* finally, which an ordinary parallel-branch failure reaches while
@@ -1029,6 +1113,9 @@ var StandardGraph = class StandardGraph extends Graph {
 			runLangfuse: this.langfuse,
 			agentLangfuse: agentContext?.langfuse
 		});
+		const interruptingToolNames = new Set(this.interruptingToolNames ?? []);
+		if (this.humanInTheLoop?.enabled === true && (agentContext?.subagentConfigs?.length ?? 0) > 0) interruptingToolNames.add("subagent");
+		const effectiveInterruptingToolNames = interruptingToolNames.size > 0 ? interruptingToolNames : void 0;
 		if (eventDrivenMode) {
 			const schemaTools = require_schema.createSchemaOnlyTools(toolDefinitions);
 			const toolDefMap = new Map(toolDefinitions.map((def) => [def.name, def]));
@@ -1065,7 +1152,7 @@ var StandardGraph = class StandardGraph extends Graph {
 				eagerEventToolSuppressions: this.eagerEventToolSuppressions,
 				toolExecution: this.toolExecution,
 				directToolNames: directToolNames.size > 0 ? directToolNames : void 0,
-				interruptingToolNames: this.interruptingToolNames != null && this.interruptingToolNames.length > 0 ? new Set(this.interruptingToolNames) : void 0,
+				interruptingToolNames: effectiveInterruptingToolNames,
 				maxContextTokens: agentContext?.maxContextTokens,
 				maxToolResultChars: agentContext?.maxToolResultChars,
 				toolOutputRegistry: this.getOrCreateToolOutputRegistry(),
@@ -1093,7 +1180,7 @@ var StandardGraph = class StandardGraph extends Graph {
 			sessions: this.sessions,
 			toolExecution: this.toolExecution,
 			codeSessionToolNames: this.codeSessionToolNames,
-			interruptingToolNames: this.interruptingToolNames != null && this.interruptingToolNames.length > 0 ? new Set(this.interruptingToolNames) : void 0,
+			interruptingToolNames: effectiveInterruptingToolNames,
 			hookRegistry: this.hookRegistry,
 			humanInTheLoop: this.humanInTheLoop,
 			maxContextTokens: agentContext?.maxContextTokens,
@@ -1113,6 +1200,10 @@ var StandardGraph = class StandardGraph extends Graph {
 			toolCalls
 		});
 	}
+	/** Explicitly overrides the model used by isolated descendant subagent graphs. */
+	setSubagentModelOverride(model) {
+		this.subagentModelOverride = model;
+	}
 	getUsageMetadata(finalMessage) {
 		if (finalMessage && "usage_metadata" in finalMessage && finalMessage.usage_metadata != null) return finalMessage.usage_metadata;
 	}
@@ -2335,17 +2426,19 @@ var StandardGraph = class StandardGraph extends Graph {
 					tokenCounter: agentContext.tokenCounter,
 					usageSink: this.subagentUsageSink,
 					streamLimits: this.streamLimits,
+					humanInTheLoop: this.humanInTheLoop,
+					checkpointer: this.compileOptions?.checkpointer,
 					maxDepth: effectiveSubagentDepth,
 					createChildGraph: (input) => {
 						const childGraph = new StandardGraph(input);
+						if (this.subagentModelOverride != null) {
+							childGraph.overrideModel = this.subagentModelOverride;
+							childGraph.setSubagentModelOverride(this.subagentModelOverride);
+						}
 						const toolHandlerRegistry = createToolHandlerRegistry(getParentHandlerRegistry());
 						childGraph.hookRegistry = this.hookRegistry;
-						/**
-						* Do not propagate `humanInTheLoop` into the child graph yet:
-						* nested subagent interrupts need a stable child checkpoint and
-						* resume bridge. Child hooks still fire; `ask` decisions fail
-						* closed inside the subagent until that flow is implemented.
-						*/
+						childGraph.humanInTheLoop = this.humanInTheLoop;
+						if (this.humanInTheLoop?.enabled === true) childGraph.compileOptions = { checkpointer: this.compileOptions?.checkpointer };
 						childGraph.toolOutputReferences = this.toolOutputReferences;
 						childGraph.eagerEventToolExecution = this.eagerEventToolExecution;
 						childGraph.codeSessionToolNames = this.codeSessionToolNames;
@@ -2356,24 +2449,19 @@ var StandardGraph = class StandardGraph extends Graph {
 						return childGraph;
 					}
 				});
+				this.registerSubagentExecutor(executor);
 				const subagentTool = (0, _langchain_core_tools.tool)(async (rawInput, config) => {
 					const input = rawInput;
 					const description = typeof input.description === "string" && input.description.trim().length > 0 ? input.description : "No task description provided";
 					const subagentType = typeof input.subagent_type === "string" ? input.subagent_type : "";
 					const threadId = config.configurable?.thread_id;
-					/**
-					* When the tool is dispatched from an LLM's `tool_call`, LangChain
-					* threads the originating `ToolCall` onto the RunnableConfig as
-					* `config.toolCall` (see `ToolRunnableConfig` in
-					* `@langchain/core/tools` — internal but stable since ≥0.3.x).
-					* Surfacing its id lets hosts correlate `SubagentUpdateEvent`s
-					* back to the parent's `tool_call_id` deterministically — no
-					* temporal heuristics needed. If a future LangChain version
-					* changes the threading, the type-guarded read falls back to
-					* `undefined` and the correlation degrades gracefully.
-					*/
-					const toolCall = config.toolCall;
-					const parentToolCallId = typeof toolCall?.id === "string" ? toolCall.id : void 0;
+					/** Surface the parent call id so child checkpoints, interrupts, and
+					* update events remain correlated across replay and resume. */
+					const toolRuntime = config;
+					const toolCall = toolRuntime.toolCall;
+					let parentToolCallId;
+					if (typeof toolRuntime.toolCallId === "string" && toolRuntime.toolCallId !== "") parentToolCallId = toolRuntime.toolCallId;
+					else if (typeof toolCall?.id === "string" && toolCall.id !== "") parentToolCallId = toolCall.id;
 					/** The parent tool batch's entry-captured scope (stamped by
 					* ToolNode before PreToolUse hooks) — binds this child to the
 					* run that dispatched it, not to whatever controller a reset
@@ -2394,6 +2482,12 @@ var StandardGraph = class StandardGraph extends Graph {
 						parentConfigurable: config.configurable
 					})).content;
 				}, require_SubagentTool.buildSubagentToolParams(resolvedConfigs));
+				const replayableSubagentTool = subagentTool;
+				replayableSubagentTool[require_SubagentReplay.SUBAGENT_REPLAY_CONTROLLER] = {
+					getResumeManifest: (parentToolCallIds) => executor.getResumeManifest(parentToolCallIds),
+					getSettledOutput: (call, config) => executor.getSettledToolOutput(call, config),
+					persistSettledOutput: (call, config, output) => executor.persistSettledToolOutput(call, config, output)
+				};
 				if (!agentContext.graphTools) agentContext.graphTools = [];
 				agentContext.graphTools.push(subagentTool);
 				/**
@@ -2546,7 +2640,7 @@ var StandardGraph = class StandardGraph extends Graph {
 		const agentNode = this.createAgentNode(this.defaultAgentId);
 		return new _langchain_langgraph.StateGraph(_langchain_langgraph.Annotation.Root({ messages: (0, _langchain_langgraph.Annotation)({
 			reducer: (a, b) => {
-				if (!this.messages.length) this.startIndex = a.length + b.length;
+				if (!this.messages.length && !this.hasRestoredCheckpointMessages) this.startIndex = a.length + b.length;
 				const result = require_reducer.messagesStateReducer(a, b);
 				this.messages = result;
 				return result;