@librechat/agents 3.2.33 → 3.2.34

package/dist/esm/tools/ToolNode.mjs

@@ -1541,6 +1541,30 @@ var ToolNode = class extends RunnableCallable {
 				});
 				else dispatchRequests.push(request);
 			}
+			/**
+			* Per-call completion fast-path: when the host reports a result
+			* through `onResult` before the batch resolves, emit that call's
+			* completed run step immediately instead of waiting for the slowest
+			* call in the batch. Safe only when nothing can change the result
+			* after execution — post-tool hooks may rewrite output and HITL may
+			* deny a call, so those configurations keep batch-time emission.
+			* Ids are claimed synchronously before the async dispatch and
+			* released if the dispatch fails, letting the batch path re-emit.
+			*/
+			const canEmitEarlyCompletions = this.hookRegistry == null && this.humanInTheLoop?.enabled !== true;
+			const earlyCompletionDispatchedIds = /* @__PURE__ */ new Set();
+			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;
+				if (request == null || earlyCompletionDispatchedIds.has(result.toolCallId)) return;
+				earlyCompletionDispatchedIds.add(result.toolCallId);
+				earlyCompletionDispatches.push(this.dispatchEarlyToolCompletion(result, request, config).then((dispatched) => {
+					if (!dispatched) earlyCompletionDispatchedIds.delete(result.toolCallId);
+				}, () => {
+					earlyCompletionDispatchedIds.delete(result.toolCallId);
+				}));
+			};
 			const dispatchPromise = dispatchRequests.length === 0 ? Promise.resolve([]) : new Promise((resolve, reject) => {
 				let dispatchSettled = false;
 				let resultSettled = false;
@@ -1559,7 +1583,8 @@ var ToolNode = class extends RunnableCallable {
 						settledResults = results;
 						maybeResolve();
 					},
-					reject
+					reject,
+					...canEmitEarlyCompletions && { onResult }
 				}, config).then(() => {
 					dispatchSettled = true;
 					maybeResolve();
@@ -1573,6 +1598,7 @@ var ToolNode = class extends RunnableCallable {
 				};
 			}));
 			const [eagerResults, dispatchedResults] = await Promise.all([eagerResultsPromise, dispatchPromise]);
+			await Promise.allSettled(earlyCompletionDispatches);
 			const eagerCompletionDispatchedIds = new Set(eagerResults.filter((result) => result.completionDispatched).map((result) => result.toolCallId));
 			const flattenedEagerResults = eagerResults.flatMap((result) => result.results);
 			const results = [
@@ -1693,7 +1719,7 @@ var ToolNode = class extends RunnableCallable {
 						...successRefMeta != null && { additional_kwargs: successRefMeta }
 					});
 				}
-				if (!eagerCompletionDispatchedIds.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);
 				postToolBatchEntryByCallId.set(result.toolCallId, {
 					toolName,
 					toolInput: request?.args ?? {},
@@ -1816,7 +1842,7 @@ var ToolNode = class extends RunnableCallable {
 	async dispatchStepCompleted(toolCallId, toolName, args, output, config, turn) {
 		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}`);
-		await safeDispatchCustomEvent("on_run_step_completed", { result: {
+		return await safeDispatchCustomEvent("on_run_step_completed", { result: {
 			id: stepId,
 			index: turn ?? this.toolUsageCount.get(toolName) ?? 0,
 			type: "tool_call",
@@ -1827,7 +1853,18 @@ var ToolNode = class extends RunnableCallable {
 				output,
 				progress: 1
 			}
-		} }, config);
+		} }, config) !== false;
+	}
+	/**
+	* Emits the completed run step for a single host-reported result before
+	* the batch resolves. Mirrors the batch loop's output formatting exactly;
+	* callers gate on the no-hooks/no-HITL configuration, so the raw result
+	* content here is also the final content. Returns whether the event was
+	* actually dispatched so the caller can fall back to batch-time emission.
+	*/
+	async dispatchEarlyToolCompletion(result, request, config) {
+		const output = result.status === "error" ? `Error: ${result.errorMessage ?? "Unknown error"}\n Please fix your mistakes.` : truncateToolResultContent(typeof result.content === "string" ? result.content : JSON.stringify(result.content), this.maxToolResultChars);
+		return this.dispatchStepCompleted(result.toolCallId, request.name, request.args, output, config, request.turn);
 	}
 	/**
 	* Converts InjectedMessage instances to LangChain HumanMessage objects.