@librechat/agents 3.4.0 → 3.4.2

package/dist/cjs/run.cjs

@@ -1,3 +1,4 @@
+const require_SubagentReplay = require("./tools/subagent/SubagentReplay.cjs");
 const require_langfuseRuntimeContext = require("./langfuseRuntimeContext.cjs");
 const require_langfuseConfig = require("./langfuseConfig.cjs");
 const require_langfuseRuntimeScope = require("./langfuseRuntimeScope.cjs");
@@ -8,16 +9,16 @@ require("./common/index.cjs");
 const require_activityLabel = require("./prompts/activityLabel.cjs");
 const require_callbacks = require("./utils/callbacks.cjs");
 const require_title = require("./utils/title.cjs");
+const require_applyGraphRuntimeConfig = require("./graphs/applyGraphRuntimeConfig.cjs");
 const require_tokens = require("./utils/tokens.cjs");
 const require_instrumentation = require("./instrumentation.cjs");
 const require_llm = require("./utils/llm.cjs");
-const require_preempt = require("./llm/preempt.cjs");
 const require_events = require("./events.cjs");
+const require_preempt = require("./llm/preempt.cjs");
 const require_init = require("./llm/init.cjs");
 const require_executeHooks = require("./hooks/executeHooks.cjs");
 require("./hooks/index.cjs");
-const require_Graph = require("./graphs/Graph.cjs");
-const require_MultiAgentGraph = require("./graphs/MultiAgentGraph.cjs");
+const require_createGraph = require("./graphs/createGraph.cjs");
 let nanoid = require("nanoid");
 let _langchain_core_prompts = require("@langchain/core/prompts");
 let _langchain_core_runnables = require("@langchain/core/runnables");
@@ -69,6 +70,30 @@ function isLangGraphResumeMapForInterrupt(value, interruptId) {
 	if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
 	return Object.prototype.hasOwnProperty.call(value, interruptId);
 }
+function getInterruptHookSessionId(payload) {
+	const publicPayload = require_SubagentReplay.stripSubagentResumeManifest(payload);
+	if (publicPayload == null || typeof publicPayload !== "object" || publicPayload.type !== "tool_approval") return;
+	const sessionId = publicPayload.hook_session_id;
+	return typeof sessionId === "string" && sessionId.length > 0 ? sessionId : void 0;
+}
+function getFirstPersistedInterrupt(snapshot) {
+	for (const task of snapshot.tasks ?? []) for (const pendingInterrupt of task.interrupts ?? []) if (typeof pendingInterrupt.id === "string" && pendingInterrupt.id.length > 0) return {
+		id: pendingInterrupt.id,
+		value: pendingInterrupt.value
+	};
+}
+function getPersistedMessages(snapshot) {
+	const messages = snapshot.values?.messages;
+	if (!Array.isArray(messages) || !messages.every(_langchain_core_messages.BaseMessage.isInstance)) return;
+	return messages;
+}
+function getResumeUpdateMessages(update) {
+	if (update == null) return;
+	const messages = Array.isArray(update) ? update.find(([key]) => key === "messages")?.[1] : update.messages;
+	if (_langchain_core_messages.BaseMessage.isInstance(messages)) return [messages];
+	if (!Array.isArray(messages) || !messages.every(_langchain_core_messages.BaseMessage.isInstance)) return;
+	return messages;
+}
 var Run = class Run {
 	id;
 	tokenCounter;
@@ -140,10 +165,7 @@ var Run = class Run {
 		} else {
 			/** Default to legacy graph for 'standard' or undefined type */
 			this.graphRunnable = this.createLegacyGraph(config.graphConfig);
-			if (this.Graph) {
-				this.Graph.compileOptions = config.graphConfig.compileOptions ?? this.Graph.compileOptions;
-				this.Graph.handlerRegistry = handlerRegistry;
-			}
+			if (this.Graph) this.Graph.handlerRegistry = handlerRegistry;
 		}
 		if (config.initialSessions && this.Graph) for (const [key, value] of config.initialSessions) this.Graph.sessions.set(key, value);
 		this.returnContent = config.returnContent ?? false;
@@ -170,54 +192,64 @@ var Run = class Run {
 			};
 			signal = legacySignal;
 		}
