@librechat/agents 3.1.66 → 3.1.67-dev.4

package/dist/cjs/tools/SubagentTool.cjs

@@ -0,0 +1,92 @@
+'use strict';
+
+var _enum = require('../common/enum.cjs');
+
+const SubagentToolName = _enum.Constants.SUBAGENT;
+const SubagentToolDescription = `Delegate a task to a specialized subagent that runs in an isolated context window. The subagent executes independently and returns only its final text result — all intermediate tool calls, reasoning, and context stay isolated.
+
+WHEN TO USE:
+- The task is self-contained and can be described in a single prompt.
+- You want to offload verbose or exploratory work without bloating your own context.
+- A specialized subagent is available for the task domain.
+
+WHAT HAPPENS:
+- A fresh agent is created with the task description as its only input.
+- The subagent runs to completion using its own tools and context.
+- Only the final text response is returned to you.
+
+CONSTRAINTS:
+- subagent_type must match one of the available types listed below.
+- The subagent cannot see your conversation history.`;
+const DESCRIPTION_PROP_DESCRIPTION = 'Complete task description for the subagent. This is the ONLY information it receives — include all necessary context, requirements, and constraints.';
+const SUBAGENT_TYPE_PROP_DESCRIPTION = 'Which subagent type to delegate to. Must be one of the available types.';
+const SubagentToolSchema = {
+    type: 'object',
+    properties: {
+        description: {
+            type: 'string',
+            description: DESCRIPTION_PROP_DESCRIPTION,
+        },
+        subagent_type: {
+            type: 'string',
+            description: SUBAGENT_TYPE_PROP_DESCRIPTION,
+        },
+    },
+    required: ['description', 'subagent_type'],
+};
+const SubagentToolDefinition = {
+    name: SubagentToolName,
+    description: SubagentToolDescription,
+    parameters: SubagentToolSchema,
+};
+/**
+ * Build the name, schema, and description params for `tool()` from available configs.
+ * Used by `Graph.createAgentNode()` when constructing the runtime tool instance.
+ * Extends `SubagentToolSchema` by populating `subagent_type.enum` dynamically.
+ */
+function buildSubagentToolParams(configs) {
+    const types = configs.map((c) => c.type);
+    const typeDescriptions = configs
+        .map((c) => `- "${c.type}" (${c.name}): ${c.description}`)
+        .join('\n');
+    return {
+        name: SubagentToolName,
+        schema: {
+            type: 'object',
+            properties: {
+                description: {
+                    type: 'string',
+                    description: DESCRIPTION_PROP_DESCRIPTION,
+                },
+                subagent_type: {
+                    type: 'string',
+                    enum: types,
+                    description: `${SUBAGENT_TYPE_PROP_DESCRIPTION} Available: ${types.join(', ')}.`,
+                },
+            },
+            required: ['description', 'subagent_type'],
+        },
+        description: `${SubagentToolDescription}\n\nAvailable types:\n${typeDescriptions}`,
+    };
+}
+/**
+ * Create a SubagentTool LCTool definition with dynamic enum and description
+ * populated from the available subagent configs.
+ * Used for the tool registry in event-driven mode.
+ */
+function createSubagentToolDefinition(configs) {
+    const params = buildSubagentToolParams(configs);
+    return {
+        name: params.name,
+        description: params.description,
+        parameters: params.schema,
+    };
+}
+
+exports.SubagentToolDefinition = SubagentToolDefinition;
+exports.SubagentToolDescription = SubagentToolDescription;
+exports.SubagentToolName = SubagentToolName;
+exports.SubagentToolSchema = SubagentToolSchema;
+exports.buildSubagentToolParams = buildSubagentToolParams;
+exports.createSubagentToolDefinition = createSubagentToolDefinition;
+//# sourceMappingURL=SubagentTool.cjs.map

