@librechat/agents 3.1.67-dev.4 → 3.1.68

package/dist/cjs/tools/ToolNode.cjs

@@ -11,7 +11,6 @@ require('uuid');
 var run = require('../utils/run.cjs');
 require('ai-tokenizer');
 require('zod-to-json-schema');
-var executeHooks = require('../hooks/executeHooks.cjs');
 
 /**
  * Helper to check if a value is a Send object
@@ -19,32 +18,6 @@ var executeHooks = require('../hooks/executeHooks.cjs');
 function isSend(value) {
     return value instanceof langgraph.Send;
 }
-/** Merges code execution session context into the sessions map. */
-function updateCodeSession(sessions, sessionId, files) {
-    const newFiles = files ?? [];
-    const existingSession = sessions.get(_enum.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(_enum.Constants.EXECUTE_CODE, {
-            session_id: sessionId,
-            files: [...filteredExisting, ...filesWithSession],
-            lastUpdated: Date.now(),
-        });
-    }
-    else {
-        sessions.set(_enum.Constants.EXECUTE_CODE, {
-            session_id: sessionId,
-            files: existingFiles,
-            lastUpdated: Date.now(),
-        });
-    }
-}
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 class ToolNode extends run.RunnableCallable {
     toolMap;
@@ -70,9 +43,7 @@ class ToolNode extends run.RunnableCallable {
     directToolNames;
     /** Maximum characters allowed in a single tool result before truncation. */
     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, }) {
+    constructor({ tools, toolMap, name, tags, errorHandler, toolCallStepIds, handleToolErrors, loadRuntimeTools, toolRegistry, sessions, eventDrivenMode, agentId, directToolNames, maxContextTokens, maxToolResultChars, }) {
         super({ name, tags, func: (input, config) => this.run(input, config) });
         this.toolMap = toolMap ?? new Map(tools.map((tool) => [tool.name, tool]));
         this.toolCallStepIds = toolCallStepIds;
@@ -87,7 +58,6 @@ class ToolNode extends run.RunnableCallable {
         this.directToolNames = directToolNames;
         this.maxToolResultChars =
             maxToolResultChars ?? truncation.calculateMaxToolResultChars(maxContextTokens);
-        this.hookRegistry = hookRegistry;
     }
     /**
      * Returns cached programmatic tools, computing once on first access.
@@ -143,8 +113,7 @@ class ToolNode extends run.RunnableCallable {
                 turn,
             };
             // Inject runtime data for special tools (becomes available at config.toolCall)
-            if (call.name === _enum.Constants.PROGRAMMATIC_TOOL_CALLING ||
-                call.name === _enum.Constants.BASH_PROGRAMMATIC_TOOL_CALLING) {
+            if (call.name === _enum.Constants.PROGRAMMATIC_TOOL_CALLING) {
                 const { toolMap, toolDefs } = this.getProgrammaticTools();
                 invokeParams = {
                     ...invokeParams,
@@ -167,7 +136,8 @@ class ToolNode extends run.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 (_enum.CODE_EXECUTION_TOOLS.has(call.name)) {
+            if (call.name === _enum.Constants.EXECUTE_CODE ||
+                call.name === _enum.Constants.PROGRAMMATIC_TOOL_CALLING) {
                 const codeSession = this.sessions?.get(_enum.Constants.EXECUTE_CODE);
                 if (codeSession?.session_id != null && codeSession.session_id !== '') {
                     invokeParams = {
@@ -276,7 +246,7 @@ class ToolNode extends run.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, requestMap) {
+    storeCodeSessionFromResults(results, requests) {
         if (!this.sessions) {
             return;
         }
@@ -285,17 +255,38 @@ class ToolNode extends run.RunnableCallable {
             if (result.status !== 'success' || result.artifact == null) {
                 continue;
             }
-            const request = requestMap.get(result.toolCallId);
-            if (!request?.name ||
-                (!_enum.CODE_EXECUTION_TOOLS.has(request.name) &&
-                    request.name !== _enum.Constants.SKILL_TOOL)) {
+            const request = requests.find((r) => r.id === result.toolCallId);
+            if (request?.name !== _enum.Constants.EXECUTE_CODE &&
+                request?.name !== _enum.Constants.PROGRAMMATIC_TOOL_CALLING) {
                 continue;
             }
             const artifact = result.artifact;
             if (artifact?.session_id == null || artifact.session_id === '') {
                 continue;
             }
-            updateCodeSession(this.sessions, artifact.session_id, artifact.files);
+            const newFiles = artifact.files ?? [];
+            const existingSession = this.sessions.get(_enum.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(_enum.Constants.EXECUTE_CODE, {
+                    session_id: artifact.session_id,
+                    files: [...filteredExisting, ...filesWithSession],
+                    lastUpdated: Date.now(),
+                });
+            }
+            else {
+                this.sessions.set(_enum.Constants.EXECUTE_CODE, {
+                    session_id: artifact.session_id,
+                    files: existingFiles,
+                    lastUpdated: Date.now(),
+                });
+            }
         }
     }
     /**
@@ -322,10 +313,35 @@ class ToolNode extends run.RunnableCallable {
             if (toolMessage.status === 'error' && this.errorHandler != null) {
                 continue;
             }
-            if (this.sessions && _enum.CODE_EXECUTION_TOOLS.has(call.name)) {
+            // Store code session context from tool results
+            if (this.sessions &&
+                (call.name === _enum.Constants.EXECUTE_CODE ||
+                    call.name === _enum.Constants.PROGRAMMATIC_TOOL_CALLING)) {
                 const artifact = toolMessage.artifact;
                 if (artifact?.session_id != null && artifact.session_id !== '') {
-                    updateCodeSession(this.sessions, artifact.session_id, artifact.files);
+                    const newFiles = artifact.files ?? [];
+                    const existingSession = this.sessions.get(_enum.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(_enum.Constants.EXECUTE_CODE, {
+                            session_id: artifact.session_id,
+                            files: [...filteredExisting, ...filesWithSession],
+                            lastUpdated: Date.now(),
+                        });
+                    }
+                    else {
+                        this.sessions.set(_enum.Constants.EXECUTE_CODE, {
+                            session_id: artifact.session_id,
+                            files: existingFiles,
+                            lastUpdated: Date.now(),
+                        });
+                    }
                 }
             }
             // Dispatch ON_RUN_STEP_COMPLETED via custom event (same path as dispatchToolEvents)
@@ -358,273 +374,100 @@ class ToolNode extends run.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 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: [],
+        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 === _enum.Constants.EXECUTE_CODE ||
+                call.name === _enum.Constants.PROGRAMMATIC_TOOL_CALLING) {
+                request.codeSessionContext = this.getCodeSessionContext();
+            }
+            return request;
         });
-        if (this.hookRegistry?.hasHookFor('PreToolUse', runId) === true) {
-            const preResults = await Promise.all(preToolCalls.map((entry) => executeHooks.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 messages.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.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);
+        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,
+            };
+            events.safeDispatchCustomEvent(_enum.GraphEvents.ON_TOOL_EXECUTE, request, config);
+        });
+        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}`);
             }
-        }
-        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 (_enum.CODE_EXECUTION_TOOLS.has(entry.call.name) ||
-                    entry.call.name === _enum.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,
-                };
-                events.safeDispatchCustomEvent(_enum.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 messages.ToolMessage({
-                        status: 'error',
-                        content: contentString,
-                        name: toolName,
-                        tool_call_id: result.toolCallId,
-                    });
-                    if (hasFailureHook) {
-                        await executeHooks.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 = truncation.truncateToolResultContent(rawContent, this.maxToolResultChars);
-                    if (hasPostHook) {
-                        const hookResult = await executeHooks.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 = truncation.truncateToolResultContent(replaced, this.maxToolResultChars);
-                        }
-                    }
-                    toolMessage = new messages.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);
+            let toolMessage;
+            let contentString;
+            if (result.status === 'error') {
+                contentString = `Error: ${result.errorMessage ?? 'Unknown error'}\n Please fix your mistakes.`;
+                toolMessage = new messages.ToolMessage({
+                    status: 'error',
+                    content: contentString,
+                    name: toolName,
+                    tool_call_id: result.toolCallId,
+                });
             }
-        }
-        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}`);
-        }
-        events.safeDispatchCustomEvent(_enum.GraphEvents.ON_RUN_STEP_COMPLETED, {
-            result: {
-                id: stepId,
-                index: turn ?? this.toolUsageCount.get(toolName) ?? 0,
-                type: 'tool_call',
-                tool_call: {
-                    args: JSON.stringify(args),
+            else {
+                const rawContent = typeof result.content === 'string'
+                    ? result.content
+                    : JSON.stringify(result.content);
+                contentString = truncation.truncateToolResultContent(rawContent, this.maxToolResultChars);
+                toolMessage = new messages.ToolMessage({
+                    status: 'success',
                     name: toolName,
-                    id: toolCallId,
-                    output,
-                    progress: 1,
+                    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,
                 },
-            },
-        }, 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$1) {
-        const converted = [];
-        for (const msg of messages$1) {
-            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 messages.HumanMessage({ content: msg.content, additional_kwargs }));
-        }
-        return converted;
+            events.safeDispatchCustomEvent(_enum.GraphEvents.ON_RUN_STEP_COMPLETED, runStepCompletedData, config);
+            return toolMessage;
+        });
     }
     /**
      * Execute all tool calls via ON_TOOL_EXECUTE event dispatch.
-     * Injected messages are placed AFTER ToolMessages to respect provider
-     * message ordering (AIMessage tool_calls must be immediately followed
-     * by their ToolMessage results).
+     * Used in event-driven mode where the host handles actual tool execution.
      */
     async executeViaEvent(toolCalls, config, 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     input) {
-        const { toolMessages, injected } = await this.dispatchToolEvents(toolCalls, config);
-        const outputs = [...toolMessages, ...injected];
+        const outputs = await this.dispatchToolEvents(toolCalls, config);
         return (Array.isArray(input) ? outputs : { messages: outputs });
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -693,17 +536,10 @@ class ToolNode extends run.RunnableCallable {
                 if (directCalls.length > 0 && directOutputs.length > 0) {
                     this.handleRunToolCompletions(directCalls, directOutputs, config);
                 }
-                const eventResult = eventCalls.length > 0
+                const eventOutputs = eventCalls.length > 0
                     ? await this.dispatchToolEvents(eventCalls, config)
-                    : {
-                        toolMessages: [],
-                        injected: [],
-                    };
-                outputs = [
-                    ...directOutputs,
-                    ...eventResult.toolMessages,
-                    ...eventResult.injected,
-                ];
+                    : [];
+                outputs = [...directOutputs, ...eventOutputs];
             }
             else {
                 outputs = await Promise.all(filteredCalls.map((call) => this.runTool(call, config)));