@librechat/agents 3.4.0 → 3.4.2

package/dist/esm/run.mjs

@@ -1,3 +1,4 @@
+import { SUBAGENT_RESUME_ATTEMPT_CONFIG_KEY, SUBAGENT_RESUME_MANIFEST_CONFIG_KEY, requireValidSubagentResumeManifest, stripSubagentResumeManifest } from "./tools/subagent/SubagentReplay.mjs";
 import { getTraceIdSeed } from "./langfuseRuntimeContext.mjs";
 import { hasToolOutputTracingConfig, resolveLangfuseConfig, resolveToolOutputTracingConfig } from "./langfuseConfig.mjs";
 import { resolveLangfuseRuntimeScope, withLangfuseRuntimeScope } from "./langfuseRuntimeScope.mjs";
@@ -8,22 +9,22 @@ import "./common/index.mjs";
 import { ACTIVITY_LABEL_PROMPT, buildActivityLabelPrompt } from "./prompts/activityLabel.mjs";
 import { appendCallbacks, findCallback } from "./utils/callbacks.mjs";
 import { createCompletionTitleRunnable, createTitleRunnable } from "./utils/title.mjs";
+import { applyGraphRuntimeConfig } from "./graphs/applyGraphRuntimeConfig.mjs";
 import { createTokenCounter, encodingForModel } from "./utils/tokens.mjs";
 import { initializeLangfuseTracing } from "./instrumentation.mjs";
 import { isOpenAILike } from "./utils/llm.mjs";
-import { resolveMaxSeals } from "./llm/preempt.mjs";
 import { HandlerRegistry } from "./events.mjs";
+import { resolveMaxSeals } from "./llm/preempt.mjs";
 import { initializeModel } from "./llm/init.mjs";
 import { executeHooks } from "./hooks/executeHooks.mjs";
 import "./hooks/index.mjs";
-import { StandardGraph } from "./graphs/Graph.mjs";
-import { MultiAgentGraph } from "./graphs/MultiAgentGraph.mjs";
+import { createGraph } from "./graphs/createGraph.mjs";
 import { nanoid } from "nanoid";
 import { PromptTemplate } from "@langchain/core/prompts";
 import { RunnableLambda } from "@langchain/core/runnables";
 import { AzureChatOpenAI, ChatOpenAI } from "@langchain/openai";
 import { BaseCallbackHandler } from "@langchain/core/callbacks/base";
-import { HumanMessage, SystemMessage } from "@langchain/core/messages";
+import { BaseMessage, HumanMessage, SystemMessage } from "@langchain/core/messages";
 import { Command, INTERRUPT, MemorySaver, isInterrupted } from "@langchain/langgraph";
 //#region src/run.ts
 const defaultOmitOptions = new Set([
@@ -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 = 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(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 (BaseMessage.isInstance(messages)) return [messages];
+	if (!Array.isArray(messages) || !messages.every(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 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 = 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;
+		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 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 = 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;
+		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?.[SUBAGENT_RESUME_ATTEMPT_CONFIG_KEY];
+			delete config.configurable?.[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: 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 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 = requireValidSubagentResumeManifest(interrupt?.payload);
+		const resumeConfigurable = { ...callerConfig.configurable };
+		delete resumeConfigurable[SUBAGENT_RESUME_ATTEMPT_CONFIG_KEY];
+		delete resumeConfigurable[SUBAGENT_RESUME_MANIFEST_CONFIG_KEY];
+		resumeConfigurable[SUBAGENT_RESUME_ATTEMPT_CONFIG_KEY] = nanoid();
+		if (resumeManifest != null) resumeConfigurable[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) => {