@librechat/agents 3.1.66-dev.0 → 3.1.67

package/src/tools/ToolNode.ts

@@ -1,7 +1,6 @@
 import { ToolCall } from '@langchain/core/messages/tool';
 import {
   ToolMessage,
-  HumanMessage,
   isAIMessage,
   isBaseMessage,
 } from '@langchain/core/messages';
@@ -20,15 +19,13 @@ import type {
 import type { BaseMessage, AIMessage } from '@langchain/core/messages';
 import type { StructuredToolInterface } from '@langchain/core/tools';
 import type * as t from '@/types';
-import type { HookRegistry, AggregatedHookResult } from '@/hooks';
 import { RunnableCallable } from '@/utils';
 import {
   calculateMaxToolResultChars,
   truncateToolResultContent,
 } from '@/utils/truncation';
 import { safeDispatchCustomEvent } from '@/utils/events';
-import { executeHooks } from '@/hooks';
-import { Constants, GraphEvents, CODE_EXECUTION_TOOLS } from '@/common';
+import { Constants, GraphEvents } from '@/common';
 
 /**
  * Helper to check if a value is a Send object
@@ -37,41 +34,6 @@ function isSend(value: unknown): value is Send {
   return value instanceof Send;
 }
 
-/** Merges code execution session context into the sessions map. */
-function updateCodeSession(
-  sessions: t.ToolSessionMap,
-  sessionId: string,
-  files: t.FileRefs | undefined
-): void {
-  const newFiles = files ?? [];
-  const existingSession = sessions.get(Constants.EXECUTE_CODE) as
-    | t.CodeSessionContext
-    | undefined;
-  const existingFiles = existingSession?.files ?? [];
-
-  if (newFiles.length > 0) {
-    const filesWithSession: t.FileRefs = 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
 export class ToolNode<T = any> extends RunnableCallable<T, T> {
   private toolMap: Map<string, StructuredToolInterface | RunnableToolLike>;
@@ -97,8 +59,6 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
   private directToolNames?: Set<string>;
   /** Maximum characters allowed in a single tool result before truncation. */
   private maxToolResultChars: number;
-  /** Hook registry for PreToolUse/PostToolUse lifecycle hooks */
-  private hookRegistry?: HookRegistry;
 
   constructor({
     tools,
@@ -116,7 +76,6 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
     directToolNames,
     maxContextTokens,
     maxToolResultChars,
-    hookRegistry,
   }: t.ToolNodeConstructorParams) {
     super({ name, tags, func: (input, config) => this.run(input, config) });
     this.toolMap = toolMap ?? new Map(tools.map((tool) => [tool.name, tool]));
@@ -132,7 +91,6 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
     this.directToolNames = directToolNames;
     this.maxToolResultChars =
       maxToolResultChars ?? calculateMaxToolResultChars(maxContextTokens);
-    this.hookRegistry = hookRegistry;
   }
 
   /**
@@ -199,10 +157,7 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
       };
 
       // Inject runtime data for special tools (becomes available at config.toolCall)
-      if (
-        call.name === Constants.PROGRAMMATIC_TOOL_CALLING ||
-        call.name === Constants.BASH_PROGRAMMATIC_TOOL_CALLING
-      ) {
+      if (call.name === Constants.PROGRAMMATIC_TOOL_CALLING) {
         const { toolMap, toolDefs } = this.getProgrammaticTools();
         invokeParams = {
           ...invokeParams,
@@ -225,7 +180,10 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
        * 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 (CODE_EXECUTION_TOOLS.has(call.name)) {
+      if (
+        call.name === Constants.EXECUTE_CODE ||
+        call.name === Constants.PROGRAMMATIC_TOOL_CALLING
+      ) {
         const codeSession = this.sessions?.get(Constants.EXECUTE_CODE) as
           | t.CodeSessionContext
           | undefined;
@@ -355,7 +313,7 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
    */
   private storeCodeSessionFromResults(
     results: t.ToolExecuteResult[],
-    requestMap: Map<string, t.ToolCallRequest>
+    requests: t.ToolCallRequest[]
   ): void {
     if (!this.sessions) {
       return;
@@ -367,11 +325,10 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
         continue;
       }
 
-      const request = requestMap.get(result.toolCallId);
+      const request = requests.find((r) => r.id === result.toolCallId);
       if (
-        !request?.name ||
-        (!CODE_EXECUTION_TOOLS.has(request.name) &&
-          request.name !== Constants.SKILL_TOOL)
+        request?.name !== Constants.EXECUTE_CODE &&
+        request?.name !== Constants.PROGRAMMATIC_TOOL_CALLING
       ) {
         continue;
       }
@@ -381,7 +338,35 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
         continue;
       }
 
-      updateCodeSession(this.sessions, artifact.session_id!, artifact.files);
+      const newFiles = artifact.files ?? [];
+      const existingSession = this.sessions.get(Constants.EXECUTE_CODE) as
+        | t.CodeSessionContext
+        | undefined;
+      const existingFiles = existingSession?.files ?? [];
+
+      if (newFiles.length > 0) {
+        const filesWithSession: t.FileRefs = 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(),
+        });
+      }
     }
   }
 
