@librechat/agents 3.3.11 → 3.3.12

package/dist/cjs/tools/ToolNode.cjs

@@ -1,3 +1,4 @@
+const require_misc = require("../utils/misc.cjs");
 const require_langfuseRuntimeScope = require("../langfuseRuntimeScope.cjs");
 const require_enum = require("../common/enum.cjs");
 require("../common/index.cjs");
@@ -6,6 +7,7 @@ const require_toolContent = require("../utils/toolContent.cjs");
 const require_events = require("../utils/events.cjs");
 const require_injected = require("../messages/injected.cjs");
 const require_eagerEventExecution = require("./eagerEventExecution.cjs");
+const require_streamLimits = require("../llm/streamLimits.cjs");
 const require_intentArg = require("./intentArg.cjs");
 const require_toolOutputReferences = require("./toolOutputReferences.cjs");
 const require_run = require("../utils/run.cjs");
@@ -20,6 +22,13 @@ let _langchain_core_messages = require("@langchain/core/messages");
 let _langchain_langgraph = require("@langchain/langgraph");
 let _langchain_core_singletons = require("@langchain/core/singletons");
 //#region src/tools/ToolNode.ts
+/** Host-facing batch requests must not carry the batch's breaker scope —
+* hosts spread `configurable` into their own run configs. */
+function stripRunBreakerScope(configurable) {
+	if (configurable == null || !("lc_run_breaker_scope" in configurable)) return configurable;
+	const { [require_streamLimits.RUN_BREAKER_SCOPE_CONFIG_KEY]: _scope, ...rest } = configurable;
+	return rest;
+}
 function createToolErrorOwnership() {
 	return {
 		handlerOwned: /* @__PURE__ */ new Set(),
@@ -357,6 +366,10 @@ var ToolNode = class extends require_run.RunnableCallable {
 	toolOutputRegistry;
 	/** Run-scoped selection for swapping remote code tools to local executors. */
 	toolExecution;
+	/** Owning graph's run-scoped breaker signal, composed into each batch's config. */
+	getBreakerSignal;
+	/** Owning graph's immutable run scope; captured once per batch. */
+	getRunScope;
 	/**
 	* Monotonic counter used to mint a unique scope id for anonymous
 	* batches (ones invoked without a `run_id` in
@@ -365,7 +378,7 @@ var ToolNode = class extends require_run.RunnableCallable {
 	* other's in-flight state.
 	*/
 	anonBatchCounter = 0;
-	constructor({ tools, toolMap, name, tags, trace, runLangfuse, agentLangfuse, errorHandler, toolCallStepIds, handleToolErrors, loadRuntimeTools, toolRegistry, sessions, eventDrivenMode, eagerEventToolExecution, eagerEventToolExecutions, eagerEventToolUsageCount, eagerEventToolSuppressions, agentId, executingAgentId, directToolNames, interruptingToolNames, codeSessionToolNames, maxContextTokens, maxToolResultChars, hookRegistry, humanInTheLoop, toolOutputReferences, toolOutputRegistry, toolExecution, fileCheckpointer }) {
+	constructor({ tools, toolMap, name, tags, trace, runLangfuse, agentLangfuse, errorHandler, toolCallStepIds, handleToolErrors, loadRuntimeTools, toolRegistry, sessions, eventDrivenMode, eagerEventToolExecution, eagerEventToolExecutions, eagerEventToolUsageCount, eagerEventToolSuppressions, agentId, executingAgentId, directToolNames, interruptingToolNames, codeSessionToolNames, maxContextTokens, maxToolResultChars, hookRegistry, humanInTheLoop, toolOutputReferences, toolOutputRegistry, toolExecution, fileCheckpointer, getBreakerSignal, getRunScope }) {
 		super({
 			name: name ?? TOOL_NODE_RUN_NAME,
 			tags,
@@ -399,6 +412,8 @@ var ToolNode = class extends require_run.RunnableCallable {
 		this.hookRegistry = hookRegistry;
 		this.humanInTheLoop = humanInTheLoop;
 		this.toolExecution = toolExecution;
+		this.getBreakerSignal = getBreakerSignal;
+		this.getRunScope = getRunScope;
 		this.fileCheckpointer = fileCheckpointer;
 		this.applyToolExecutionOverrides();
 		/**
@@ -698,6 +713,10 @@ var ToolNode = class extends require_run.RunnableCallable {
 				store: lgConfig.store ?? null,
 				writer: lgConfig.writer ?? config.configurable?.writer ?? null
 			};
+			/** A sibling can trip the breaker while the PreToolUse hooks above
+			* are awaited; a tool that never inspects its runtime signal would
+			* still run. Recheck at the last moment before execution. */
+			this.throwIfBreakerTripped(config);
 			const output = await tool.invoke(invokeParams, runtime);
 			if ((0, _langchain_langgraph.isCommand)(output)) return output;
 			if ((0, _langchain_core_messages.isBaseMessage)(output) && output._getType() === "tool") {
@@ -759,6 +778,12 @@ var ToolNode = class extends require_run.RunnableCallable {
 			const e = _e;
 			if (!this.handleToolErrors) throw e;
 			if ((0, _langchain_langgraph.isGraphInterrupt)(e)) throw e;
+			/**
+			* A stream circuit breaker tripped by a child run (subagent) is a
+			* safety abort, not a tool failure to report back to the model. It
+			* passes through like an interrupt so the whole run rejects.
+			*/
+			if (e instanceof require_streamLimits.StreamLimitExceededError) throw e;
 			if (this.errorHandler) try {
 				const dispatched = await this.errorHandler({
 					error: e,
@@ -1279,7 +1304,17 @@ var ToolNode = class extends require_run.RunnableCallable {
 	* 4. Injected messages from results are collected and returned alongside
 	*    ToolMessages (appended AFTER to respect provider ordering).
 	*/
+	/** Rethrows a stream-limit trip carried on the batch config's composed
+	* signal. Rechecked at each later execution/dispatch stage because a tool
+	* that ignores cancellation can complete normally across the trip, and
+	* the next stage would otherwise start fresh side effects on a failed
+	* run. */
+	throwIfBreakerTripped(config) {
+		const signal = config.signal;
+		if (signal?.aborted === true && signal.reason instanceof require_streamLimits.StreamLimitExceededError) throw signal.reason;
+	}
 	async dispatchToolEvents(toolCalls, config, batchContext = {}) {
+		this.throwIfBreakerTripped(config);
 		const { batchIndices, turn, batchScopeId, preResolvedArgs, preBatchSnapshot } = batchContext;
 		const runId = config.configurable?.run_id ?? "";
 		/**
@@ -1775,7 +1810,10 @@ var ToolNode = class extends require_run.RunnableCallable {
 			const earlyCompletionDispatches = [];
 			const dispatchRequestById = new Map(dispatchRequests.map((request) => [request.id, request]));
 			const onResult = (result) => {
-				const request = result.toolCallId != null ? dispatchRequestById.get(result.toolCallId) : void 0;
+				/** Runtime-honest widening: hosts may omit the id despite the
+				* field type. */
+				const resultToolCallId = result.toolCallId;
+				const request = resultToolCallId != null ? dispatchRequestById.get(resultToolCallId) : void 0;
 				if (request == null || earlyCompletionDispatchedIds.has(result.toolCallId)) return;
 				earlyCompletionDispatchedIds.add(result.toolCallId);
 				earlyCompletionDispatches.push(this.dispatchEarlyToolCompletion(result, request, config).then((dispatched) => {
@@ -1784,6 +1822,10 @@ var ToolNode = class extends require_run.RunnableCallable {
 					earlyCompletionDispatchedIds.delete(result.toolCallId);
 				}));
 			};
+			/** The approval hooks above are awaited; a sibling's trip during them
+			* must stop the approved batch before it reaches a host handler that
+			* may never inspect the request signal. */
+			if (dispatchRequests.length > 0) this.throwIfBreakerTripped(config);
 			const dispatchPromise = dispatchRequests.length === 0 ? Promise.resolve([]) : new Promise((resolve, reject) => {
 				let dispatchSettled = false;
 				let resultSettled = false;
@@ -1795,8 +1837,9 @@ var ToolNode = class extends require_run.RunnableCallable {
 					toolCalls: dispatchRequests,
 					userId: config.configurable?.user_id,
 					agentId: this.executingAgentId,
-					configurable: config.configurable,
+					configurable: stripRunBreakerScope(config.configurable),
 					metadata: config.metadata,
+					signal: config.signal,
 					resolve: (results) => {
 						resultSettled = true;
 						settledResults = results;
@@ -2179,6 +2222,10 @@ var ToolNode = class extends require_run.RunnableCallable {
 		interruptingPositions.forEach((i, k) => {
 			outputs[i] = interruptingOutputs[k];
 		});
+		/** The breaker can trip while the interrupting group is awaited — e.g.
+		* a tool that ignores cancellation and completes normally. Recheck
+		* before starting the non-idempotent siblings. */
+		this.throwIfBreakerTripped(config);
 		const regularOutputs = await Promise.all(regularPositions.map((i) => runOne(directCalls[i], i)));
 		regularPositions.forEach((i, k) => {
 			outputs[i] = regularOutputs[k];
@@ -2202,6 +2249,32 @@ var ToolNode = class extends require_run.RunnableCallable {
 		return Array.isArray(input) ? outputs : { messages: outputs };
 	}
 	async run(input, config) {
+		/**
+		* Breaker read once at batch entry: every downstream path (direct
+		* `tool.invoke` runtimes and the ON_TOOL_EXECUTE dispatch) inherits this
+		* config, and a graph reset mid-batch must not detach in-flight tools
+		* from an already-tripped signal.
+		*/
+		const breakerSignal = this.getBreakerSignal?.();
+		const composedSignal = require_misc.composeAbortSignals(config.signal, breakerSignal);
+		/** Immutable batch scope, captured with the signal BEFORE hooks: tools
+		* that spawn runs (subagents) bind their child to this controller, so a
+		* reset during a PreToolUse hook cannot hand them the new run's one. */
+		const batchRunScope = this.getRunScope?.();
+		if (composedSignal !== config.signal || batchRunScope != null) config = {
+			...config,
+			signal: composedSignal,
+			...batchRunScope != null && { configurable: {
+				...config.configurable,
+				["lc_run_breaker_scope"]: batchRunScope
+			} }
+		};
+		/** Already-tripped-at-entry: a parallel sibling's breach failed the run
+		* before this batch was scheduled. Rethrow before hooks, direct
+		* `tool.invoke` calls, or ON_TOOL_EXECUTE dispatch — a tool or host
+		* handler that doesn't synchronously inspect an aborted signal would
+		* otherwise perform side effects on a failed run. */
+		if (composedSignal?.aborted === true && composedSignal.reason instanceof require_streamLimits.StreamLimitExceededError) throw composedSignal.reason;
 		this.toolCallTurns.clear();
 		/**
 		* Per-batch local map for resolved (post-substitution) args.