@librechat/agents 3.1.86 → 3.1.88

package/src/run.ts

@@ -47,6 +47,60 @@ export const defaultOmitOptions = new Set([
   'additionalModelRequestFields',
 ]);
 
+const CUSTOM_GRAPH_EVENTS = new Set<string>([
+  GraphEvents.ON_AGENT_UPDATE,
+  GraphEvents.ON_RUN_STEP,
+  GraphEvents.ON_RUN_STEP_DELTA,
+  GraphEvents.ON_RUN_STEP_COMPLETED,
+  GraphEvents.ON_MESSAGE_DELTA,
+  GraphEvents.ON_REASONING_DELTA,
+  GraphEvents.ON_TOOL_EXECUTE,
+  GraphEvents.ON_SUMMARIZE_START,
+  GraphEvents.ON_SUMMARIZE_DELTA,
+  GraphEvents.ON_SUMMARIZE_COMPLETE,
+  GraphEvents.ON_SUBAGENT_UPDATE,
+  GraphEvents.ON_AGENT_LOG,
+  GraphEvents.ON_CUSTOM_EVENT,
+]);
+
+const DIRECT_DISPATCHED_STEP_EVENTS = new Set<string>([
+  GraphEvents.ON_RUN_STEP,
+  GraphEvents.ON_RUN_STEP_DELTA,
+  GraphEvents.ON_MESSAGE_DELTA,
+  GraphEvents.ON_REASONING_DELTA,
+]);
+
+function getStepScopedEventId(data: unknown): string | undefined {
+  if (data == null || typeof data !== 'object') {
+    return undefined;
+  }
+  const candidate = data as { id?: unknown };
+  return typeof candidate.id === 'string' ? candidate.id : undefined;
+}
+
+function isLangGraphResumeMapForInterrupt(
+  value: unknown,
+  interruptId: string
+): value is Record<string, unknown> {
+  if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+    return false;
+  }
+  return Object.prototype.hasOwnProperty.call(value, interruptId);
+}
+
+type InterruptStateSnapshot = {
+  config?: RunnableConfig;
+  tasks?: Array<{
+    interrupts?: Array<{ id?: string }>;
+  }>;
+};
+
+type WorkflowWithStateHistory = {
+  getStateHistory?(
+    config: RunnableConfig
+  ): AsyncIterableIterator<InterruptStateSnapshot>;
+};
+
 export class Run<_T extends t.BaseGraphState> {
   id: string;
   private tokenCounter?: t.TokenCounter;
@@ -54,6 +108,7 @@ export class Run<_T extends t.BaseGraphState> {
   private hookRegistry?: HookRegistry;
   private humanInTheLoop?: t.HumanInTheLoopConfig;
   private toolOutputReferences?: t.ToolOutputReferencesConfig;
+  private eagerEventToolExecution?: t.EagerEventToolExecutionConfig;
   private toolExecution?: t.ToolExecutionConfig;
   private indexTokenCountMap?: Record<string, number>;
   calibrationRatio: number = 1;
@@ -99,6 +154,7 @@ export class Run<_T extends t.BaseGraphState> {
     this.hookRegistry = config.hooks;
     this.humanInTheLoop = config.humanInTheLoop;
     this.toolOutputReferences = config.toolOutputReferences;
+    this.eagerEventToolExecution = config.eagerEventToolExecution;
     this.toolExecution = config.toolExecution;
 
     if (!config.graphConfig) {
@@ -180,6 +236,7 @@ export class Run<_T extends t.BaseGraphState> {
     standardGraph.hookRegistry = this.hookRegistry;
     standardGraph.humanInTheLoop = this.humanInTheLoop;
     standardGraph.toolOutputReferences = this.toolOutputReferences;
+    standardGraph.eagerEventToolExecution = this.eagerEventToolExecution;
     standardGraph.toolExecution = this.toolExecution;
     this.Graph = standardGraph;
     return standardGraph.createWorkflow();
@@ -205,6 +262,7 @@ export class Run<_T extends t.BaseGraphState> {
     multiAgentGraph.hookRegistry = this.hookRegistry;
     multiAgentGraph.humanInTheLoop = this.humanInTheLoop;
     multiAgentGraph.toolOutputReferences = this.toolOutputReferences;
+    multiAgentGraph.eagerEventToolExecution = this.eagerEventToolExecution;
     multiAgentGraph.toolExecution = this.toolExecution;
     this.Graph = multiAgentGraph;
     return multiAgentGraph.createWorkflow();
@@ -444,13 +502,15 @@ export class Run<_T extends t.BaseGraphState> {
       tags?: string[],
       metadata?: Record<string, unknown>
     ): Promise<void> => {
-      // ON_RUN_STEP is dispatched directly via handler registry in
-      // Graph.dispatchRunStep (primary, reliable path).  Skip the
-      // callback-based dispatch to prevent double handling.
+      // Step-scoped SDK events are dispatched directly via the handler
+      // registry first. Skip callback-based echoes to prevent double
+      // handling when LangGraph invokes custom callbacks more than once.
+      const stepScopedEventId = getStepScopedEventId(data);
       if (
-        eventName === GraphEvents.ON_RUN_STEP &&
+        DIRECT_DISPATCHED_STEP_EVENTS.has(eventName) &&
         this.Graph != null &&
-        this.Graph.handlerDispatchedStepIds.has((data as t.RunStep).id)
+        stepScopedEventId != null &&
+        this.Graph.hasHandlerDispatchedEvent(eventName, stepScopedEventId)
       ) {
         return;
       }
@@ -630,7 +690,7 @@ export class Run<_T extends t.BaseGraphState> {
         const eventName: t.EventName = info.event;
 
         /** Skip custom events as they're handled by our callback */
-        if (eventName === GraphEvents.ON_CUSTOM_EVENT) {
+        if (CUSTOM_GRAPH_EVENTS.has(eventName)) {
           continue;
         }
 
@@ -697,6 +757,10 @@ export class Run<_T extends t.BaseGraphState> {
         }
       }
 
+      if (this._interrupt != null) {
+        await this.resolveInterruptResumeConfig(config);
+      }
+
       /**
        * Skip the Stop hook when the run paused on a HITL interrupt
        * (still pending human input) or was halted by a hook (the host
@@ -937,13 +1001,99 @@ export class Run<_T extends t.BaseGraphState> {
     },
     streamOptions?: t.EventStreamOptions
   ): Promise<MessageContentComplex[] | undefined> {
+    const interruptId = this._interrupt?.interruptId;
+    const scopedResume =
+      typeof interruptId === 'string' &&
+      interruptId.length > 0 &&
+      !isLangGraphResumeMapForInterrupt(resumeValue, interruptId)
+        ? { [interruptId]: resumeValue }
+        : resumeValue;
+    const resumeConfig = await this.resolveInterruptResumeConfig(callerConfig);
     return this.processStream(
-      new Command({ resume: resumeValue }),
-      callerConfig,
+      new Command({ resume: scopedResume }),
+      resumeConfig,
       streamOptions
     );
   }
 
+  private async resolveInterruptResumeConfig(
+    callerConfig: Partial<RunnableConfig> & {
+      version: 'v1' | 'v2';
+      run_id?: string;
+    }
+  ): Promise<
+    Partial<RunnableConfig> & {
+      version: 'v1' | 'v2';
+      run_id?: string;
+    }
+  > {
+    const interrupt = this._interrupt;
+    const interruptId = interrupt?.interruptId;
+    const workflow = this.graphRunnable as
+      | (t.CompiledStateWorkflow & WorkflowWithStateHistory)
+      | undefined;
+    const stateHistory = workflow?.getStateHistory;
+    if (interrupt?.checkpointId != null && interrupt.checkpointId.length > 0) {
+      return {
+        ...callerConfig,
+        configurable: {
+          ...callerConfig.configurable,
+          checkpoint_id: interrupt.checkpointId,
+          ...(typeof interrupt.checkpointNs === 'string'
+            ? { checkpoint_ns: interrupt.checkpointNs }
+            : {}),
+        },
+      };
+    }
+    if (
+      interrupt == null ||
+      typeof interruptId !== 'string' ||
+      interruptId.length === 0 ||
+      typeof stateHistory !== 'function'
+    ) {
+      return callerConfig;
+    }
+
+    for await (const snapshot of stateHistory.call(
+      this.graphRunnable,
+      callerConfig as RunnableConfig
+    )) {
+      const hasMatchingInterrupt =
+        snapshot.tasks?.some(
+          (task) =>
+            task.interrupts?.some(
+              (interrupt) => interrupt.id === interruptId
+            ) === true
+        ) === true;
+      const checkpointConfigurable = snapshot.config?.configurable;
+      if (!hasMatchingInterrupt || checkpointConfigurable == null) {
+        continue;
+      }
+
+      const checkpointId = checkpointConfigurable.checkpoint_id;
+      const checkpointNs = checkpointConfigurable.checkpoint_ns;
+      if (typeof checkpointId === 'string' && checkpointId.length > 0) {
+        this._interrupt = {
+          ...interrupt,
+          checkpointId,
+          ...(typeof checkpointNs === 'string' ? { checkpointNs } : {}),
+        };
+        return {
+          ...callerConfig,
+          configurable: {
+            ...callerConfig.configurable,
+            checkpoint_id: checkpointId,
+            ...(typeof checkpointNs === 'string'
+              ? { checkpoint_ns: checkpointNs }
+              : {}),
+          },
+        };
+      }
+    }
+
+    return callerConfig;
+  }
+
   private createSystemCallback<K extends keyof t.ClientCallbacks>(
     clientCallbacks: t.ClientCallbacks,
     key: K