@librechat/agents 3.3.8 → 3.3.9

package/dist/cjs/tools/ToolNode.cjs

@@ -5,9 +5,9 @@ const require_truncation = require("../utils/truncation.cjs");
 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_intentArg = require("./intentArg.cjs");
 const require_toolOutputReferences = require("./toolOutputReferences.cjs");
+const require_eagerEventExecution = require("./eagerEventExecution.cjs");
 const require_run = require("../utils/run.cjs");
 require("../utils/index.cjs");
 const require_CodeSessionFileSummary = require("./CodeSessionFileSummary.cjs");
@@ -15,9 +15,9 @@ const require_executeHooks = require("../hooks/executeHooks.cjs");
 require("../hooks/index.cjs");
 const require_resolveLocalExecutionTools = require("./local/resolveLocalExecutionTools.cjs");
 require("./local/index.cjs");
+let nanoid = require("nanoid");
 let _langchain_core_messages = require("@langchain/core/messages");
 let _langchain_langgraph = require("@langchain/langgraph");
-let nanoid = require("nanoid");
 let _langchain_core_singletons = require("@langchain/core/singletons");
 //#region src/tools/ToolNode.ts
 function createToolErrorOwnership() {
@@ -294,6 +294,12 @@ var ToolNode = class extends require_run.RunnableCallable {
 	eagerEventToolExecutions;
 	/** Shared per-run per-tool turn counter used by eager and normal event dispatch. */
 	eagerEventToolUsageCount;
+	/**
+	* Shared per-run eager prestart circuit breaker. Tool names added here
+	* (when a prestarted execution's args mismatch the final request) are no
+	* longer prestarted by the stream handler for the rest of the run.
+	*/
+	eagerEventToolSuppressions;
 	/** Agent ID for event-driven mode */
 	agentId;
 	/**
@@ -359,7 +365,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, 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 }) {
 		super({
 			name: name ?? TOOL_NODE_RUN_NAME,
 			tags,
@@ -383,6 +389,7 @@ var ToolNode = class extends require_run.RunnableCallable {
 		this.eagerEventToolExecution = eagerEventToolExecution;
 		this.eagerEventToolExecutions = eagerEventToolExecutions;
 		this.eagerEventToolUsageCount = eagerEventToolUsageCount;
+		this.eagerEventToolSuppressions = eagerEventToolSuppressions;
 		this.agentId = agentId;
 		this.executingAgentId = executingAgentId ?? agentId;
 		this.directToolNames = directToolNames;
@@ -412,10 +419,18 @@ var ToolNode = class extends require_run.RunnableCallable {
 		});
 	}
 	async invoke(input, options) {
+		const scopedOptions = this.executingAgentId == null ? options : {
+			...options,
+			metadata: {
+				...options?.metadata,
+				agentId: this.executingAgentId
+			}
+		};
 		return require_langfuseRuntimeScope.withLangfuseRuntimeScope(require_langfuseRuntimeScope.resolveLangfuseRuntimeScope({
 			runLangfuse: this.runLangfuse,
-			langfuseOverlay: this.agentLangfuse
-		}), () => super.invoke(input, options));
+			langfuseOverlay: this.agentLangfuse,
+			agentId: this.executingAgentId
+		}), () => super.invoke(input, scopedOptions));
 	}
 	/**
 	* Returns the run-scoped tool output registry, or `undefined` when
@@ -1968,18 +1983,23 @@ var ToolNode = class extends require_run.RunnableCallable {
 		const execution = this.eagerEventToolExecutions?.get(request.id);
 		if (execution == null) return;
 		this.eagerEventToolExecutions?.delete(request.id);
-		if (execution.toolName !== request.name || !require_eagerEventExecution.recordArgsEqual(execution.args, request.args)) return {
-			toolCallId: request.id,
-			toolName: request.name,
-			args: request.args,
-			request,
-			promise: Promise.resolve({ results: [{
+		if (execution.toolName !== request.name || !require_eagerEventExecution.recordArgsEqual(execution.args, request.args)) {
+			this.eagerEventToolSuppressions?.add(request.name);
+			this.eagerEventToolSuppressions?.add(execution.toolName);
+			console.warn(`[ToolNode] eager prestart args diverged from the final request for tool "${request.name}" (toolCallId=${request.id}); suppressing eager prestart for this tool for the rest of the run`);
+			return {
 				toolCallId: request.id,
-				status: "error",
-				content: "",
-				errorMessage: "Tool call changed after eager execution started; refusing to re-run the tool to avoid duplicate side effects."
-			}] })
-		};
+				toolName: request.name,
+				args: request.args,
+				request,
+				promise: Promise.resolve({ results: [{
+					toolCallId: request.id,
+					status: "error",
+					content: "",
+					errorMessage: "Tool call changed after eager execution started; refusing to re-run the tool to avoid duplicate side effects."
+				}] })
+			};
+		}
 		return execution;
 	}
 	async resolveEagerEventExecution(request, execution) {
@@ -2194,6 +2214,11 @@ var ToolNode = class extends require_run.RunnableCallable {
 		const batchScopeId = config.configurable?.run_id ?? `\0anon-${this.anonBatchCounter++}`;
 		const turn = this.toolOutputRegistry?.nextTurn(batchScopeId) ?? 0;
 		let outputs;
+		/** Hoisted from the messages-state branch so the Command tail can carry
+		*  the promotion into handoff updates (same-id state copies there would
+		*  otherwise overwrite the replacement message). */
+		let promotedAiMessage;
+		let invalidCallResults = [];
 		if (this.isSendInput(input)) {
 			const isLocalTool = this.directToolNames?.has(input.lg_tool_call.name) === true || this.shouldHandleUnknownHandoffLocally(input.lg_tool_call.name);
 			if (this.eventDrivenMode && !isLocalTool) return this.executeViaEvent([input.lg_tool_call], config, input, {
@@ -2250,6 +2275,43 @@ var ToolNode = class extends require_run.RunnableCallable {
 				*/
 				return (call.id == null || !toolMessageIds.has(call.id)) && !(call.id?.startsWith("srvtoolu_") ?? false);
 			}) ?? [];
+			const attributableInvalidCalls = !(!Array.isArray(input) && typeof aiMessage.id === "string" && aiMessage.id.length > 0) ? [] : (aiMessage.invalid_tool_calls ?? []).filter((call) => call.id != null && call.id !== "" && !toolMessageIds.has(call.id) && !call.id.startsWith("srvtoolu_"));
+			invalidCallResults = attributableInvalidCalls.map((call) => new _langchain_core_messages.ToolMessage({
+				status: "error",
+				content: require_truncation.truncateToolResultContent(`Error: ${call.error ?? "Malformed tool call arguments."} The tool call input could not be parsed as a JSON object; the tool was not run.
+ Please fix your mistakes.`, this.maxToolResultChars),
+				name: normalizeInvalidCallName(call.name),
+				tool_call_id: call.id
+			}));
+			/**
+			* Promote the answered invalid calls into well-formed `tool_calls` on a
+			* REPLACEMENT copy of the AI message (`messagesStateReducer` upserts by
+			* id). Without this, provider converters that rebuild the call side of
+			* the wire from `tool_calls` — OpenAI Completions `tool_calls`, OpenAI
+			* Responses `function_call` items, Gemini/Bedrock function-call parts —
+			* drop the invalid call while the synthesized result above still
+			* references it, inverting the dangling-pair rejection (an output whose
+			* call is missing). Promoting at this single seam keeps the call and
+			* result sides agreeing for EVERY provider; args become `{}` (the raw
+			* string never parsed — the paired error result tells the model why).
+			* Skipped when the message has no id: the reducer would append a
+			* duplicate instead of replacing, which is worse than the dangle.
+			*/
+			promotedAiMessage = attributableInvalidCalls.length > 0 ? new _langchain_core_messages.AIMessage({
+				id: aiMessage.id,
+				content: sanitizeInvalidToolUseBlocks(aiMessage.content, attributableInvalidCalls),
+				name: aiMessage.name,
+				additional_kwargs: aiMessage.additional_kwargs,
+				response_metadata: aiMessage.response_metadata,
+				usage_metadata: aiMessage.usage_metadata,
+				tool_calls: [...aiMessage.tool_calls ?? [], ...attributableInvalidCalls.map((call) => ({
+					id: call.id,
+					name: normalizeInvalidCallName(call.name),
+					args: {},
+					type: "tool_call"
+				}))],
+				invalid_tool_calls: (aiMessage.invalid_tool_calls ?? []).filter((call) => !attributableInvalidCalls.includes(call))
+			}) : void 0;
 			if (this.eventDrivenMode && filteredCalls.length > 0) {
 				const directToolNames = this.directToolNames;
 				const hasRegisteredHandoffTool = this.hasRegisteredHandoffTool();
@@ -2264,7 +2326,7 @@ var ToolNode = class extends require_run.RunnableCallable {
 					if (directToolNames?.has(call.name) === true || this.shouldHandleUnknownHandoffLocally(call.name, hasRegisteredHandoffTool)) directEntries.push(entry);
 					else eventEntries.push(entry);
 				}
-				if (directEntries.length === 0) return this.executeViaEvent(filteredCalls, config, input, {
+				if (directEntries.length === 0 && invalidCallResults.length === 0) return this.executeViaEvent(filteredCalls, config, input, {
 					batchIndices: eventEntries.map((entry) => entry.batchIndex),
 					turn,
 					batchScopeId
@@ -2333,8 +2395,10 @@ var ToolNode = class extends require_run.RunnableCallable {
 					}
 				})] : [];
 				outputs = [
+					...promotedAiMessage != null ? [promotedAiMessage] : [],
 					...directOutputs,
 					...eventResult.toolMessages,
+					...invalidCallResults,
 					...directInjected,
 					...eventResult.injected
 				];
@@ -2351,16 +2415,51 @@ var ToolNode = class extends require_run.RunnableCallable {
 					runInput: input
 				});
 				await this.handleRunToolCompletions(filteredCalls, toolOutputs, config, resolvedArgsByCallId, errorOwnership);
-				outputs = directAdditionalContexts.length > 0 ? [...toolOutputs, new _langchain_core_messages.HumanMessage({
-					content: directAdditionalContexts.join("\n\n"),
-					additional_kwargs: {
-						role: "system",
-						source: "hook"
-					}
-				})] : toolOutputs;
+				const promotedPrefix = promotedAiMessage != null ? [promotedAiMessage] : [];
+				outputs = directAdditionalContexts.length > 0 ? [
+					...promotedPrefix,
+					...toolOutputs,
+					...invalidCallResults,
+					new _langchain_core_messages.HumanMessage({
+						content: directAdditionalContexts.join("\n\n"),
+						additional_kwargs: {
+							role: "system",
+							source: "hook"
+						}
+					})
+				] : [
+					...promotedPrefix,
+					...toolOutputs,
+					...invalidCallResults
+				];
+			}
+			/**
+			* Resolve the streamed tool-call cards for invalid calls, best-effort.
+			* Runs AFTER the direct batch settled: on an interrupting first pass
+			* this line is unreachable (the node unwound), so interrupt/resume
+			* flows emit the completion exactly once — same reasoning as the
+			* deferred blocked-call side effects. Skipped when the stream never
+			* registered a step for the call (non-streaming providers), where a
+			* completion could not be routed to a card anyway.
+			*/
+			for (const result of invalidCallResults) {
+				const invalidStepId = this.toolCallStepIds?.get(result.tool_call_id);
+				if (invalidStepId == null || invalidStepId === "") continue;
+				await this.dispatchStepCompleted(result.tool_call_id, result.name ?? "unknown", {}, typeof result.content === "string" ? result.content : "", config);
 			}
 		}
 		if (!outputs.some(_langchain_langgraph.isCommand)) return Array.isArray(input) ? outputs : { messages: outputs };
+		/**
+		* Carry the invalid-call promotion into handoff commands. A handoff
+		* tool's Command snapshots `update.messages` from the PRE-promotion
+		* state (MultiAgentGraph builds a filtered same-id copy of the original
+		* AI message), and commands apply after the sibling reducer updates —
+		* so the stale copy would overwrite the replacement message, and a
+		* Send handoff's child state could omit the synthesized results
+		* entirely. Patch each command's same-id AI message with the promotion
+		* and append any missing synthesized results.
+		*/
+		if (promotedAiMessage != null) outputs = outputs.map((output) => (0, _langchain_langgraph.isCommand)(output) ? patchCommandUpdateForPromotedInvalidCalls(output, promotedAiMessage, invalidCallResults) : output);
 		const combinedOutputs = [];
 		let parentCommand = null;
 		/**
@@ -2449,10 +2548,140 @@ function areToolCallsInvoked(message, invokedToolIds) {
 	if (!invokedToolIds || invokedToolIds.size === 0) return false;
 	return message.tool_calls?.every((toolCall) => toolCall.id != null && invokedToolIds.has(toolCall.id)) ?? false;
 }
+/**
+* Normalize the `tool_use` content blocks of promoted invalid calls so the
+* replacement AI message is valid on EVERY provider surface, not just
+* `tool_calls`. Anthropic formats an array-content AI message from its blocks
+* verbatim, and a call whose streamed `input_json` never parsed leaves the
+* block's `input` as the raw accumulated STRING — replayed as-is, the API
+* rejects it with `tool_use.input: Input should be an object` before pairing
+* is even checked. Blocks matching a promoted call id get `input: {}`
+* (mirroring the promoted args); everything else passes through untouched.
+* String content (OpenAI-style) is returned as-is.
+*/
+function sanitizeInvalidToolUseBlocks(content, promotedCalls) {
+	if (!Array.isArray(content)) return content;
+	const promotedNamesById = new Map(promotedCalls.filter((call) => call.id != null).map((call) => [call.id, normalizeInvalidCallName(call.name)]));
+	return content.map((block) => {
+		if (typeof block !== "object" || block?.type !== "tool_use") return block;
+		const toolUse = block;
+		if (toolUse.id == null || !promotedNamesById.has(toolUse.id)) return block;
+		const inputIsObject = typeof toolUse.input === "object" && toolUse.input != null && !Array.isArray(toolUse.input);
+		/** `name` normalizes with the SAME fallback the promoted `tool_calls`
+		*  entry uses — a nameless block would fail provider validation on its
+		*  own even with a valid input. */
+		const nameIsValid = typeof toolUse.name === "string" && toolUse.name !== "";
+		if (inputIsObject && nameIsValid) return block;
+		return {
+			...block,
+			...inputIsObject ? {} : { input: {} },
+			...nameIsValid ? {} : { name: promotedNamesById.get(toolUse.id) }
+		};
+	});
+}
+/**
+* Name fallback for attributable invalid calls, shared by every surface that
+* materializes them (synthesized result, promoted tool_calls entry, sanitized
+* block, handoff patch): `''` is normalized like `undefined` — providers
+* reject nameless calls, so an empty string would defeat the promotion.
+*
+* INVARIANT MAP — a tool call lives in several parallel representations, and
+* any surface that materializes, copies, filters, routes on, or reports one
+* must keep ALL of them agreeing (`tool_calls`, `invalid_tool_calls`,
+* provider content blocks, paired results). The attribution predicate is:
+* id-bearing (non-empty), non-server (`srvtoolu_`), unanswered
+* (`toolMessageIds`), messages-state input, id-bearing AI message. Surfaces
+* that apply it today — extend this list when adding another:
+*   - `run()`'s `canPromoteInvalidCalls` gate + attributable filter
+*   - `toolsCondition`'s invalid-only / server-mix routing branch
+*   - `sanitizeInvalidToolUseBlocks` (block input AND name)
+*   - `patchCommandUpdateForPromotedInvalidCalls` (handoff snapshots)
+*   - `processHandoffReception`'s transfer-block filtering (MultiAgentGraph)
+*   - `findPendingToolCalls` in langfuseTraceShaping (span claims)
+*   - `serializeMessage`/`deserializeMessage` (session round-trip keeps
+*     `invalid_tool_calls` with the content blocks they repair)
+*/
+function normalizeInvalidCallName(name) {
+	return name != null && name !== "" ? name : "unknown";
+}
+/**
+* Rewrite a handoff Command's `update.messages` so the invalid-call promotion
+* survives into the child state: the same-id AI message copy (snapshotted
+* pre-promotion by the handoff tool) gets the sanitized content, the promoted
+* `tool_calls` entries for the answered invalid calls, and the leftover
+* `invalid_tool_calls`; synthesized results missing from the update are
+* appended so the child's history keeps every call/result pair. The update
+* copy's own `tool_calls` narrowing (parallel handoffs filter to a single
+* call) is preserved. Commands without a same-id AI message pass through.
+*/
+function patchCommandUpdateForPromotedInvalidCalls(command, promoted, invalidResults) {
+	const update = command.update;
+	const messages = update?.messages;
+	if (!Array.isArray(messages) || promoted.id == null || invalidResults.length === 0) return command;
+	if (!messages.some((msg) => (0, _langchain_core_messages.isAIMessage)(msg) && msg.id === promoted.id)) return command;
+	const next = messages.map((msg) => {
+		if (!(0, _langchain_core_messages.isAIMessage)(msg) || msg.id !== promoted.id) return msg;
+		const existingIds = new Set((msg.tool_calls ?? []).map((call) => call.id));
+		const promotedEntries = invalidResults.filter((result) => !existingIds.has(result.tool_call_id)).map((result) => ({
+			id: result.tool_call_id,
+			name: normalizeInvalidCallName(result.name),
+			args: {},
+			type: "tool_call"
+		}));
+		return new _langchain_core_messages.AIMessage({
+			id: msg.id,
+			content: promoted.content,
+			name: msg.name,
+			additional_kwargs: msg.additional_kwargs,
+			response_metadata: msg.response_metadata,
+			usage_metadata: msg.usage_metadata,
+			tool_calls: [...msg.tool_calls ?? [], ...promotedEntries],
+			invalid_tool_calls: promoted.invalid_tool_calls
+		});
+	});
+	const presentResultIds = new Set(next.filter((msg) => msg._getType() === "tool").map((msg) => msg.tool_call_id));
+	const missingResults = invalidResults.filter((result) => !presentResultIds.has(result.tool_call_id));
+	return new _langchain_langgraph.Command({
+		graph: command.graph,
+		goto: command.goto,
+		resume: command.resume,
+		update: {
+			...update,
+			messages: [...next, ...missingResults]
+		}
+	});
+}
+/**
+* Whether the message carries an `invalid_tool_calls` entry ToolNode can pair a
+* synthesized error result with (id-bearing, non-server). Shared by the routing
+* condition below so an invalid-only turn still enters ToolNode — otherwise the
+* malformed `tool_use` block is committed with no `tool_result` and the next
+* model call is rejected by pairing-strict providers.
+*/
+function hasAttributableInvalidToolCalls(message) {
+	return message.invalid_tool_calls?.some((call) => call.id != null && call.id !== "" && !call.id.startsWith("srvtoolu_")) ?? false;
+}
 function toolsCondition(state, toolNode, invokedToolIds) {
 	const messages = Array.isArray(state) ? state : state.messages;
 	const message = messages[messages.length - 1];
 	if (message && "tool_calls" in message && (message.tool_calls?.length ?? 0) > 0 && !areToolCallsInvoked(message, invokedToolIds)) return toolNode;
+	/**
+	* The valid calls (if any) did not route above, but ToolNode still owes any
+	* malformed calls their synthesized error results. Route when EVERY valid
+	* call is provider-server-executed (`srvtoolu_` — ToolNode's batch filter
+	* excludes those before execution, so nothing re-runs): that covers both the
+	* invalid-only turn and the Anthropic server-call + malformed-client-call
+	* mix, where `handleAnthropicSearchResults` marks the server call invoked
+	* and the first branch declines. A valid NON-server call that was invoked
+	* externally stays conservative (no routing) — ToolNode does not filter on
+	* `invokedToolIds`, so entering it would re-execute that call.
+	*
+	* Mirrors ToolNode's own gating exactly, or the routed turn would no-op and
+	* bounce back to the model with the dangle intact: array-state graphs get a
+	* plain output list (no reducer upsert — ToolNode skips invalid handling
+	* there), and an id-less message cannot take the replacement upsert either.
+	*/
+	if (!Array.isArray(state) && message && typeof message.id === "string" && message.id.length > 0 && hasAttributableInvalidToolCalls(message) && (message.tool_calls ?? []).every((call) => call.id?.startsWith("srvtoolu_") === true)) return toolNode;
 	return _langchain_langgraph.END;
 }
 //#endregion