@librechat/agents 3.1.66 → 3.1.67-dev.4

package/dist/esm/tools/ToolNode.mjs

@@ -1,6 +1,6 @@
-import { isBaseMessage, ToolMessage, isAIMessage } from '@langchain/core/messages';
+import { isBaseMessage, ToolMessage, HumanMessage, isAIMessage } from '@langchain/core/messages';
 import { isCommand, isGraphInterrupt, Command, Send, END } from '@langchain/langgraph';
-import { Constants, GraphEvents } from '../common/enum.mjs';
+import { Constants, CODE_EXECUTION_TOOLS, GraphEvents } from '../common/enum.mjs';
 import 'nanoid';
 import '../messages/core.mjs';
 import { calculateMaxToolResultChars, truncateToolResultContent } from '../utils/truncation.mjs';
@@ -9,6 +9,7 @@ import 'uuid';
 import { RunnableCallable } from '../utils/run.mjs';
 import 'ai-tokenizer';
 import 'zod-to-json-schema';
+import { executeHooks } from '../hooks/executeHooks.mjs';
 
 /**
  * Helper to check if a value is a Send object
@@ -16,6 +17,32 @@ import 'zod-to-json-schema';
 function isSend(value) {
     return value instanceof Send;
 }
+/** Merges code execution session context into the sessions map. */
+function updateCodeSession(sessions, sessionId, files) {
+    const newFiles = files ?? [];
+    const existingSession = sessions.get(Constants.EXECUTE_CODE);
+    const existingFiles = existingSession?.files ?? [];
+    if (newFiles.length > 0) {
+        const filesWithSession = newFiles.map((file) => ({
+            ...file,
+            session_id: sessionId,
+        }));
+        const newFileNames = new Set(filesWithSession.map((f) => f.name));
+        const filteredExisting = existingFiles.filter((f) => !newFileNames.has(f.name));
+        sessions.set(Constants.EXECUTE_CODE, {
+            session_id: sessionId,
+            files: [...filteredExisting, ...filesWithSession],
+            lastUpdated: Date.now(),
+        });
+    }
+    else {
+        sessions.set(Constants.EXECUTE_CODE, {
+            session_id: sessionId,
+            files: existingFiles,
+            lastUpdated: Date.now(),
+        });
+    }
+}
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 class ToolNode extends RunnableCallable {
     toolMap;
@@ -41,7 +68,9 @@ class ToolNode extends RunnableCallable {
     directToolNames;
     /** Maximum characters allowed in a single tool result before truncation. */
     maxToolResultChars;
-    constructor({ tools, toolMap, name, tags, errorHandler, toolCallStepIds, handleToolErrors, loadRuntimeTools, toolRegistry, sessions, eventDrivenMode, agentId, directToolNames, maxContextTokens, maxToolResultChars, }) {
+    /** Hook registry for PreToolUse/PostToolUse lifecycle hooks */
+    hookRegistry;
+    constructor({ tools, toolMap, name, tags, errorHandler, toolCallStepIds, handleToolErrors, loadRuntimeTools, toolRegistry, sessions, eventDrivenMode, agentId, directToolNames, maxContextTokens, maxToolResultChars, hookRegistry, }) {
         super({ name, tags, func: (input, config) => this.run(input, config) });
         this.toolMap = toolMap ?? new Map(tools.map((tool) => [tool.name, tool]));
         this.toolCallStepIds = toolCallStepIds;
@@ -56,6 +85,7 @@ class ToolNode extends RunnableCallable {
         this.directToolNames = directToolNames;
         this.maxToolResultChars =
             maxToolResultChars ?? calculateMaxToolResultChars(maxContextTokens);
+        this.hookRegistry = hookRegistry;
     }
     /**
      * Returns cached programmatic tools, computing once on first access.
@@ -111,7 +141,8 @@ class ToolNode extends RunnableCallable {
                 turn,
             };
             // Inject runtime data for special tools (becomes available at config.toolCall)
-            if (call.name === Constants.PROGRAMMATIC_TOOL_CALLING) {
+            if (call.name === Constants.PROGRAMMATIC_TOOL_CALLING ||
+                call.name === Constants.BASH_PROGRAMMATIC_TOOL_CALLING) {
                 const { toolMap, toolDefs } = this.getProgrammaticTools();
                 invokeParams = {
                     ...invokeParams,
@@ -134,8 +165,7 @@ class ToolNode extends RunnableCallable {
              * session_id is always injected when available (even without tracked files)
              * so the CodeExecutor can fall back to the /files endpoint for session continuity.
              */
-            if (call.name === Constants.EXECUTE_CODE ||
-                call.name === Constants.PROGRAMMATIC_TOOL_CALLING) {
+            if (CODE_EXECUTION_TOOLS.has(call.name)) {
                 const codeSession = this.sessions?.get(Constants.EXECUTE_CODE);
                 if (codeSession?.session_id != null && codeSession.session_id !== '') {
                     invokeParams = {
@@ -244,7 +274,7 @@ class ToolNode extends RunnableCallable {
      * Extracts code execution session context from tool results and stores in Graph.sessions.
      * Mirrors the session storage logic in handleRunToolCompletions for direct execution.
      */
-    storeCodeSessionFromResults(results, requests) {
+    storeCodeSessionFromResults(results, requestMap) {
         if (!this.sessions) {
             return;
         }
@@ -253,38 +283,17 @@ class ToolNode extends RunnableCallable {
             if (result.status !== 'success' || result.artifact == null) {
                 continue;
             }
-            const request = requests.find((r) => r.id === result.toolCallId);
-            if (request?.name !== Constants.EXECUTE_CODE &&
-                request?.name !== Constants.PROGRAMMATIC_TOOL_CALLING) {
+            const request = requestMap.get(result.toolCallId);
+            if (!request?.name ||
+                (!CODE_EXECUTION_TOOLS.has(request.name) &&
+                    request.name !== Constants.SKILL_TOOL)) {
                 continue;
             }
             const artifact = result.artifact;
             if (artifact?.session_id == null || artifact.session_id === '') {
                 continue;
             }
-            const newFiles = artifact.files ?? [];
-            const existingSession = this.sessions.get(Constants.EXECUTE_CODE);
-            const existingFiles = existingSession?.files ?? [];
-            if (newFiles.length > 0) {
-                const filesWithSession = newFiles.map((file) => ({
-                    ...file,
-                    session_id: artifact.session_id,
-                }));
-                const newFileNames = new Set(filesWithSession.map((f) => f.name));
-                const filteredExisting = existingFiles.filter((f) => !newFileNames.has(f.name));
-                this.sessions.set(Constants.EXECUTE_CODE, {
-                    session_id: artifact.session_id,
-                    files: [...filteredExisting, ...filesWithSession],
-                    lastUpdated: Date.now(),
-                });
-            }
-            else {
-                this.sessions.set(Constants.EXECUTE_CODE, {
-                    session_id: artifact.session_id,
-                    files: existingFiles,
-                    lastUpdated: Date.now(),
-                });
-            }
+            updateCodeSession(this.sessions, artifact.session_id, artifact.files);
         }
     }
     /**
@@ -311,35 +320,10 @@ class ToolNode extends RunnableCallable {
             if (toolMessage.status === 'error' && this.errorHandler != null) {
                 continue;
             }
-            // Store code session context from tool results
-            if (this.sessions &&
-                (call.name === Constants.EXECUTE_CODE ||
-                    call.name === Constants.PROGRAMMATIC_TOOL_CALLING)) {
+            if (this.sessions && CODE_EXECUTION_TOOLS.has(call.name)) {
                 const artifact = toolMessage.artifact;
                 if (artifact?.session_id != null && artifact.session_id !== '') {
-                    const newFiles = artifact.files ?? [];
-                    const existingSession = this.sessions.get(Constants.EXECUTE_CODE);
-                    const existingFiles = existingSession?.files ?? [];
-                    if (newFiles.length > 0) {
-                        const filesWithSession = newFiles.map((file) => ({
-                            ...file,
-                            session_id: artifact.session_id,
-                        }));
-                        const newFileNames = new Set(filesWithSession.map((f) => f.name));
-                        const filteredExisting = existingFiles.filter((f) => !newFileNames.has(f.name));
-                        this.sessions.set(Constants.EXECUTE_CODE, {
-                            session_id: artifact.session_id,
-                            files: [...filteredExisting, ...filesWithSession],
-                            lastUpdated: Date.now(),
-                        });
-                    }
-                    else {
-                        this.sessions.set(Constants.EXECUTE_CODE, {
-                            session_id: artifact.session_id,
-                            files: existingFiles,
-                            lastUpdated: Date.now(),
-                        });
-                    }
+                    updateCodeSession(this.sessions, artifact.session_id, artifact.files);
                 }
             }
             // Dispatch ON_RUN_STEP_COMPLETED via custom event (same path as dispatchToolEvents)
@@ -372,100 +356,273 @@ class ToolNode extends RunnableCallable {
     /**
      * Dispatches tool calls to the host via ON_TOOL_EXECUTE event and returns raw ToolMessages.
      * Core logic for event-driven execution, separated from output shaping.
+     *
+     * Hook lifecycle (when `hookRegistry` is set):
+     * 1. **PreToolUse** fires per call in parallel before dispatch. Denied
+     *    calls produce error ToolMessages and fire **PermissionDenied**;
+     *    surviving calls proceed with optional `updatedInput`.
+     * 2. Surviving calls are dispatched to the host via `ON_TOOL_EXECUTE`.
+     * 3. **PostToolUse** / **PostToolUseFailure** fire per result. Post hooks
+     *    can replace tool output via `updatedOutput`.
+     * 4. Injected messages from results are collected and returned alongside
+     *    ToolMessages (appended AFTER to respect provider ordering).
      */
     async dispatchToolEvents(toolCalls, config) {
-        const requests = toolCalls.map((call) => {
-            const turn = this.toolUsageCount.get(call.name) ?? 0;
-            this.toolUsageCount.set(call.name, turn + 1);
-            const request = {
-                id: call.id,
-                name: call.name,
-                args: call.args,
-                stepId: this.toolCallStepIds?.get(call.id),
-                turn,
-            };
-            if (call.name === Constants.EXECUTE_CODE ||
-                call.name === Constants.PROGRAMMATIC_TOOL_CALLING) {
-                request.codeSessionContext = this.getCodeSessionContext();
-            }
-            return request;
-        });
-        const results = await new Promise((resolve, reject) => {
-            const request = {
-                toolCalls: requests,
-                userId: config.configurable?.user_id,
-                agentId: this.agentId,
-                configurable: config.configurable,
-                metadata: config.metadata,
-                resolve,
-                reject,
-            };
-            safeDispatchCustomEvent(GraphEvents.ON_TOOL_EXECUTE, request, config);
+        const runId = config.configurable?.run_id ?? '';
+        const threadId = config.configurable?.thread_id;
+        const preToolCalls = toolCalls.map((call) => ({
+            call,
+            stepId: this.toolCallStepIds?.get(call.id) ?? '',
+            args: call.args,
+        }));
+        const messageByCallId = new Map();
+        const approvedEntries = [];
+        const HOOK_FALLBACK = Object.freeze({
+            additionalContexts: [],
+            errors: [],
         });
-        this.storeCodeSessionFromResults(results, requests);
-        return results.map((result) => {
-            const request = requests.find((r) => r.id === result.toolCallId);
-            const toolName = request?.name ?? 'unknown';
-            const stepId = this.toolCallStepIds?.get(result.toolCallId) ?? '';
-            if (!stepId) {
-                // eslint-disable-next-line no-console
-                console.warn(`[ToolNode] toolCallStepIds missing entry for toolCallId=${result.toolCallId} (tool=${toolName}). ` +
-                    'This indicates a race between the stream consumer and graph execution. ' +
-                    `Map size: ${this.toolCallStepIds?.size ?? 0}`);
+        if (this.hookRegistry?.hasHookFor('PreToolUse', runId) === true) {
+            const preResults = await Promise.all(preToolCalls.map((entry) => executeHooks({
+                registry: this.hookRegistry,
+                input: {
+                    hook_event_name: 'PreToolUse',
+                    runId,
+                    threadId,
+                    agentId: this.agentId,
+                    toolName: entry.call.name,
+                    toolInput: entry.args,
+                    toolUseId: entry.call.id,
+                    stepId: entry.stepId,
+                    turn: this.toolUsageCount.get(entry.call.name) ?? 0,
+                },
+                sessionId: runId,
+                matchQuery: entry.call.name,
+            }).catch(() => HOOK_FALLBACK)));
+            for (let i = 0; i < preToolCalls.length; i++) {
+                const hookResult = preResults[i];
+                const entry = preToolCalls[i];
+                const isDenied = hookResult.decision === 'deny' || hookResult.decision === 'ask';
+                if (isDenied) {
+                    const reason = hookResult.reason ?? 'Blocked by hook';
+                    const contentString = `Blocked: ${reason}`;
+                    messageByCallId.set(entry.call.id, new ToolMessage({
+                        status: 'error',
+                        content: contentString,
+                        name: entry.call.name,
+                        tool_call_id: entry.call.id,
+                    }));
+                    this.dispatchStepCompleted(entry.call.id, entry.call.name, entry.args, contentString, config);
+                    if (this.hookRegistry.hasHookFor('PermissionDenied', runId)) {
+                        executeHooks({
+                            registry: this.hookRegistry,
+                            input: {
+                                hook_event_name: 'PermissionDenied',
+                                runId,
+                                threadId,
+                                agentId: this.agentId,
+                                toolName: entry.call.name,
+                                toolInput: entry.args,
+                                toolUseId: entry.call.id,
+                                reason,
+                            },
+                            sessionId: runId,
+                            matchQuery: entry.call.name,
+                        }).catch(() => {
+                            /* PermissionDenied is observational — swallow errors */
+                        });
+                    }
+                    continue;
+                }
+                if (hookResult.updatedInput != null) {
+                    entry.args = hookResult.updatedInput;
+                }
+                approvedEntries.push(entry);
             }
-            let toolMessage;
-            let contentString;
-            if (result.status === 'error') {
-                contentString = `Error: ${result.errorMessage ?? 'Unknown error'}\n Please fix your mistakes.`;
-                toolMessage = new ToolMessage({
-                    status: 'error',
-                    content: contentString,
-                    name: toolName,
-                    tool_call_id: result.toolCallId,
-                });
+        }
+        else {
+            approvedEntries.push(...preToolCalls);
+        }
+        const injected = [];
+        if (approvedEntries.length > 0) {
+            const requests = approvedEntries.map((entry) => {
+                const turn = this.toolUsageCount.get(entry.call.name) ?? 0;
+                this.toolUsageCount.set(entry.call.name, turn + 1);
+                const request = {
+                    id: entry.call.id,
+                    name: entry.call.name,
+                    args: entry.args,
+                    stepId: entry.stepId,
+                    turn,
+                };
+                if (CODE_EXECUTION_TOOLS.has(entry.call.name) ||
+                    entry.call.name === Constants.SKILL_TOOL) {
+                    request.codeSessionContext = this.getCodeSessionContext();
+                }
+                return request;
+            });
+            const requestMap = new Map(requests.map((r) => [r.id, r]));
+            const results = await new Promise((resolve, reject) => {
+                const batchRequest = {
+                    toolCalls: requests,
+                    userId: config.configurable?.user_id,
+                    agentId: this.agentId,
+                    configurable: config.configurable,
+                    metadata: config.metadata,
+                    resolve,
+                    reject,
+                };
+                safeDispatchCustomEvent(GraphEvents.ON_TOOL_EXECUTE, batchRequest, config);
+            });
+            this.storeCodeSessionFromResults(results, requestMap);
+            const hasPostHook = this.hookRegistry?.hasHookFor('PostToolUse', runId) === true;
+            const hasFailureHook = this.hookRegistry?.hasHookFor('PostToolUseFailure', runId) === true;
+            for (const result of results) {
+                if (result.injectedMessages && result.injectedMessages.length > 0) {
+                    try {
+                        injected.push(...this.convertInjectedMessages(result.injectedMessages));
+                    }
+                    catch (e) {
+                        // eslint-disable-next-line no-console
+                        console.warn(`[ToolNode] Failed to convert injectedMessages for toolCallId=${result.toolCallId}:`, e instanceof Error ? e.message : e);
+                    }
+                }
+                const request = requestMap.get(result.toolCallId);
+                const toolName = request?.name ?? 'unknown';
+                let contentString;
+                let toolMessage;
+                if (result.status === 'error') {
+                    contentString = `Error: ${result.errorMessage ?? 'Unknown error'}\n Please fix your mistakes.`;
+                    toolMessage = new ToolMessage({
+                        status: 'error',
+                        content: contentString,
+                        name: toolName,
+                        tool_call_id: result.toolCallId,
+                    });
+                    if (hasFailureHook) {
+                        await executeHooks({
+                            registry: this.hookRegistry,
+                            input: {
+                                hook_event_name: 'PostToolUseFailure',
+                                runId,
+                                threadId,
+                                agentId: this.agentId,
+                                toolName,
+                                toolInput: request?.args ?? {},
+                                toolUseId: result.toolCallId,
+                                error: result.errorMessage ?? 'Unknown error',
+                                stepId: request?.stepId,
+                                turn: request?.turn,
+                            },
+                            sessionId: runId,
+                            matchQuery: toolName,
+                        }).catch(() => {
+                            /* PostToolUseFailure is observational — swallow errors */
+                        });
+                    }
+                }
+                else {
+                    const rawContent = typeof result.content === 'string'
+                        ? result.content
+                        : JSON.stringify(result.content);
+                    contentString = truncateToolResultContent(rawContent, this.maxToolResultChars);
+                    if (hasPostHook) {
+                        const hookResult = await executeHooks({
+                            registry: this.hookRegistry,
+                            input: {
+                                hook_event_name: 'PostToolUse',
+                                runId,
+                                threadId,
+                                agentId: this.agentId,
+                                toolName,
+                                toolInput: request?.args ?? {},
+                                toolOutput: result.content,
+                                toolUseId: result.toolCallId,
+                                stepId: request?.stepId,
+                                turn: request?.turn,
+                            },
+                            sessionId: runId,
+                            matchQuery: toolName,
+                        }).catch(() => undefined);
+                        if (hookResult?.updatedOutput != null) {
+                            const replaced = typeof hookResult.updatedOutput === 'string'
+                                ? hookResult.updatedOutput
+                                : JSON.stringify(hookResult.updatedOutput);
+                            contentString = truncateToolResultContent(replaced, this.maxToolResultChars);
+                        }
+                    }
+                    toolMessage = new ToolMessage({
+                        status: 'success',
+                        name: toolName,
+                        content: contentString,
+                        artifact: result.artifact,
+                        tool_call_id: result.toolCallId,
+                    });
+                }
+                this.dispatchStepCompleted(result.toolCallId, toolName, request?.args ?? {}, contentString, config, request?.turn);
+                messageByCallId.set(result.toolCallId, toolMessage);
             }
-            else {
-                const rawContent = typeof result.content === 'string'
-                    ? result.content
-                    : JSON.stringify(result.content);
-                contentString = truncateToolResultContent(rawContent, this.maxToolResultChars);
-                toolMessage = new ToolMessage({
-                    status: 'success',
+        }
+        const toolMessages = toolCalls
+            .map((call) => messageByCallId.get(call.id))
+            .filter((m) => m != null);
+        return { toolMessages, injected };
+    }
+    dispatchStepCompleted(toolCallId, toolName, args, output, config, turn) {
+        const stepId = this.toolCallStepIds?.get(toolCallId) ?? '';
+        if (!stepId) {
+            // eslint-disable-next-line no-console
+            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}`);
+        }
+        safeDispatchCustomEvent(GraphEvents.ON_RUN_STEP_COMPLETED, {
+            result: {
+                id: stepId,
+                index: turn ?? this.toolUsageCount.get(toolName) ?? 0,
+                type: 'tool_call',
+                tool_call: {
+                    args: JSON.stringify(args),
                     name: toolName,
-                    content: contentString,
-                    artifact: result.artifact,
-                    tool_call_id: result.toolCallId,
-                });
-            }
-            const tool_call = {
-                args: typeof request?.args === 'string'
-                    ? request.args
-                    : JSON.stringify(request?.args ?? {}),
-                name: toolName,
-                id: result.toolCallId,
-                output: contentString,
-                progress: 1,
-            };
-            const runStepCompletedData = {
-                result: {
-                    id: stepId,
-                    index: request?.turn ?? 0,
-                    type: 'tool_call',
-                    tool_call,
+                    id: toolCallId,
+                    output,
+                    progress: 1,
                 },
+            },
+        }, config);
+    }
+    /**
+     * 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,
             };
-            safeDispatchCustomEvent(GraphEvents.ON_RUN_STEP_COMPLETED, runStepCompletedData, config);
-            return toolMessage;
-        });
+            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: msg.content, additional_kwargs }));
+        }
+        return converted;
     }
     /**
      * Execute all tool calls via ON_TOOL_EXECUTE event dispatch.
-     * Used in event-driven mode where the host handles actual tool execution.
+     * Injected messages are placed AFTER ToolMessages to respect provider
+     * message ordering (AIMessage tool_calls must be immediately followed
+     * by their ToolMessage results).
      */
     async executeViaEvent(toolCalls, config, 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     input) {
-        const outputs = await this.dispatchToolEvents(toolCalls, config);
+        const { toolMessages, injected } = await this.dispatchToolEvents(toolCalls, config);
+        const outputs = [...toolMessages, ...injected];
         return (Array.isArray(input) ? outputs : { messages: outputs });
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -534,10 +691,17 @@ class ToolNode extends RunnableCallable {
                 if (directCalls.length > 0 && directOutputs.length > 0) {
                     this.handleRunToolCompletions(directCalls, directOutputs, config);
                 }
-                const eventOutputs = eventCalls.length > 0
+                const eventResult = eventCalls.length > 0
                     ? await this.dispatchToolEvents(eventCalls, config)
-                    : [];
-                outputs = [...directOutputs, ...eventOutputs];
+                    : {
+                        toolMessages: [],
+                        injected: [],
+                    };
+                outputs = [
+                    ...directOutputs,
+                    ...eventResult.toolMessages,
+                    ...eventResult.injected,
+                ];
             }
             else {
                 outputs = await Promise.all(filteredCalls.map((call) => this.runTool(call, config)));