@langchain/langgraph 0.2.40 → 0.2.42

package/dist/pregel/loop.cjs

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PregelLoop = exports.IterableReadableWritableStream = void 0;
-const stream_1 = require("@langchain/core/utils/stream");
+exports.PregelLoop = void 0;
 const langgraph_checkpoint_1 = require("@langchain/langgraph-checkpoint");
 const base_js_1 = require("../channels/base.cjs");
 const constants_js_1 = require("../constants.cjs");
@@ -11,66 +10,12 @@ const io_js_1 = require("./io.cjs");
 const errors_js_1 = require("../errors.cjs");
 const index_js_1 = require("./utils/index.cjs");
 const debug_js_1 = require("./debug.cjs");
+const stream_js_1 = require("./stream.cjs");
 const INPUT_DONE = Symbol.for("INPUT_DONE");
 const INPUT_RESUMING = Symbol.for("INPUT_RESUMING");
 const DEFAULT_LOOP_LIMIT = 25;
-class IterableReadableWritableStream extends stream_1.IterableReadableStream {
-    constructor(params) {
-        let streamControllerPromiseResolver;
-        const streamControllerPromise = new Promise((resolve) => {
-            streamControllerPromiseResolver = resolve;
-        });
-        super({
-            start: (controller) => {
-                streamControllerPromiseResolver(controller);
-            },
-        });
-        Object.defineProperty(this, "modes", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "controller", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "passthroughFn", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        // .start() will always be called before the stream can be interacted
-        // with anyway
-        void streamControllerPromise.then((controller) => {
-            this.controller = controller;
-        });
-        this.passthroughFn = params.passthroughFn;
-        this.modes = params.modes;
-    }
-    push(chunk) {
-        this.passthroughFn?.(chunk);
-        this.controller.enqueue(chunk);
-    }
-    close() {
-        try {
-            this.controller.close();
-        }
-        catch (e) {
-            // pass
-        }
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    error(e) {
-        this.controller.error(e);
-    }
-}
-exports.IterableReadableWritableStream = IterableReadableWritableStream;
 function createDuplexStream(...streams) {
-    return new IterableReadableWritableStream({
+    return new stream_js_1.IterableReadableWritableStream({
         passthroughFn: (value) => {
             for (const stream of streams) {
                 if (stream.modes.has(value[1])) {
@@ -249,6 +194,36 @@ class PregelLoop {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "manager", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "interruptAfter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "interruptBefore", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "toInterrupt", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "debug", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
         this.input = params.input;
         this.checkpointer = params.checkpointer;
         // TODO: if managed values no longer needs graph we can replace with
@@ -270,6 +245,7 @@ class PregelLoop {
         this.config = params.config;
         this.checkpointConfig = params.checkpointConfig;
         this.isNested = params.isNested;
+        this.manager = params.manager;
         this.outputKeys = params.outputKeys;
         this.streamKeys = params.streamKeys;
         this.nodes = params.nodes;
@@ -278,6 +254,9 @@ class PregelLoop {
         this.stream = params.stream;
         this.checkpointNamespace = params.checkpointNamespace;
         this.prevCheckpointConfig = params.prevCheckpointConfig;
+        this.interruptAfter = params.interruptAfter;
+        this.interruptBefore = params.interruptBefore;
+        this.debug = params.debug;
     }
     static async initialize(params) {
         let { config, stream } = params;
@@ -368,6 +347,7 @@ class PregelLoop {
             channels,
             managed: params.managed,
             isNested,
+            manager: params.manager,
             skipDoneTasks,
             step,
             stop,
@@ -378,6 +358,9 @@ class PregelLoop {
             nodes: params.nodes,
             stream,
             store,
+            interruptAfter: params.interruptAfter,
+            interruptBefore: params.interruptBefore,
+            debug: params.debug,
         });
     }
     _checkpointerPutAfterPrevious(input) {
@@ -458,7 +441,7 @@ class PregelLoop {
         if (this.store && !this.store.isRunning) {
             this.store?.start();
         }
-        const { inputKeys = [], interruptAfter = [], interruptBefore = [], manager, } = params;
+        const { inputKeys = [] } = params;
         if (this.status !== "pending") {
             throw new Error(`Cannot tick when status is no longer "pending". Current status: "${this.status}"`);
         }
@@ -482,7 +465,7 @@ class PregelLoop {
                 writes: (0, io_js_1.mapOutputUpdates)(this.outputKeys, Object.values(this.tasks).map((task) => [task, task.writes])).next().value ?? null,
             });
             // after execution, check if we should interrupt
-            if ((0, algo_js_1.shouldInterrupt)(this.checkpoint, interruptAfter, Object.values(this.tasks))) {
+            if ((0, algo_js_1.shouldInterrupt)(this.checkpoint, this.interruptAfter, Object.values(this.tasks))) {
                 this.status = "interrupt_after";
                 throw new errors_js_1.GraphInterrupt();
             }
@@ -498,8 +481,9 @@ class PregelLoop {
             step: this.step,
             checkpointer: this.checkpointer,
             isResuming: this.input === INPUT_RESUMING,
-            manager,
+            manager: this.manager,
             store: this.store,
+            stream: this.stream,
         });
         this.tasks = nextTasks;
         // Produce debug output
@@ -530,15 +514,10 @@ class PregelLoop {
         }
         // if all tasks have finished, re-tick
         if (Object.values(this.tasks).every((task) => task.writes.length > 0)) {
-            return this.tick({
-                inputKeys,
-                interruptAfter,
-                interruptBefore,
-                manager,
-            });
+            return this.tick({ inputKeys });
         }
         // Before execution, check if we should interrupt
-        if ((0, algo_js_1.shouldInterrupt)(this.checkpoint, interruptBefore, Object.values(this.tasks))) {
+        if ((0, algo_js_1.shouldInterrupt)(this.checkpoint, this.interruptBefore, Object.values(this.tasks))) {
             this.status = "interrupt_before";
             throw new errors_js_1.GraphInterrupt();
         }
@@ -575,20 +554,59 @@ class PregelLoop {
         }
         return suppress;
     }
+    acceptPush(task, writeIdx, call) {
+        if (this.interruptAfter?.length > 0 &&
+            (0, algo_js_1.shouldInterrupt)(this.checkpoint, this.interruptAfter, [task])) {
+            this.toInterrupt.push(task);
+            return;
+        }
+        const pushed = (0, algo_js_1._prepareSingleTask)([constants_js_1.PUSH, task.path ?? [], writeIdx, task.id, call], this.checkpoint, this.checkpointPendingWrites, this.nodes, this.channels, this.managed, this.config, true, {
+            step: this.step,
+            checkpointer: this.checkpointer,
+            manager: this.manager,
+            store: this.store,
+            stream: this.stream,
+        });
+        if (pushed) {
+            if (this.interruptBefore?.length > 0 &&
+                (0, algo_js_1.shouldInterrupt)(this.checkpoint, this.interruptBefore, [pushed])) {
+                this.toInterrupt.push(pushed);
+                return;
+            }
+            this._emit((0, utils_js_1.gatherIteratorSync)((0, utils_js_1.prefixGenerator)((0, debug_js_1.mapDebugTasks)(this.step, [pushed]), "debug")));
+            if (this.debug) {
+                (0, debug_js_1.printStepTasks)(this.step, [pushed]);
+            }
+            this.tasks[pushed.id] = pushed;
+            if (this.skipDoneTasks) {
+                this._matchWrites({ [pushed.id]: pushed });
+            }
+            return pushed;
+        }
+    }
     _suppressInterrupt(e) {
         return (0, errors_js_1.isGraphInterrupt)(e) && !this.isNested;
     }
-    /**
-     * Resuming from previous checkpoint requires
-     * - finding a previous checkpoint
-     * - receiving null input (outer graph) or RESUMING flag (subgraph)
-     */
     async _first(inputKeys) {
+        /*
+         * Resuming from previous checkpoint requires
+         * - finding a previous checkpoint
+         * - receiving null input (outer graph) or RESUMING flag (subgraph)
+         */
+        const { configurable } = this.config;
         const isResuming = Object.keys(this.checkpoint.channel_versions).length !== 0 &&
             (this.config.configurable?.[constants_js_1.CONFIG_KEY_RESUMING] !== undefined ||
                 this.input === null ||
                 (0, constants_js_1.isCommand)(this.input));
+        // take resume value from parent
+        const scratchpad = configurable?.[constants_js_1.CONFIG_KEY_SCRATCHPAD];
+        if (scratchpad && scratchpad.nullResume !== undefined) {
+            this.putWrites(constants_js_1.NULL_TASK_ID, [[constants_js_1.RESUME, scratchpad.nullResume]]);
+        }
         if ((0, constants_js_1.isCommand)(this.input)) {
+            if (this.input.resume != null && this.checkpointer == null) {
+                throw new Error("Cannot use Command(resume=...) without checkpointer");
+            }
             const writes = {};
             // group writes by task id
             for (const [tid, key, value] of (0, io_js_1.mapCommand)(this.input, this.checkpointPendingWrites)) {
@@ -653,10 +671,10 @@ class PregelLoop {
             });
         }
         // done with input
-        this.input = isResuming ? INPUT_RESUMING : INPUT_DONE;
+        this.input = this.input === INPUT_RESUMING ? INPUT_RESUMING : INPUT_DONE;
         if (!this.isNested) {
             this.config = (0, index_js_1.patchConfigurable)(this.config, {
-                [constants_js_1.CONFIG_KEY_RESUMING]: isResuming,
+                [constants_js_1.CONFIG_KEY_RESUMING]: this.input === INPUT_RESUMING,
             });
         }
     }
@@ -717,5 +735,21 @@ class PregelLoop {
         }
         this.step += 1;
     }
+    _matchWrites(tasks) {
+        for (const [tid, k, v] of this.checkpointPendingWrites) {
+            if (k === constants_js_1.ERROR || k === constants_js_1.INTERRUPT || k === constants_js_1.RESUME) {
+                continue;
+            }
+            const task = Object.values(tasks).find((t) => t.id === tid);
+            if (task) {
+                task.writes.push([k, v]);
+            }
+        }
+        for (const task of Object.values(tasks)) {
+            if (task.writes.length > 0) {
+                this._outputWrites(task.id, task.writes, true);
+            }
+        }
+    }
 }
 exports.PregelLoop = PregelLoop;

package/dist/pregel/loop.d.ts

@@ -1,14 +1,13 @@
 import type { RunnableConfig } from "@langchain/core/runnables";
 import type { CallbackManagerForChainRun } from "@langchain/core/callbacks/manager";
-import { IterableReadableStream } from "@langchain/core/utils/stream";
 import { BaseCheckpointSaver, Checkpoint, PendingWrite, CheckpointPendingWrite, CheckpointMetadata, All, BaseStore, AsyncBatchedStore } from "@langchain/langgraph-checkpoint";
 import { BaseChannel } from "../channels/base.js";
-import { PregelExecutableTask, StreamMode } from "./types.js";
+import { Call, PregelExecutableTask, StreamMode } from "./types.js";
 import { Command } from "../constants.js";
 import { PregelNode } from "./read.js";
 import { ManagedValueMapping } from "../managed/base.js";
 import { LangGraphRunnableConfig } from "./runnable_types.js";
-export type StreamChunk = [string[], StreamMode, unknown];
+import { IterableReadableWritableStream } from "./stream.js";
 export type PregelLoopInitializeParams = {
     input?: any | Command;
     config: RunnableConfig;
@@ -21,6 +20,10 @@ export type PregelLoopInitializeParams = {
     stream: IterableReadableWritableStream;
     store?: BaseStore;
     checkSubgraphs?: boolean;
+    interruptAfter: string[] | All;
+    interruptBefore: string[] | All;
+    manager?: CallbackManagerForChainRun;
+    debug: boolean;
 };
 type PregelLoopParams = {
     input?: any | Command;
@@ -41,22 +44,14 @@ type PregelLoopParams = {
     checkpointNamespace: string[];
     skipDoneTasks: boolean;
     isNested: boolean;
+    manager?: CallbackManagerForChainRun;
     stream: IterableReadableWritableStream;
     store?: AsyncBatchedStore;
     prevCheckpointConfig: RunnableConfig | undefined;
+    interruptAfter: string[] | All;
+    interruptBefore: string[] | All;
+    debug: boolean;
 };
-export declare class IterableReadableWritableStream extends IterableReadableStream<StreamChunk> {
-    modes: Set<StreamMode>;
-    private controller;
-    private passthroughFn?;
-    constructor(params: {
-        passthroughFn?: (chunk: StreamChunk) => void;
-        modes: Set<StreamMode>;
-    });
-    push(chunk: StreamChunk): void;
-    close(): void;
-    error(e: any): void;
-}
 export declare class PregelLoop {
     protected input?: any | Command;
     output: any;
@@ -85,6 +80,11 @@ export declare class PregelLoop {
     isNested: boolean;
     protected _checkpointerChainedPromise: Promise<unknown>;
     store?: AsyncBatchedStore;
+    manager?: CallbackManagerForChainRun;
+    interruptAfter: string[] | All;
+    interruptBefore: string[] | All;
+    toInterrupt: PregelExecutableTask<string, string>[];
+    debug: boolean;
     constructor(params: PregelLoopParams);
     static initialize(params: PregelLoopInitializeParams): Promise<PregelLoop>;
     protected _checkpointerPutAfterPrevious(input: {
@@ -108,19 +108,13 @@ export declare class PregelLoop {
      */
     tick(params: {
         inputKeys?: string | string[];
-        interruptAfter: string[] | All;
-        interruptBefore: string[] | All;
-        manager?: CallbackManagerForChainRun;
     }): Promise<boolean>;
     finishAndHandleError(error?: Error): Promise<boolean>;
+    acceptPush(task: PregelExecutableTask<string, string>, writeIdx: number, call?: Call): PregelExecutableTask<string, string> | void;
     protected _suppressInterrupt(e?: Error): boolean;
-    /**
-     * Resuming from previous checkpoint requires
-     * - finding a previous checkpoint
-     * - receiving null input (outer graph) or RESUMING flag (subgraph)
-     */
     protected _first(inputKeys: string | string[]): Promise<void>;
     protected _emit(values: [StreamMode, unknown][]): void;
     protected _putCheckpoint(inputMetadata: Omit<CheckpointMetadata, "step" | "parents">): Promise<void>;
+    protected _matchWrites(tasks: Record<string, PregelExecutableTask<string, string>>): void;
 }
 export {};

package/dist/pregel/loop.js

@@ -1,70 +1,16 @@
-import { IterableReadableStream } from "@langchain/core/utils/stream";
 import { copyCheckpoint, emptyCheckpoint, AsyncBatchedStore, WRITES_IDX_MAP, } from "@langchain/langgraph-checkpoint";
 import { createCheckpoint, emptyChannels, } from "../channels/base.js";
-import { isCommand, CHECKPOINT_NAMESPACE_SEPARATOR, CONFIG_KEY_CHECKPOINT_MAP, CONFIG_KEY_READ, CONFIG_KEY_RESUMING, CONFIG_KEY_STREAM, ERROR, INPUT, INTERRUPT, NULL_TASK_ID, RESUME, TAG_HIDDEN, } from "../constants.js";
-import { _applyWrites, _prepareNextTasks, increment, shouldInterrupt, } from "./algo.js";
+import { isCommand, CHECKPOINT_NAMESPACE_SEPARATOR, CONFIG_KEY_CHECKPOINT_MAP, CONFIG_KEY_READ, CONFIG_KEY_RESUMING, CONFIG_KEY_STREAM, ERROR, INPUT, INTERRUPT, NULL_TASK_ID, RESUME, TAG_HIDDEN, PUSH, CONFIG_KEY_SCRATCHPAD, } from "../constants.js";
+import { _applyWrites, _prepareNextTasks, _prepareSingleTask, increment, shouldInterrupt, } from "./algo.js";
 import { gatherIterator, gatherIteratorSync, prefixGenerator, } from "../utils.js";
 import { mapCommand, mapInput, mapOutputUpdates, mapOutputValues, readChannels, } from "./io.js";
 import { getSubgraphsSeenSet, EmptyInputError, GraphInterrupt, isGraphInterrupt, MultipleSubgraphsError, } from "../errors.js";
 import { getNewChannelVersions, patchConfigurable } from "./utils/index.js";
-import { mapDebugTasks, mapDebugCheckpoint, mapDebugTaskResults, } from "./debug.js";
+import { mapDebugTasks, mapDebugCheckpoint, mapDebugTaskResults, printStepTasks, } from "./debug.js";
+import { IterableReadableWritableStream } from "./stream.js";
 const INPUT_DONE = Symbol.for("INPUT_DONE");
 const INPUT_RESUMING = Symbol.for("INPUT_RESUMING");
 const DEFAULT_LOOP_LIMIT = 25;
-export class IterableReadableWritableStream extends IterableReadableStream {
-    constructor(params) {
-        let streamControllerPromiseResolver;
-        const streamControllerPromise = new Promise((resolve) => {
-            streamControllerPromiseResolver = resolve;
-        });
-        super({
-            start: (controller) => {
-                streamControllerPromiseResolver(controller);
-            },
-        });
-        Object.defineProperty(this, "modes", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "controller", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "passthroughFn", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        // .start() will always be called before the stream can be interacted
-        // with anyway
-        void streamControllerPromise.then((controller) => {
-            this.controller = controller;
-        });
-        this.passthroughFn = params.passthroughFn;
-        this.modes = params.modes;
-    }
-    push(chunk) {
-        this.passthroughFn?.(chunk);
-        this.controller.enqueue(chunk);
-    }
-    close() {
-        try {
-            this.controller.close();
-        }
-        catch (e) {
-            // pass
-        }
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    error(e) {
-        this.controller.error(e);
-    }
-}
 function createDuplexStream(...streams) {
     return new IterableReadableWritableStream({
         passthroughFn: (value) => {
@@ -245,6 +191,36 @@ export class PregelLoop {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "manager", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "interruptAfter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "interruptBefore", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "toInterrupt", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "debug", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
         this.input = params.input;
         this.checkpointer = params.checkpointer;
         // TODO: if managed values no longer needs graph we can replace with
@@ -266,6 +242,7 @@ export class PregelLoop {
         this.config = params.config;
         this.checkpointConfig = params.checkpointConfig;
         this.isNested = params.isNested;
+        this.manager = params.manager;
         this.outputKeys = params.outputKeys;
         this.streamKeys = params.streamKeys;
         this.nodes = params.nodes;
@@ -274,6 +251,9 @@ export class PregelLoop {
         this.stream = params.stream;
         this.checkpointNamespace = params.checkpointNamespace;
         this.prevCheckpointConfig = params.prevCheckpointConfig;
+        this.interruptAfter = params.interruptAfter;
+        this.interruptBefore = params.interruptBefore;
+        this.debug = params.debug;
     }
     static async initialize(params) {
         let { config, stream } = params;
@@ -364,6 +344,7 @@ export class PregelLoop {
             channels,
             managed: params.managed,
             isNested,
+            manager: params.manager,
             skipDoneTasks,
             step,
             stop,
@@ -374,6 +355,9 @@ export class PregelLoop {
             nodes: params.nodes,
             stream,
             store,
+            interruptAfter: params.interruptAfter,
+            interruptBefore: params.interruptBefore,
+            debug: params.debug,
         });
     }
     _checkpointerPutAfterPrevious(input) {
@@ -454,7 +438,7 @@ export class PregelLoop {
         if (this.store && !this.store.isRunning) {
             this.store?.start();
         }
-        const { inputKeys = [], interruptAfter = [], interruptBefore = [], manager, } = params;
+        const { inputKeys = [] } = params;
         if (this.status !== "pending") {
             throw new Error(`Cannot tick when status is no longer "pending". Current status: "${this.status}"`);
         }
@@ -478,7 +462,7 @@ export class PregelLoop {
                 writes: mapOutputUpdates(this.outputKeys, Object.values(this.tasks).map((task) => [task, task.writes])).next().value ?? null,
             });
             // after execution, check if we should interrupt
-            if (shouldInterrupt(this.checkpoint, interruptAfter, Object.values(this.tasks))) {
+            if (shouldInterrupt(this.checkpoint, this.interruptAfter, Object.values(this.tasks))) {
                 this.status = "interrupt_after";
                 throw new GraphInterrupt();
             }
@@ -494,8 +478,9 @@ export class PregelLoop {
             step: this.step,
             checkpointer: this.checkpointer,
             isResuming: this.input === INPUT_RESUMING,
-            manager,
+            manager: this.manager,
             store: this.store,
+            stream: this.stream,
         });
         this.tasks = nextTasks;
         // Produce debug output
@@ -526,15 +511,10 @@ export class PregelLoop {
         }
         // if all tasks have finished, re-tick
         if (Object.values(this.tasks).every((task) => task.writes.length > 0)) {
-            return this.tick({
-                inputKeys,
-                interruptAfter,
-                interruptBefore,
-                manager,
-            });
+            return this.tick({ inputKeys });
         }
         // Before execution, check if we should interrupt
-        if (shouldInterrupt(this.checkpoint, interruptBefore, Object.values(this.tasks))) {
+        if (shouldInterrupt(this.checkpoint, this.interruptBefore, Object.values(this.tasks))) {
             this.status = "interrupt_before";
             throw new GraphInterrupt();
         }
@@ -571,20 +551,59 @@ export class PregelLoop {
         }
         return suppress;
     }
+    acceptPush(task, writeIdx, call) {
+        if (this.interruptAfter?.length > 0 &&
+            shouldInterrupt(this.checkpoint, this.interruptAfter, [task])) {
+            this.toInterrupt.push(task);
+            return;
+        }
+        const pushed = _prepareSingleTask([PUSH, task.path ?? [], writeIdx, task.id, call], this.checkpoint, this.checkpointPendingWrites, this.nodes, this.channels, this.managed, this.config, true, {
+            step: this.step,
+            checkpointer: this.checkpointer,
+            manager: this.manager,
+            store: this.store,
+            stream: this.stream,
+        });
+        if (pushed) {
+            if (this.interruptBefore?.length > 0 &&
+                shouldInterrupt(this.checkpoint, this.interruptBefore, [pushed])) {
+                this.toInterrupt.push(pushed);
+                return;
+            }
+            this._emit(gatherIteratorSync(prefixGenerator(mapDebugTasks(this.step, [pushed]), "debug")));
+            if (this.debug) {
+                printStepTasks(this.step, [pushed]);
+            }
+            this.tasks[pushed.id] = pushed;
+            if (this.skipDoneTasks) {
+                this._matchWrites({ [pushed.id]: pushed });
+            }
+            return pushed;
+        }
+    }
     _suppressInterrupt(e) {
         return isGraphInterrupt(e) && !this.isNested;
     }
-    /**
-     * Resuming from previous checkpoint requires
-     * - finding a previous checkpoint
-     * - receiving null input (outer graph) or RESUMING flag (subgraph)
-     */
     async _first(inputKeys) {
+        /*
+         * Resuming from previous checkpoint requires
+         * - finding a previous checkpoint
+         * - receiving null input (outer graph) or RESUMING flag (subgraph)
+         */
+        const { configurable } = this.config;
         const isResuming = Object.keys(this.checkpoint.channel_versions).length !== 0 &&
             (this.config.configurable?.[CONFIG_KEY_RESUMING] !== undefined ||
                 this.input === null ||
                 isCommand(this.input));
+        // take resume value from parent
+        const scratchpad = configurable?.[CONFIG_KEY_SCRATCHPAD];
+        if (scratchpad && scratchpad.nullResume !== undefined) {
+            this.putWrites(NULL_TASK_ID, [[RESUME, scratchpad.nullResume]]);
+        }
         if (isCommand(this.input)) {
+            if (this.input.resume != null && this.checkpointer == null) {
+                throw new Error("Cannot use Command(resume=...) without checkpointer");
+            }
             const writes = {};
             // group writes by task id
             for (const [tid, key, value] of mapCommand(this.input, this.checkpointPendingWrites)) {
@@ -649,10 +668,10 @@ export class PregelLoop {
             });
         }
         // done with input
-        this.input = isResuming ? INPUT_RESUMING : INPUT_DONE;
+        this.input = this.input === INPUT_RESUMING ? INPUT_RESUMING : INPUT_DONE;
         if (!this.isNested) {
             this.config = patchConfigurable(this.config, {
-                [CONFIG_KEY_RESUMING]: isResuming,
+                [CONFIG_KEY_RESUMING]: this.input === INPUT_RESUMING,
             });
         }
     }
@@ -713,4 +732,20 @@ export class PregelLoop {
         }
         this.step += 1;
     }
+    _matchWrites(tasks) {
+        for (const [tid, k, v] of this.checkpointPendingWrites) {
+            if (k === ERROR || k === INTERRUPT || k === RESUME) {
+                continue;
+            }
+            const task = Object.values(tasks).find((t) => t.id === tid);
+            if (task) {
+                task.writes.push([k, v]);
+            }
+        }
+        for (const task of Object.values(tasks)) {
+            if (task.writes.length > 0) {
+                this._outputWrites(task.id, task.writes, true);
+            }
+        }
+    }
 }

package/dist/pregel/messages.d.ts

@@ -3,7 +3,7 @@ import { BaseMessage } from "@langchain/core/messages";
 import { Serialized } from "@langchain/core/load/serializable";
 import { LLMResult } from "@langchain/core/outputs";
 import { ChainValues } from "@langchain/core/utils/types";
-import { StreamChunk } from "./loop.js";
+import { StreamChunk } from "./stream.js";
 type Meta = [string[], Record<string, any>];
 /**
  * A callback handler that implements stream_mode=messages.