package/dist/cjs/tools/SubagentTool.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"SubagentTool.cjs","sources":["../../../src/tools/SubagentTool.ts"],"sourcesContent":["import { Constants } from '@/common';\nimport type { SubagentConfig } from '@/types';\nimport type { JsonSchemaType, LCTool } from '@/types/tools';\n\nexport const SubagentToolName = Constants.SUBAGENT;\n\nexport const SubagentToolDescription = `Delegate a task to a specialized subagent that runs in an isolated context window. The subagent executes independently and returns only its final text result — all intermediate tool calls, reasoning, and context stay isolated.\n\nWHEN TO USE:\n- The task is self-contained and can be described in a single prompt.\n- You want to offload verbose or exploratory work without bloating your own context.\n- A specialized subagent is available for the task domain.\n\nWHAT HAPPENS:\n- A fresh agent is created with the task description as its only input.\n- The subagent runs to completion using its own tools and context.\n- Only the final text response is returned to you.\n\nCONSTRAINTS:\n- subagent_type must match one of the available types listed below.\n- The subagent cannot see your conversation history.`;\n\nconst DESCRIPTION_PROP_DESCRIPTION =\n  'Complete task description for the subagent. This is the ONLY information it receives — include all necessary context, requirements, and constraints.';\n\nconst SUBAGENT_TYPE_PROP_DESCRIPTION =\n  'Which subagent type to delegate to. Must be one of the available types.';\n\nexport const SubagentToolSchema = {\n  type: 'object',\n  properties: {\n    description: {\n      type: 'string',\n      description: DESCRIPTION_PROP_DESCRIPTION,\n    },\n    subagent_type: {\n      type: 'string',\n      description: SUBAGENT_TYPE_PROP_DESCRIPTION,\n    },\n  },\n  required: ['description', 'subagent_type'] as string[],\n} as const;\n\nexport const SubagentToolDefinition: LCTool = {\n  name: SubagentToolName,\n  description: SubagentToolDescription,\n  parameters: SubagentToolSchema,\n};\n\n/**\n * Build the name, schema, and description params for `tool()` from available configs.\n * Used by `Graph.createAgentNode()` when constructing the runtime tool instance.\n * Extends `SubagentToolSchema` by populating `subagent_type.enum` dynamically.\n */\nexport function buildSubagentToolParams(configs: SubagentConfig[]): {\n  name: string;\n  schema: JsonSchemaType;\n  description: string;\n} {\n  const types = configs.map((c) => c.type);\n  const typeDescriptions = configs\n    .map((c) => `- \"${c.type}\" (${c.name}): ${c.description}`)\n    .join('\\n');\n\n  return {\n    name: SubagentToolName,\n    schema: {\n      type: 'object',\n      properties: {\n        description: {\n          type: 'string',\n          description: DESCRIPTION_PROP_DESCRIPTION,\n        },\n        subagent_type: {\n          type: 'string',\n          enum: types,\n          description: `${SUBAGENT_TYPE_PROP_DESCRIPTION} Available: ${types.join(', ')}.`,\n        },\n      },\n      required: ['description', 'subagent_type'],\n    },\n    description: `${SubagentToolDescription}\\n\\nAvailable types:\\n${typeDescriptions}`,\n  };\n}\n\n/**\n * Create a SubagentTool LCTool definition with dynamic enum and description\n * populated from the available subagent configs.\n * Used for the tool registry in event-driven mode.\n */\nexport function createSubagentToolDefinition(\n  configs: SubagentConfig[]\n): LCTool {\n  const params = buildSubagentToolParams(configs);\n  return {\n    name: params.name,\n    description: params.description,\n    parameters: params.schema,\n  };\n}\n"],"names":["Constants"],"mappings":";;;;AAIO,MAAM,gBAAgB,GAAGA,eAAS,CAAC;AAEnC,MAAM,uBAAuB,GAAG,CAAA;;;;;;;;;;;;;;;AAgBvC,MAAM,4BAA4B,GAChC,sJAAsJ;AAExJ,MAAM,8BAA8B,GAClC,yEAAyE;AAEpE,MAAM,kBAAkB,GAAG;AAChC,IAAA,IAAI,EAAE,QAAQ;AACd,IAAA,UAAU,EAAE;AACV,QAAA,WAAW,EAAE;AACX,YAAA,IAAI,EAAE,QAAQ;AACd,YAAA,WAAW,EAAE,4BAA4B;AAC1C,SAAA;AACD,QAAA,aAAa,EAAE;AACb,YAAA,IAAI,EAAE,QAAQ;AACd,YAAA,WAAW,EAAE,8BAA8B;AAC5C,SAAA;AACF,KAAA;AACD,IAAA,QAAQ,EAAE,CAAC,aAAa,EAAE,eAAe,CAAa;;AAGjD,MAAM,sBAAsB,GAAW;AAC5C,IAAA,IAAI,EAAE,gBAAgB;AACtB,IAAA,WAAW,EAAE,uBAAuB;AACpC,IAAA,UAAU,EAAE,kBAAkB;;AAGhC;;;;AAIG;AACG,SAAU,uBAAuB,CAAC,OAAyB,EAAA;AAK/D,IAAA,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC;IACxC,MAAM,gBAAgB,GAAG;AACtB,SAAA,GAAG,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,CAAC,IAAI,CAAA,GAAA,EAAM,CAAC,CAAC,IAAI,CAAA,GAAA,EAAM,CAAC,CAAC,WAAW,EAAE;SACxD,IAAI,CAAC,IAAI,CAAC;IAEb,OAAO;AACL,QAAA,IAAI,EAAE,gBAAgB;AACtB,QAAA,MAAM,EAAE;AACN,YAAA,IAAI,EAAE,QAAQ;AACd,YAAA,UAAU,EAAE;AACV,gBAAA,WAAW,EAAE;AACX,oBAAA,IAAI,EAAE,QAAQ;AACd,oBAAA,WAAW,EAAE,4BAA4B;AAC1C,iBAAA;AACD,gBAAA,aAAa,EAAE;AACb,oBAAA,IAAI,EAAE,QAAQ;AACd,oBAAA,IAAI,EAAE,KAAK;oBACX,WAAW,EAAE,CAAA,EAAG,8BAA8B,CAAA,YAAA,EAAe,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA,CAAA,CAAG;AACjF,iBAAA;AACF,aAAA;AACD,YAAA,QAAQ,EAAE,CAAC,aAAa,EAAE,eAAe,CAAC;AAC3C,SAAA;AACD,QAAA,WAAW,EAAE,CAAA,EAAG,uBAAuB,CAAA,sBAAA,EAAyB,gBAAgB,CAAA,CAAE;KACnF;AACH;AAEA;;;;AAIG;AACG,SAAU,4BAA4B,CAC1C,OAAyB,EAAA;AAEzB,IAAA,MAAM,MAAM,GAAG,uBAAuB,CAAC,OAAO,CAAC;IAC/C,OAAO;QACL,IAAI,EAAE,MAAM,CAAC,IAAI;QACjB,WAAW,EAAE,MAAM,CAAC,WAAW;QAC/B,UAAU,EAAE,MAAM,CAAC,MAAM;KAC1B;AACH;;;;;;;;;"}

