@librechat/agents 3.1.86 → 3.1.88

package/dist/esm/graphs/Graph.mjs

@@ -14,7 +14,7 @@ import { messagesStateReducer } from '../messages/reducer.mjs';
 import { GraphNodeKeys, ContentTypes, Providers, StepTypes, GraphEvents } from '../common/enum.mjs';
 import { resetIfNotEmpty, joinKeys } from '../utils/graph.mjs';
 import { isAnthropicLike, isOpenAILike, isGoogleLike } from '../utils/llm.mjs';
-import { handleToolCalls } from '../tools/handlers.mjs';
+import '../stream.mjs';
 import { sleep } from '../utils/run.mjs';
 import 'ai-tokenizer';
 import 'zod-to-json-schema';
@@ -29,6 +29,7 @@ import { createSummarizeNode } from '../summarization/node.mjs';
 import { createSchemaOnlyTools } from '../tools/schema.mjs';
 import { AgentContext } from '../agents/AgentContext.mjs';
 import { createFakeStreamingLLM } from '../llm/fake.mjs';
+import { handleToolCalls } from '../tools/handlers.mjs';
 import '../tools/local/CompileCheckTool.mjs';
 import 'path';
 import 'fs/promises';
@@ -51,6 +52,9 @@ import { partitionAndMarkOpenRouterToolCache } from '../llm/openrouter/toolCache
 const { AGENT, TOOLS, SUMMARIZE } = 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();
@@ -61,11 +65,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;
@@ -84,6 +89,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.
@@ -122,7 +137,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
@@ -152,6 +172,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
@@ -282,7 +335,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 = resetIfNotEmpty(this.handlerDispatchedStepIds, new Set());
+        this.handlerDispatchedEventCounts = resetIfNotEmpty(this.handlerDispatchedEventCounts, new Map());
         this.messageIdsByStepKey = resetIfNotEmpty(this.messageIdsByStepKey, new Map());
         this.messageStepHasToolCalls = resetIfNotEmpty(this.messageStepHasToolCalls, new Map());
         this.prelimMessageIdsByStepKey = resetIfNotEmpty(this.prelimMessageIdsByStepKey, new Map());
@@ -506,6 +563,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,
@@ -956,7 +1016,7 @@ class StandardGraph extends Graph {
                         if (typeof content === 'string') {
                             await this.dispatchMessageDelta(stepId, {
                                 content: [{ type: ContentTypes.TEXT, text: content }],
-                            });
+                            }, metadata);
                         }
                         else if (Array.isArray(content) &&
                             content.every((c) => typeof c === 'object' &&
@@ -965,7 +1025,7 @@ class StandardGraph extends Graph {
                                 c.type.startsWith('text'))) {
                             await this.dispatchMessageDelta(stepId, {
                                 content: content,
-                            });
+                            }, metadata);
                         }
                     }
                 }
@@ -995,7 +1055,7 @@ class StandardGraph extends Graph {
                     if (typeof content === 'string') {
                         await this.dispatchMessageDelta(stepId, {
                             content: [{ type: ContentTypes.TEXT, text: content }],
-                        });
+                        }, metadata);
                     }
                     else if (Array.isArray(content) &&
                         content.every((c) => typeof c === 'object' &&
@@ -1004,7 +1064,7 @@ class StandardGraph extends Graph {
                             c.type.startsWith('text'))) {
                         await this.dispatchMessageDelta(stepId, {
                             content: content,
-                        });
+                        }, metadata);
                     }
                 }
             }
@@ -1174,8 +1234,16 @@ class StandardGraph extends Graph {
                         await handler.handle(GraphEvents.ON_RUN_STEP, runStep, resolvedConfig?.configurable, this);
                         this.handlerDispatchedStepIds.add(runStep.id);
                     }
