@librechat/agents 3.2.51 → 3.2.53

package/dist/types/run.d.ts

@@ -1,6 +1,5 @@
 import { Command } from '@langchain/langgraph';
 import type { MessageContentComplex, BaseMessage } from '@langchain/core/messages';
-import type { RunnableConfig } from '@langchain/core/runnables';
 import type * as t from '@/types';
 import { MultiAgentGraph } from '@/graphs/MultiAgentGraph';
 import { StandardGraph } from '@/graphs/Graph';
@@ -22,6 +21,13 @@ export declare class Run<_T extends t.BaseGraphState> {
     Graph: StandardGraph | MultiAgentGraph | undefined;
     returnContent: boolean;
     private skipCleanup;
+    /**
+     * Whether the compiled graph was built with a checkpointer (host-supplied
+     * or the HITL `MemorySaver` fallback). Captured at graph creation because
+     * the constructor can later overwrite `Graph.compileOptions` with the raw
+     * caller options, dropping the fallback checkpointer from that metadata.
+     */
+    private hasCheckpointer;
     private _streamResult;
     /**
      * Captured interrupt payload typed as `unknown` because the SDK
@@ -107,10 +113,7 @@ export declare class Run<_T extends t.BaseGraphState> {
     private isAwaitingResume;
     private getStreamLangfuseConfig;
     private getStreamToolOutputTracingLangfuseConfig;
-    processStream(inputs: t.IState | Command, callerConfig: Partial<RunnableConfig> & {
-        version: 'v1' | 'v2';
-        run_id?: string;
-    }, streamOptions?: t.EventStreamOptions): Promise<MessageContentComplex[] | undefined>;
+    processStream(inputs: t.IState | Command, callerConfig: t.RunStreamConfig, streamOptions?: t.EventStreamOptions): Promise<MessageContentComplex[] | undefined>;
     /**
      * Returns the pending interrupt captured during the most recent
      * `processStream` (or `resume`) invocation. `undefined` when the run
@@ -180,10 +183,21 @@ export declare class Run<_T extends t.BaseGraphState> {
      * paths processed; returns 0 when checkpointing is disabled.
      */
     rewindFiles(): Promise<number>;
-    resume<TResume = t.ToolApprovalDecision[] | t.ToolApprovalDecisionMap>(resumeValue: TResume, callerConfig: Partial<RunnableConfig> & {
-        version: 'v1' | 'v2';
-        run_id?: string;
-    }, streamOptions?: t.EventStreamOptions): Promise<MessageContentComplex[] | undefined>;
+    /**
+     * Resume an interrupted run. `commandOptions` forwards langgraph 1.4.5
+     * `Command` fields applied together with `resume` in one superstep:
+     * - `update`: channel updates committed at the resume point. On a *rebuilt*
+     *   Run (new instance + durable checkpointer), `update.messages` are the first
+     *   write the fresh wrapper sees, so they seed the `getRunMessages()` /
+     *   `returnContent` baseline and are excluded from them (still committed to the
+     *   checkpoint). Hosts that rebuild + inject messages should persist them
+     *   directly or read from `getState`. Unreachable without a durable checkpointer.
+     * - `goto`: a *dynamic* edge that does not cancel static `addEdge` routes. On
+     *   the built-in standard graph the fixed `toolNode -> agentNode/END` edge still
+     *   fires, so `goto` adds rather than replaces (e.g. `goto: END` will not stop a
+     *   tool-node resume). Intended for custom, Command-routed graphs.
+     */
+    resume<TResume = t.ToolApprovalDecision[] | t.ToolApprovalDecisionMap>(resumeValue: TResume, callerConfig: t.RunStreamConfig, streamOptions?: t.EventStreamOptions, commandOptions?: Pick<ConstructorParameters<typeof Command>[0], 'update' | 'goto'>): Promise<MessageContentComplex[] | undefined>;
     private resolveInterruptResumeConfig;
     private createSystemCallback;
     getCallbacks(clientCallbacks: t.ClientCallbacks): t.SystemCallbacks;

package/dist/types/session/types.d.ts

@@ -144,6 +144,7 @@ export interface AgentSessionRunOptions {
     threadId?: string;
     config?: Partial<RunnableConfig> & {
         version?: 'v1' | 'v2';
+        durability?: t.Durability;
     };
     streamOptions?: t.EventStreamOptions;
 }

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

@@ -11,7 +11,7 @@ import { RunnableCallable } from '@/utils';
  * batch-scoped value the method needs so the signature stays at
  * three positional parameters even as new context fields are added.
  */
-type RunToolBatchContext = {
+type RunToolBatchContext<T = unknown> = {
     /** Position of this call within the parent ToolNode batch. */
     batchIndex?: number;
     /** Batch turn shared across every call in the batch. */
@@ -50,6 +50,13 @@ type RunToolBatchContext = {
      * contract for hosts relying on it for policy / recovery guidance.
      */
     additionalContextsSink?: string[];
+    /**
+     * Graph state the ToolNode was invoked with, threaded from `run()`
+     * so `tool.invoke` can forward it as langgraph 1.4's `runtime.state`
+     * (the deprecation-free replacement for `getCurrentTaskInput()`,
+     * which relies on `node:async_hooks` and is browser-incompatible).
+     */
+    runInput?: T;
 };
 export declare class ToolNode<T = any> extends RunnableCallable<T, T> {
     private toolMap;
@@ -203,7 +210,7 @@ export declare class ToolNode<T = any> extends RunnableCallable<T, T> {
      * register the output for future `{{tool<idx>turn<turn>}}`
      * substitutions. Omit when no registration should occur.
      */
-    protected runTool(call: ToolCall, config: RunnableConfig, batchContext?: RunToolBatchContext): Promise<BaseMessage | Command>;
+    protected runTool(call: ToolCall, config: RunnableConfig, batchContext?: RunToolBatchContext<T>): Promise<BaseMessage | Command>;
     /**
      * Runs a single in-process tool call with the same lifecycle hooks
      * the event-dispatch path fires (`PreToolUse`, `PermissionDenied`,

package/dist/types/types/run.d.ts

@@ -243,3 +243,20 @@ export type EventStreamOptions = {
     callbacks?: g.ClientCallbacks;
     keepContent?: boolean;
 };
+/**
+ * When to persist checkpoints during a run. Mirrors langgraph's option:
+ * `'async'`/`'sync'` checkpoint every superstep; `'exit'` checkpoints only
+ * at the graph's exit/interrupt boundary. Kept as a local union to avoid
+ * coupling to langgraph internals (it is not exported from the root).
+ */
+export type Durability = 'async' | 'sync' | 'exit';
+/**
+ * Config accepted by `processStream`/`resume`. Extends `RunnableConfig` with
+ * the stream `version`, an optional `run_id`, and an optional `durability`
+ * override forwarded to langgraph's run options.
+ */
+export type RunStreamConfig = Partial<RunnableConfig> & {
+    version: 'v1' | 'v2';
+    run_id?: string;
+    durability?: Durability;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@librechat/agents",
-  "version": "3.2.51",
+  "version": "3.2.53",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/esm/main.mjs",
   "types": "./dist/types/index.d.ts",
@@ -222,7 +222,7 @@
     "@langchain/google-gauth": "2.2.0",
     "@langchain/google-genai": "2.2.0",
     "@langchain/google-vertexai": "2.2.0",
-    "@langchain/langgraph": "^1.4.5",
+    "@langchain/langgraph": "^1.4.6",
     "@langchain/mistralai": "^1.2.0",
     "@langchain/openai": "1.5.3",
     "@langchain/textsplitters": "^1.0.1",
@@ -262,6 +262,7 @@
     "@anthropic-ai/sandbox-runtime": "^0.0.54",
     "@anthropic-ai/vertex-sdk": "^0.12.0",
     "@eslint/compat": "^1.2.7",
+    "@langchain/langgraph-checkpoint-mongodb": "^1.4.0",
     "@swc/core": "^1.6.13",
     "@types/jest": "^30.0.0",
     "@types/node": "^24.13.1",
@@ -276,6 +277,8 @@
     "jest": "^30.2.0",
     "jest-util": "^30.2.0",
     "lint-staged": "^16.4.0",
+    "mongodb": "^6.21.0",
+    "mongodb-memory-server-core": "^11.2.0",
     "prettier": "^3.6.2",
     "ts-jest": "^29.4.6",
     "ts-node": "^10.9.2",

package/src/graphs/MultiAgentGraph.ts

@@ -12,12 +12,11 @@ import {
   Command,
   StateGraph,
   Annotation,
-  getCurrentTaskInput,
   messagesStateReducer,
 } from '@langchain/langgraph';
 import type { BaseMessage, AIMessageChunk } from '@langchain/core/messages';
 import type { LangGraphRunnableConfig } from '@langchain/langgraph';
-import type { ToolRunnableConfig } from '@langchain/core/tools';
+import type { ToolRuntime } from '@langchain/core/tools';
 import type * as t from '@/types';
 import { StandardGraph } from './Graph';
 import { Constants } from '@/common';
@@ -330,12 +329,10 @@ export class MultiAgentGraph extends StandardGraph {
 
       tools.push(
         tool(
-          async (rawInput, config) => {
+          async (rawInput, runtime: ToolRuntime) => {
             const input = rawInput as Record<string, unknown>;
-            const state = getCurrentTaskInput() as t.BaseGraphState;
-            const toolCallId =
-              (config as ToolRunnableConfig | undefined)?.toolCall?.id ??
-              'unknown';
+            const state = runtime.state as t.BaseGraphState;
+            const toolCallId = runtime.toolCall?.id ?? 'unknown';
 
             /** Evaluated condition */
             const result = edge.condition!(state);
@@ -414,11 +411,9 @@ export class MultiAgentGraph extends StandardGraph {
 
         tools.push(
           tool(
-            async (rawInput, config) => {
+            async (rawInput, runtime: ToolRuntime) => {
               const input = rawInput as Record<string, unknown>;
-              const toolCallId =
-                (config as ToolRunnableConfig | undefined)?.toolCall?.id ??
-                'unknown';
+              const toolCallId = runtime.toolCall?.id ?? 'unknown';
 
               let content = `Successfully transferred to ${destination}`;
               if (
@@ -439,7 +434,7 @@ export class MultiAgentGraph extends StandardGraph {
                 },
               });
 
-              const state = getCurrentTaskInput() as t.BaseGraphState;
+              const state = runtime.state as t.BaseGraphState;
 
               /**
                * For parallel handoff support:

package/src/run.ts

@@ -135,6 +135,13 @@ export class Run<_T extends t.BaseGraphState> {
   Graph: StandardGraph | MultiAgentGraph | undefined;
   returnContent: boolean = false;
   private skipCleanup: boolean = false;
+  /**
+   * Whether the compiled graph was built with a checkpointer (host-supplied
+   * or the HITL `MemorySaver` fallback). Captured at graph creation because
+   * the constructor can later overwrite `Graph.compileOptions` with the raw
+   * caller options, dropping the fallback checkpointer from that metadata.
+   */
+  private hasCheckpointer: boolean = false;
   private _streamResult: t.MessageContentComplex[] | undefined;
   /**
    * Captured interrupt payload typed as `unknown` because the SDK
@@ -256,6 +263,7 @@ export class Run<_T extends t.BaseGraphState> {
     standardGraph.compileOptions = this.applyHITLCheckpointerFallback(
       config.compileOptions
     );
+    this.hasCheckpointer = standardGraph.compileOptions?.checkpointer != null;
     standardGraph.hookRegistry = this.hookRegistry;
     standardGraph.humanInTheLoop = this.humanInTheLoop;
     standardGraph.toolOutputReferences = this.toolOutputReferences;
@@ -283,6 +291,7 @@ export class Run<_T extends t.BaseGraphState> {
 
     multiAgentGraph.compileOptions =
       this.applyHITLCheckpointerFallback(compileOptions);
+    this.hasCheckpointer = multiAgentGraph.compileOptions?.checkpointer != null;
 
     multiAgentGraph.hookRegistry = this.hookRegistry;
     multiAgentGraph.humanInTheLoop = this.humanInTheLoop;
@@ -647,10 +656,7 @@ export class Run<_T extends t.BaseGraphState> {
 
   async processStream(
     inputs: t.IState | Command,
-    callerConfig: Partial<RunnableConfig> & {
-      version: 'v1' | 'v2';
-      run_id?: string;
-    },
+    callerConfig: t.RunStreamConfig,
     streamOptions?: t.EventStreamOptions
   ): Promise<MessageContentComplex[] | undefined> {
     if (this.graphRunnable == null) {
@@ -667,7 +673,7 @@ export class Run<_T extends t.BaseGraphState> {
     const graph = this.Graph;
 
     /**
-     * `Command` inputs (currently only `Command({ resume })`) are
+     * `Command` inputs (`Command({ resume, update?, goto? })`) are
      * resume-mode invocations: LangGraph rebuilds graph state from the
      * checkpointer, so we skip RunStart / UserPromptSubmit hooks (no
      * new prompt to evaluate) and read run-state from the Graph wrapper
@@ -676,10 +682,7 @@ export class Run<_T extends t.BaseGraphState> {
     const isResume = inputs instanceof Command;
     const stateInputs = isResume ? undefined : (inputs as t.IState);
 
-    const config: Partial<RunnableConfig> & {
-      version: 'v1' | 'v2';
-      run_id?: string;
-    } = {
+    const config: t.RunStreamConfig = {
       recursionLimit: 50,
       ...callerConfig,
       configurable: { ...callerConfig.configurable },
@@ -763,6 +766,16 @@ export class Run<_T extends t.BaseGraphState> {
       run_id: this.id,
     });
 
+    /**
+     * Default `durability: 'exit'` whenever a checkpointer is active so
+     * runs skip per-superstep checkpoint writes and persist only at the
+     * exit/interrupt boundary (all HITL/resume needs). An explicit caller
+     * value wins; no checkpointer leaves it unset (langgraph default).
+     */
+    if (config.durability == null && this.hasCheckpointer) {
+      config.durability = 'exit';
+    }
+
     const threadId = config.configurable.thread_id as string | undefined;
 
     if (this.hookRegistry != null && stateInputs != null) {
@@ -1139,13 +1152,28 @@ export class Run<_T extends t.BaseGraphState> {
     return cp == null ? 0 : cp.rewind();
   }
 
+  /**
+   * Resume an interrupted run. `commandOptions` forwards langgraph 1.4.5
+   * `Command` fields applied together with `resume` in one superstep:
+   * - `update`: channel updates committed at the resume point. On a *rebuilt*
+   *   Run (new instance + durable checkpointer), `update.messages` are the first
+   *   write the fresh wrapper sees, so they seed the `getRunMessages()` /
+   *   `returnContent` baseline and are excluded from them (still committed to the
+   *   checkpoint). Hosts that rebuild + inject messages should persist them
+   *   directly or read from `getState`. Unreachable without a durable checkpointer.
+   * - `goto`: a *dynamic* edge that does not cancel static `addEdge` routes. On
+   *   the built-in standard graph the fixed `toolNode -> agentNode/END` edge still
+   *   fires, so `goto` adds rather than replaces (e.g. `goto: END` will not stop a
+   *   tool-node resume). Intended for custom, Command-routed graphs.
+   */
   async resume<TResume = t.ToolApprovalDecision[] | t.ToolApprovalDecisionMap>(
     resumeValue: TResume,
-    callerConfig: Partial<RunnableConfig> & {
-      version: 'v1' | 'v2';
-      run_id?: string;
-    },
-    streamOptions?: t.EventStreamOptions
+    callerConfig: t.RunStreamConfig,
+    streamOptions?: t.EventStreamOptions,
+    commandOptions?: Pick<
+      ConstructorParameters<typeof Command>[0],
+      'update' | 'goto'
+    >
   ): Promise<MessageContentComplex[] | undefined> {
     const interruptId = this._interrupt?.interruptId;
     const scopedResume =
@@ -1155,24 +1183,26 @@ export class Run<_T extends t.BaseGraphState> {
         ? { [interruptId]: resumeValue }
         : resumeValue;
     const resumeConfig = await this.resolveInterruptResumeConfig(callerConfig);
+    // langgraph 1.4.5 applies resume + state update + reroute in one superstep
+    // (single checkpoint). `update`/`goto` are omitted unless the caller sets them.
     return this.processStream(
-      new Command({ resume: scopedResume }),
+      new Command({
+        resume: scopedResume,
+        ...(commandOptions?.update !== undefined
+          ? { update: commandOptions.update }
+          : {}),
+        ...(commandOptions?.goto !== undefined
+          ? { goto: commandOptions.goto }
+          : {}),
+      }),
       resumeConfig,
       streamOptions
     );
   }
 
   private async resolveInterruptResumeConfig(
-    callerConfig: Partial<RunnableConfig> & {
-      version: 'v1' | 'v2';
-      run_id?: string;
-    }
-  ): Promise<
-    Partial<RunnableConfig> & {
-      version: 'v1' | 'v2';
-      run_id?: string;
-    }
-  > {
+    callerConfig: t.RunStreamConfig
+  ): Promise<t.RunStreamConfig> {
     const interrupt = this._interrupt;
     const interruptId = interrupt?.interruptId;
     const workflow = this.graphRunnable as

package/src/scripts/handoff-test.ts

@@ -10,10 +10,10 @@ import {
   MessagesAnnotation,
   Command,
   START,
-  getCurrentTaskInput,
   END,
 } from '@langchain/langgraph';
 import { ToolMessage } from '@langchain/core/messages';
+import type { ToolRuntime } from '@langchain/core/tools';
 
 interface CreateHandoffToolParams {
   agentName: string;
@@ -28,16 +28,15 @@ const createHandoffTool = ({
   const toolDescription = description || `Ask agent '${agentName}' for help`;
 
   const handoffTool = tool(
-    async (_, config) => {
+    async (_, runtime: ToolRuntime) => {
       const toolMessage = new ToolMessage({
         content: `Successfully transferred to ${agentName}`,
         name: toolName,
-        tool_call_id: config.toolCall.id,
+        tool_call_id: runtime.toolCallId,
       });
 
-      // inject the current agent state
-      const state =
-        getCurrentTaskInput() as (typeof MessagesAnnotation)['State'];
+      // inject the current agent state via langgraph 1.4 `runtime.state`
+      const state = runtime.state as (typeof MessagesAnnotation)['State'];
       return new Command({
         goto: agentName,
         update: { messages: state.messages.concat(toolMessage) },

package/src/session/types.ts

@@ -209,7 +209,10 @@ export type AgentSessionInput = string | BaseMessage | BaseMessage[] | t.IState;
 export interface AgentSessionRunOptions {
   runId?: string;
   threadId?: string;
-  config?: Partial<RunnableConfig> & { version?: 'v1' | 'v2' };
+  config?: Partial<RunnableConfig> & {
+    version?: 'v1' | 'v2';
+    durability?: t.Durability;
+  };
   streamOptions?: t.EventStreamOptions;
 }
 

package/src/specs/durability-checkpoint.integration.test.ts

@@ -0,0 +1,243 @@
+import { MongoClient } from 'mongodb';
+import { HumanMessage } from '@langchain/core/messages';
+import { MongoMemoryServer } from 'mongodb-memory-server-core';
+import { MongoDBSaver } from '@langchain/langgraph-checkpoint-mongodb';
+import { describe, it, expect, beforeAll, afterAll } from '@jest/globals';
+import {
+  END,
+  START,
+  Command,
+  Annotation,
+  StateGraph,
+  interrupt,
+} from '@langchain/langgraph';
+import type * as t from '@/types';
+import { Providers } from '@/common';
+import { Run } from '@/run';
+
+/**
+ * End-to-end proof against a real Mongo store that the durability default is
+ * the storage optimization it claims to be, not just a config flag. A real
+ * `Run` with a fake streaming model (no provider API hit) writes through the
+ * official MongoDBSaver, and a langgraph interrupt graph exercises the HITL
+ * pause/resume boundary. `exit` persists only at the exit/interrupt boundary
+ * with no per-superstep writes; `async` checkpoints every superstep.
+ */
+describe('durability default — real Mongo checkpointer', () => {
+  let mongod: MongoMemoryServer;
+  let client: MongoClient;
+
+  beforeAll(async () => {
+    // First CI run downloads a mongod binary — allow time beyond the 60s default.
+    mongod = await MongoMemoryServer.create();
+    client = new MongoClient(mongod.getUri());
+    await client.connect();
+  }, 120000);
+
+  afterAll(async () => {
+    await client.close();
+    await mongod.stop();
+  });
+
+  const counts = async (
+    dbName: string
+  ): Promise<{ checkpoints: number; writes: number }> => {
+    const db = client.db(dbName);
+    const [checkpoints, writes] = await Promise.all([
+      db.collection('checkpoints').countDocuments({}),
+      db.collection('checkpoint_writes').countDocuments({}),
+    ]);
+    return { checkpoints, writes };
+  };
+
+  describe('normal run (real Run + fake model)', () => {
+    const runOnce = async (
+      dbName: string,
+      durability?: t.Durability
+    ): Promise<void> => {
+      const run = await Run.create<t.IState>({
+        runId: `durability-${dbName}`,
+        graphConfig: {
+          type: 'standard',
+          agents: [
+            {
+              agentId: 'a',
+              provider: Providers.OPENAI,
+              clientOptions: { modelName: 'gpt-4o-mini', apiKey: 'test-key' },
+              instructions: 'noop',
+              maxContextTokens: 8000,
+            },
+          ],
+          compileOptions: {
+            checkpointer: new MongoDBSaver({ client, dbName }),
+          },
+        },
+      });
+      // Fake streaming model: one assistant turn, no tool calls -> agent -> END.
+      run.Graph?.overrideTestModel(['done'], 1);
+      await run.processStream(
+        { messages: [new HumanMessage('hi')] },
+        {
+          version: 'v2',
+          ...(durability != null ? { durability } : {}),
+          configurable: { thread_id: dbName },
+        }
+      );
+    };
+
+    it('exit default writes one checkpoint and no per-superstep writes; async writes more of both', async () => {
+      await runOnce('normal_exit');
+      await runOnce('normal_async', 'async');
+
+      const exitCounts = await counts('normal_exit');
+      const asyncCounts = await counts('normal_async');
+
+      // exit: only the final checkpoint, zero per-superstep pending writes.
+      expect(exitCounts).toEqual({ checkpoints: 1, writes: 0 });
+      // async: a checkpoint plus pending writes for every superstep.
+      expect(asyncCounts.checkpoints).toBeGreaterThan(exitCounts.checkpoints);
+      expect(asyncCounts.writes).toBeGreaterThan(exitCounts.writes);
+    });
+  });
+
+  describe('HITL interrupt (langgraph graph + real saver)', () => {
+    const State = Annotation.Root({
+      steps: Annotation<string[]>({
+        reducer: (a, b) => a.concat(b),
+        default: () => [],
+      }),
+    });
+
+    const drain = async (stream: AsyncIterable<unknown>): Promise<void> => {
+      for await (const _event of stream) {
+        // Consume the event stream exactly like Run.processStream does.
+      }
+    };
+
+    const runInterruptGraph = async (
+      dbName: string,
+      durability: t.Durability
+    ): Promise<{
+      atPause: { checkpoints: number; writes: number };
+      done: { checkpoints: number; writes: number };
+    }> => {
+      const saver = new MongoDBSaver({ client, dbName });
+      const graph = new StateGraph(State)
+        .addNode('a', () => ({ steps: ['a'] }))
+        .addNode('b', () => {
+          interrupt({ ask: 'approve?' });
+          return { steps: ['b'] };
+        })
+        .addNode('c', () => ({ steps: ['c'] }))
+        .addEdge(START, 'a')
+        .addEdge('a', 'b')
+        .addEdge('b', 'c')
+        .addEdge('c', END)
+        .compile({ checkpointer: saver });
+
+      // durability rides in the 2nd-arg config, exactly as run.ts threads it.
+      const cfg = {
+        configurable: { thread_id: dbName },
+        durability,
+        version: 'v2' as const,
+      };
+
+      await drain(graph.streamEvents({ steps: [] }, cfg, { raiseError: true }));
+      const atPause = await counts(dbName);
+
+      await drain(
+        graph.streamEvents(new Command({ resume: 'ok' }), cfg, {
+          raiseError: true,
+        })
+      );
+      const done = await counts(dbName);
+
+      return { atPause, done };
+    };
+
+    it('exit checkpoints only at the interrupt boundary and final exit; async checkpoints every superstep', async () => {
+      const exitRun = await runInterruptGraph('hitl_exit', 'exit');
+      const asyncRun = await runInterruptGraph('hitl_async', 'async');
+
+      // exit: one checkpoint at the pause (the interrupt), two once resumed
+      // (interrupt boundary + final exit).
+      expect(exitRun.atPause.checkpoints).toBe(1);
+      expect(exitRun.done.checkpoints).toBe(2);
+
+      // async: a checkpoint for every superstep, strictly more at each stage.
+      expect(asyncRun.atPause.checkpoints).toBeGreaterThan(
+        exitRun.atPause.checkpoints
+      );
+      expect(asyncRun.done.checkpoints).toBeGreaterThan(
+        exitRun.done.checkpoints
+      );
+      expect(asyncRun.done.writes).toBeGreaterThan(exitRun.done.writes);
+    });
+  });
+
+  describe('multiple interrupts (sequential ask-user-questions)', () => {
+    const State = Annotation.Root({
+      qa: Annotation<string[]>({
+        reducer: (a, b) => a.concat(b),
+        default: () => [],
+      }),
+    });
+
+    const drain = async (stream: AsyncIterable<unknown>): Promise<void> => {
+      for await (const _event of stream) {
+        // Consume the event stream.
+      }
+    };
+
+    it('checkpoints each interrupt boundary, chains them, and discards none across resumes', async () => {
+      const dbName = 'multi_exit';
+      const saver = new MongoDBSaver({ client, dbName });
+      const graph = new StateGraph(State)
+        .addNode('ask1', () => ({ qa: [`Q1=${interrupt({ q: 'Q1' })}`] }))
+        .addNode('ask2', () => ({ qa: [`Q2=${interrupt({ q: 'Q2' })}`] }))
+        .addNode('done', () => ({ qa: ['done'] }))
+        .addEdge(START, 'ask1')
+        .addEdge('ask1', 'ask2')
+        .addEdge('ask2', 'done')
+        .addEdge('done', END)
+        .compile({ checkpointer: saver });
+
+      const cfg = {
+        configurable: { thread_id: dbName },
+        durability: 'exit' as const,
+        version: 'v2' as const,
+      };
+
+      // First question -> pauses at ask1, one checkpoint at that boundary.
+      await drain(graph.streamEvents({ qa: [] }, cfg, { raiseError: true }));
+      let state = await graph.getState(cfg);
+      expect(state.next).toEqual(['ask1']);
+      expect((await counts(dbName)).checkpoints).toBe(1);
+
+      // Answer 1 -> the run continues and the LLM asks a second question.
+      // The chain grows to 2: the first interrupt checkpoint is retained as
+      // the parent, not discarded or overwritten.
+      await drain(
+        graph.streamEvents(new Command({ resume: 'A1' }), cfg, {
+          raiseError: true,
+        })
+      );
+      state = await graph.getState(cfg);
+      expect(state.next).toEqual(['ask2']);
+      expect(state.values.qa).toEqual(['Q1=A1']);
+      expect((await counts(dbName)).checkpoints).toBe(2);
+
+      // Answer 2 -> run completes; both answers applied, three checkpoints
+      // total (two interrupt boundaries + final exit).
+      await drain(
+        graph.streamEvents(new Command({ resume: 'A2' }), cfg, {
+          raiseError: true,
+        })
+      );
+      state = await graph.getState(cfg);
+      expect(state.next).toEqual([]);
+      expect(state.values.qa).toEqual(['Q1=A1', 'Q2=A2', 'done']);
+      expect((await counts(dbName)).checkpoints).toBe(3);
+    });
+  });
+});