package/dist/cjs/tools/ToolNode.cjs

@@ -11,6 +11,7 @@ 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
@@ -18,6 +19,32 @@ require('zod-to-json-schema');
 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;
@@ -43,7 +70,9 @@ class ToolNode extends run.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;
@@ -58,6 +87,7 @@ 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.
@@ -113,7 +143,8 @@ 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) {
+            if (call.name === _enum.Constants.PROGRAMMATIC_TOOL_CALLING ||
+                call.name === _enum.Constants.BASH_PROGRAMMATIC_TOOL_CALLING) {
                 const { toolMap, toolDefs } = this.getProgrammaticTools();
                 invokeParams = {
                     ...invokeParams,
@@ -136,8 +167,7 @@ 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 (call.name === _enum.Constants.EXECUTE_CODE ||
-                call.name === _enum.Constants.PROGRAMMATIC_TOOL_CALLING) {
+            if (_enum.CODE_EXECUTION_TOOLS.has(call.name)) {
                 const codeSession = this.sessions?.get(_enum.Constants.EXECUTE_CODE);
                 if (codeSession?.session_id != null && codeSession.session_id !== '') {
                     invokeParams = {
@@ -246,7 +276,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, requests) {
+    storeCodeSessionFromResults(results, requestMap) {
         if (!this.sessions) {
             return;
         }
@@ -255,38 +285,17 @@ class ToolNode extends run.RunnableCallable {
             if (result.status !== 'success' || result.artifact == null) {
                 continue;
             }
-            const request = requests.find((r) => r.id === result.toolCallId);
-            if (request?.name !== _enum.Constants.EXECUTE_CODE &&
-                request?.name !== _enum.Constants.PROGRAMMATIC_TOOL_CALLING) {
+            const request = requestMap.get(result.toolCallId);
+            if (!request?.name ||
+                (!_enum.CODE_EXECUTION_TOOLS.has(request.name) &&
+                    request.name !== _enum.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(_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(),
-                });
-            }
+            updateCodeSession(this.sessions, artifact.session_id, artifact.files);
         }
     }
     /**
@@ -313,35 +322,10 @@ class ToolNode extends run.RunnableCallable {
             if (toolMessage.status === 'error' && this.errorHandler != null) {
                 continue;
             }
-            // Store code session context from tool results
-            if (this.sessions &&
-                (call.name === _enum.Constants.EXECUTE_CODE ||
-                    call.name === _enum.Constants.PROGRAMMATIC_TOOL_CALLING)) {
+            if (this.sessions && _enum.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(_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(),
-                        });
-                    }
+                    updateCodeSession(this.sessions, artifact.session_id, artifact.files);
                 }
             }
             // Dispatch ON_RUN_STEP_COMPLETED via custom event (same path as dispatchToolEvents)
@@ -374,100 +358,273 @@ 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 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;
-        });
-        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);
+        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.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);
             }
-            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,
-                });
+        }
+        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);
             }
-            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',
+        }
+        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),
                     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$1) {
+        const converted = [];
+        for (const msg of messages$1) {
+            const additional_kwargs = {
+                role: msg.role,
             };
-            events.safeDispatchCustomEvent(_enum.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 messages.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
@@ -536,10 +693,17 @@ class ToolNode extends run.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)));