-                    if (resolvedConfig) {
-                        await safeDispatchCustomEvent(GraphEvents.ON_RUN_STEP, runStep, resolvedConfig);
+                    const unmarkHandlerDispatchedEvent = handler
+                        ? this.markHandlerDispatchedEvent(GraphEvents.ON_RUN_STEP, runStep.id)
+                        : undefined;
+                    try {
+                        if (resolvedConfig) {
+                            await safeDispatchCustomEvent(GraphEvents.ON_RUN_STEP, runStep, resolvedConfig);
+                        }
+                    }
+                    finally {
+                        unmarkHandlerDispatchedEvent?.();
                     }
                 },
                 dispatchRunStepCompleted: async (stepId, result, nodeConfig) => {
@@ -1206,7 +1274,7 @@ class StandardGraph extends Graph {
         const StateAnnotation = Annotation.Root({
             messages: Annotation({
                 reducer: (a, b) => {
-                    if (!a.length) {
+                    if (!this.messages.length) {
                         this.startIndex = a.length + b.length;
                     }
                     const result = messagesStateReducer(a, b);
@@ -1303,7 +1371,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 safeDispatchCustomEvent(GraphEvents.ON_RUN_STEP, runStep, this.config);
+        const unmarkHandlerDispatchedEvent = handler
+            ? this.markHandlerDispatchedEvent(GraphEvents.ON_RUN_STEP, stepId)
+            : undefined;
+        try {
+            await safeDispatchCustomEvent(GraphEvents.ON_RUN_STEP, runStep, this.config);
+        }
+        finally {
+            unmarkHandlerDispatchedEvent?.();
+        }
         return stepId;
     }
     /**
@@ -1352,7 +1428,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');
         }
@@ -1363,9 +1439,22 @@ class StandardGraph extends Graph {
             id,
             delta,
         };
-        await safeDispatchCustomEvent(GraphEvents.ON_RUN_STEP_DELTA, runStepDelta, this.config);
+        const handler = this.handlerRegistry?.getHandler(GraphEvents.ON_RUN_STEP_DELTA);
+        if (handler) {
+            await handler.handle(GraphEvents.ON_RUN_STEP_DELTA, runStepDelta, metadata, this);
+            this.handlerDispatchedStepIds.add(id);
+        }
+        const unmarkHandlerDispatchedEvent = handler
+            ? this.markHandlerDispatchedEvent(GraphEvents.ON_RUN_STEP_DELTA, id)
+            : undefined;
+        try {
+            await safeDispatchCustomEvent(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');
         }
@@ -1373,9 +1462,22 @@ class StandardGraph extends Graph {
             id,
             delta,
         };
-        await safeDispatchCustomEvent(GraphEvents.ON_MESSAGE_DELTA, messageDelta, this.config);
+        const handler = this.handlerRegistry?.getHandler(GraphEvents.ON_MESSAGE_DELTA);
+        if (handler) {
+            await handler.handle(GraphEvents.ON_MESSAGE_DELTA, messageDelta, metadata, this);
+            this.handlerDispatchedStepIds.add(id);
+        }
+        const unmarkHandlerDispatchedEvent = handler
+            ? this.markHandlerDispatchedEvent(GraphEvents.ON_MESSAGE_DELTA, id)
+            : undefined;
+        try {
+            await safeDispatchCustomEvent(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');
         }
@@ -1383,7 +1485,20 @@ class StandardGraph extends Graph {
             id: stepId,
             delta,
         };
-        await safeDispatchCustomEvent(GraphEvents.ON_REASONING_DELTA, reasoningDelta, this.config);
+        const handler = this.handlerRegistry?.getHandler(GraphEvents.ON_REASONING_DELTA);
+        if (handler) {
+            await handler.handle(GraphEvents.ON_REASONING_DELTA, reasoningDelta, metadata, this);
+            this.handlerDispatchedStepIds.add(stepId);
+        }
+        const unmarkHandlerDispatchedEvent = handler
+            ? this.markHandlerDispatchedEvent(GraphEvents.ON_REASONING_DELTA, stepId)
+            : undefined;
+        try {
+            await safeDispatchCustomEvent(GraphEvents.ON_REASONING_DELTA, reasoningDelta, this.config);
+        }
+        finally {
+            unmarkHandlerDispatchedEvent?.();
+        }
     };
 }