@@ -417,12 +402,43 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
         continue;
       }
 
-      if (this.sessions && CODE_EXECUTION_TOOLS.has(call.name)) {
+      // Store code session context from tool results
+      if (
+        this.sessions &&
+        (call.name === Constants.EXECUTE_CODE ||
+          call.name === Constants.PROGRAMMATIC_TOOL_CALLING)
+      ) {
         const artifact = toolMessage.artifact as
           | t.CodeExecutionArtifact
           | undefined;
         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(Constants.EXECUTE_CODE) as
+            | t.CodeSessionContext
+            | undefined;
+          const existingFiles = existingSession?.files ?? [];
+
+          if (newFiles.length > 0) {
+            const filesWithSession: t.FileRefs = 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(),
+            });
+          }
         }
       }
 
@@ -466,355 +482,128 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
   /**
    * 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).
    */
   private async dispatchToolEvents(
     toolCalls: ToolCall[],
     config: RunnableConfig
-  ): Promise<{ toolMessages: ToolMessage[]; injected: BaseMessage[] }> {
-    const runId = (config.configurable?.run_id as string | undefined) ?? '';
-    const threadId = config.configurable?.thread_id as string | undefined;
-
-    const preToolCalls = toolCalls.map((call) => ({
-      call,
-      stepId: this.toolCallStepIds?.get(call.id!) ?? '',
-      args: call.args as Record<string, unknown>,
-    }));
-
-    const messageByCallId = new Map<string, ToolMessage>();
-    const approvedEntries: typeof preToolCalls = [];
-    const HOOK_FALLBACK: AggregatedHookResult = Object.freeze({
-      additionalContexts: [] as string[],
-      errors: [] as string[],
-    });
+  ): Promise<ToolMessage[]> {
+    const requests: t.ToolCallRequest[] = toolCalls.map((call) => {
+      const turn = this.toolUsageCount.get(call.name) ?? 0;
+      this.toolUsageCount.set(call.name, turn + 1);
 
-    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((): AggregatedHookResult => HOOK_FALLBACK)
-        )
-      );
+      const request: t.ToolCallRequest = {
+        id: call.id!,
+        name: call.name,
+        args: call.args as Record<string, unknown>,
+        stepId: this.toolCallStepIds?.get(call.id!),
+        turn,
+      };
 
-      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);
+      if (
+        call.name === Constants.EXECUTE_CODE ||
+        call.name === Constants.PROGRAMMATIC_TOOL_CALLING
+      ) {
+        request.codeSessionContext = this.getCodeSessionContext();
       }
-    } else {
-      approvedEntries.push(...preToolCalls);
-    }
-
-    const injected: BaseMessage[] = [];
 
