@langchain/langgraph 0.2.26 → 0.2.28

package/dist/pregel/algo.cjs

@@ -100,6 +100,21 @@ const IGNORE = new Set([constants_js_1.PUSH, constants_js_1.RESUME, constants_js
 function _applyWrites(checkpoint, channels, tasks, 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 getNextVersion) {
+    // Sort tasks by first 3 path elements for deterministic order
+    // Later path parts (like task IDs) are ignored for sorting
+    tasks.sort((a, b) => {
+        const aPath = a.path?.slice(0, 3) || [];
+        const bPath = b.path?.slice(0, 3) || [];
+        // Compare each path element
+        for (let i = 0; i < Math.min(aPath.length, bPath.length); i += 1) {
+            if (aPath[i] < bPath[i])
+                return -1;
+            if (aPath[i] > bPath[i])
+                return 1;
+        }
+        // If one path is shorter, it comes first
+        return aPath.length - bPath.length;
+    });
     // if no task has triggers this is applying writes from the null task only
     // so we don't do anything other than update the channels written to
     const bumpStep = tasks.some((task) => task.triggers.length > 0);
@@ -146,6 +161,7 @@ getNextVersion) {
                 // do nothing
             }
             else if (chan === constants_js_1.TASKS) {
+                // TODO: remove branch in 1.0
                 checkpoint.pending_sends.push({
                     node: val.node,
                     args: val.args,
@@ -214,6 +230,11 @@ getNextVersion) {
     return pendingWritesByManaged;
 }
 exports._applyWrites = _applyWrites;
+/**
+ * Prepare the set of tasks that will make up the next Pregel step.
+ * This is the union of all PUSH tasks (Sends) and PULL tasks (nodes triggered
+ * by edges).
+ */
 function _prepareNextTasks(checkpoint, pendingWrites, processes, channels, managed, config, forExecution, extra) {
     const tasks = {};
     // Consume pending packets
@@ -234,12 +255,18 @@ function _prepareNextTasks(checkpoint, pendingWrites, processes, channels, manag
     return tasks;
 }
 exports._prepareNextTasks = _prepareNextTasks;
+/**
+ * Prepares a single task for the next Pregel step, given a task path, which
+ * uniquely identifies a PUSH or PULL task within the graph.
+ */
 function _prepareSingleTask(taskPath, checkpoint, pendingWrites, processes, channels, managed, config, forExecution, extra) {
     const { step, checkpointer, manager } = extra;
     const configurable = config.configurable ?? {};
     const parentNamespace = configurable.checkpoint_ns ?? "";
     if (taskPath[0] === constants_js_1.PUSH) {
-        const index = typeof taskPath[1] === "number" ? taskPath[1] : parseInt(taskPath[1], 10);
+        const index = typeof taskPath[1] === "number"
+            ? taskPath[1]
+            : parseInt(taskPath[1], 10);
         if (index >= checkpoint.pending_sends.length) {
             return undefined;
         }
@@ -302,6 +329,7 @@ function _prepareSingleTask(taskPath, checkpoint, pendingWrites, processes, chan
                                 name: packet.node,
                                 writes: writes,
                                 triggers,
+                                path: taskPath,
                             }, select_, fresh_),
                             [constants_js_1.CONFIG_KEY_CHECKPOINTER]: checkpointer ?? configurable[constants_js_1.CONFIG_KEY_CHECKPOINTER],
                             [constants_js_1.CONFIG_KEY_CHECKPOINT_MAP]: {
@@ -319,6 +347,7 @@ function _prepareSingleTask(taskPath, checkpoint, pendingWrites, processes, chan
                     retry_policy: proc.retryPolicy,
                     id: taskId,
                     path: taskPath,
+                    writers: proc.getWriters(),
                 };
             }
         }
@@ -405,6 +434,7 @@ function _prepareSingleTask(taskPath, checkpoint, pendingWrites, processes, chan
                                     name,
                                     writes: writes,
                                     triggers,
+                                    path: taskPath,
                                 }, select_, fresh_),
                                 [constants_js_1.CONFIG_KEY_CHECKPOINTER]: checkpointer ?? configurable[constants_js_1.CONFIG_KEY_CHECKPOINTER],
                                 [constants_js_1.CONFIG_KEY_CHECKPOINT_MAP]: {
@@ -422,6 +452,7 @@ function _prepareSingleTask(taskPath, checkpoint, pendingWrites, processes, chan
                         retry_policy: proc.retryPolicy,
                         id: taskId,
                         path: taskPath,
+                        writers: proc.getWriters(),
                     };
                 }
             }

package/dist/pregel/algo.d.ts

@@ -15,6 +15,7 @@ export type WritesProtocol<C = string> = {
     name: string;
     writes: PendingWrite<C>[];
     triggers: string[];
+    path?: [string, ...(string | number)[]];
 };
 export declare const increment: (current?: number) => number;
 export declare function shouldInterrupt<N extends PropertyKey, C extends PropertyKey>(checkpoint: Checkpoint, interruptNodes: All | N[], tasks: PregelExecutableTask<N, C>[]): boolean;
@@ -37,5 +38,5 @@ export type NextTaskExtraFieldsWithoutStore = NextTaskExtraFields & {
 export declare function _prepareNextTasks<Nn extends StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel>>(checkpoint: ReadonlyCheckpoint, pendingWrites: [string, string, unknown][] | undefined, processes: Nn, channels: Cc, managed: ManagedValueMapping, config: RunnableConfig, forExecution: false, extra: NextTaskExtraFieldsWithoutStore): Record<string, PregelTaskDescription>;
 export declare function _prepareNextTasks<Nn extends StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel>>(checkpoint: ReadonlyCheckpoint, pendingWrites: [string, string, unknown][] | undefined, processes: Nn, channels: Cc, managed: ManagedValueMapping, config: RunnableConfig, forExecution: true, extra: NextTaskExtraFieldsWithStore): Record<string, PregelExecutableTask<keyof Nn, keyof Cc>>;
 export declare function _prepareSingleTask<Nn extends StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel>>(taskPath: [string, string | number], checkpoint: ReadonlyCheckpoint, pendingWrites: [string, string, unknown][] | undefined, processes: Nn, channels: Cc, managed: ManagedValueMapping, config: RunnableConfig, forExecution: false, extra: NextTaskExtraFields): PregelTaskDescription | undefined;
-export declare function _prepareSingleTask<Nn extends StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel>>(taskPath: [string, string | number], checkpoint: ReadonlyCheckpoint, pendingWrites: [string, string, unknown][] | undefined, processes: Nn, channels: Cc, managed: ManagedValueMapping, config: RunnableConfig, forExecution: true, extra: NextTaskExtraFields): PregelExecutableTask<keyof Nn, keyof Cc> | undefined;
-export declare function _prepareSingleTask<Nn extends StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel>>(taskPath: [string, string | number], checkpoint: ReadonlyCheckpoint, pendingWrites: [string, string, unknown][] | undefined, processes: Nn, channels: Cc, managed: ManagedValueMapping, config: RunnableConfig, forExecution: boolean, extra: NextTaskExtraFieldsWithStore): PregelTaskDescription | PregelExecutableTask<keyof Nn, keyof Cc> | undefined;
+export declare function _prepareSingleTask<Nn extends StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel>>(taskPath: [string, ...(string | number)[]], checkpoint: ReadonlyCheckpoint, pendingWrites: [string, string, unknown][] | undefined, processes: Nn, channels: Cc, managed: ManagedValueMapping, config: RunnableConfig, forExecution: true, extra: NextTaskExtraFields): PregelExecutableTask<keyof Nn, keyof Cc> | undefined;
+export declare function _prepareSingleTask<Nn extends StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel>>(taskPath: [string, ...(string | number)[]], checkpoint: ReadonlyCheckpoint, pendingWrites: [string, string, unknown][] | undefined, processes: Nn, channels: Cc, managed: ManagedValueMapping, config: RunnableConfig, forExecution: boolean, extra: NextTaskExtraFieldsWithStore): PregelTaskDescription | PregelExecutableTask<keyof Nn, keyof Cc> | undefined;

package/dist/pregel/algo.js

@@ -93,6 +93,21 @@ const IGNORE = new Set([PUSH, RESUME, INTERRUPT]);
 export function _applyWrites(checkpoint, channels, tasks, 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 getNextVersion) {
+    // Sort tasks by first 3 path elements for deterministic order
+    // Later path parts (like task IDs) are ignored for sorting
+    tasks.sort((a, b) => {
+        const aPath = a.path?.slice(0, 3) || [];
+        const bPath = b.path?.slice(0, 3) || [];
+        // Compare each path element
+        for (let i = 0; i < Math.min(aPath.length, bPath.length); i += 1) {
+            if (aPath[i] < bPath[i])
+                return -1;
+            if (aPath[i] > bPath[i])
+                return 1;
+        }
+        // If one path is shorter, it comes first
+        return aPath.length - bPath.length;
+    });
     // if no task has triggers this is applying writes from the null task only
     // so we don't do anything other than update the channels written to
     const bumpStep = tasks.some((task) => task.triggers.length > 0);
@@ -139,6 +154,7 @@ getNextVersion) {
                 // do nothing
             }
             else if (chan === TASKS) {
+                // TODO: remove branch in 1.0
                 checkpoint.pending_sends.push({
                     node: val.node,
                     args: val.args,
@@ -206,6 +222,11 @@ getNextVersion) {
     // Return managed values writes to be applied externally
     return pendingWritesByManaged;
 }
+/**
+ * Prepare the set of tasks that will make up the next Pregel step.
+ * This is the union of all PUSH tasks (Sends) and PULL tasks (nodes triggered
+ * by edges).
+ */
 export function _prepareNextTasks(checkpoint, pendingWrites, processes, channels, managed, config, forExecution, extra) {
     const tasks = {};
     // Consume pending packets
@@ -225,12 +246,18 @@ export function _prepareNextTasks(checkpoint, pendingWrites, processes, channels
     }
     return tasks;
 }
+/**
+ * Prepares a single task for the next Pregel step, given a task path, which
+ * uniquely identifies a PUSH or PULL task within the graph.
+ */
 export function _prepareSingleTask(taskPath, checkpoint, pendingWrites, processes, channels, managed, config, forExecution, extra) {
     const { step, checkpointer, manager } = extra;
     const configurable = config.configurable ?? {};
     const parentNamespace = configurable.checkpoint_ns ?? "";
     if (taskPath[0] === PUSH) {
-        const index = typeof taskPath[1] === "number" ? taskPath[1] : parseInt(taskPath[1], 10);
+        const index = typeof taskPath[1] === "number"
+            ? taskPath[1]
+            : parseInt(taskPath[1], 10);
         if (index >= checkpoint.pending_sends.length) {
             return undefined;
         }
@@ -293,6 +320,7 @@ export function _prepareSingleTask(taskPath, checkpoint, pendingWrites, processe
                                 name: packet.node,
                                 writes: writes,
                                 triggers,
+                                path: taskPath,
                             }, select_, fresh_),
                             [CONFIG_KEY_CHECKPOINTER]: checkpointer ?? configurable[CONFIG_KEY_CHECKPOINTER],
                             [CONFIG_KEY_CHECKPOINT_MAP]: {
@@ -310,6 +338,7 @@ export function _prepareSingleTask(taskPath, checkpoint, pendingWrites, processe
                     retry_policy: proc.retryPolicy,
                     id: taskId,
                     path: taskPath,
+                    writers: proc.getWriters(),
                 };
             }
         }
@@ -396,6 +425,7 @@ export function _prepareSingleTask(taskPath, checkpoint, pendingWrites, processe
                                     name,
                                     writes: writes,
                                     triggers,
+                                    path: taskPath,
                                 }, select_, fresh_),
                                 [CONFIG_KEY_CHECKPOINTER]: checkpointer ?? configurable[CONFIG_KEY_CHECKPOINTER],
                                 [CONFIG_KEY_CHECKPOINT_MAP]: {
@@ -413,6 +443,7 @@ export function _prepareSingleTask(taskPath, checkpoint, pendingWrites, processe
                         retry_policy: proc.retryPolicy,
                         id: taskId,
                         path: taskPath,
+                        writers: proc.getWriters(),
                     };
                 }
             }

package/dist/pregel/index.cjs

@@ -472,8 +472,13 @@ class Pregel extends runnables_1.Runnable {
         let checkpointConfig = (0, utils_js_1.patchConfigurable)(config, {
             checkpoint_ns: config.configurable?.checkpoint_ns ?? "",
         });
+        let checkpointMetadata = config.metadata ?? {};
         if (saved?.config.configurable) {
             checkpointConfig = (0, utils_js_1.patchConfigurable)(config, saved.config.configurable);
+            checkpointMetadata = {
+                ...saved.metadata,
+                ...checkpointMetadata,
+            };
         }
         // Find last node that updated the state, if not provided
         if (values == null && asNode === undefined) {
@@ -485,6 +490,54 @@ class Pregel extends runnables_1.Runnable {
             }, {});
             return (0, index_js_1.patchCheckpointMap)(nextConfig, saved ? saved.metadata : undefined);
         }
+        // update channels
+        const channels = (0, base_js_1.emptyChannels)(this.channels, checkpoint);
+        // Pass `skipManaged: true` as managed values are not used/relevant in update state calls.
+        const { managed } = await this.prepareSpecs(config, { skipManaged: true });
+        if (values === null && asNode === "__end__") {
+            if (saved) {
+                // tasks for this checkpoint
+                const nextTasks = (0, algo_js_1._prepareNextTasks)(checkpoint, saved.pendingWrites || [], this.nodes, channels, managed, saved.config, true, {
+                    step: (saved.metadata?.step ?? -1) + 1,
+                    checkpointer: this.checkpointer || undefined,
+                    store: this.store,
+                });
+                // apply null writes
+                const nullWrites = (saved.pendingWrites || [])
+                    .filter((w) => w[0] === constants_js_1.NULL_TASK_ID)
+                    .flatMap((w) => w.slice(1));
+                if (nullWrites.length > 0) {
+                    (0, algo_js_1._applyWrites)(saved.checkpoint, channels, [
+                        {
+                            name: constants_js_1.INPUT,
+                            writes: nullWrites,
+                            triggers: [],
+                        },
+                    ]);
+                }
+                // apply writes from tasks that already ran
+                for (const [taskId, k, v] of saved.pendingWrites || []) {
+                    if ([constants_js_1.ERROR, constants_js_1.INTERRUPT, langgraph_checkpoint_1.SCHEDULED].includes(k)) {
+                        continue;
+                    }
+                    if (!(taskId in nextTasks)) {
+                        continue;
+                    }
+                    nextTasks[taskId].writes.push([k, v]);
+                }
+                // clear all current tasks
+                (0, algo_js_1._applyWrites)(checkpoint, channels, Object.values(nextTasks));
+            }
+            // save checkpoint
+            const nextConfig = await checkpointer.put(checkpointConfig, (0, base_js_1.createCheckpoint)(checkpoint, undefined, step), {
+                ...checkpointMetadata,
+                source: "update",
+                step: step + 1,
+                writes: {},
+                parents: saved?.metadata?.parents ?? {},
+            }, {});
+            return (0, index_js_1.patchCheckpointMap)(nextConfig, saved ? saved.metadata : undefined);
+        }
         if (values == null && asNode === "__copy__") {
             const nextConfig = await checkpointer.put(saved?.parentConfig ?? checkpointConfig, (0, base_js_1.createCheckpoint)(checkpoint, undefined, step), {
                 source: "fork",
@@ -534,10 +587,6 @@ class Pregel extends runnables_1.Runnable {
         if (this.nodes[asNode] === undefined) {
             throw new errors_js_1.InvalidUpdateError(`Node "${asNode.toString()}" does not exist`);
         }
-        // update channels
-        const channels = (0, base_js_1.emptyChannels)(this.channels, checkpoint);
-        // Pass `skipManaged: true` as managed values are not used/relevant in update state calls.
-        const { managed } = await this.prepareSpecs(config, { skipManaged: true });
         // run all writers of the chosen node
         const writers = this.nodes[asNode].getWriters();
         if (!writers.length) {
@@ -553,6 +602,7 @@ class Pregel extends runnables_1.Runnable {
             writes: [],
             triggers: [constants_js_1.INTERRUPT],
             id: (0, langgraph_checkpoint_1.uuid5)(constants_js_1.INTERRUPT, checkpoint.id),
+            writers: [],
         };
         // execute task
         await task.proc.invoke(task.input, (0, runnables_1.patchConfig)({
@@ -568,8 +618,15 @@ class Pregel extends runnables_1.Runnable {
             },
         }));
         // save task writes
-        if (saved !== undefined) {
-            await checkpointer.putWrites(checkpointConfig, task.writes, task.id);
+        // channel writes are saved to current checkpoint
+        // push writes are saved to next checkpoint
+        const [channelWrites, pushWrites] = [
+            task.writes.filter((w) => w[0] !== constants_js_1.PUSH),
+            task.writes.filter((w) => w[0] === constants_js_1.PUSH),
+        ];
+        // save task writes
+        if (saved !== undefined && channelWrites.length > 0) {
+            await checkpointer.putWrites(checkpointConfig, channelWrites, task.id);
         }
         // apply to checkpoint
         // TODO: Why does keyof StrRecord allow number and symbol?
@@ -581,6 +638,9 @@ class Pregel extends runnables_1.Runnable {
             writes: { [asNode]: values },
             parents: saved?.metadata?.parents ?? {},
         }, newVersions);
+        if (pushWrites.length > 0) {
+            await checkpointer.putWrites(nextConfig, pushWrites, task.id);
+        }
         return (0, index_js_1.patchCheckpointMap)(nextConfig, saved ? saved.metadata : undefined);
     }
     _defaults(config) {

package/dist/pregel/index.js

@@ -1,13 +1,13 @@
 /* eslint-disable no-param-reassign */
 import { Runnable, RunnableSequence, getCallbackManagerForConfig, mergeConfigs, patchConfig, _coerceToRunnable, } from "@langchain/core/runnables";
-import { compareChannelVersions, copyCheckpoint, emptyCheckpoint, uuid5, } from "@langchain/langgraph-checkpoint";
+import { compareChannelVersions, copyCheckpoint, emptyCheckpoint, SCHEDULED, uuid5, } from "@langchain/langgraph-checkpoint";
 import { createCheckpoint, emptyChannels, isBaseChannel, } from "../channels/base.js";
 import { PregelNode } from "./read.js";
 import { validateGraph, validateKeys } from "./validate.js";
 import { readChannels } from "./io.js";
 import { printStepCheckpoint, printStepTasks, printStepWrites, tasksWithWrites, } from "./debug.js";
 import { ChannelWrite, PASSTHROUGH } from "./write.js";
-import { CONFIG_KEY_CHECKPOINTER, CONFIG_KEY_READ, CONFIG_KEY_SEND, ERROR, INTERRUPT, CHECKPOINT_NAMESPACE_SEPARATOR, CHECKPOINT_NAMESPACE_END, CONFIG_KEY_STREAM, CONFIG_KEY_TASK_ID, } from "../constants.js";
+import { CONFIG_KEY_CHECKPOINTER, CONFIG_KEY_READ, CONFIG_KEY_SEND, ERROR, INTERRUPT, CHECKPOINT_NAMESPACE_SEPARATOR, CHECKPOINT_NAMESPACE_END, CONFIG_KEY_STREAM, CONFIG_KEY_TASK_ID, NULL_TASK_ID, INPUT, PUSH, } from "../constants.js";
 import { GraphRecursionError, GraphValueError, InvalidUpdateError, isGraphBubbleUp, isGraphInterrupt, } from "../errors.js";
 import { _prepareNextTasks, _localRead, _applyWrites, } from "./algo.js";
 import { _coerceToDict, getNewChannelVersions, patchCheckpointMap, } from "./utils/index.js";
@@ -468,8 +468,13 @@ export class Pregel extends Runnable {
         let checkpointConfig = patchConfigurable(config, {
             checkpoint_ns: config.configurable?.checkpoint_ns ?? "",
         });
+        let checkpointMetadata = config.metadata ?? {};
         if (saved?.config.configurable) {
             checkpointConfig = patchConfigurable(config, saved.config.configurable);
+            checkpointMetadata = {
+                ...saved.metadata,
+                ...checkpointMetadata,
+            };
         }
         // Find last node that updated the state, if not provided
         if (values == null && asNode === undefined) {
@@ -481,6 +486,54 @@ export class Pregel extends Runnable {
             }, {});
             return patchCheckpointMap(nextConfig, saved ? saved.metadata : undefined);
         }
+        // update channels
+        const channels = emptyChannels(this.channels, checkpoint);
+        // Pass `skipManaged: true` as managed values are not used/relevant in update state calls.
+        const { managed } = await this.prepareSpecs(config, { skipManaged: true });
+        if (values === null && asNode === "__end__") {
+            if (saved) {
+                // tasks for this checkpoint
+                const nextTasks = _prepareNextTasks(checkpoint, saved.pendingWrites || [], this.nodes, channels, managed, saved.config, true, {
+                    step: (saved.metadata?.step ?? -1) + 1,
+                    checkpointer: this.checkpointer || undefined,
+                    store: this.store,
+                });
+                // apply null writes
+                const nullWrites = (saved.pendingWrites || [])
+                    .filter((w) => w[0] === NULL_TASK_ID)
+                    .flatMap((w) => w.slice(1));
+                if (nullWrites.length > 0) {
+                    _applyWrites(saved.checkpoint, channels, [
+                        {
+                            name: INPUT,
+                            writes: nullWrites,
+                            triggers: [],
+                        },
+                    ]);
+                }
+                // apply writes from tasks that already ran
+                for (const [taskId, k, v] of saved.pendingWrites || []) {
+                    if ([ERROR, INTERRUPT, SCHEDULED].includes(k)) {
+                        continue;
+                    }
+                    if (!(taskId in nextTasks)) {
+                        continue;
+                    }
+                    nextTasks[taskId].writes.push([k, v]);
+                }
+                // clear all current tasks
+                _applyWrites(checkpoint, channels, Object.values(nextTasks));
+            }
+            // save checkpoint
+            const nextConfig = await checkpointer.put(checkpointConfig, createCheckpoint(checkpoint, undefined, step), {
+                ...checkpointMetadata,
+                source: "update",
+                step: step + 1,
+                writes: {},
+                parents: saved?.metadata?.parents ?? {},
+            }, {});
+            return patchCheckpointMap(nextConfig, saved ? saved.metadata : undefined);
+        }
         if (values == null && asNode === "__copy__") {
             const nextConfig = await checkpointer.put(saved?.parentConfig ?? checkpointConfig, createCheckpoint(checkpoint, undefined, step), {
                 source: "fork",
@@ -530,10 +583,6 @@ export class Pregel extends Runnable {
         if (this.nodes[asNode] === undefined) {
             throw new InvalidUpdateError(`Node "${asNode.toString()}" does not exist`);
         }
-        // update channels
-        const channels = emptyChannels(this.channels, checkpoint);
-        // Pass `skipManaged: true` as managed values are not used/relevant in update state calls.
-        const { managed } = await this.prepareSpecs(config, { skipManaged: true });
         // run all writers of the chosen node
         const writers = this.nodes[asNode].getWriters();
         if (!writers.length) {
@@ -549,6 +598,7 @@ export class Pregel extends Runnable {
             writes: [],
             triggers: [INTERRUPT],
             id: uuid5(INTERRUPT, checkpoint.id),
+            writers: [],
         };
         // execute task
         await task.proc.invoke(task.input, patchConfig({
@@ -564,8 +614,15 @@ export class Pregel extends Runnable {
             },
         }));
         // save task writes
-        if (saved !== undefined) {
-            await checkpointer.putWrites(checkpointConfig, task.writes, task.id);
+        // channel writes are saved to current checkpoint
+        // push writes are saved to next checkpoint
+        const [channelWrites, pushWrites] = [
+            task.writes.filter((w) => w[0] !== PUSH),
+            task.writes.filter((w) => w[0] === PUSH),
+        ];
+        // save task writes
+        if (saved !== undefined && channelWrites.length > 0) {
+            await checkpointer.putWrites(checkpointConfig, channelWrites, task.id);
         }
         // apply to checkpoint
         // TODO: Why does keyof StrRecord allow number and symbol?
@@ -577,6 +634,9 @@ export class Pregel extends Runnable {
             writes: { [asNode]: values },
             parents: saved?.metadata?.parents ?? {},
         }, newVersions);
+        if (pushWrites.length > 0) {
+            await checkpointer.putWrites(nextConfig, pushWrites, task.id);
+        }
         return patchCheckpointMap(nextConfig, saved ? saved.metadata : undefined);
     }
     _defaults(config) {

package/dist/pregel/io.cjs

@@ -46,7 +46,34 @@ function readChannels(channels, select, skipEmpty = true
     }
 }
 exports.readChannels = readChannels;
+/**
+ * Map input chunk to a sequence of pending writes in the form (channel, value).
+ */
 function* mapCommand(cmd) {
+    if (cmd.graph === constants_js_1.Command.PARENT) {
+        throw new errors_js_1.InvalidUpdateError("There is no parent graph.");
+    }
+    if (cmd.goto) {
+        let sends;
+        if (Array.isArray(cmd.goto)) {
+            sends = cmd.goto;
+        }
+        else {
+            sends = [cmd.goto];
+        }
+        for (const send of sends) {
+            if ((0, constants_js_1._isSend)(send)) {
+                yield [constants_js_1.NULL_TASK_ID, constants_js_1.TASKS, send];
+            }
+            else if (typeof send === "string") {
+                yield [constants_js_1.NULL_TASK_ID, `branch:__start__:${constants_js_1.SELF}:${send}`, "__start__"];
+            }
+            else {
+                throw new Error(`In Command.send, expected Send or string, got ${typeof send}`);
+            }
+        }
+        // TODO: handle goto str for state graph
+    }
     if (cmd.resume) {
         if (typeof cmd.resume === "object" &&
             !!cmd.resume &&
@@ -60,6 +87,14 @@ function* mapCommand(cmd) {
             yield [constants_js_1.NULL_TASK_ID, constants_js_1.RESUME, cmd.resume];
         }
     }
+    if (cmd.update) {
+        if (typeof cmd.update !== "object" || !cmd.update) {
+            throw new Error("Expected cmd.update to be a dict mapping channel names to update values");
+        }
+        for (const [k, v] of Object.entries(cmd.update)) {
+            yield [constants_js_1.NULL_TASK_ID, k, v];
+        }
+    }
 }
 exports.mapCommand = mapCommand;
 /**

package/dist/pregel/io.d.ts

@@ -4,6 +4,9 @@ import type { PregelExecutableTask } from "./types.js";
 import { Command } from "../constants.js";
 export declare function readChannel<C extends PropertyKey>(channels: Record<C, BaseChannel>, chan: C, catchErrors?: boolean, returnException?: boolean): unknown | null;
 export declare function readChannels<C extends PropertyKey>(channels: Record<C, BaseChannel>, select: C | Array<C>, skipEmpty?: boolean): Record<string, any> | any;
+/**
+ * Map input chunk to a sequence of pending writes in the form (channel, value).
+ */
 export declare function mapCommand(cmd: Command): Generator<[string, string, unknown]>;
 /**
  * Map input chunk to a sequence of pending writes in the form [channel, value].

package/dist/pregel/io.js

@@ -1,6 +1,6 @@
 import { validate } from "uuid";
-import { NULL_TASK_ID, RESUME, TAG_HIDDEN } from "../constants.js";
-import { EmptyChannelError } from "../errors.js";
+import { _isSend, Command, NULL_TASK_ID, RESUME, SELF, TAG_HIDDEN, TASKS, } from "../constants.js";
+import { EmptyChannelError, InvalidUpdateError } from "../errors.js";
 export function readChannel(channels, chan, catchErrors = true, returnException = false) {
     try {
         return channels[chan].get();
@@ -41,7 +41,34 @@ export function readChannels(channels, select, skipEmpty = true
         return readChannel(channels, select);
     }
 }
+/**
+ * Map input chunk to a sequence of pending writes in the form (channel, value).
+ */
 export function* mapCommand(cmd) {
+    if (cmd.graph === Command.PARENT) {
+        throw new InvalidUpdateError("There is no parent graph.");
+    }
+    if (cmd.goto) {
+        let sends;
+        if (Array.isArray(cmd.goto)) {
+            sends = cmd.goto;
+        }
+        else {
+            sends = [cmd.goto];
+        }
+        for (const send of sends) {
+            if (_isSend(send)) {
+                yield [NULL_TASK_ID, TASKS, send];
+            }
+            else if (typeof send === "string") {
+                yield [NULL_TASK_ID, `branch:__start__:${SELF}:${send}`, "__start__"];
+            }
+            else {
+                throw new Error(`In Command.send, expected Send or string, got ${typeof send}`);
+            }
+        }
+        // TODO: handle goto str for state graph
+    }
     if (cmd.resume) {
         if (typeof cmd.resume === "object" &&
             !!cmd.resume &&
@@ -55,6 +82,14 @@ export function* mapCommand(cmd) {
             yield [NULL_TASK_ID, RESUME, cmd.resume];
         }
     }
+    if (cmd.update) {
+        if (typeof cmd.update !== "object" || !cmd.update) {
+            throw new Error("Expected cmd.update to be a dict mapping channel names to update values");
+        }
+        for (const [k, v] of Object.entries(cmd.update)) {
+            yield [NULL_TASK_ID, k, v];
+        }
+    }
 }
 /**
  * Map input chunk to a sequence of pending writes in the form [channel, value].

package/dist/pregel/loop.cjs

@@ -576,22 +576,9 @@ class PregelLoop {
     async _first(inputKeys) {
         const isResuming = Object.keys(this.checkpoint.channel_versions).length !== 0 &&
             (this.config.configurable?.[constants_js_1.CONFIG_KEY_RESUMING] !== undefined ||
-                this.input === null);
-        if (isResuming) {
-            for (const channelName of Object.keys(this.channels)) {
-                if (this.checkpoint.channel_versions[channelName] !== undefined) {
-                    const version = this.checkpoint.channel_versions[channelName];
-                    this.checkpoint.versions_seen[constants_js_1.INTERRUPT] = {
-                        ...this.checkpoint.versions_seen[constants_js_1.INTERRUPT],
-                        [channelName]: version,
-                    };
-                }
-            }
-            // produce values output
-            const valuesOutput = await (0, utils_js_1.gatherIterator)((0, utils_js_1.prefixGenerator)((0, io_js_1.mapOutputValues)(this.outputKeys, true, this.channels), "values"));
-            this._emit(valuesOutput);
-        }
-        else if ((0, constants_js_1._isCommand)(this.input)) {
+                this.input === null ||
+                (0, constants_js_1._isCommand)(this.input));
+        if ((0, constants_js_1._isCommand)(this.input)) {
             const writes = {};
             // group writes by task id
             for (const [tid, key, value] of (0, io_js_1.mapCommand)(this.input)) {
@@ -608,6 +595,20 @@ class PregelLoop {
                 this.putWrites(tid, ws);
             }
         }
+        if (isResuming) {
+            for (const channelName of Object.keys(this.channels)) {
+                if (this.checkpoint.channel_versions[channelName] !== undefined) {
+                    const version = this.checkpoint.channel_versions[channelName];
+                    this.checkpoint.versions_seen[constants_js_1.INTERRUPT] = {
+                        ...this.checkpoint.versions_seen[constants_js_1.INTERRUPT],
+                        [channelName]: version,
+                    };
+                }
+            }
+            // produce values output
+            const valuesOutput = await (0, utils_js_1.gatherIterator)((0, utils_js_1.prefixGenerator)((0, io_js_1.mapOutputValues)(this.outputKeys, true, this.channels), "values"));
+            this._emit(valuesOutput);
+        }
         else {
             // map inputs to channel updates
             const inputWrites = await (0, utils_js_1.gatherIterator)((0, io_js_1.mapInput)(inputKeys, this.input));

package/dist/pregel/loop.js

@@ -572,22 +572,9 @@ export class PregelLoop {
     async _first(inputKeys) {
         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) {
-                    const version = this.checkpoint.channel_versions[channelName];
-                    this.checkpoint.versions_seen[INTERRUPT] = {
-                        ...this.checkpoint.versions_seen[INTERRUPT],
-                        [channelName]: version,
-                    };
-                }
-            }
-            // produce values output
-            const valuesOutput = await gatherIterator(prefixGenerator(mapOutputValues(this.outputKeys, true, this.channels), "values"));
-            this._emit(valuesOutput);
-        }
-        else if (_isCommand(this.input)) {
+                this.input === null ||
+                _isCommand(this.input));
+        if (_isCommand(this.input)) {
             const writes = {};
             // group writes by task id
             for (const [tid, key, value] of mapCommand(this.input)) {
@@ -604,6 +591,20 @@ export class PregelLoop {
                 this.putWrites(tid, ws);
             }
         }
+        if (isResuming) {
+            for (const channelName of Object.keys(this.channels)) {
+                if (this.checkpoint.channel_versions[channelName] !== undefined) {
+                    const version = this.checkpoint.channel_versions[channelName];
+                    this.checkpoint.versions_seen[INTERRUPT] = {
+                        ...this.checkpoint.versions_seen[INTERRUPT],
+                        [channelName]: version,
+                    };
+                }
+            }
+            // produce values output
+            const valuesOutput = await gatherIterator(prefixGenerator(mapOutputValues(this.outputKeys, true, this.channels), "values"));
+            this._emit(valuesOutput);
+        }
         else {
             // map inputs to channel updates
             const inputWrites = await gatherIterator(mapInput(inputKeys, this.input));