@langchain/langgraph 0.2.8 → 0.2.9

package/dist/pregel/loop.d.ts

@@ -1,4 +1,3 @@
-import Deque from "double-ended-queue";
 import type { RunnableConfig } from "@langchain/core/runnables";
 import type { CallbackManagerForChainRun } from "@langchain/core/callbacks/manager";
 import { BaseCheckpointSaver, Checkpoint, PendingWrite, CheckpointPendingWrite, CheckpointMetadata, All } from "@langchain/langgraph-checkpoint";
@@ -8,6 +7,7 @@ import { PregelNode } from "./read.js";
 import { BaseStore } from "../store/base.js";
 import { AsyncBatchedStore } from "../store/batch.js";
 import { ManagedValueMapping } from "../managed/base.js";
+export type StreamChunk = [string[], StreamMode, unknown];
 export type PregelLoopInitializeParams = {
     input?: any;
     config: RunnableConfig;
@@ -17,6 +17,7 @@ export type PregelLoopInitializeParams = {
     nodes: Record<string, PregelNode>;
     channelSpecs: Record<string, BaseChannel>;
     managed: ManagedValueMapping;
+    stream: StreamProtocol;
     store?: BaseStore;
 };
 type PregelLoopParams = {
@@ -35,10 +36,20 @@ type PregelLoopParams = {
     outputKeys: string | string[];
     streamKeys: string | string[];
     nodes: Record<string, PregelNode>;
+    checkpointNamespace: string[];
+    skipDoneTasks: boolean;
+    isNested: boolean;
+    stream: StreamProtocol;
     store?: AsyncBatchedStore;
 };
+export declare class StreamProtocol {
+    push: (chunk: StreamChunk) => void;
+    modes: Set<StreamMode>;
+    constructor(pushFn: (chunk: StreamChunk) => void, modes: Set<StreamMode>);
+}
 export declare class PregelLoop {
     protected input?: any;
+    output: any;
     config: RunnableConfig;
     protected checkpointer?: BaseCheckpointSaver;
     protected checkpointerGetNextVersion: (current: number | undefined, channel: BaseChannel) => number;
@@ -47,6 +58,7 @@ export declare class PregelLoop {
     protected checkpoint: Checkpoint;
     protected checkpointConfig: RunnableConfig;
     checkpointMetadata: CheckpointMetadata;
+    protected checkpointNamespace: string[];
     protected checkpointPendingWrites: CheckpointPendingWrite[];
     protected checkpointPreviousVersions: Record<string, string | number>;
     step: number;
@@ -55,11 +67,12 @@ export declare class PregelLoop {
     protected streamKeys: string | string[];
     protected nodes: Record<string, PregelNode>;
     protected skipDoneTasks: boolean;
+    protected taskWritesLeft: number;
     status: "pending" | "done" | "interrupt_before" | "interrupt_after" | "out_of_steps";
-    tasks: PregelExecutableTask<any, any>[];
-    stream: Deque<[StreamMode, any]>;
+    tasks: Record<string, PregelExecutableTask<any, any>>;
+    stream: StreamProtocol;
     checkpointerPromises: Promise<unknown>[];
-    protected isNested: boolean;
+    isNested: boolean;
     protected _checkpointerChainedPromise: Promise<unknown>;
     store?: AsyncBatchedStore;
     constructor(params: PregelLoopParams);
@@ -77,6 +90,7 @@ export declare class PregelLoop {
      * @param writes
      */
     putWrites(taskId: string, writes: PendingWrite<string>[]): void;
+    _outputWrites(taskId: string, writes: [string, unknown][], cached?: boolean): void;
     /**
      * Execute a single iteration of the Pregel loop.
      * Returns true if more iterations are needed.
@@ -88,12 +102,14 @@ export declare class PregelLoop {
         interruptBefore: string[] | All;
         manager?: CallbackManagerForChainRun;
     }): Promise<boolean>;
+    protected _suppressInterrupt(e?: Error): boolean;
     /**
      * Resuming from previous checkpoint requires
      * - finding a previous checkpoint
      * - receiving None input (outer graph) or RESUMING flag (subgraph)
      */
     protected _first(inputKeys: string | string[]): Promise<void>;
-    protected _putCheckpoint(inputMetadata: Omit<CheckpointMetadata, "step">): Promise<void>;
+    protected _emit(values: [StreamMode, unknown][]): void;
+    protected _putCheckpoint(inputMetadata: Omit<CheckpointMetadata, "step" | "parents">): Promise<void>;
 }
 export {};

package/dist/pregel/loop.js

@@ -1,17 +1,44 @@
-import Deque from "double-ended-queue";
 import { copyCheckpoint, emptyCheckpoint, } from "@langchain/langgraph-checkpoint";
 import { createCheckpoint, emptyChannels, } from "../channels/base.js";
-import { CONFIG_KEY_READ, CONFIG_KEY_RESUMING, ERROR, INPUT, INTERRUPT, } from "../constants.js";
+import { CHECKPOINT_NAMESPACE_SEPARATOR, CONFIG_KEY_CHECKPOINT_MAP, CONFIG_KEY_READ, CONFIG_KEY_RESUMING, CONFIG_KEY_STREAM, ERROR, INPUT, INTERRUPT, TAG_HIDDEN, TASKS, } from "../constants.js";
 import { _applyWrites, _prepareNextTasks, increment, shouldInterrupt, } from "./algo.js";
 import { gatherIterator, gatherIteratorSync, prefixGenerator, } from "../utils.js";
-import { mapInput, mapOutputUpdates, mapOutputValues } from "./io.js";
-import { EmptyInputError, GraphInterrupt } from "../errors.js";
-import { getNewChannelVersions } from "./utils.js";
+import { mapInput, mapOutputUpdates, mapOutputValues, readChannels, } from "./io.js";
+import { EmptyInputError, GraphInterrupt, isGraphInterrupt, } from "../errors.js";
+import { getNewChannelVersions, patchConfigurable } from "./utils/index.js";
 import { mapDebugTasks, mapDebugCheckpoint, mapDebugTaskResults, } from "./debug.js";
 import { AsyncBatchedStore } from "../store/batch.js";
 const INPUT_DONE = Symbol.for("INPUT_DONE");
 const INPUT_RESUMING = Symbol.for("INPUT_RESUMING");
 const DEFAULT_LOOP_LIMIT = 25;
+const SPECIAL_CHANNELS = [ERROR, INTERRUPT];
+export class StreamProtocol {
+    constructor(pushFn, modes) {
+        Object.defineProperty(this, "push", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "modes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.push = pushFn;
+        this.modes = modes;
+    }
+}
+function createDuplexStream(...streams) {
+    return new StreamProtocol((value) => {
+        for (const stream of streams) {
+            if (stream.modes.has(value[1])) {
+                stream.push(value);
+            }
+        }
+    }, new Set(streams.flatMap((s) => Array.from(s.modes))));
+}
 export class PregelLoop {
     constructor(params) {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -21,6 +48,13 @@ export class PregelLoop {
             writable: true,
             value: void 0
         });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        Object.defineProperty(this, "output", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "config", {
             enumerable: true,
             configurable: true,
@@ -69,6 +103,12 @@ export class PregelLoop {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "checkpointNamespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "checkpointPendingWrites", {
             enumerable: true,
             configurable: true,
@@ -117,6 +157,12 @@ export class PregelLoop {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "taskWritesLeft", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
         Object.defineProperty(this, "status", {
             enumerable: true,
             configurable: true,
@@ -128,14 +174,14 @@ export class PregelLoop {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: []
+            value: {}
         });
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         Object.defineProperty(this, "stream", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: new Deque()
+            value: void 0
         });
         Object.defineProperty(this, "checkpointerPromises", {
             enumerable: true,
@@ -162,7 +208,6 @@ export class PregelLoop {
             value: void 0
         });
         this.input = params.input;
-        this.config = params.config;
         this.checkpointer = params.checkpointer;
         // TODO: if managed values no longer needs graph we can replace with
         // managed_specs, channel_specs
@@ -173,7 +218,6 @@ export class PregelLoop {
             this.checkpointerGetNextVersion = increment;
         }
         this.checkpoint = params.checkpoint;
-        this.checkpointConfig = params.checkpointConfig;
         this.checkpointMetadata = params.checkpointMetadata;
         this.checkpointPreviousVersions = params.checkpointPreviousVersions;
         this.channels = params.channels;
@@ -181,29 +225,58 @@ export class PregelLoop {
         this.checkpointPendingWrites = params.checkpointPendingWrites;
         this.step = params.step;
         this.stop = params.stop;
-        this.isNested = CONFIG_KEY_READ in (this.config.configurable ?? {});
+        this.config = params.config;
+        this.checkpointConfig = params.checkpointConfig;
+        this.isNested = params.isNested;
         this.outputKeys = params.outputKeys;
         this.streamKeys = params.streamKeys;
         this.nodes = params.nodes;
-        this.skipDoneTasks = this.config.configurable?.checkpoint_id === undefined;
+        this.skipDoneTasks = params.skipDoneTasks;
         this.store = params.store;
+        this.stream = params.stream;
+        this.checkpointNamespace = params.checkpointNamespace;
     }
     static async initialize(params) {
-        const saved = (await params.checkpointer?.getTuple(params.config)) ?? {
-            config: params.config,
+        let { config, stream } = params;
+        if (stream !== undefined &&
+            config.configurable?.[CONFIG_KEY_STREAM] !== undefined) {
+            stream = createDuplexStream(stream, config.configurable[CONFIG_KEY_STREAM]);
+        }
+        const skipDoneTasks = config.configurable?.checkpoint_id === undefined;
+        const isNested = CONFIG_KEY_READ in (config.configurable ?? {});
+        if (!isNested &&
+            config.configurable?.checkpoint_ns !== undefined &&
+            config.configurable?.checkpoint_ns !== "") {
+            config = patchConfigurable(config, {
+                checkpoint_ns: "",
+                checkpoint_id: undefined,
+            });
+        }
+        let checkpointConfig = config;
+        if (config.configurable?.[CONFIG_KEY_CHECKPOINT_MAP] !== undefined &&
+            config.configurable?.[CONFIG_KEY_CHECKPOINT_MAP]?.[config.configurable?.checkpoint_ns]) {
+            checkpointConfig = patchConfigurable(config, {
+                checkpoint_id: config.configurable[CONFIG_KEY_CHECKPOINT_MAP][config.configurable?.checkpoint_ns],
+            });
+        }
+        const checkpointNamespace = config.configurable?.checkpoint_ns?.split(CHECKPOINT_NAMESPACE_SEPARATOR) ?? [];
+        const saved = (await params.checkpointer?.getTuple(checkpointConfig)) ?? {
+            config,
             checkpoint: emptyCheckpoint(),
             metadata: {
                 source: "input",
                 step: -2,
                 writes: null,
+                parents: {},
             },
             pendingWrites: [],
         };
-        const checkpointConfig = {
-            ...params.config,
+        checkpointConfig = {
+            ...config,
             ...saved.config,
             configurable: {
-                ...params.config.configurable,
+                checkpoint_ns: "",
+                ...config.configurable,
                 ...saved.config.configurable,
             },
         };
@@ -212,7 +285,7 @@ export class PregelLoop {
         const checkpointPendingWrites = saved.pendingWrites ?? [];
         const channels = emptyChannels(params.channelSpecs, checkpoint);
         const step = (checkpointMetadata.step ?? 0) + 1;
-        const stop = step + (params.config.recursionLimit ?? DEFAULT_LOOP_LIMIT) + 1;
+        const stop = step + (config.recursionLimit ?? DEFAULT_LOOP_LIMIT) + 1;
         const checkpointPreviousVersions = { ...checkpoint.channel_versions };
         const store = params.store
             ? new AsyncBatchedStore(params.store)
@@ -223,13 +296,16 @@ export class PregelLoop {
         }
         return new PregelLoop({
             input: params.input,
-            config: params.config,
+            config,
             checkpointer: params.checkpointer,
             checkpoint,
             checkpointMetadata,
             checkpointConfig,
+            checkpointNamespace,
             channels,
             managed: params.managed,
+            isNested,
+            skipDoneTasks,
             step,
             stop,
             checkpointPreviousVersions,
@@ -237,6 +313,7 @@ export class PregelLoop {
             outputKeys: params.outputKeys ?? [],
             streamKeys: params.streamKeys ?? [],
             nodes: params.nodes,
+            stream,
             store,
         });
     }
@@ -259,6 +336,22 @@ export class PregelLoop {
      * @param writes
      */
     putWrites(taskId, writes) {
+        if (writes.length === 0) {
+            return;
+        }
+        // adjust taskWritesLeft
+        const firstChannel = writes[0][0];
+        const anyChannelIsSend = writes.find(([channel]) => channel === TASKS);
+        const alwaysSave = anyChannelIsSend || SPECIAL_CHANNELS.includes(firstChannel);
+        if (!alwaysSave && !this.taskWritesLeft) {
+            return this._outputWrites(taskId, writes);
+        }
+        else if (firstChannel !== INTERRUPT) {
+            // INTERRUPT makes us want to save the last task's writes
+            // so we don't decrement tasksWritesLeft in that case
+            this.taskWritesLeft -= 1;
+        }
+        // save writes
         const pendingWrites = writes.map(([key, value]) => {
             return [taskId, key, value];
         });
@@ -274,10 +367,23 @@ export class PregelLoop {
         if (putWritePromise !== undefined) {
             this.checkpointerPromises.push(putWritePromise);
         }
-        const task = this.tasks.find((task) => task.id === taskId);
+        this._outputWrites(taskId, writes);
+    }
+    _outputWrites(taskId, writes, cached = false) {
+        const task = this.tasks[taskId];
         if (task !== undefined) {
-            this.stream.push(...gatherIteratorSync(prefixGenerator(mapOutputUpdates(this.outputKeys, [task]), "updates")));
-            this.stream.push(...gatherIteratorSync(prefixGenerator(mapDebugTaskResults(this.step, [[task, writes]], this.streamKeys), "debug")));
+            if (task.config !== undefined &&
+                (task.config.tags ?? []).includes(TAG_HIDDEN)) {
+                return;
+            }
+            if (writes.length > 0 &&
+                writes[0][0] !== ERROR &&
+                writes[0][0] !== INTERRUPT) {
+                this._emit(gatherIteratorSync(prefixGenerator(mapOutputUpdates(this.outputKeys, [[task, writes]], cached), "updates")));
+            }
+            if (!cached) {
+                this._emit(gatherIteratorSync(prefixGenerator(mapDebugTaskResults(this.step, [[task, writes]], this.streamKeys), "debug")));
+            }
         }
     }
     /**
@@ -286,35 +392,98 @@ export class PregelLoop {
      * @param params
      */
     async tick(params) {
-        if (this.store && !this.store.isRunning) {
-            this.store?.start();
-        }
-        const { inputKeys = [], interruptAfter = [], interruptBefore = [], manager, } = params;
-        if (this.status !== "pending") {
-            throw new Error(`Cannot tick when status is no longer "pending". Current status: "${this.status}"`);
-        }
-        if (![INPUT_DONE, INPUT_RESUMING].includes(this.input)) {
-            await this._first(inputKeys);
-        }
-        else if (this.tasks.every((task) => task.writes.length > 0)) {
-            const writes = this.tasks.flatMap((t) => t.writes);
-            // All tasks have finished
-            const myWrites = _applyWrites(this.checkpoint, this.channels, this.tasks, this.checkpointerGetNextVersion);
-            for (const [key, values] of Object.entries(myWrites)) {
-                await this.updateManagedValues(key, values);
+        let tickError;
+        try {
+            if (this.store && !this.store.isRunning) {
+                this.store?.start();
             }
-            // produce values output
-            const valuesOutput = await gatherIterator(prefixGenerator(mapOutputValues(this.outputKeys, writes, this.channels), "values"));
-            this.stream.push(...valuesOutput);
-            // clear pending writes
-            this.checkpointPendingWrites = [];
-            await this._putCheckpoint({
-                source: "loop",
-                writes: mapOutputUpdates(this.outputKeys, this.tasks).next().value ?? null,
+            const { inputKeys = [], interruptAfter = [], interruptBefore = [], manager, } = params;
+            if (this.status !== "pending") {
+                throw new Error(`Cannot tick when status is no longer "pending". Current status: "${this.status}"`);
+            }
+            if (![INPUT_DONE, INPUT_RESUMING].includes(this.input)) {
+                await this._first(inputKeys);
+            }
+            else if (Object.values(this.tasks).every((task) => task.writes.length > 0)) {
+                const writes = Object.values(this.tasks).flatMap((t) => t.writes);
+                // All tasks have finished
+                const managedValueWrites = _applyWrites(this.checkpoint, this.channels, Object.values(this.tasks), this.checkpointerGetNextVersion);
+                for (const [key, values] of Object.entries(managedValueWrites)) {
+                    await this.updateManagedValues(key, values);
+                }
+                // produce values output
+                const valuesOutput = await gatherIterator(prefixGenerator(mapOutputValues(this.outputKeys, writes, this.channels), "values"));
+                this._emit(valuesOutput);
+                // clear pending writes
+                this.checkpointPendingWrites = [];
+                await this._putCheckpoint({
+                    source: "loop",
+                    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))) {
+                    this.status = "interrupt_after";
+                    if (this.isNested) {
+                        throw new GraphInterrupt();
+                    }
+                    else {
+                        return false;
+                    }
+                }
+            }
+            else {
+                return false;
+            }
+            if (this.step > this.stop) {
+                this.status = "out_of_steps";
+                return false;
+            }
+            const nextTasks = _prepareNextTasks(this.checkpoint, this.nodes, this.channels, this.managed, this.config, true, {
+                step: this.step,
+                checkpointer: this.checkpointer,
+                isResuming: this.input === INPUT_RESUMING,
+                manager,
             });
-            // after execution, check if we should interrupt
-            if (shouldInterrupt(this.checkpoint, interruptAfter, this.tasks)) {
-                this.status = "interrupt_after";
+            this.tasks = nextTasks;
+            this.taskWritesLeft = Object.values(this.tasks).length - 1;
+            // Produce debug output
+            if (this.checkpointer) {
+                this._emit(await gatherIterator(prefixGenerator(mapDebugCheckpoint(this.step - 1, // printing checkpoint for previous step
+                this.checkpointConfig, this.channels, this.streamKeys, this.checkpointMetadata, Object.values(this.tasks), this.checkpointPendingWrites), "debug")));
+            }
+            if (Object.values(this.tasks).length === 0) {
+                this.status = "done";
+                return false;
+            }
+            // if there are pending writes from a previous loop, apply them
+            if (this.skipDoneTasks && this.checkpointPendingWrites.length > 0) {
+                for (const [tid, k, v] of this.checkpointPendingWrites) {
+                    if (k === ERROR || k === INTERRUPT) {
+                        continue;
+                    }
+                    const task = Object.values(this.tasks).find((t) => t.id === tid);
+                    if (task) {
+                        task.writes.push([k, v]);
+                    }
+                }
+                for (const task of Object.values(this.tasks)) {
+                    if (task.writes.length > 0) {
+                        this._outputWrites(task.id, task.writes, true);
+                    }
+                }
+            }
+            // 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,
+                });
+            }
+            // Before execution, check if we should interrupt
+            if (shouldInterrupt(this.checkpoint, interruptBefore, Object.values(this.tasks))) {
+                this.status = "interrupt_before";
                 if (this.isNested) {
                     throw new GraphInterrupt();
                 }
@@ -322,65 +491,29 @@ export class PregelLoop {
                     return false;
                 }
             }
+            // Produce debug output
+            const debugOutput = await gatherIterator(prefixGenerator(mapDebugTasks(this.step, Object.values(this.tasks)), "debug"));
+            this._emit(debugOutput);
+            return true;
         }
-        else {
-            return false;
-        }
-        if (this.step > this.stop) {
-            this.status = "out_of_steps";
-            return false;
-        }
-        const nextTasks = _prepareNextTasks(this.checkpoint, this.nodes, this.channels, this.managed, this.config, true, {
-            step: this.step,
-            checkpointer: this.checkpointer,
-            isResuming: this.input === INPUT_RESUMING,
-            manager,
-        });
-        this.tasks = nextTasks;
-        // Produce debug output
-        if (this.checkpointer) {
-            this.stream.push(...(await gatherIterator(prefixGenerator(mapDebugCheckpoint(this.step - 1, // printing checkpoint for previous step
-            this.checkpointConfig, this.channels, this.streamKeys, this.checkpointMetadata, this.tasks, this.checkpointPendingWrites), "debug"))));
-        }
-        if (this.tasks.length === 0) {
-            this.status = "done";
-            return false;
-        }
-        // if there are pending writes from a previous loop, apply them
-        if (this.checkpointPendingWrites.length > 0 && this.skipDoneTasks) {
-            for (const [tid, k, v] of this.checkpointPendingWrites) {
-                if (k === ERROR || k === INTERRUPT) {
-                    continue;
-                }
-                const task = this.tasks.find((t) => t.id === tid);
-                if (task) {
-                    task.writes.push([k, v]);
-                }
-            }
-        }
-        // if all tasks have finished, re-tick
-        if (this.tasks.every((task) => task.writes.length > 0)) {
-            return this.tick({
-                inputKeys,
-                interruptAfter,
-                interruptBefore,
-                manager,
-            });
-        }
-        // Before execution, check if we should interrupt
-        if (shouldInterrupt(this.checkpoint, interruptBefore, this.tasks)) {
-            this.status = "interrupt_before";
-            if (this.isNested) {
-                throw new GraphInterrupt();
+        catch (e) {
+            tickError = e;
+            if (!this._suppressInterrupt(tickError)) {
+                throw tickError;
             }
             else {
-                return false;
+                this.output = readChannels(this.channels, this.outputKeys);
+            }
+            return false;
+        }
+        finally {
+            if (tickError === undefined) {
+                this.output = readChannels(this.channels, this.outputKeys);
             }
         }
-        // Produce debug output
-        const debugOutput = await gatherIterator(prefixGenerator(mapDebugTasks(this.step, this.tasks), "debug"));
-        this.stream.push(...debugOutput);
-        return true;
+    }
+    _suppressInterrupt(e) {
+        return isGraphInterrupt(e) && !this.isNested;
     }
     /**
      * Resuming from previous checkpoint requires
@@ -388,9 +521,9 @@ export class PregelLoop {
      * - receiving None input (outer graph) or RESUMING flag (subgraph)
      */
     async _first(inputKeys) {
-        const isResuming = (Object.keys(this.checkpoint.channel_versions).length !== 0 &&
-            this.config.configurable?.[CONFIG_KEY_RESUMING] !== undefined) ||
-            this.input === null;
+        const isResuming = Object.keys(this.checkpoint.channel_versions).length !== 0 &&
+            (this.config.configurable?.[CONFIG_KEY_RESUMING] !== undefined ||
+                this.input === null);
         if (isResuming) {
             for (const channelName of Object.keys(this.channels)) {
                 if (this.checkpoint.channel_versions[channelName] !== undefined) {
@@ -401,6 +534,9 @@ export class PregelLoop {
                     };
                 }
             }
+            // produce values output
+            const valuesOutput = await gatherIterator(prefixGenerator(mapOutputValues(this.outputKeys, true, this.channels), "values"));
+            this._emit(valuesOutput);
             // map inputs to channel updates
         }
         else {
@@ -409,7 +545,7 @@ export class PregelLoop {
                 throw new EmptyInputError(`Received no input writes for ${JSON.stringify(inputKeys, null, 2)}`);
             }
             const discardTasks = _prepareNextTasks(this.checkpoint, this.nodes, this.channels, this.managed, this.config, true, { step: this.step });
-            _applyWrites(this.checkpoint, this.channels, discardTasks.concat([
+            _applyWrites(this.checkpoint, this.channels, Object.values(discardTasks).concat([
                 {
                     name: INPUT,
                     writes: inputWrites,
@@ -424,12 +560,25 @@ export class PregelLoop {
         }
         // done with input
         this.input = isResuming ? INPUT_RESUMING : INPUT_DONE;
+        if (!this.isNested) {
+            this.config = patchConfigurable(this.config, {
+                [CONFIG_KEY_RESUMING]: isResuming,
+            });
+        }
+    }
+    _emit(values) {
+        for (const chunk of values) {
+            if (this.stream.modes.has(chunk[0])) {
+                this.stream.push([this.checkpointNamespace, ...chunk]);
+            }
+        }
     }
     async _putCheckpoint(inputMetadata) {
         // Assign step
         const metadata = {
             ...inputMetadata,
             step: this.step,
+            parents: this.config.configurable?.[CONFIG_KEY_CHECKPOINT_MAP] ?? {},
         };
         // Bail if no checkpointer
         if (this.checkpointer !== undefined) {
@@ -439,9 +588,7 @@ export class PregelLoop {
             // this is achieved by writing child checkpoints as progress is made
             // (so that error recovery / resuming from interrupt don't lose work)
             // but doing so always with an id equal to that of the parent checkpoint
-            this.checkpoint = createCheckpoint(this.checkpoint, this.channels, this.step
-            // id: this.isNested ? this.config.configurable?.checkpoint_id : undefined,
-            );
+            this.checkpoint = createCheckpoint(this.checkpoint, this.channels, this.step);
             this.checkpointConfig = {
                 ...this.checkpointConfig,
                 configurable: {

package/dist/pregel/read.cjs

@@ -63,10 +63,10 @@ const defaultRunnableBound =
 /* #__PURE__ */ new runnables_1.RunnablePassthrough();
 class PregelNode extends runnables_1.RunnableBinding {
     constructor(fields) {
-        const { channels, triggers, mapper, writers, bound, kwargs, metadata, retryPolicy, } = fields;
+        const { channels, triggers, mapper, writers, bound, kwargs, metadata, retryPolicy, tags, } = fields;
         const mergedTags = [
             ...(fields.config?.tags ? fields.config.tags : []),
-            ...(fields.tags ? fields.tags : []),
+            ...(tags ?? []),
         ];
         super({
             ...fields,
@@ -127,6 +127,12 @@ class PregelNode extends runnables_1.RunnableBinding {
             writable: true,
             value: {}
         });
+        Object.defineProperty(this, "tags", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
         Object.defineProperty(this, "retryPolicy", {
             enumerable: true,
             configurable: true,
@@ -140,6 +146,7 @@ class PregelNode extends runnables_1.RunnableBinding {
         this.bound = bound ?? this.bound;
         this.kwargs = kwargs ?? this.kwargs;
         this.metadata = metadata ?? this.metadata;
+        this.tags = mergedTags;
         this.retryPolicy = retryPolicy;
     }
     getWriters() {