-    if (approvedEntries.length > 0) {
-      const requests: t.ToolCallRequest[] = approvedEntries.map((entry) => {
-        const turn = this.toolUsageCount.get(entry.call.name) ?? 0;
-        this.toolUsageCount.set(entry.call.name, turn + 1);
+      return request;
+    });
 
-        const request: t.ToolCallRequest = {
-          id: entry.call.id!,
-          name: entry.call.name,
-          args: entry.args,
-          stepId: entry.stepId,
-          turn,
+    const results = await new Promise<t.ToolExecuteResult[]>(
+      (resolve, reject) => {
+        const request: t.ToolExecuteBatchRequest = {
+          toolCalls: requests,
+          userId: config.configurable?.user_id as string | undefined,
+          agentId: this.agentId,
+          configurable: config.configurable as
+            | Record<string, unknown>
+            | undefined,
+          metadata: config.metadata as Record<string, unknown> | undefined,
+          resolve,
+          reject,
         };
 
-        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<t.ToolExecuteResult[]>(
-        (resolve, reject) => {
-          const batchRequest: t.ToolExecuteBatchRequest = {
-            toolCalls: requests,
-            userId: config.configurable?.user_id as string | undefined,
-            agentId: this.agentId,
-            configurable: config.configurable as
-              | Record<string, unknown>
-              | undefined,
-            metadata: config.metadata as Record<string, unknown> | undefined,
-            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: string;
-        let toolMessage: 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,
-          });
+        safeDispatchCustomEvent(GraphEvents.ON_TOOL_EXECUTE, request, config);
+      }
+    );
 
-          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
-          );
+    this.storeCodeSessionFromResults(results, requests);
 
-          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 => undefined);
-            if (hookResult?.updatedOutput != null) {
-              const replaced =
-                typeof hookResult.updatedOutput === 'string'
-                  ? hookResult.updatedOutput
-                  : JSON.stringify(hookResult.updatedOutput);
-              contentString = truncateToolResultContent(
-                replaced,
-                this.maxToolResultChars
-              );
-            }
-          }
+    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}`
+        );
+      }
 
-          toolMessage = new ToolMessage({
-            status: 'success',
-            name: toolName,
-            content: contentString,
-            artifact: result.artifact,
-            tool_call_id: result.toolCallId,
-          });
-        }
+      let toolMessage: ToolMessage;
+      let contentString: string;
 
-        this.dispatchStepCompleted(
-          result.toolCallId,
-          toolName,
-          request?.args ?? {},
-          contentString,
-          config,
-          request?.turn
+      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 {
+        const rawContent =
+          typeof result.content === 'string'
+            ? result.content
+            : JSON.stringify(result.content);
+        contentString = truncateToolResultContent(
+          rawContent,
+          this.maxToolResultChars
         );
-
-        messageByCallId.set(result.toolCallId, toolMessage);
+        toolMessage = new ToolMessage({
+          status: 'success',
+          name: toolName,
+          content: contentString,
+          artifact: result.artifact,
+          tool_call_id: result.toolCallId,
+        });
       }
-    }
-
-    const toolMessages = toolCalls
-      .map((call) => messageByCallId.get(call.id!))
-      .filter((m): m is ToolMessage => m != null);
-    return { toolMessages, injected };
-  }
 
-  private dispatchStepCompleted(
-    toolCallId: string,
-    toolName: string,
-    args: Record<string, unknown>,
-    output: string,
-    config: RunnableConfig,
-    turn?: number
-  ): void {
-    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}`
-      );
-    }
+      const tool_call: t.ProcessedToolCall = {
+        args:
+          typeof request?.args === 'string'
+            ? request.args
+            : JSON.stringify(request?.args ?? {}),
+        name: toolName,
+        id: result.toolCallId,
+        output: contentString,
+        progress: 1,
+      };
 
-    safeDispatchCustomEvent(
-      GraphEvents.ON_RUN_STEP_COMPLETED,
-      {
+      const runStepCompletedData = {
         result: {
           id: stepId,
-          index: turn ?? this.toolUsageCount.get(toolName) ?? 0,
+          index: request?.turn ?? 0,
           type: 'tool_call' as const,
-          tool_call: {
-            args: JSON.stringify(args),
-            name: toolName,
-            id: toolCallId,
-            output,
-            progress: 1,
-          } as t.ProcessedToolCall,
+          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.
-   */
-  private convertInjectedMessages(
-    messages: t.InjectedMessage[]
-  ): BaseMessage[] {
-    const converted: BaseMessage[] = [];
-    for (const msg of messages) {
-      const additional_kwargs: Record<string, unknown> = {
-        role: msg.role,
       };
-      if (msg.isMeta != null) additional_kwargs.isMeta = msg.isMeta;
-      if (msg.source != null) additional_kwargs.source = msg.source;
-      if (msg.skillName != null) additional_kwargs.skillName = msg.skillName;
 
-      converted.push(
-        new HumanMessage({ content: msg.content, additional_kwargs })
+      safeDispatchCustomEvent(
+        GraphEvents.ON_RUN_STEP_COMPLETED,
+        runStepCompletedData,
+        config
       );
-    }
-    return converted;
+
+      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.
    */
   private async executeViaEvent(
     toolCalls: ToolCall[],
@@ -822,11 +611,7 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     input: any
   ): Promise<T> {
-    const { toolMessages, injected } = await this.dispatchToolEvents(
-      toolCalls,
-      config
-    );
-    const outputs: BaseMessage[] = [...toolMessages, ...injected];
+    const outputs = await this.dispatchToolEvents(toolCalls, config);
     return (Array.isArray(input) ? outputs : { messages: outputs }) as T;
   }
 
@@ -922,19 +707,12 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
           this.handleRunToolCompletions(directCalls, directOutputs, config);
         }
 
-        const eventResult =
+        const eventOutputs: ToolMessage[] =
           eventCalls.length > 0
             ? await this.dispatchToolEvents(eventCalls, config)
-            : {
-              toolMessages: [] as ToolMessage[],
-              injected: [] as BaseMessage[],
-            };
-
-        outputs = [
-          ...directOutputs,
-          ...eventResult.toolMessages,
-          ...eventResult.injected,
-        ];
+            : [];
+
+        outputs = [...directOutputs, ...eventOutputs];
       } else {
         outputs = await Promise.all(
           filteredCalls.map((call) => this.runTool(call, config))