@librechat/agents 3.1.85 → 3.1.87

package/dist/cjs/graphs/Graph.cjs

@@ -16,7 +16,7 @@ var reducer = require('../messages/reducer.cjs');
 var _enum = require('../common/enum.cjs');
 var graph = require('../utils/graph.cjs');
 var llm = require('../utils/llm.cjs');
-var handlers = require('../tools/handlers.cjs');
+require('../stream.cjs');
 var run = require('../utils/run.cjs');
 require('ai-tokenizer');
 require('zod-to-json-schema');
@@ -31,6 +31,7 @@ var node = require('../summarization/node.cjs');
 var schema = require('../tools/schema.cjs');
 var AgentContext = require('../agents/AgentContext.cjs');
 var fake = require('../llm/fake.cjs');
+var handlers = require('../tools/handlers.cjs');
 require('../tools/local/CompileCheckTool.cjs');
 require('path');
 require('fs/promises');
@@ -53,6 +54,9 @@ var toolCache = require('../llm/openrouter/toolCache.cjs');
 const { AGENT, TOOLS, SUMMARIZE } = _enum.GraphNodeKeys;
 /** Minimum relative variance before calibrated toolSchemaTokens overrides current value. */
 const CALIBRATION_VARIANCE_THRESHOLD = 0.15;
+function getHandlerDispatchedEventKey(eventName, stepId) {
+    return `${eventName}:${stepId}`;
+}
 class Graph {
     messageStepHasToolCalls = new Map();
     messageIdsByStepKey = new Map();
@@ -63,11 +67,12 @@ class Graph {
     contentIndexMap = new Map();
     toolCallStepIds = new Map();
     /**
-     * Step IDs that have been dispatched via handler registry directly
-     * (in dispatchRunStep).  Used by the custom event callback to skip
-     * duplicate dispatch through the LangGraph callback chain.
+     * Step IDs dispatched through the handler registry during this run.
+     * Event echo suppression is tracked separately so repeated deltas for
+     * the same step are scoped to the active custom event dispatch.
      */
     handlerDispatchedStepIds = new Set();
+    handlerDispatchedEventCounts = new Map();
     signal;
     /** Set of invoked tool call IDs from non-message run steps completed mid-run, if any */
     invokedToolIds;
@@ -86,6 +91,16 @@ class Graph {
      * graph compiles.
      */
     toolOutputReferences;
+    /**
+     * Run-scoped opt-in for eager event-driven tool execution. The stream
+     * handler may prestart eligible event-driven tools; ToolNode later
+     * consumes the settled promises while preserving final ToolMessage order.
+     */
+    eagerEventToolExecution;
+    eagerEventToolExecutions = new Map();
+    eagerEventToolUsageCount = new Map();
+    eagerEventToolUsageCountsByAgentId = new Map();
+    eagerEventToolCallChunks = new Map();
     /**
      * Run-scoped execution backend for built-in code tools. Defaults to the
      * remote Code API sandbox when unset.
@@ -124,7 +139,12 @@ class Graph {
         this.hookRegistry = undefined;
         this.humanInTheLoop = undefined;
         this.toolOutputReferences = undefined;
+        this.eagerEventToolExecution = undefined;
+        this.eagerEventToolExecutions.clear();
+        this.clearEagerEventToolUsageCounts();
+        this.eagerEventToolCallChunks.clear();
         this.toolExecution = undefined;
+        this.handlerDispatchedEventCounts.clear();
         /**
          * ToolNodes compiled from this graph captured the registry
          * instance at construction time, so simply dropping the Graph's
@@ -154,6 +174,39 @@ class Graph {
         this._compiledToolNodes.clear();
         this.sessions.clear();
     }
+    getEagerEventToolUsageCount(agentId) {
+        if (agentId == null || agentId === '') {
+            return this.eagerEventToolUsageCount;
+        }
+        let usageCount = this.eagerEventToolUsageCountsByAgentId.get(agentId);
+        if (usageCount == null) {
+            usageCount = new Map();
+            this.eagerEventToolUsageCountsByAgentId.set(agentId, usageCount);
+        }
+        return usageCount;
+    }
+    clearEagerEventToolUsageCounts() {
+        this.eagerEventToolUsageCount.clear();
+        for (const usageCount of this.eagerEventToolUsageCountsByAgentId.values()) {
+            usageCount.clear();
+        }
+    }
+    markHandlerDispatchedEvent(eventName, stepId) {
+        const key = getHandlerDispatchedEventKey(eventName, stepId);
+        this.handlerDispatchedEventCounts.set(key, (this.handlerDispatchedEventCounts.get(key) ?? 0) + 1);
+        return () => {
+            const count = this.handlerDispatchedEventCounts.get(key) ?? 0;
+            if (count <= 1) {
+                this.handlerDispatchedEventCounts.delete(key);
+                return;
+            }
+            this.handlerDispatchedEventCounts.set(key, count - 1);
+        };
+    }
+    hasHandlerDispatchedEvent(eventName, stepId) {
+        const key = getHandlerDispatchedEventKey(eventName, stepId);
+        return (this.handlerDispatchedEventCounts.get(key) ?? 0) > 0;
+    }
     /**
      * Subclass hook to register a freshly compiled ToolNode so
      * `clearHeavyState` can flush its per-Run direct-path turn cache
@@ -284,7 +337,11 @@ class StandardGraph extends Graph {
          * a stale reference on 2nd+ processStream calls.
          */
         this.toolCallStepIds.clear();
+        this.eagerEventToolExecutions.clear();
+        this.clearEagerEventToolUsageCounts();
+        this.eagerEventToolCallChunks.clear();
         this.handlerDispatchedStepIds = graph.resetIfNotEmpty(this.handlerDispatchedStepIds, new Set());
+        this.handlerDispatchedEventCounts = graph.resetIfNotEmpty(this.handlerDispatchedEventCounts, new Map());
         this.messageIdsByStepKey = graph.resetIfNotEmpty(this.messageIdsByStepKey, new Map());
         this.messageStepHasToolCalls = graph.resetIfNotEmpty(this.messageStepHasToolCalls, new Map());
         this.prelimMessageIdsByStepKey = graph.resetIfNotEmpty(this.prelimMessageIdsByStepKey, new Map());
@@ -508,6 +565,9 @@ class StandardGraph extends Graph {
                 toolRegistry: agentContext?.toolRegistry,
                 hookRegistry: this.hookRegistry,
                 humanInTheLoop: this.humanInTheLoop,
+                eagerEventToolExecution: this.eagerEventToolExecution,
+                eagerEventToolExecutions: this.eagerEventToolExecutions,
+                eagerEventToolUsageCount: this.getEagerEventToolUsageCount(agentContext?.agentId),
                 toolExecution: this.toolExecution,
                 directToolNames: directToolNames.size > 0 ? directToolNames : undefined,
                 maxContextTokens: agentContext?.maxContextTokens,
@@ -958,7 +1018,7 @@ class StandardGraph extends Graph {
                         if (typeof content === 'string') {
                             await this.dispatchMessageDelta(stepId, {
                                 content: [{ type: _enum.ContentTypes.TEXT, text: content }],
-                            });
+                            }, metadata);
                         }
                         else if (Array.isArray(content) &&
                             content.every((c) => typeof c === 'object' &&
@@ -967,7 +1027,7 @@ class StandardGraph extends Graph {
                                 c.type.startsWith('text'))) {
                             await this.dispatchMessageDelta(stepId, {
                                 content: content,
-                            });
+                            }, metadata);
                         }
                     }
                 }