-		const standardGraph = new require_Graph.StandardGraph({
-			signal,
-			runId: this.id,
-			agents: [agentConfig],
-			langfuse: this.langfuse,
-			tokenCounter: this.tokenCounter,
-			indexTokenCountMap: this.indexTokenCountMap,
-			calibrationRatio: this.calibrationRatio,
-			subagentUsageSink: this.subagentUsageSink,
-			preemption: this.preemption,
-			streamLimits: this.streamLimits
+		const standardGraph = require_createGraph.createGraph({
+			kind: "standard",
+			input: {
+				signal,
+				runId: this.id,
+				agents: [agentConfig],
+				langfuse: this.langfuse,
+				tokenCounter: this.tokenCounter,
+				indexTokenCountMap: this.indexTokenCountMap,
+				calibrationRatio: this.calibrationRatio,
+				subagentUsageSink: this.subagentUsageSink,
+				preemption: this.preemption,
+				streamLimits: this.streamLimits
+			}
 		});
 		/** Propagate compile options from graph config */
 		standardGraph.compileOptions = this.applyHITLCheckpointerFallback(config.compileOptions);
 		this.hasCheckpointer = standardGraph.compileOptions?.checkpointer != null;
-		standardGraph.hookRegistry = this.hookRegistry;
-		standardGraph.humanInTheLoop = this.humanInTheLoop;
-		standardGraph.toolOutputReferences = this.toolOutputReferences;
-		standardGraph.eagerEventToolExecution = this.eagerEventToolExecution;
-		standardGraph.codeSessionToolNames = this.codeSessionToolNames;
-		standardGraph.interruptingToolNames = this.interruptingToolNames;
-		standardGraph.toolExecution = this.toolExecution;
+		require_applyGraphRuntimeConfig.applyGraphRuntimeConfig(standardGraph, {
+			hookRegistry: this.hookRegistry,
+			humanInTheLoop: this.humanInTheLoop,
+			toolOutputReferences: this.toolOutputReferences,
+			eagerEventToolExecution: this.eagerEventToolExecution,
+			codeSessionToolNames: this.codeSessionToolNames,
+			interruptingToolNames: this.interruptingToolNames,
+			toolExecution: this.toolExecution
+		});
 		this.Graph = standardGraph;
 		return standardGraph.createWorkflow();
 	}
 	createMultiAgentGraph(config) {
 		const { agents, edges, compileOptions } = config;
-		const multiAgentGraph = new require_MultiAgentGraph.MultiAgentGraph({
-			runId: this.id,
-			agents,
-			edges,
-			langfuse: this.langfuse,
-			tokenCounter: this.tokenCounter,
-			indexTokenCountMap: this.indexTokenCountMap,
-			calibrationRatio: this.calibrationRatio,
-			subagentUsageSink: this.subagentUsageSink,
-			preemption: this.preemption,
-			streamLimits: this.streamLimits
+		const multiAgentGraph = require_createGraph.createGraph({
+			kind: "multi-agent",
+			input: {
+				runId: this.id,
+				agents,
+				edges,
+				langfuse: this.langfuse,
+				tokenCounter: this.tokenCounter,
+				indexTokenCountMap: this.indexTokenCountMap,
+				calibrationRatio: this.calibrationRatio,
+				subagentUsageSink: this.subagentUsageSink,
+				preemption: this.preemption,
+				streamLimits: this.streamLimits
+			}
 		});
 		multiAgentGraph.compileOptions = this.applyHITLCheckpointerFallback(compileOptions);
 		this.hasCheckpointer = multiAgentGraph.compileOptions?.checkpointer != null;
-		multiAgentGraph.hookRegistry = this.hookRegistry;
-		multiAgentGraph.humanInTheLoop = this.humanInTheLoop;
-		multiAgentGraph.toolOutputReferences = this.toolOutputReferences;
-		multiAgentGraph.eagerEventToolExecution = this.eagerEventToolExecution;
-		multiAgentGraph.codeSessionToolNames = this.codeSessionToolNames;
-		multiAgentGraph.interruptingToolNames = this.interruptingToolNames;
-		multiAgentGraph.toolExecution = this.toolExecution;
+		require_applyGraphRuntimeConfig.applyGraphRuntimeConfig(multiAgentGraph, {
+			hookRegistry: this.hookRegistry,
+			humanInTheLoop: this.humanInTheLoop,
+			toolOutputReferences: this.toolOutputReferences,
+			eagerEventToolExecution: this.eagerEventToolExecution,
+			codeSessionToolNames: this.codeSessionToolNames,
+			interruptingToolNames: this.interruptingToolNames,
+			toolExecution: this.toolExecution
+		});
 		this.Graph = multiAgentGraph;
 		return multiAgentGraph.createWorkflow();
 	}
@@ -380,6 +412,9 @@ var Run = class Run {
 		if (!this.Graph) throw new Error("Graph not initialized. Make sure to use Run.create() to instantiate the Run.");
 		return this.Graph.getRunMessages();
 	}
+	getChildCheckpointThreadIds() {
+		return this.Graph?.getChildCheckpointThreadIds() ?? [];
+	}
 	/**
 	* Returns a defensive snapshot of tools discovered by the current run.
 	* Pass an agent id for that context, or omit it for the ordered union across
@@ -498,6 +533,10 @@ var Run = class Run {
 			recursionLimit,
 			configurable: { ...callerConfig.configurable }
 		};
+		if (!isResume) {
+			delete config.configurable?.[require_SubagentReplay.SUBAGENT_RESUME_ATTEMPT_CONFIG_KEY];
+			delete config.configurable?.[require_SubagentReplay.SUBAGENT_RESUME_MANIFEST_CONFIG_KEY];
+		}
 		/**
 		* Cancellation can arrive either at graph construction or per-call through
 		* `callerConfig.signal`, and boundary hooks need to observe both — for a
@@ -855,7 +894,11 @@ var Run = class Run {
 	* fields.
 	*/
 	getInterrupt() {
-		return this._interrupt;
+		if (this._interrupt == null) return;
+		return {
+			...this._interrupt,
+			payload: require_SubagentReplay.stripSubagentResumeManifest(this._interrupt.payload)
+		};
 	}
 	/**
 	* Returns the reason a hook halted the run via
@@ -926,29 +969,42 @@ var Run = class Run {
 	*   tool-node resume). Intended for custom, Command-routed graphs.
 	*/
 	async resume(resumeValue, callerConfig, streamOptions, commandOptions) {
+		const resumeConfig = await this.resolveInterruptResumeConfig(callerConfig, commandOptions?.update);
 		const interruptId = this._interrupt?.interruptId;
 		const scopedResume = typeof interruptId === "string" && interruptId.length > 0 && !isLangGraphResumeMapForInterrupt(resumeValue, interruptId) ? { [interruptId]: resumeValue } : resumeValue;
-		const resumeConfig = await this.resolveInterruptResumeConfig(callerConfig);
 		return this.processStream(new _langchain_langgraph.Command({
 			resume: scopedResume,
 			...commandOptions?.update !== void 0 ? { update: commandOptions.update } : {},
 			...commandOptions?.goto !== void 0 ? { goto: commandOptions.goto } : {}
 		}), resumeConfig, streamOptions);
 	}
-	async resolveInterruptResumeConfig(callerConfig) {
+	async resolveInterruptResumeConfig(callerConfig, resumeUpdate) {
+		await this.restoreInterruptFromCheckpoint(callerConfig, resumeUpdate);
 		const interrupt = this._interrupt;
+		const resumeManifest = require_SubagentReplay.requireValidSubagentResumeManifest(interrupt?.payload);
+		const resumeConfigurable = { ...callerConfig.configurable };
+		delete resumeConfigurable[require_SubagentReplay.SUBAGENT_RESUME_ATTEMPT_CONFIG_KEY];
+		delete resumeConfigurable[require_SubagentReplay.SUBAGENT_RESUME_MANIFEST_CONFIG_KEY];
+		resumeConfigurable[require_SubagentReplay.SUBAGENT_RESUME_ATTEMPT_CONFIG_KEY] = (0, nanoid.nanoid)();
+		if (resumeManifest != null) resumeConfigurable[require_SubagentReplay.SUBAGENT_RESUME_MANIFEST_CONFIG_KEY] = resumeManifest;
+		const manifestConfig = {
+			...callerConfig,
+			configurable: resumeConfigurable
+		};
+		const hookSessionId = getInterruptHookSessionId(interrupt?.payload);
+		if (hookSessionId != null) this.hookRegistry?.copySession(hookSessionId, this.id);
 		const interruptId = interrupt?.interruptId;
 		const stateHistory = this.graphRunnable?.getStateHistory;
 		if (interrupt?.checkpointId != null && interrupt.checkpointId.length > 0) return {
-			...callerConfig,
+			...manifestConfig,
 			configurable: {
-				...callerConfig.configurable,
+				...manifestConfig.configurable,
 				checkpoint_id: interrupt.checkpointId,
 				...typeof interrupt.checkpointNs === "string" ? { checkpoint_ns: interrupt.checkpointNs } : {}
 			}
 		};
-		if (interrupt == null || typeof interruptId !== "string" || interruptId.length === 0 || typeof stateHistory !== "function") return callerConfig;
-		for await (const snapshot of stateHistory.call(this.graphRunnable, callerConfig)) {
+		if (interrupt == null || typeof interruptId !== "string" || interruptId.length === 0 || typeof stateHistory !== "function") return manifestConfig;
+		for await (const snapshot of stateHistory.call(this.graphRunnable, manifestConfig)) {
 			const hasMatchingInterrupt = snapshot.tasks?.some((task) => task.interrupts?.some((interrupt) => interrupt.id === interruptId) === true) === true;
 			const checkpointConfigurable = snapshot.config?.configurable;
 			if (!hasMatchingInterrupt || checkpointConfigurable == null) continue;
@@ -961,16 +1017,37 @@ var Run = class Run {
 					...typeof checkpointNs === "string" ? { checkpointNs } : {}
 				};
 				return {
-					...callerConfig,
+					...manifestConfig,
 					configurable: {
-						...callerConfig.configurable,
+						...manifestConfig.configurable,
 						checkpoint_id: checkpointId,
 						...typeof checkpointNs === "string" ? { checkpoint_ns: checkpointNs } : {}
 					}
 				};
 			}
 		}
-		return callerConfig;
+		return manifestConfig;
+	}
+	async restoreInterruptFromCheckpoint(callerConfig, resumeUpdate) {
+		if (this._interrupt != null || this.humanInTheLoop?.enabled !== true) return;
+		const workflow = this.graphRunnable;
+		if (typeof workflow?.getState !== "function") return;
+		const snapshot = await workflow.getState(callerConfig);
+		const persistedInterrupt = getFirstPersistedInterrupt(snapshot);
+		if (persistedInterrupt == null) return;
+		const persistedMessages = getPersistedMessages(snapshot);
+		if (persistedMessages != null) this.Graph?.restoreCheckpointMessages(persistedMessages, getResumeUpdateMessages(resumeUpdate));
+		const checkpointConfigurable = snapshot.config?.configurable;
+		const checkpointId = checkpointConfigurable?.checkpoint_id;
+		const checkpointNs = checkpointConfigurable?.checkpoint_ns;
+		const threadId = callerConfig.configurable?.thread_id;
+		this._interrupt = {
+			interruptId: persistedInterrupt.id,
+			payload: persistedInterrupt.value,
+			...typeof threadId === "string" ? { threadId } : {},
+			...typeof checkpointId === "string" ? { checkpointId } : {},
+			...typeof checkpointNs === "string" ? { checkpointNs } : {}
+		};
 	}
 	createSystemCallback(clientCallbacks, key) {
 		return ((...args) => {