@librechat/agents 3.2.59 → 3.2.61

package/dist/cjs/graphs/Graph.cjs

@@ -275,6 +275,14 @@ var Graph = class {
 	*/
 	eagerEventToolExecution;
 	codeSessionToolNames;
+	/**
+	* Run-scoped names of tools whose in-process body may raise a LangGraph
+	* `interrupt()` (e.g. `ask_user_question`). Threaded from
+	* `RunConfig.interruptingToolNames` into every ToolNode this graph
+	* compiles so a mid-batch interrupt cannot double-execute non-idempotent
+	* siblings on resume. See {@link t.ToolNodeOptions.interruptingToolNames}.
+	*/
+	interruptingToolNames;
 	eagerEventToolExecutions = /* @__PURE__ */ new Map();
 	eagerEventToolUsageCount = /* @__PURE__ */ new Map();
 	eagerEventToolUsageCountsByAgentId = /* @__PURE__ */ new Map();
@@ -321,6 +329,7 @@ var Graph = class {
 		this.toolOutputReferences = void 0;
 		this.eagerEventToolExecution = void 0;
 		this.codeSessionToolNames = void 0;
+		this.interruptingToolNames = void 0;
 		this.eagerEventToolExecutions.clear();
 		this.clearEagerEventToolUsageCounts();
 		this.eagerEventToolCallChunks.clear();
@@ -685,6 +694,7 @@ var StandardGraph = class StandardGraph extends Graph {
 				eagerEventToolUsageCount: this.getEagerEventToolUsageCount(agentContext?.agentId),
 				toolExecution: this.toolExecution,
 				directToolNames: directToolNames.size > 0 ? directToolNames : void 0,
+				interruptingToolNames: this.interruptingToolNames != null && this.interruptingToolNames.length > 0 ? new Set(this.interruptingToolNames) : void 0,
 				maxContextTokens: agentContext?.maxContextTokens,
 				maxToolResultChars: agentContext?.maxToolResultChars,
 				toolOutputRegistry: this.getOrCreateToolOutputRegistry(),
@@ -709,6 +719,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,
 			hookRegistry: this.hookRegistry,
 			humanInTheLoop: this.humanInTheLoop,
 			maxContextTokens: agentContext?.maxContextTokens,
@@ -1252,6 +1263,7 @@ var StandardGraph = class StandardGraph extends Graph {
 						childGraph.toolOutputReferences = this.toolOutputReferences;
 						childGraph.eagerEventToolExecution = this.eagerEventToolExecution;
 						childGraph.codeSessionToolNames = this.codeSessionToolNames;
+						childGraph.interruptingToolNames = this.interruptingToolNames;
 						childGraph.toolExecution = this.toolExecution;
 						childGraph.eventToolExecutionAvailable = this.handlerRegistry?.getHandler("on_tool_execute") != null;
 						return childGraph;
@@ -1444,19 +1456,28 @@ var StandardGraph = class StandardGraph extends Graph {
 	}
 	/**
 	* Static version of handleToolCallError to avoid creating strong references
-	* that prevent garbage collection
+	* that prevent garbage collection.
+	*
+	* Returns whether the error completion event was actually dispatched. A
+	* tool can error before this graph instance has a run step for the call —
+	* on a resume pass the interrupted batch re-executes IMMEDIATELY on graph
+	* re-entry, before any step replay has registered `toolCallStepIds` (a
+	* fast-failing tool, e.g. a schema-validation reject, loses that race).
+	* That is a caller-recoverable condition, not an invariant violation: the
+	* ToolNode falls back to its normal completion dispatch for the error
+	* ToolMessage when this returns `false`, so throwing here would only
+	* replace a recoverable miss with a lost completion event and a scary log.
 	*/
 	static async handleToolCallErrorStatic(graph, data, metadata) {
-		if (!graph.config) throw new Error("No config provided");
 		if (!data.id) {
 			console.warn("No Tool ID provided for Tool Error");
-			return;
+			return false;
 		}
 		const stepId = graph.toolCallStepIds.get(data.id) ?? "";
-		if (!stepId) throw new Error(`No stepId found for tool_call_id ${data.id}`);
+		if (!stepId) return false;
 		const { name, input: args, error } = data;
 		const runStep = graph.getRunStep(stepId);
-		if (!runStep) throw new Error(`No run step found for stepId ${stepId}`);
+		if (!runStep) return false;
 		const tool_call = {
 			id: data.id,
 			name: name || "",
@@ -1464,19 +1485,22 @@ var StandardGraph = class StandardGraph extends Graph {
 			output: `Error processing tool${error?.message != null ? `: ${error.message}` : ""}`,
 			progress: 1
 		};
-		await graph.handlerRegistry?.getHandler("on_run_step_completed")?.handle("on_run_step_completed", { result: {
+		const handler = graph.handlerRegistry?.getHandler("on_run_step_completed");
+		if (!handler) return false;
+		await handler.handle("on_run_step_completed", { result: {
 			id: stepId,
 			index: runStep.index,
 			type: "tool_call",
 			tool_call
 		} }, metadata, graph);
+		return true;
 	}
 	/**
 	* Instance method that delegates to the static method
 	* Kept for backward compatibility
 	*/
 	async handleToolCallError(data, metadata) {
-		await StandardGraph.handleToolCallErrorStatic(this, data, metadata);
+		return StandardGraph.handleToolCallErrorStatic(this, data, metadata);
 	}
 	async dispatchRunStepDelta(id, delta, metadata) {
 		if (!this.config) throw new Error("No config provided");