@librechat/agents 3.3.4 → 3.3.6

package/dist/esm/tools/ToolNode.mjs

@@ -3,9 +3,10 @@ import { CODE_EXECUTION_TOOLS } from "../common/enum.mjs";
 import "../common/index.mjs";
 import { calculateMaxToolResultChars, truncateToolResultContent } from "../utils/truncation.mjs";
 import { cloneToolMessageWithContent, compactToolContent, hasComputerCallOutputMarker, isComputerCallOutputContent, isComputerCallOutputMessage, serializeStructuredValueBounded, serializeToolContentBounded } from "../utils/toolContent.mjs";
-import { toLangChainContent } from "../messages/langchain.mjs";
 import { safeDispatchCustomEvent } from "../utils/events.mjs";
+import { convertInjectedMessages } from "../messages/injected.mjs";
 import { buildToolExecutionRequestPlan, recordArgsEqual, resolveRuntimeSessionHint } from "./eagerEventExecution.mjs";
+import { INTENT_ARG, isIntentLabelProperty, outcomeFieldsFromResult, readOutcomeFields, resolveToolOutcome } from "./intentArg.mjs";
 import { ToolOutputReferenceRegistry, buildReferenceKey } from "./toolOutputReferences.mjs";
 import { RunnableCallable } from "../utils/run.mjs";
 import "../utils/index.mjs";
@@ -19,6 +20,12 @@ import { Command, END, Send, interrupt, isCommand, isGraphInterrupt } from "@lan
 import { nanoid } from "nanoid";
 import { AsyncLocalStorageProviderSingleton } from "@langchain/core/singletons";
 //#region src/tools/ToolNode.ts
+function createToolErrorOwnership() {
+	return {
+		handlerOwned: /* @__PURE__ */ new Set(),
+		undispatched: /* @__PURE__ */ new Set()
+	};
+}
 /**
 * Produces the provider preview and, when requested, the exact registry prefix
 * in one bounded traversal. String outputs already exist in memory when a tool
@@ -251,12 +258,12 @@ var ToolNode = class extends RunnableCallable {
 	toolCallStepIds;
 	errorHandler;
 	/**
-	* Tool call ids whose `errorHandler` did NOT dispatch the error completion
-	* event (it returned `false` or threw). The output loop must dispatch the
-	* completion for these itself — skipping them there would strand the
-	* client's tool-call part without a terminal event.
+	* Fallback error-completion ownership for calls that reach `runTool`
+	* outside a batch context (direct `runTool` use in tests / embedders).
+	* Batch-scoped ownership is threaded via `RunToolBatchContext` instead —
+	* see {@link ToolErrorOwnership} for why per-invocation scoping matters.
 	*/
-	undispatchedToolErrors = /* @__PURE__ */ new Set();
+	looseErrorOwnership = createToolErrorOwnership();
 	toolUsageCount;
 	/** Maps toolCallId → turn captured in runTool, used by handleRunToolCompletions */
 	toolCallTurns = /* @__PURE__ */ new Map();
