@librechat/agents 3.3.11 → 3.3.12

package/dist/esm/tools/ToolNode.mjs

@@ -1,3 +1,4 @@
+import { composeAbortSignals } from "../utils/misc.mjs";
 import { resolveLangfuseRuntimeScope, withLangfuseRuntimeScope } from "../langfuseRuntimeScope.mjs";
 import { CODE_EXECUTION_TOOLS } from "../common/enum.mjs";
 import "../common/index.mjs";
@@ -6,6 +7,7 @@ import { cloneToolMessageWithContent, compactToolContent, hasComputerCallOutputM
 import { safeDispatchCustomEvent } from "../utils/events.mjs";
 import { convertInjectedMessages } from "../messages/injected.mjs";
 import { buildToolExecutionRequestPlan, recordArgsEqual, resolveRuntimeSessionHint } from "./eagerEventExecution.mjs";
+import { RUN_BREAKER_SCOPE_CONFIG_KEY, StreamLimitExceededError } from "../llm/streamLimits.mjs";
 import { INTENT_ARG, isIntentLabelProperty, outcomeFieldsFromResult, readOutcomeFields, resolveToolOutcome } from "./intentArg.mjs";
 import { ToolOutputReferenceRegistry, buildReferenceKey } from "./toolOutputReferences.mjs";
 import { RunnableCallable } from "../utils/run.mjs";
@@ -20,6 +22,13 @@ import { AIMessage, HumanMessage, ToolMessage, isAIMessage, isBaseMessage } from
 import { Command, END, Send, interrupt, isCommand, isGraphInterrupt } from "@langchain/langgraph";
 import { AsyncLocalStorageProviderSingleton } from "@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 { [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 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 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 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 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 (isCommand(output)) return output;
 			if (isBaseMessage(output) && output._getType() === "tool") {
@@ -759,6 +778,12 @@ var ToolNode = class extends RunnableCallable {
 			const e = _e;
 			if (!this.handleToolErrors) throw e;
 			if (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 StreamLimitExceededError) throw e;
 			if (this.errorHandler) try {
 				const dispatched = await this.errorHandler({
 					error: e,
@@ -1278,7 +1303,17 @@ var ToolNode = class extends 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 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 ?? "";
 		/**
@@ -1774,7 +1809,10 @@ var ToolNode = class extends 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) => {
@@ -1783,6 +1821,10 @@ var ToolNode = class extends 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;
@@ -1794,8 +1836,9 @@ var ToolNode = class extends 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;
@@ -2177,6 +2220,10 @@ var ToolNode = class extends 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];
@@ -2200,6 +2247,32 @@ var ToolNode = class extends 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 = 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 StreamLimitExceededError) throw composedSignal.reason;
 		this.toolCallTurns.clear();
 		/**
 		* Per-batch local map for resolved (post-substitution) args.