@@ -997,7 +1057,7 @@ class StandardGraph extends Graph {
                     if (typeof content === 'string') {
                         await this.dispatchMessageDelta(stepId, {
                             content: [{ type: _enum.ContentTypes.TEXT, text: content }],
-                        });
+                        }, metadata);
                     }
                     else if (Array.isArray(content) &&
                         content.every((c) => typeof c === 'object' &&
@@ -1006,7 +1066,7 @@ class StandardGraph extends Graph {
                             c.type.startsWith('text'))) {
                         await this.dispatchMessageDelta(stepId, {
                             content: content,
-                        });
+                        }, metadata);
                     }
                 }
             }
@@ -1176,8 +1236,16 @@ class StandardGraph extends Graph {
                         await handler.handle(_enum.GraphEvents.ON_RUN_STEP, runStep, resolvedConfig?.configurable, this);
                         this.handlerDispatchedStepIds.add(runStep.id);
                     }
-                    if (resolvedConfig) {
-                        await events.safeDispatchCustomEvent(_enum.GraphEvents.ON_RUN_STEP, runStep, resolvedConfig);
+                    const unmarkHandlerDispatchedEvent = handler
+                        ? this.markHandlerDispatchedEvent(_enum.GraphEvents.ON_RUN_STEP, runStep.id)
+                        : undefined;
+                    try {
+                        if (resolvedConfig) {
+                            await events.safeDispatchCustomEvent(_enum.GraphEvents.ON_RUN_STEP, runStep, resolvedConfig);
+                        }
+                    }
+                    finally {
+                        unmarkHandlerDispatchedEvent?.();
                     }
                 },
                 dispatchRunStepCompleted: async (stepId, result, nodeConfig) => {
@@ -1208,7 +1276,7 @@ class StandardGraph extends Graph {
         const StateAnnotation = langgraph.Annotation.Root({
             messages: langgraph.Annotation({
                 reducer: (a, b) => {
-                    if (!a.length) {
+                    if (!this.messages.length) {
                         this.startIndex = a.length + b.length;
                     }
                     const result = reducer.messagesStateReducer(a, b);
@@ -1305,7 +1373,15 @@ class StandardGraph extends Graph {
         // but the primary dispatch above guarantees the event reaches the handler.
         // The customEventCallback in run.ts skips events already dispatched above
         // to prevent double handling.
-        await events.safeDispatchCustomEvent(_enum.GraphEvents.ON_RUN_STEP, runStep, this.config);
+        const unmarkHandlerDispatchedEvent = handler
+            ? this.markHandlerDispatchedEvent(_enum.GraphEvents.ON_RUN_STEP, stepId)
+            : undefined;
+        try {
+            await events.safeDispatchCustomEvent(_enum.GraphEvents.ON_RUN_STEP, runStep, this.config);
+        }
+        finally {
+            unmarkHandlerDispatchedEvent?.();
+        }
         return stepId;
     }
     /**
@@ -1354,7 +1430,7 @@ class StandardGraph extends Graph {
     async handleToolCallError(data, metadata) {
         await StandardGraph.handleToolCallErrorStatic(this, data, metadata);
     }
-    async dispatchRunStepDelta(id, delta) {
+    async dispatchRunStepDelta(id, delta, metadata) {
         if (!this.config) {
             throw new Error('No config provided');
         }
@@ -1365,9 +1441,22 @@ class StandardGraph extends Graph {
             id,
             delta,
         };
-        await events.safeDispatchCustomEvent(_enum.GraphEvents.ON_RUN_STEP_DELTA, runStepDelta, this.config);
+        const handler = this.handlerRegistry?.getHandler(_enum.GraphEvents.ON_RUN_STEP_DELTA);
+        if (handler) {
+            await handler.handle(_enum.GraphEvents.ON_RUN_STEP_DELTA, runStepDelta, metadata, this);
+            this.handlerDispatchedStepIds.add(id);
+        }
+        const unmarkHandlerDispatchedEvent = handler
+            ? this.markHandlerDispatchedEvent(_enum.GraphEvents.ON_RUN_STEP_DELTA, id)
+            : undefined;
+        try {
+            await events.safeDispatchCustomEvent(_enum.GraphEvents.ON_RUN_STEP_DELTA, runStepDelta, this.config);
+        }
+        finally {
+            unmarkHandlerDispatchedEvent?.();
+        }
     }
-    async dispatchMessageDelta(id, delta) {
+    async dispatchMessageDelta(id, delta, metadata) {
         if (!this.config) {
             throw new Error('No config provided');
         }
@@ -1375,9 +1464,22 @@ class StandardGraph extends Graph {
             id,
             delta,
         };
-        await events.safeDispatchCustomEvent(_enum.GraphEvents.ON_MESSAGE_DELTA, messageDelta, this.config);
+        const handler = this.handlerRegistry?.getHandler(_enum.GraphEvents.ON_MESSAGE_DELTA);
+        if (handler) {
+            await handler.handle(_enum.GraphEvents.ON_MESSAGE_DELTA, messageDelta, metadata, this);
+            this.handlerDispatchedStepIds.add(id);
+        }
+        const unmarkHandlerDispatchedEvent = handler
+            ? this.markHandlerDispatchedEvent(_enum.GraphEvents.ON_MESSAGE_DELTA, id)
+            : undefined;
+        try {
+            await events.safeDispatchCustomEvent(_enum.GraphEvents.ON_MESSAGE_DELTA, messageDelta, this.config);
+        }
+        finally {
+            unmarkHandlerDispatchedEvent?.();
+        }
     }
-    dispatchReasoningDelta = async (stepId, delta) => {
+    dispatchReasoningDelta = async (stepId, delta, metadata) => {
         if (!this.config) {
             throw new Error('No config provided');
         }
@@ -1385,7 +1487,20 @@ class StandardGraph extends Graph {
             id: stepId,
             delta,
         };
-        await events.safeDispatchCustomEvent(_enum.GraphEvents.ON_REASONING_DELTA, reasoningDelta, this.config);
+        const handler = this.handlerRegistry?.getHandler(_enum.GraphEvents.ON_REASONING_DELTA);
+        if (handler) {
+            await handler.handle(_enum.GraphEvents.ON_REASONING_DELTA, reasoningDelta, metadata, this);
+            this.handlerDispatchedStepIds.add(stepId);
+        }
+        const unmarkHandlerDispatchedEvent = handler
+            ? this.markHandlerDispatchedEvent(_enum.GraphEvents.ON_REASONING_DELTA, stepId)
+            : undefined;
+        try {
+            await events.safeDispatchCustomEvent(_enum.GraphEvents.ON_REASONING_DELTA, reasoningDelta, this.config);
+        }
+        finally {
+            unmarkHandlerDispatchedEvent?.();
+        }
     };
 }