@@ -543,8 +550,9 @@ var ToolNode = class extends RunnableCallable {
 		const tool = this.toolMap.get(call.name);
 		const registry = this.toolOutputRegistry;
 		let resolveFn;
-		if (preBatchSnapshot != null) resolveFn = (_runId, args) => preBatchSnapshot.resolve(args);
-		else if (registry != null) resolveFn = (runIdArg, args) => registry.resolve(runIdArg, args);
+		const resolveOptions = { substituteIntentKey: this.toolDeclaresBusinessIntent(call.name) };
+		if (preBatchSnapshot != null) resolveFn = (_runId, args) => preBatchSnapshot.resolve(args, resolveOptions);
+		else if (registry != null) resolveFn = (runIdArg, args) => registry.resolve(runIdArg, args, resolveOptions);
 		/**
 		* Precompute the reference key once per call — captured locally
 		* so concurrent `invoke()` calls on the same ToolNode cannot race
@@ -737,12 +745,14 @@ var ToolNode = class extends RunnableCallable {
 			if (!this.handleToolErrors) throw e;
 			if (isGraphInterrupt(e)) throw e;
 			if (this.errorHandler) try {
-				if (await this.errorHandler({
+				const dispatched = await this.errorHandler({
 					error: e,
 					id: call.id,
 					name: call.name,
 					input: call.args
-				}, config.metadata) === false && call.id != null && call.id !== "")
+				}, config.metadata);
+				const ownership = batchContext.errorOwnership ?? this.looseErrorOwnership;
+				if (call.id != null && call.id !== "") if (dispatched === false)
  /**
 				* The handler could not dispatch the error completion (typically
 				* a resume pass, where a fast-failing tool errors before the
@@ -750,8 +760,10 @@ var ToolNode = class extends RunnableCallable {
 				* output loop dispatches the completion itself instead of
 				* assuming the handler covered it.
 				*/
-				this.undispatchedToolErrors.add(call.id);
+				ownership.undispatched.add(call.id);
+				else ownership.handlerOwned.add(call.id);
 			} catch (handlerError) {
+				if (call.id != null && call.id !== "") (batchContext.errorOwnership ?? this.looseErrorOwnership).handlerOwned.add(call.id);
 				console.error("Error in errorHandler:", {
 					toolName: call.name,
 					toolCallId: call.id,
@@ -852,11 +864,12 @@ var ToolNode = class extends RunnableCallable {
 		const turn = usageCount;
 		const stepId = this.toolCallStepIds?.get(call.id ?? "") ?? "";
 		let resolvedArgs = call.args;
+		const hookResolveOptions = { substituteIntentKey: this.toolDeclaresBusinessIntent(call.name) };
 		if (batchContext.preBatchSnapshot != null) {
-			const { resolved } = batchContext.preBatchSnapshot.resolve(call.args);
+			const { resolved } = batchContext.preBatchSnapshot.resolve(call.args, hookResolveOptions);
 			resolvedArgs = resolved;
 		} else if (this.toolOutputRegistry != null) {
-			const { resolved } = this.toolOutputRegistry.resolve(registryRunId, call.args);
+			const { resolved } = this.toolOutputRegistry.resolve(registryRunId, call.args, hookResolveOptions);
 			resolvedArgs = resolved;
 		}
 		let effectiveCall = call;
@@ -968,6 +981,16 @@ var ToolNode = class extends RunnableCallable {
 				}
 			}
 		}
+		/**
+		* A hook (`PreToolUse.updatedInput`) or HITL `edit` decision rewrote the
+		* args: expose the EFFECTIVE args to downstream completion handling
+		* (`handleRunToolCompletions` reads this sink), so the emitted
+		* `tool_call.args` — and any intent/outcome label resolved from them —
+		* reflect what the tool actually ran with. `runTool`'s own placeholder
+		* substitution may overwrite this entry with the post-substitution args,
+		* which is strictly more accurate.
+		*/
+		if (effectiveCall !== call && batchContext.resolvedArgsByCallId != null && call.id != null && call.id !== "") batchContext.resolvedArgsByCallId.set(call.id, effectiveCall.args);
 		const output = await this.runTool(effectiveCall, config, {
 			...batchContext,
 			usageCount
@@ -1174,7 +1197,8 @@ var ToolNode = class extends RunnableCallable {
 	*   by `runTool`. Threaded as a local map (instead of instance state)
 	*   so concurrent batches cannot read each other's entries.
 	*/
-	async handleRunToolCompletions(calls, outputs, config, resolvedArgsByCallId) {
+	async handleRunToolCompletions(calls, outputs, config, resolvedArgsByCallId, errorOwnership) {
+		const ownership = errorOwnership ?? this.looseErrorOwnership;
 		for (let i = 0; i < calls.length; i++) {
 			const call = calls[i];
 			const output = outputs[i];
@@ -1182,8 +1206,13 @@ var ToolNode = class extends RunnableCallable {
 			if (isCommand(output)) continue;
 			const toolMessage = output;
 			const toolCallId = call.id ?? "";
-			if (toolMessage.status === "error" && this.errorHandler != null) if (this.undispatchedToolErrors.has(toolCallId)) this.undispatchedToolErrors.delete(toolCallId);
-			else continue;
+			if (toolMessage.status === "error" && this.errorHandler != null) {
+				if (ownership.handlerOwned.has(toolCallId)) {
+					ownership.handlerOwned.delete(toolCallId);
+					continue;
+				}
+				ownership.undispatched.delete(toolCallId);
+			}
 			if (this.sessions && this.participatesInCodeSession(call.name)) {
 				const artifact = toolMessage.artifact;
 				const execSessionId = artifact?.session_id;
@@ -1195,16 +1224,27 @@ var ToolNode = class extends RunnableCallable {
 			if (isComputerCallOutputMessage(toolMessage)) contentString = truncateToolResultContent("[Computer screenshot omitted from completion event]", this.maxToolResultChars);
 			else if (typeof toolMessage.content === "string") contentString = toolMessage.content;
 			else contentString = serializeStructuredValueBounded(toolMessage.content, this.maxToolResultChars).content;
+			/**
+			* Prefer the post-substitution args when a `{{…}}` placeholder
+			* was resolved in `runTool`. This keeps
+			* `ON_RUN_STEP_COMPLETED.tool_call.args` consistent with what
+			* the tool actually received rather than leaking the template.
+			*/
+			const effectiveArgs = resolvedArgsByCallId?.get(toolCallId) ?? call.args;
+			/** Authored outcomes apply to failed calls too (“Search failed for…”);
+			*  without one, an error call simply stays unlabeled. */
+			const outcome = resolveToolOutcome(effectiveArgs, readOutcomeFields(toolMessage.artifact), { isError: toolMessage.status === "error" });
 			await safeDispatchCustomEvent("on_run_step_completed", { result: {
 				id: stepId,
 				index: turn,
 				type: "tool_call",
 				tool_call: {
-					args: serializeToolContentBounded(resolvedArgsByCallId?.get(toolCallId) ?? call.args ?? {}, this.maxToolResultChars),
+					args: serializeToolContentBounded(effectiveArgs ?? {}, this.maxToolResultChars),
 					name: call.name,
 					id: toolCallId,
 					output: contentString,
-					progress: 1
+					progress: 1,
+					...outcome != null && { outcome }
 				}
 			} }, config);
 		}
@@ -1253,7 +1293,7 @@ var ToolNode = class extends RunnableCallable {
 				resolvedArgs = pre.resolved;
 				if (pre.unresolved.length > 0 && call.id != null) unresolvedByCallId.set(call.id, pre.unresolved);
 			} else if (registry != null) {
-				const { resolved, unresolved } = registry.resolve(registryRunId, originalArgs);
+				const { resolved, unresolved } = registry.resolve(registryRunId, originalArgs, { substituteIntentKey: this.toolDeclaresBusinessIntent(call.name) });
 				resolvedArgs = resolved;
 				if (unresolved.length > 0 && call.id != null) unresolvedByCallId.set(call.id, unresolved);
 			}
@@ -1429,7 +1469,7 @@ var ToolNode = class extends RunnableCallable {
 			*/
 			const applyInputOverride = (entry, nextArgs) => {
 				if (registry != null) {
-					const { resolved, unresolved } = (preBatchSnapshot ?? { resolve: (args) => registry.resolve(registryRunId, args) }).resolve(nextArgs);
+					const { resolved, unresolved } = (preBatchSnapshot ?? { resolve: (args, options) => registry.resolve(registryRunId, args, options) }).resolve(nextArgs, { substituteIntentKey: this.toolDeclaresBusinessIntent(entry.call.name) });
 					entry.args = resolved;
 					if (entry.call.id != null) if (unresolved.length > 0) unresolvedByCallId.set(entry.call.id, unresolved);
 					else unresolvedByCallId.delete(entry.call.id);
@@ -1772,7 +1812,7 @@ var ToolNode = class extends RunnableCallable {
 			this.storeCodeSessionFromResults(results, requestMap);
 			for (const result of results) {
 				if (result.injectedMessages && result.injectedMessages.length > 0) try {
-					injected.push(...this.convertInjectedMessages(result.injectedMessages));
+					injected.push(...convertInjectedMessages(result.injectedMessages));
 				} catch (e) {
 					console.warn(`[ToolNode] Failed to convert injectedMessages for toolCallId=${result.toolCallId}:`, e instanceof Error ? e.message : e);
 				}
@@ -1890,7 +1930,7 @@ var ToolNode = class extends RunnableCallable {
 						...successRefMeta != null && { additional_kwargs: successRefMeta }
 					});
 				}
-				if (!eagerCompletionDispatchedIds.has(result.toolCallId) && !earlyCompletionDispatchedIds.has(result.toolCallId)) await this.dispatchStepCompleted(result.toolCallId, toolName, request?.args ?? {}, contentString, config, request?.turn);
+				if (!eagerCompletionDispatchedIds.has(result.toolCallId) && !earlyCompletionDispatchedIds.has(result.toolCallId)) await this.dispatchStepCompleted(result.toolCallId, toolName, request?.args ?? {}, contentString, config, request?.turn, resolveToolOutcome(request?.args, outcomeFieldsFromResult(result), { isError: result.status === "error" }));
 				postToolBatchEntryByCallId.set(result.toolCallId, {
 					toolName,
 					toolInput: request?.args ?? {},
@@ -2021,12 +2061,26 @@ var ToolNode = class extends RunnableCallable {
 		* user speech (e.g. steering) sits closest to the next model call.
 		*/
 		if (hookInjectedMessages.length > 0) try {
-			injected.push(...this.convertInjectedMessages(hookInjectedMessages));
+			injected.push(...convertInjectedMessages(hookInjectedMessages));
 		} catch (e) {
 			console.warn("[ToolNode] Failed to convert PostToolBatch injectedMessages:", e instanceof Error ? e.message : e);
 		}
 	}
-	async dispatchStepCompleted(toolCallId, toolName, args, output, config, turn) {
+	/**
+	* Whether `name`'s own schema declares a BUSINESS parameter called
+	* `intent` (declared, and not the injected label contract — see
+	* `isIntentLabelProperty`). Such a parameter must keep participating in
+	* `{{tool…}}` placeholder substitution; only the display label is exempt.
+	*/
+	toolDeclaresBusinessIntent(name) {
+		const instance = this.toolMap.get(name);
+		const instanceProp = instance?.schema?.properties?.["intent"] ?? instance?.schema?.shape?.["intent"];
+		if (instanceProp != null) return !isIntentLabelProperty(instanceProp);
+		const defProp = this.toolRegistry?.get(name)?.parameters?.properties?.[INTENT_ARG];
+		if (defProp != null) return !isIntentLabelProperty(defProp);
+		return false;
+	}
+	async dispatchStepCompleted(toolCallId, toolName, args, output, config, turn, outcome) {
 		const stepId = this.toolCallStepIds?.get(toolCallId) ?? "";
 		if (!stepId) console.warn(`[ToolNode] toolCallStepIds missing entry for toolCallId=${toolCallId} (tool=${toolName}). This indicates a race between the stream consumer and graph execution. Map size: ${this.toolCallStepIds?.size ?? 0}`);
 		return await safeDispatchCustomEvent("on_run_step_completed", { result: {
@@ -2038,7 +2092,8 @@ var ToolNode = class extends RunnableCallable {
 				name: toolName,
 				id: toolCallId,
 				output,
-				progress: 1
+				progress: 1,
+				...outcome != null && { outcome }
 			}
 		} }, config) !== false;
 	}
@@ -2051,27 +2106,7 @@ var ToolNode = class extends RunnableCallable {
 	*/
 	async dispatchEarlyToolCompletion(result, request, config) {
 		const output = result.status === "error" ? truncateToolResultContent(`Error: ${result.errorMessage ?? "Unknown error"}\n Please fix your mistakes.`, this.maxToolResultChars) : serializeToolOutputWithinLimits(result.content, this.maxToolResultChars).content;
-		return this.dispatchStepCompleted(result.toolCallId, request.name, request.args, output, config, request.turn);
-	}
-	/**
-	* Converts InjectedMessage instances to LangChain HumanMessage objects.
-	* Both 'user' and 'system' roles become HumanMessage to avoid provider
-	* rejections (Anthropic/Google reject non-leading SystemMessages).
-	* The original role is preserved in additional_kwargs for downstream consumers.
-	*/
-	convertInjectedMessages(messages) {
-		const converted = [];
-		for (const msg of messages) {
-			const additional_kwargs = { role: msg.role };
-			if (msg.isMeta != null) additional_kwargs.isMeta = msg.isMeta;
-			if (msg.source != null) additional_kwargs.source = msg.source;
-			if (msg.skillName != null) additional_kwargs.skillName = msg.skillName;
-			converted.push(new HumanMessage({
-				content: toLangChainContent(msg.content),
-				additional_kwargs
-			}));
-		}
-		return converted;
+		return this.dispatchStepCompleted(result.toolCallId, request.name, request.args, output, config, request.turn, resolveToolOutcome(request.args, outcomeFieldsFromResult(result), { isError: result.status === "error" }));
 	}
 	/**
 	* Execute a group of direct (in-process) tool calls with interrupt-safe
@@ -2152,6 +2187,8 @@ var ToolNode = class extends RunnableCallable {
 		* ToolNode cannot read or wipe each other's entries.
 		*/
 		const resolvedArgsByCallId = /* @__PURE__ */ new Map();
+		/** Per-invocation error-completion ownership — see `ToolErrorOwnership`. */
+		const errorOwnership = createToolErrorOwnership();
 		const batchScopeId = config.configurable?.run_id ?? `\0anon-${this.anonBatchCounter++}`;
 		const turn = this.toolOutputRegistry?.nextTurn(batchScopeId) ?? 0;
 		let outputs;
@@ -2169,6 +2206,7 @@ var ToolNode = class extends RunnableCallable {
 				turn,
 				batchScopeId,
 				resolvedArgsByCallId,
+				errorOwnership,
 				additionalContextsSink: directAdditionalContexts,
 				runInput: sendState
 			});
@@ -2179,7 +2217,7 @@ var ToolNode = class extends RunnableCallable {
 					source: "hook"
 				}
 			})] : [sendOutput];
-			await this.handleRunToolCompletions([input.lg_tool_call], [sendOutput], config, resolvedArgsByCallId);
+			await this.handleRunToolCompletions([input.lg_tool_call], [sendOutput], config, resolvedArgsByCallId, errorOwnership);
 		} else {
 			let messages;
 			if (Array.isArray(input)) messages = input;
@@ -2257,7 +2295,7 @@ var ToolNode = class extends RunnableCallable {
 				const preBatchSnapshot = this.toolOutputRegistry?.snapshot(batchScopeId);
 				if (preBatchSnapshot != null) {
 					for (const entry of eventEntries) if (entry.call.id != null) {
-						const { resolved, unresolved } = preBatchSnapshot.resolve(entry.call.args);
+						const { resolved, unresolved } = preBatchSnapshot.resolve(entry.call.args, { substituteIntentKey: this.toolDeclaresBusinessIntent(entry.call.name) });
 						preResolvedEventArgs.set(entry.call.id, {
 							resolved,
 							unresolved
@@ -2269,11 +2307,12 @@ var ToolNode = class extends RunnableCallable {
 					turn,
 					batchScopeId,
 					resolvedArgsByCallId,
+					errorOwnership,
 					preBatchSnapshot,
 					additionalContextsSink: directAdditionalContexts,
 					runInput: input
 				}) : [];
-				if (directCalls.length > 0 && directOutputs.length > 0) await this.handleRunToolCompletions(directCalls, directOutputs, config, resolvedArgsByCallId);
+				if (directCalls.length > 0 && directOutputs.length > 0) await this.handleRunToolCompletions(directCalls, directOutputs, config, resolvedArgsByCallId, errorOwnership);
 				const eventResult = eventCalls.length > 0 ? await this.dispatchToolEvents(eventCalls, config, {
 					batchIndices: eventIndices,
 					turn,
@@ -2304,11 +2343,12 @@ var ToolNode = class extends RunnableCallable {
 					turn,
 					batchScopeId,
 					resolvedArgsByCallId,
+					errorOwnership,
 					preBatchSnapshot,
 					additionalContextsSink: directAdditionalContexts,
 					runInput: input
 				});
-				await this.handleRunToolCompletions(filteredCalls, toolOutputs, config, resolvedArgsByCallId);
+				await this.handleRunToolCompletions(filteredCalls, toolOutputs, config, resolvedArgsByCallId, errorOwnership);
 				outputs = directAdditionalContexts.length > 0 ? [...toolOutputs, new HumanMessage({
 					content: directAdditionalContexts.join("\n\n"),
 					additional_kwargs: {
@@ -2414,6 +2454,6 @@ function toolsCondition(state, toolNode, invokedToolIds) {
 	return END;
 }
 //#endregion
-export { ToolNode, toolsCondition };
+export { ToolNode, createToolErrorOwnership, toolsCondition };
 
 //# sourceMappingURL=ToolNode.mjs.map