@librechat/agents 3.5.1 → 3.6.0

package/dist/types/types/tools.d.ts

@@ -1,9 +1,9 @@
 import type { StructuredToolInterface } from '@langchain/core/tools';
-import type { RunnableToolLike } from '@langchain/core/runnables';
+import type { RunnableConfig, RunnableToolLike } from '@langchain/core/runnables';
 import type { ToolCall } from '@langchain/core/messages/tool';
 import type { ToolOutputReferenceRegistry } from '@/tools/toolOutputReferences';
 import type { RunBreakerScope } from '@/llm/streamLimits';
-import type { MessageContentComplex, ToolErrorData } from './stream';
+import type { MessageContentComplex, RunStepResumeState, ToolErrorData } from './stream';
 import type { HumanInTheLoopConfig } from './hitl';
 import type { LangfuseConfig } from './graph';
 import type { HookRegistry } from '@/hooks';
@@ -118,6 +118,8 @@ export type ToolNodeOptions = {
     toolRegistry?: LCToolRegistry;
     /** Reference to Graph's sessions map for automatic session injection */
     sessions?: ToolSessionMap;
+    /** Partition within `sessions` used by this agent's code tools. */
+    codeSessionKey?: string;
     /** When true, dispatches ON_TOOL_EXECUTE events instead of invoking tools directly */
     eventDrivenMode?: boolean;
     /** Tool definitions for event-driven mode (used for context, not invocation) */
@@ -264,6 +266,10 @@ export type ToolNodeOptions = {
      * controller.
      */
     getRunScope?: () => RunBreakerScope;
+    /** SDK-owned checkpoint bridge for open run-step lifecycle state. */
+    restoreRunStepResumeState?: (state?: RunStepResumeState, config?: RunnableConfig) => void;
+    /** SDK-owned checkpoint snapshot for open run-step lifecycle state. */
+    createRunStepResumeState?: () => RunStepResumeState;
 };
 export type ToolNodeConstructorParams = ToolRefs & ToolNodeOptions;
 export type ToolEndEvent = {
@@ -361,6 +367,19 @@ export type CodeEnvFile = (CodeEnvFileBase & {
     kind: 'user';
 });
 export type CodeExecutionToolParams = undefined | {
+    /** Trusted Code API endpoint selected by the host for this agent. */
+    baseUrl?: string;
+    /**
+     * Expected Code API execution profile. Sent as a request assertion so
+     * endpoint/configuration drift fails closed instead of silently using
+     * the wrong sandbox backend.
+     */
+    executionProfile?: CodeApiExecutionProfile;
+    /**
+     * Trusted warm-runtime affinity hint selected by the host for this
+     * agent invocation. This overrides the legacy ToolNode-injected hint.
+     */
+    runtimeSessionHint?: string;
     /** Execution session — see `CodeSessionContext.session_id`. */
     session_id?: string;
     user_id?: string;
@@ -368,15 +387,14 @@ export type CodeExecutionToolParams = undefined | {
     /** Optional host-supplied Code API auth headers. */
     authHeaders?: CodeApiAuthHeaders;
     /**
-     * Advertise best-effort stateful sessions in the tool description
-     * (variables/files may persist between calls, may reset). Prompt text
-     * only, and it must be set here because the description is bound to the
-     * LLM at construction time. Pair it with the run-scoped
-     * `toolExecution.sandbox.statefulSessions` gate, which drives the wire
-     * hint — set both from one flag so the prompt and the backend agree.
+     * Advertise filesystem-tier stateful sessions in the tool description
+     * and allow a trusted runtime affinity hint onto the wire. Resolve this,
+     * `baseUrl`, `executionProfile`, and `runtimeSessionHint` together from
+     * the executing agent so the prompt and backend agree.
      */
     statefulSessions?: boolean;
 };
+export type CodeApiExecutionProfile = 'default' | 'stateful';
 export type CodeApiAuthHeaderMap = Record<string, string>;
 export type CodeApiAuthHeaders = CodeApiAuthHeaderMap | (() => CodeApiAuthHeaderMap | Promise<CodeApiAuthHeaderMap>);
 export type FileRef = {
@@ -1032,19 +1050,17 @@ export type CloudflareSandboxExecutionConfig = {
 };
 export type SandboxExecutionConfig = {
     /**
-     * Opt into best-effort stateful runtime sessions on the remote Code API
-     * (its warm per-session MicroVM backend). This gate is run-scoped: it only
-     * controls the wire behavior (ToolNode injecting the session hint on
-     * execute_code/bash calls). The transport is otherwise unchanged.
+     * Legacy run-scoped opt-in for warm runtime hint injection. New hosts that
+     * need mixed execution profiles should resolve `statefulSessions`,
+     * `baseUrl`, `executionProfile`, and `runtimeSessionHint` on each executing
+     * agent's tool factories instead. Direct executors ignore this injected hint
+     * unless their own factory has `statefulSessions: true`.
      *
      * It does NOT change the model-facing tool description. Tool descriptions are
      * bound to the LLM at construction time (`createCodeExecutionTool` /
      * `createBashExecutionTool`), before this run config is applied inside the
      * graph, so they can only be adjusted via the tools' own `statefulSessions`
-     * factory param. Set BOTH from one flag (as LibreChat does): with this on but
-     * the factory param off, the backend runs statefully while the model is still
-     * told the environment is stateless (non-corrupting — the model just won't
-     * exploit persistence).
+     * factory param.
      */
     statefulSessions?: boolean;
     /**
@@ -1193,6 +1209,10 @@ export type BashProgrammaticToolCallingParams = ProgrammaticToolCallingParams;
 export type ProgrammaticToolCallingParams = {
     /** Code API base URL (or use CODE_BASEURL env var) */
     baseUrl?: string;
+    /** Expected Code API execution profile (host-controlled). */
+    executionProfile?: CodeApiExecutionProfile;
+    /** Trusted warm-runtime affinity hint for this agent invocation. */
+    runtimeSessionHint?: string;
     /** Safety limit for round-trips (default: 20) */
     maxRoundTrips?: number;
     /** Maximum per-sandbox-run timeout for PTC's legacy `timeout` field. */

package/dist/types/utils/toolSessions.d.ts

@@ -0,0 +1,18 @@
+import type * as t from '@/types';
+type CodeSessionAgent = Pick<t.AgentInputs, 'codeSessionKey' | 'initialSessions'>;
+/**
+ * Seeds a top-level graph while preserving the legacy run-wide session map.
+ * A legacy `execute_code` seed is copied into every custom agent partition
+ * unless the host already supplied an explicit seed for that partition.
+ */
+export declare function seedRunInitialSessions(args: {
+    sessions: t.ToolSessionMap;
+    initialSessions: t.ToolSessionMap;
+    agents: Iterable<Pick<t.AgentInputs, 'codeSessionKey'>>;
+}): void;
+/**
+ * Seeds an isolated child graph from each selected agent. Legacy code-session
+ * entries are remapped to the owning agent's partition before they are merged.
+ */
+export declare function seedAgentInitialSessions(sessions: t.ToolSessionMap, agents: Iterable<CodeSessionAgent>): void;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@librechat/agents",
-  "version": "3.5.1",
+  "version": "3.6.0",
   "reova": {
     "enabled": true,
     "endpoint": "https://telemetry.reo.dev/data"

package/src/agents/AgentContext.ts

@@ -63,6 +63,7 @@ export class AgentContext {
   ): AgentContext {
     const {
       agentId,
+      codeSessionKey,
       name,
       provider,
       clientOptions,
@@ -92,6 +93,7 @@ export class AgentContext {
 
     const agentContext = new AgentContext({
       agentId,
+      codeSessionKey,
       name: name ?? agentId,
       provider,
       clientOptions,
@@ -167,6 +169,8 @@ export class AgentContext {
 
   /** Agent identifier */
   agentId: string;
+  /** Partition for this agent's transient code session and file refs. */
+  codeSessionKey?: string;
   /** Human-readable name for this agent (used in handoff context). Falls back to agentId if not provided. */
   name?: string;
   /** Provider for this specific agent */
@@ -370,6 +374,7 @@ export class AgentContext {
 
   constructor({
     agentId,
+    codeSessionKey,
     name,
     provider,
     clientOptions,
@@ -394,6 +399,7 @@ export class AgentContext {
     maxToolResultChars,
   }: {
     agentId: string;
+    codeSessionKey?: string;
     name?: string;
     provider: Providers;
     clientOptions?: t.ClientOptions;
@@ -418,6 +424,7 @@ export class AgentContext {
     maxToolResultChars?: number;
   }) {
     this.agentId = agentId;
+    this.codeSessionKey = codeSessionKey;
     this.name = name;
     this.provider = provider;
     this.clientOptions = clientOptions;

package/src/graphs/Graph.ts

@@ -16,6 +16,7 @@ import type {
   BaseMessage,
   MessageContent,
 } from '@langchain/core/messages';
+import type { BaseChannel, OverwriteValue } from '@langchain/langgraph';
 import type { ToolCall } from '@langchain/core/messages/tool';
 import type {
   ReplayableSubagentTool,
@@ -167,6 +168,7 @@ import { createSchemaOnlyTools } from '@/tools/schema';
 import { AgentContext } from '@/agents/AgentContext';
 import { createFakeStreamingLLM } from '@/llm/fake';
 import { handleToolCalls } from '@/tools/handlers';
+import { isRunStepResumeState } from '@/tools/runStepResume';
 import { isThinkingEnabled } from '@/llm/request';
 import { resolveMaxSeals } from '@/llm/preempt';
 import { initializeModel } from '@/llm/init';
@@ -673,11 +675,36 @@ function getDispatchableFinalReasoningContent({
   return responseReasoningContent;
 }
 
+function createEmptyRunStepResumeState(): t.RunStepResumeState {
+  return {
+    version: 1,
+    revision: 0,
+    nextIndex: 0,
+    toolCallSteps: [],
+    steps: [],
+  };
+}
+
+type RunStepStateChannel = BaseChannel<
+  t.RunStepResumeState,
+  t.RunStepResumeState | OverwriteValue<t.RunStepResumeState>
+>;
+
+function buildRunStepStateAnnotation(): RunStepStateChannel {
+  return Annotation<t.RunStepResumeState>({
+    reducer: (current, update) =>
+      update.revision >= current.revision ? update : current,
+    default: createEmptyRunStepResumeState,
+  });
+}
+
 export abstract class Graph<
   T extends t.BaseGraphState = t.BaseGraphState,
   _TNodeName extends string = string,
 > {
   abstract resetValues(keepContent?: boolean, checkpointScope?: string): void;
+  abstract createRunStepResumeState(): t.RunStepResumeState;
+  abstract restoreRunStepResumeState(state?: t.RunStepResumeState): void;
   restoreCheckpointMessages(
     _messages: BaseMessage[],
     _pendingMessages?: BaseMessage[]
@@ -739,6 +766,8 @@ export abstract class Graph<
   prelimMessageIdsByStepKey: Map<string, string> = new Map();
   config: RunnableConfig | undefined;
   contentData: t.RunStep[] = [];
+  protected nextContentIndex = 0;
+  protected runStepStateRevision = 0;
   stepKeyIds: Map<string, string[]> = new Map<string, string[]>();
   contentIndexMap: Map<string, number> = new Map();
   toolCallStepIds: Map<string, string> = new Map();
@@ -866,6 +895,8 @@ export abstract class Graph<
     this.signal = undefined;
     this.callerSignal = undefined;
     this.contentData = [];
+    this.nextContentIndex = 0;
+    this.runStepStateRevision = 0;
     this.contentIndexMap = new Map();
     this.stepKeyIds = new Map();
     this.toolCallStepIds.clear();
@@ -950,15 +981,18 @@ export abstract class Graph<
 
   /**
    * Tracks a tool call whose completion must arrive before its step can be
-   * considered finished. Registered wherever `toolCallStepIds` gains entries,
-   * except cross-process subagent resume restoration, where pending state
-   * cannot be faithfully rebuilt and closes fall back to completions/sweep.
+   * considered finished. Registered wherever `toolCallStepIds` gains entries.
    */
   registerPendingToolCall(toolCallId: string, stepId: string): void {
     if (!toolCallId || !stepId) {
       return;
     }
-    this.getPendingToolCallSet(stepId).add(toolCallId);
+    const pending = this.getPendingToolCallSet(stepId);
+    const size = pending.size;
+    pending.add(toolCallId);
+    if (pending.size !== size) {
+      this.runStepStateRevision += 1;
+    }
   }
 
   /** Lazily creates a step's pending-completions set; callers registering a
@@ -1063,6 +1097,7 @@ export abstract class Graph<
         ),
       ],
       eagerToolSuppressions: [...this.eagerEventToolSuppressions],
+      runStepState: this.createRunStepResumeState(),
       ...(this._toolOutputRegistry == null
         ? {}
         : {
@@ -1099,6 +1134,7 @@ export abstract class Graph<
       throw new Error('Cannot restore disabled tool output references.');
     }
 
+    this.restoreRunStepResumeState(state.runStepState);
     this.toolCallStepIds.clear();
     for (const { toolCallId, stepId } of state.toolCallSteps) {
       this.toolCallStepIds.set(toolCallId, stepId);
@@ -1469,6 +1505,8 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
     this.config = resetIfNotEmpty(this.config, undefined);
     if (keepContent !== true) {
       this.contentData = resetIfNotEmpty(this.contentData, []);
+      this.nextContentIndex = 0;
+      this.runStepStateRevision = 0;
       this.contentIndexMap = resetIfNotEmpty(this.contentIndexMap, new Map());
     }
     this.stepKeyIds = resetIfNotEmpty(this.stepKeyIds, new Map());
@@ -1737,6 +1775,78 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
 
   /* Run Step Processing */
 
+  createRunStepResumeState(): t.RunStepResumeState {
+    const steps: t.RunStepResumeEntry[] = [];
+    for (const runStep of this.contentData) {
+      if (runStep.status != null && runStep.status !== 'in_progress') {
+        continue;
+      }
+      const agentKey = runStep.agentId ?? '';
+      steps.push({
+        step: structuredClone(runStep),
+        pendingToolCallIds: [
+          ...(this.pendingToolCallsByStep.get(runStep.id) ?? []),
+        ],
+        ...(this.latestCompletionByStep.has(runStep.id)
+          ? {
+            latestCompletionAt: this.latestCompletionByStep.get(runStep.id),
+          }
+          : {}),
+        openMessageStep:
+          this.openMessageStepByAgent.get(agentKey) === runStep.id,
+      });
+    }
+    return {
+      version: 1,
+      revision: this.runStepStateRevision,
+      nextIndex: this.nextContentIndex,
+      toolCallSteps: [...this.toolCallStepIds].map(
+        ([toolCallId, stepId]) => ({ toolCallId, stepId })
+      ),
+      steps,
+    };
+  }
+
+  restoreRunStepResumeState(state?: t.RunStepResumeState): void {
+    if (
+      !isRunStepResumeState(state) ||
+      this.contentData.length > 0 ||
+      this.runStepStateRevision > 0
+    ) {
+      return;
+    }
+
+    this.nextContentIndex = state.nextIndex;
+    this.runStepStateRevision = state.revision;
+    for (const { toolCallId, stepId } of state.toolCallSteps) {
+      this.toolCallStepIds.set(toolCallId, stepId);
+    }
+    for (const entry of state.steps) {
+      const runStep = structuredClone(entry.step);
+      runStep.status = 'in_progress';
+      this.nextContentIndex = Math.max(
+        this.nextContentIndex,
+        runStep.index + 1
+      );
+      const position = this.contentData.length;
+      this.contentData.push(runStep);
+      this.contentIndexMap.set(runStep.id, position);
+      if (entry.pendingToolCallIds.length > 0) {
+        const pending = new Set(entry.pendingToolCallIds);
+        this.pendingToolCallsByStep.set(runStep.id, pending);
+      }
+      if (entry.latestCompletionAt != null) {
+        this.latestCompletionByStep.set(
+          runStep.id,
+          entry.latestCompletionAt
+        );
+      }
+      if (entry.openMessageStep) {
+        this.openMessageStepByAgent.set(runStep.agentId ?? '', runStep.id);
+      }
+    }
+  }
+
   getRunStep(stepId: string): t.RunStep | undefined {
     const index = this.contentIndexMap.get(stepId);
     if (index !== undefined) {
@@ -1813,9 +1923,11 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
      * would mutate the wrong agent's step. Assigning the index at push time
      * also supersedes whatever the caller computed before this await point.
      */
-    runStep.index = this.contentData.length;
+    runStep.index = Math.max(this.nextContentIndex, this.contentData.length);
+    this.nextContentIndex = runStep.index + 1;
+    const position = this.contentData.length;
     this.contentData.push(runStep);
-    this.contentIndexMap.set(runStep.id, runStep.index);
+    this.contentIndexMap.set(runStep.id, position);
     if (trackAsOpenMessageStep && runStep.type === StepTypes.MESSAGE_CREATION) {
       this.openMessageStepByAgent.set(agentKey, runStep.id);
     } else {
@@ -1846,6 +1958,7 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
      * absorb the latency of an arbitrarily slow predecessor handler.
      */
     runStep.created_at = Date.now();
+    this.runStepStateRevision += 1;
   }
 
   /**
@@ -1906,6 +2019,7 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
       closedEvent.stepIndex = runStep.stepIndex;
     }
     this.untrackRunStep(runStep);
+    this.runStepStateRevision += 1;
 
     const handler = this.handlerRegistry?.getHandler(
       GraphEvents.ON_RUN_STEP_CLOSED
@@ -1950,10 +2064,12 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
       return;
     }
     const { toolCallId, metadata, at } = options ?? {};
+    let lifecycleChanged = false;
     if (at != null) {
       const latest = this.latestCompletionByStep.get(stepId);
       if (latest == null || at > latest) {
         this.latestCompletionByStep.set(stepId, at);
+        lifecycleChanged = true;
       }
     }
     const closeAt = this.latestCompletionByStep.get(stepId) ?? at;
@@ -1963,9 +2079,12 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
       return;
     }
     if (toolCallId != null && toolCallId !== '') {
-      pending.delete(toolCallId);
+      lifecycleChanged = pending.delete(toolCallId) || lifecycleChanged;
     }
     if (pending.size > 0) {
+      if (lifecycleChanged) {
+        this.runStepStateRevision += 1;
+      }
       return;
     }
     await this.closeRunStep(stepId, 'completed', { metadata, at: closeAt });
@@ -2391,6 +2510,7 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
         agentLangfuse: agentContext?.langfuse,
         eventDrivenMode: true,
         sessions: this.sessions,
+        codeSessionKey: agentContext?.codeSessionKey,
         toolDefinitions: toolDefMap,
         // `agentId` is the subagent-scope marker — set ONLY for child-run
         // graphs (hooks fire for child scopes too, via the inherited
@@ -2417,6 +2537,12 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
         fileCheckpointer: this.getOrCreateFileCheckpointer(),
         getBreakerSignal: (): AbortSignal => this.breakerAbort.signal,
         getRunScope: (): RunBreakerScope => this.runScope,
+        restoreRunStepResumeState: (state, config): void => {
+          this.config = config;
+          this.restoreRunStepResumeState(state);
+        },
+        createRunStepResumeState: (): t.RunStepResumeState =>
+          this.createRunStepResumeState(),
         errorHandler: (data, metadata): Promise<boolean> =>
           StandardGraph.handleToolCallErrorStatic(this, data, metadata),
       });
@@ -2471,6 +2597,7 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
         StandardGraph.handleToolCallErrorStatic(this, data, metadata),
       toolRegistry: agentContext?.toolRegistry,
       sessions: this.sessions,
+      codeSessionKey: agentContext?.codeSessionKey,
       toolExecution: this.toolExecution,
       codeSessionToolNames: this.codeSessionToolNames,
       interruptingToolNames: effectiveInterruptingToolNames,
@@ -2482,6 +2609,12 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
       fileCheckpointer: this.getOrCreateFileCheckpointer(),
       getBreakerSignal: (): AbortSignal => this.breakerAbort.signal,
       getRunScope: (): RunBreakerScope => this.runScope,
+      restoreRunStepResumeState: (state, config): void => {
+        this.config = config;
+        this.restoreRunStepResumeState(state);
+      },
+      createRunStepResumeState: (): t.RunStepResumeState =>
+        this.createRunStepResumeState(),
     });
     this.registerCompiledToolNode(node);
     return node;
@@ -4571,6 +4704,10 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
     };
   }
 
+  protected createRunStepStateAnnotation(): RunStepStateChannel {
+    return buildRunStepStateAnnotation();
+  }
+
   createAgentNode(agentId: string): t.CompiledAgentWorfklow {
     const getConfig = (): RunnableConfig | undefined => this.config;
     const agentContext = this.agentContexts.get(agentId);
@@ -4779,6 +4916,22 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
     const agentNode = `${AGENT}${agentId}` as const;
     const toolNode = `${TOOLS}${agentId}` as const;
     const summarizeNode = `${SUMMARIZE}${agentId}` as const;
+    const callModel = this.createCallModel(agentId);
+    const callTools = this.initializeTools({
+      currentTools: agentContext.tools,
+      currentToolMap: agentContext.toolMap,
+      agentContext,
+    });
+    const invokeWithRunStepState = async (
+      state: t.AgentSubgraphState,
+      config: RunnableConfig | undefined,
+      invoke: () => Promise<Partial<t.AgentSubgraphState>>
+    ): Promise<Partial<t.AgentSubgraphState>> => {
+      this.config = config;
+      this.restoreRunStepResumeState(state.runStepState);
+      const result = await invoke();
+      return { ...result, runStepState: this.createRunStepResumeState() };
+    };
 
     const routeMessage = (
       state: t.AgentSubgraphState,
@@ -4815,6 +4968,7 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
         ) => b,
         default: () => undefined,
       }),
+      runStepState: this.createRunStepStateAnnotation(),
     });
 
     const readChargeCredits = ():
@@ -4833,14 +4987,12 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
     };
 
     const workflow = new StateGraph(StateAnnotation)
-      .addNode(agentNode, this.createCallModel(agentId))
+      .addNode(agentNode, (state, config) =>
+        invokeWithRunStepState(state, config, () => callModel(state, config))
+      )
       .addNode(
         toolNode,
-        this.initializeTools({
-          currentTools: agentContext.tools,
-          currentToolMap: agentContext.toolMap,
-          agentContext,
-        })
+        callTools
       )
       .addNode(
         summarizeNode,
@@ -5019,6 +5171,7 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
         },
         default: () => [],
       }),
+      runStepState: this.createRunStepStateAnnotation(),
     });
     const workflow = new StateGraph(StateAnnotation)
       .addNode(
@@ -5097,6 +5250,32 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
       throw new Error('No config provided');
     }
 
+    if (stepDetails.type === StepTypes.TOOL_CALLS && stepDetails.tool_calls) {
+      let replayStepId: string | undefined;
+      let reusesOpenStep = stepDetails.tool_calls.length > 0;
+      for (const toolCall of stepDetails.tool_calls) {
+        const toolCallId = toolCall.id ?? '';
+        const mappedStepId = this.toolCallStepIds.get(toolCallId);
+        if (!toolCallId || mappedStepId == null) {
+          reusesOpenStep = false;
+          continue;
+        }
+        replayStepId ??= mappedStepId;
+        if (mappedStepId !== replayStepId) {
+          reusesOpenStep = false;
+        }
+      }
+      const replayStep =
+        replayStepId == null ? undefined : this.getRunStep(replayStepId);
+      if (
+        reusesOpenStep &&
+        replayStep != null &&
+        (replayStep.status == null || replayStep.status === 'in_progress')
+      ) {
+        return replayStep.id;
+      }
+    }
+
     const [stepId, stepIndex] = this.generateStepId(stepKey);
     if (stepDetails.type === StepTypes.TOOL_CALLS && stepDetails.tool_calls) {
       let pendingToolCalls: Set<string> | undefined;

package/src/graphs/MultiAgentGraph.ts

@@ -1036,6 +1036,7 @@ export class MultiAgentGraph extends StandardGraph {
         reducer: (_current, update) => update,
         default: () => undefined,
       }),
+      runStepState: this.createRunStepStateAnnotation(),
     });
 
     const builder = new StateGraph(StateAnnotation);