@langchain/langgraph 0.2.21 → 0.2.23

package/dist/constants.cjs

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._isSend = exports.Send = exports._isSendInterface = exports.CHECKPOINT_NAMESPACE_END = exports.CHECKPOINT_NAMESPACE_SEPARATOR = exports.RESERVED = exports.TASK_NAMESPACE = exports.PULL = exports.PUSH = exports.TASKS = exports.TAG_NOSTREAM = exports.TAG_HIDDEN = exports.RECURSION_LIMIT_DEFAULT = exports.RUNTIME_PLACEHOLDER = exports.INTERRUPT = exports.CONFIG_KEY_CHECKPOINT_MAP = exports.CONFIG_KEY_STREAM = exports.CONFIG_KEY_TASK_ID = exports.CONFIG_KEY_RESUMING = exports.CONFIG_KEY_CHECKPOINTER = exports.CONFIG_KEY_READ = exports.CONFIG_KEY_SEND = exports.ERROR = exports.INPUT = void 0;
+exports._isCommand = exports.Command = exports._isSend = exports.Send = exports._isSendInterface = exports.CHECKPOINT_NAMESPACE_END = exports.CHECKPOINT_NAMESPACE_SEPARATOR = exports.RESERVED = exports.NULL_TASK_ID = exports.TASK_NAMESPACE = exports.PULL = exports.PUSH = exports.TASKS = exports.TAG_NOSTREAM = exports.TAG_HIDDEN = exports.RECURSION_LIMIT_DEFAULT = exports.RUNTIME_PLACEHOLDER = exports.RESUME = exports.INTERRUPT = exports.CONFIG_KEY_CHECKPOINT_MAP = exports.CONFIG_KEY_RESUME_VALUE = exports.CONFIG_KEY_STREAM = exports.CONFIG_KEY_TASK_ID = exports.CONFIG_KEY_RESUMING = exports.CONFIG_KEY_CHECKPOINTER = exports.CONFIG_KEY_READ = exports.CONFIG_KEY_SEND = exports.ERROR = exports.INPUT = exports.MISSING = void 0;
+exports.MISSING = Symbol.for("__missing__");
 exports.INPUT = "__input__";
 exports.ERROR = "__error__";
 exports.CONFIG_KEY_SEND = "__pregel_send";
@@ -9,9 +10,11 @@ exports.CONFIG_KEY_CHECKPOINTER = "__pregel_checkpointer";
 exports.CONFIG_KEY_RESUMING = "__pregel_resuming";
 exports.CONFIG_KEY_TASK_ID = "__pregel_task_id";
 exports.CONFIG_KEY_STREAM = "__pregel_stream";
+exports.CONFIG_KEY_RESUME_VALUE = "__pregel_resume_value";
 // this one is part of public API
 exports.CONFIG_KEY_CHECKPOINT_MAP = "checkpoint_map";
 exports.INTERRUPT = "__interrupt__";
+exports.RESUME = "__resume__";
 exports.RUNTIME_PLACEHOLDER = "__pregel_runtime_placeholder__";
 exports.RECURSION_LIMIT_DEFAULT = 25;
 exports.TAG_HIDDEN = "langsmith:hidden";
@@ -20,8 +23,10 @@ exports.TASKS = "__pregel_tasks";
 exports.PUSH = "__pregel_push";
 exports.PULL = "__pregel_pull";
 exports.TASK_NAMESPACE = "6ba7b831-9dad-11d1-80b4-00c04fd430c8";
+exports.NULL_TASK_ID = "00000000-0000-0000-0000-000000000000";
 exports.RESERVED = [
     exports.INTERRUPT,
+    exports.RESUME,
     exports.ERROR,
     exports.TASKS,
     exports.CONFIG_KEY_SEND,
@@ -115,3 +120,25 @@ function _isSend(x) {
     return operation.lg_name === "Send";
 }
 exports._isSend = _isSend;
+class Command {
+    constructor(args) {
+        Object.defineProperty(this, "lg_name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "Command"
+        });
+        Object.defineProperty(this, "resume", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.resume = args.resume;
+    }
+}
+exports.Command = Command;
+function _isCommand(x) {
+    return typeof x === "object" && !!x && x.lg_name === "Command";
+}
+exports._isCommand = _isCommand;

package/dist/constants.d.ts

@@ -1,3 +1,4 @@
+export declare const MISSING: unique symbol;
 export declare const INPUT = "__input__";
 export declare const ERROR = "__error__";
 export declare const CONFIG_KEY_SEND = "__pregel_send";
@@ -6,8 +7,10 @@ export declare const CONFIG_KEY_CHECKPOINTER = "__pregel_checkpointer";
 export declare const CONFIG_KEY_RESUMING = "__pregel_resuming";
 export declare const CONFIG_KEY_TASK_ID = "__pregel_task_id";
 export declare const CONFIG_KEY_STREAM = "__pregel_stream";
+export declare const CONFIG_KEY_RESUME_VALUE = "__pregel_resume_value";
 export declare const CONFIG_KEY_CHECKPOINT_MAP = "checkpoint_map";
 export declare const INTERRUPT = "__interrupt__";
+export declare const RESUME = "__resume__";
 export declare const RUNTIME_PLACEHOLDER = "__pregel_runtime_placeholder__";
 export declare const RECURSION_LIMIT_DEFAULT = 25;
 export declare const TAG_HIDDEN = "langsmith:hidden";
@@ -16,6 +19,7 @@ export declare const TASKS = "__pregel_tasks";
 export declare const PUSH = "__pregel_push";
 export declare const PULL = "__pregel_pull";
 export declare const TASK_NAMESPACE = "6ba7b831-9dad-11d1-80b4-00c04fd430c8";
+export declare const NULL_TASK_ID = "00000000-0000-0000-0000-000000000000";
 export declare const RESERVED: string[];
 export declare const CHECKPOINT_NAMESPACE_SEPARATOR = "|";
 export declare const CHECKPOINT_NAMESPACE_END = ":";
@@ -81,3 +85,11 @@ export type Interrupt = {
     value: any;
     when: "during";
 };
+export declare class Command<R = unknown> {
+    lg_name: string;
+    resume: R;
+    constructor(args: {
+        resume: R;
+    });
+}
+export declare function _isCommand(x: unknown): x is Command;

package/dist/constants.js

@@ -1,3 +1,4 @@
+export const MISSING = Symbol.for("__missing__");
 export const INPUT = "__input__";
 export const ERROR = "__error__";
 export const CONFIG_KEY_SEND = "__pregel_send";
@@ -6,9 +7,11 @@ export const CONFIG_KEY_CHECKPOINTER = "__pregel_checkpointer";
 export const CONFIG_KEY_RESUMING = "__pregel_resuming";
 export const CONFIG_KEY_TASK_ID = "__pregel_task_id";
 export const CONFIG_KEY_STREAM = "__pregel_stream";
+export const CONFIG_KEY_RESUME_VALUE = "__pregel_resume_value";
 // this one is part of public API
 export const CONFIG_KEY_CHECKPOINT_MAP = "checkpoint_map";
 export const INTERRUPT = "__interrupt__";
+export const RESUME = "__resume__";
 export const RUNTIME_PLACEHOLDER = "__pregel_runtime_placeholder__";
 export const RECURSION_LIMIT_DEFAULT = 25;
 export const TAG_HIDDEN = "langsmith:hidden";
@@ -17,8 +20,10 @@ export const TASKS = "__pregel_tasks";
 export const PUSH = "__pregel_push";
 export const PULL = "__pregel_pull";
 export const TASK_NAMESPACE = "6ba7b831-9dad-11d1-80b4-00c04fd430c8";
+export const NULL_TASK_ID = "00000000-0000-0000-0000-000000000000";
 export const RESERVED = [
     INTERRUPT,
+    RESUME,
     ERROR,
     TASKS,
     CONFIG_KEY_SEND,
@@ -109,3 +114,23 @@ export function _isSend(x) {
     const operation = x;
     return operation.lg_name === "Send";
 }
+export class Command {
+    constructor(args) {
+        Object.defineProperty(this, "lg_name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "Command"
+        });
+        Object.defineProperty(this, "resume", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.resume = args.resume;
+    }
+}
+export function _isCommand(x) {
+    return typeof x === "object" && !!x && x.lg_name === "Command";
+}

package/dist/errors.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSubgraphsSeenSet = exports.RemoteException = exports.MultipleSubgraphsError = exports.InvalidUpdateError = exports.EmptyChannelError = exports.EmptyInputError = exports.isGraphInterrupt = exports.NodeInterrupt = exports.GraphInterrupt = exports.GraphValueError = exports.GraphRecursionError = exports.BaseLangGraphError = void 0;
+exports.getSubgraphsSeenSet = exports.RemoteException = exports.MultipleSubgraphsError = exports.InvalidUpdateError = exports.EmptyChannelError = exports.EmptyInputError = exports.isGraphInterrupt = exports.isGraphBubbleUp = exports.NodeInterrupt = exports.GraphInterrupt = exports.GraphValueError = exports.GraphRecursionError = exports.GraphBubbleUp = exports.BaseLangGraphError = void 0;
 // TODO: Merge with base LangChain error class when we drop support for core@0.2.0
 class BaseLangGraphError extends Error {
     constructor(message, fields) {
@@ -19,6 +19,12 @@ class BaseLangGraphError extends Error {
     }
 }
 exports.BaseLangGraphError = BaseLangGraphError;
+class GraphBubbleUp extends BaseLangGraphError {
+    get is_bubble_up() {
+        return true;
+    }
+}
+exports.GraphBubbleUp = GraphBubbleUp;
 class GraphRecursionError extends BaseLangGraphError {
     constructor(message, fields) {
         super(message, fields);
@@ -39,7 +45,7 @@ class GraphValueError extends BaseLangGraphError {
     }
 }
 exports.GraphValueError = GraphValueError;
-class GraphInterrupt extends BaseLangGraphError {
+class GraphInterrupt extends GraphBubbleUp {
     constructor(interrupts, fields) {
         super(JSON.stringify(interrupts, null, 2), fields);
         Object.defineProperty(this, "interrupts", {
@@ -72,6 +78,10 @@ class NodeInterrupt extends GraphInterrupt {
     }
 }
 exports.NodeInterrupt = NodeInterrupt;
+function isGraphBubbleUp(e) {
+    return e !== undefined && e.is_bubble_up === true;
+}
+exports.isGraphBubbleUp = isGraphBubbleUp;
 function isGraphInterrupt(e) {
     return (e !== undefined &&
         [

package/dist/errors.d.ts

@@ -6,6 +6,9 @@ export declare class BaseLangGraphError extends Error {
     lc_error_code?: string;
     constructor(message?: string, fields?: BaseLangGraphErrorFields);
 }
+export declare class GraphBubbleUp extends BaseLangGraphError {
+    get is_bubble_up(): boolean;
+}
 export declare class GraphRecursionError extends BaseLangGraphError {
     constructor(message?: string, fields?: BaseLangGraphErrorFields);
     static get unminifiable_name(): string;
@@ -14,7 +17,7 @@ export declare class GraphValueError extends BaseLangGraphError {
     constructor(message?: string, fields?: BaseLangGraphErrorFields);
     static get unminifiable_name(): string;
 }
-export declare class GraphInterrupt extends BaseLangGraphError {
+export declare class GraphInterrupt extends GraphBubbleUp {
     interrupts: Interrupt[];
     constructor(interrupts?: Interrupt[], fields?: BaseLangGraphErrorFields);
     static get unminifiable_name(): string;
@@ -24,6 +27,7 @@ export declare class NodeInterrupt extends GraphInterrupt {
     constructor(message: string, fields?: BaseLangGraphErrorFields);
     static get unminifiable_name(): string;
 }
+export declare function isGraphBubbleUp(e?: Error): e is GraphBubbleUp;
 export declare function isGraphInterrupt(e?: GraphInterrupt | Error): e is GraphInterrupt;
 export declare class EmptyInputError extends BaseLangGraphError {
     constructor(message?: string, fields?: BaseLangGraphErrorFields);

package/dist/errors.js

@@ -15,6 +15,11 @@ export class BaseLangGraphError extends Error {
         this.lc_error_code = fields?.lc_error_code;
     }
 }
+export class GraphBubbleUp extends BaseLangGraphError {
+    get is_bubble_up() {
+        return true;
+    }
+}
 export class GraphRecursionError extends BaseLangGraphError {
     constructor(message, fields) {
         super(message, fields);
@@ -33,7 +38,7 @@ export class GraphValueError extends BaseLangGraphError {
         return "GraphValueError";
     }
 }
-export class GraphInterrupt extends BaseLangGraphError {
+export class GraphInterrupt extends GraphBubbleUp {
     constructor(interrupts, fields) {
         super(JSON.stringify(interrupts, null, 2), fields);
         Object.defineProperty(this, "interrupts", {
@@ -64,6 +69,9 @@ export class NodeInterrupt extends GraphInterrupt {
         return "NodeInterrupt";
     }
 }
+export function isGraphBubbleUp(e) {
+    return e !== undefined && e.is_bubble_up === true;
+}
 export function isGraphInterrupt(e) {
     return (e !== undefined &&
         [

package/dist/interrupt.cjs

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interrupt = void 0;
+const singletons_1 = require("@langchain/core/singletons");
+const errors_js_1 = require("./errors.cjs");
+const constants_js_1 = require("./constants.cjs");
+function interrupt(value) {
+    const config = singletons_1.AsyncLocalStorageProviderSingleton.getRunnableConfig();
+    if (!config) {
+        throw new Error("Called interrupt() outside the context of a graph.");
+    }
+    const resume = config.configurable?.[constants_js_1.CONFIG_KEY_RESUME_VALUE];
+    if (resume !== constants_js_1.MISSING) {
+        return resume;
+    }
+    else {
+        throw new errors_js_1.GraphInterrupt([{ value, when: "during" }]);
+    }
+}
+exports.interrupt = interrupt;

package/dist/interrupt.d.ts

@@ -0,0 +1 @@
+export declare function interrupt<I = unknown, R = unknown>(value: I): R;

package/dist/interrupt.js

@@ -0,0 +1,16 @@
+import { AsyncLocalStorageProviderSingleton } from "@langchain/core/singletons";
+import { GraphInterrupt } from "./errors.js";
+import { CONFIG_KEY_RESUME_VALUE, MISSING } from "./constants.js";
+export function interrupt(value) {
+    const config = AsyncLocalStorageProviderSingleton.getRunnableConfig();
+    if (!config) {
+        throw new Error("Called interrupt() outside the context of a graph.");
+    }
+    const resume = config.configurable?.[CONFIG_KEY_RESUME_VALUE];
+    if (resume !== MISSING) {
+        return resume;
+    }
+    else {
+        throw new GraphInterrupt([{ value, when: "during" }]);
+    }
+}

package/dist/pregel/algo.cjs

@@ -96,9 +96,13 @@ writes) {
     commit(writes);
 }
 exports._localWrite = _localWrite;
+const IGNORE = new Set([constants_js_1.PUSH, constants_js_1.RESUME, constants_js_1.INTERRUPT]);
 function _applyWrites(checkpoint, channels, tasks, 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 getNextVersion) {
+    // 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);
     // Filter out non instances of BaseChannel
     const onlyChannels = Object.fromEntries(Object.entries(channels).filter(([_, value]) => (0, base_js_1.isBaseChannel)(value)));
     // Update seen versions
@@ -130,7 +134,7 @@ getNextVersion) {
         }
     }
     // Clear pending sends
-    if (checkpoint.pending_sends) {
+    if (checkpoint.pending_sends?.length && bumpStep) {
         checkpoint.pending_sends = [];
     }
     // Group writes by channel
@@ -138,7 +142,10 @@ getNextVersion) {
     const pendingWritesByManaged = {};
     for (const task of tasks) {
         for (const [chan, val] of task.writes) {
-            if (chan === constants_js_1.TASKS) {
+            if (IGNORE.has(chan)) {
+                // do nothing
+            }
+            else if (chan === constants_js_1.TASKS) {
                 checkpoint.pending_sends.push({
                     node: val.node,
                     args: val.args,
@@ -193,11 +200,13 @@ getNextVersion) {
         }
     }
     // Channels that weren't updated in this step are notified of a new step
-    for (const chan of Object.keys(onlyChannels)) {
-        if (!updatedChannels.has(chan)) {
-            const updated = onlyChannels[chan].update([]);
-            if (updated && getNextVersion !== undefined) {
-                checkpoint.channel_versions[chan] = getNextVersion(maxVersion, onlyChannels[chan]);
+    if (bumpStep) {
+        for (const chan of Object.keys(onlyChannels)) {
+            if (!updatedChannels.has(chan)) {
+                const updated = onlyChannels[chan].update([]);
+                if (updated && getNextVersion !== undefined) {
+                    checkpoint.channel_versions[chan] = getNextVersion(maxVersion, onlyChannels[chan]);
+                }
             }
         }
     }
@@ -205,11 +214,11 @@ getNextVersion) {
     return pendingWritesByManaged;
 }
 exports._applyWrites = _applyWrites;
-function _prepareNextTasks(checkpoint, processes, channels, managed, config, forExecution, extra) {
+function _prepareNextTasks(checkpoint, pendingWrites, processes, channels, managed, config, forExecution, extra) {
     const tasks = {};
     // Consume pending packets
     for (let i = 0; i < checkpoint.pending_sends.length; i += 1) {
-        const task = _prepareSingleTask([constants_js_1.PUSH, i], checkpoint, processes, channels, managed, config, forExecution, extra);
+        const task = _prepareSingleTask([constants_js_1.PUSH, i], checkpoint, pendingWrites, processes, channels, managed, config, forExecution, extra);
         if (task !== undefined) {
             tasks[task.id] = task;
         }
@@ -217,7 +226,7 @@ function _prepareNextTasks(checkpoint, processes, channels, managed, config, for
     // Check if any processes should be run in next step
     // If so, prepare the values to be passed to them
     for (const name of Object.keys(processes)) {
-        const task = _prepareSingleTask([constants_js_1.PULL, name], checkpoint, processes, channels, managed, config, forExecution, extra);
+        const task = _prepareSingleTask([constants_js_1.PULL, name], checkpoint, pendingWrites, processes, channels, managed, config, forExecution, extra);
         if (task !== undefined) {
             tasks[task.id] = task;
         }
@@ -225,7 +234,7 @@ function _prepareNextTasks(checkpoint, processes, channels, managed, config, for
     return tasks;
 }
 exports._prepareNextTasks = _prepareNextTasks;
-function _prepareSingleTask(taskPath, checkpoint, processes, channels, managed, config, forExecution, extra) {
+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 ?? "";
@@ -271,6 +280,7 @@ function _prepareSingleTask(taskPath, checkpoint, processes, channels, managed,
                     metadata = { ...metadata, ...proc.metadata };
                 }
                 const writes = [];
+                const resume = pendingWrites?.find((w) => [taskId, constants_js_1.NULL_TASK_ID].includes(w[0]) && w[1] === constants_js_1.RESUME);
                 return {
                     name: packet.node,
                     input: packet.args,
@@ -298,6 +308,7 @@ function _prepareSingleTask(taskPath, checkpoint, processes, channels, managed,
                                 ...configurable[constants_js_1.CONFIG_KEY_CHECKPOINT_MAP],
                                 [parentNamespace]: checkpoint.id,
                             },
+                            [constants_js_1.CONFIG_KEY_RESUME_VALUE]: resume ? resume[2] : constants_js_1.MISSING,
                             checkpoint_id: undefined,
                             checkpoint_ns: taskCheckpointNamespace,
                         },
@@ -367,6 +378,7 @@ function _prepareSingleTask(taskPath, checkpoint, processes, channels, managed,
                         metadata = { ...metadata, ...proc.metadata };
                     }
                     const writes = [];
+                    const resume = pendingWrites?.find((w) => [taskId, constants_js_1.NULL_TASK_ID].includes(w[0]) && w[1] === constants_js_1.RESUME);
                     const taskCheckpointNamespace = `${checkpointNamespace}${constants_js_1.CHECKPOINT_NAMESPACE_END}${taskId}`;
                     return {
                         name,
@@ -397,6 +409,7 @@ function _prepareSingleTask(taskPath, checkpoint, processes, channels, managed,
                                     ...configurable[constants_js_1.CONFIG_KEY_CHECKPOINT_MAP],
                                     [parentNamespace]: checkpoint.id,
                                 },
+                                [constants_js_1.CONFIG_KEY_RESUME_VALUE]: resume ? resume[2] : constants_js_1.MISSING,
                                 checkpoint_id: undefined,
                                 checkpoint_ns: taskCheckpointNamespace,
                             },

package/dist/pregel/algo.d.ts

@@ -34,8 +34,8 @@ export type NextTaskExtraFieldsWithStore = NextTaskExtraFields & {
 export type NextTaskExtraFieldsWithoutStore = NextTaskExtraFields & {
     store?: never;
 };
-export declare function _prepareNextTasks<Nn extends StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel>>(checkpoint: ReadonlyCheckpoint, 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, 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, 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, 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, processes: Nn, channels: Cc, managed: ManagedValueMapping, config: RunnableConfig, forExecution: boolean, extra: NextTaskExtraFieldsWithStore): PregelTaskDescription | PregelExecutableTask<keyof Nn, keyof Cc> | undefined;
+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;

package/dist/pregel/algo.js

@@ -3,7 +3,7 @@ import { mergeConfigs, patchConfig, } from "@langchain/core/runnables";
 import { copyCheckpoint, uuid5, maxChannelVersion, } from "@langchain/langgraph-checkpoint";
 import { createCheckpoint, emptyChannels, isBaseChannel, } from "../channels/base.js";
 import { readChannel, readChannels } from "./io.js";
-import { _isSend, _isSendInterface, CONFIG_KEY_CHECKPOINT_MAP, CHECKPOINT_NAMESPACE_SEPARATOR, CONFIG_KEY_CHECKPOINTER, CONFIG_KEY_READ, CONFIG_KEY_TASK_ID, CONFIG_KEY_SEND, INTERRUPT, RESERVED, TAG_HIDDEN, TASKS, CHECKPOINT_NAMESPACE_END, PUSH, PULL, } from "../constants.js";
+import { _isSend, _isSendInterface, CONFIG_KEY_CHECKPOINT_MAP, CHECKPOINT_NAMESPACE_SEPARATOR, CONFIG_KEY_CHECKPOINTER, CONFIG_KEY_READ, CONFIG_KEY_TASK_ID, CONFIG_KEY_SEND, INTERRUPT, RESERVED, TAG_HIDDEN, TASKS, CHECKPOINT_NAMESPACE_END, PUSH, PULL, RESUME, CONFIG_KEY_RESUME_VALUE, NULL_TASK_ID, MISSING, } from "../constants.js";
 import { EmptyChannelError, InvalidUpdateError } from "../errors.js";
 import { getNullChannelVersion } from "./utils/index.js";
 export const increment = (current) => {
@@ -89,9 +89,13 @@ writes) {
     }
     commit(writes);
 }
+const IGNORE = new Set([PUSH, RESUME, INTERRUPT]);
 export function _applyWrites(checkpoint, channels, tasks, 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 getNextVersion) {
+    // 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);
     // Filter out non instances of BaseChannel
     const onlyChannels = Object.fromEntries(Object.entries(channels).filter(([_, value]) => isBaseChannel(value)));
     // Update seen versions
@@ -123,7 +127,7 @@ getNextVersion) {
         }
     }
     // Clear pending sends
-    if (checkpoint.pending_sends) {
+    if (checkpoint.pending_sends?.length && bumpStep) {
         checkpoint.pending_sends = [];
     }
     // Group writes by channel
@@ -131,7 +135,10 @@ getNextVersion) {
     const pendingWritesByManaged = {};
     for (const task of tasks) {
         for (const [chan, val] of task.writes) {
-            if (chan === TASKS) {
+            if (IGNORE.has(chan)) {
+                // do nothing
+            }
+            else if (chan === TASKS) {
                 checkpoint.pending_sends.push({
                     node: val.node,
                     args: val.args,
@@ -186,22 +193,24 @@ getNextVersion) {
         }
     }
     // Channels that weren't updated in this step are notified of a new step
-    for (const chan of Object.keys(onlyChannels)) {
-        if (!updatedChannels.has(chan)) {
-            const updated = onlyChannels[chan].update([]);
-            if (updated && getNextVersion !== undefined) {
-                checkpoint.channel_versions[chan] = getNextVersion(maxVersion, onlyChannels[chan]);
+    if (bumpStep) {
+        for (const chan of Object.keys(onlyChannels)) {
+            if (!updatedChannels.has(chan)) {
+                const updated = onlyChannels[chan].update([]);
+                if (updated && getNextVersion !== undefined) {
+                    checkpoint.channel_versions[chan] = getNextVersion(maxVersion, onlyChannels[chan]);
+                }
             }
         }
     }
     // Return managed values writes to be applied externally
     return pendingWritesByManaged;
 }
-export function _prepareNextTasks(checkpoint, processes, channels, managed, config, forExecution, extra) {
+export function _prepareNextTasks(checkpoint, pendingWrites, processes, channels, managed, config, forExecution, extra) {
     const tasks = {};
     // Consume pending packets
     for (let i = 0; i < checkpoint.pending_sends.length; i += 1) {
-        const task = _prepareSingleTask([PUSH, i], checkpoint, processes, channels, managed, config, forExecution, extra);
+        const task = _prepareSingleTask([PUSH, i], checkpoint, pendingWrites, processes, channels, managed, config, forExecution, extra);
         if (task !== undefined) {
             tasks[task.id] = task;
         }
@@ -209,14 +218,14 @@ export function _prepareNextTasks(checkpoint, processes, channels, managed, conf
     // Check if any processes should be run in next step
     // If so, prepare the values to be passed to them
     for (const name of Object.keys(processes)) {
-        const task = _prepareSingleTask([PULL, name], checkpoint, processes, channels, managed, config, forExecution, extra);
+        const task = _prepareSingleTask([PULL, name], checkpoint, pendingWrites, processes, channels, managed, config, forExecution, extra);
         if (task !== undefined) {
             tasks[task.id] = task;
         }
     }
     return tasks;
 }
-export function _prepareSingleTask(taskPath, checkpoint, processes, channels, managed, config, forExecution, extra) {
+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 ?? "";
@@ -262,6 +271,7 @@ export function _prepareSingleTask(taskPath, checkpoint, processes, channels, ma
                     metadata = { ...metadata, ...proc.metadata };
                 }
                 const writes = [];
+                const resume = pendingWrites?.find((w) => [taskId, NULL_TASK_ID].includes(w[0]) && w[1] === RESUME);
                 return {
                     name: packet.node,
                     input: packet.args,
@@ -289,6 +299,7 @@ export function _prepareSingleTask(taskPath, checkpoint, processes, channels, ma
                                 ...configurable[CONFIG_KEY_CHECKPOINT_MAP],
                                 [parentNamespace]: checkpoint.id,
                             },
+                            [CONFIG_KEY_RESUME_VALUE]: resume ? resume[2] : MISSING,
                             checkpoint_id: undefined,
                             checkpoint_ns: taskCheckpointNamespace,
                         },
@@ -358,6 +369,7 @@ export function _prepareSingleTask(taskPath, checkpoint, processes, channels, ma
                         metadata = { ...metadata, ...proc.metadata };
                     }
                     const writes = [];
+                    const resume = pendingWrites?.find((w) => [taskId, NULL_TASK_ID].includes(w[0]) && w[1] === RESUME);
                     const taskCheckpointNamespace = `${checkpointNamespace}${CHECKPOINT_NAMESPACE_END}${taskId}`;
                     return {
                         name,
@@ -388,6 +400,7 @@ export function _prepareSingleTask(taskPath, checkpoint, processes, channels, ma
                                     ...configurable[CONFIG_KEY_CHECKPOINT_MAP],
                                     [parentNamespace]: checkpoint.id,
                                 },
+                                [CONFIG_KEY_RESUME_VALUE]: resume ? resume[2] : MISSING,
                                 checkpoint_id: undefined,
                                 checkpoint_ns: taskCheckpointNamespace,
                             },

package/dist/pregel/index.cjs

@@ -307,7 +307,7 @@ class Pregel extends runnables_1.Runnable {
         // Pass `skipManaged: true` as managed values should not be returned in get state calls.
         const { managed } = await this.prepareSpecs(config, { skipManaged: true });
         const channels = (0, base_js_1.emptyChannels)(this.channels, saved.checkpoint);
-        const nextTasks = Object.values((0, algo_js_1._prepareNextTasks)(saved.checkpoint, this.nodes, channels, managed, saved.config, false, { step: (saved.metadata?.step ?? -1) + 1 }));
+        const nextTasks = Object.values((0, algo_js_1._prepareNextTasks)(saved.checkpoint, saved.pendingWrites, this.nodes, channels, managed, saved.config, false, { step: (saved.metadata?.step ?? -1) + 1 }));
         const subgraphs = await (0, utils_js_1.gatherIterator)(this.getSubgraphsAsync());
         const parentNamespace = saved.config.configurable?.checkpoint_ns ?? "";
         const taskStates = {};
@@ -472,14 +472,23 @@ class Pregel extends runnables_1.Runnable {
         let checkpointConfig = (0, utils_js_1.patchConfigurable)(config, {
             checkpoint_ns: config.configurable?.checkpoint_ns ?? "",
         });
-        if (saved) {
+        if (saved?.config.configurable) {
             checkpointConfig = (0, utils_js_1.patchConfigurable)(config, saved.config.configurable);
         }
         // Find last node that updated the state, if not provided
         if (values == null && asNode === undefined) {
             const nextConfig = await checkpointer.put(checkpointConfig, (0, base_js_1.createCheckpoint)(checkpoint, undefined, step), {
                 source: "update",
-                step,
+                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",
+                step: step + 1,
                 writes: {},
                 parents: saved?.metadata?.parents ?? {},
             }, {});
@@ -789,11 +798,11 @@ class Pregel extends runnables_1.Runnable {
                     // Timeouts will be thrown
                     for await (const { task, error } of taskStream) {
                         if (error !== undefined) {
-                            if ((0, errors_js_1.isGraphInterrupt)(error)) {
+                            if ((0, errors_js_1.isGraphBubbleUp)(error)) {
                                 if (loop.isNested) {
                                     throw error;
                                 }
-                                if (error.interrupts.length) {
+                                if ((0, errors_js_1.isGraphInterrupt)(error) && error.interrupts.length) {
                                     loop.putWrites(task.id, error.interrupts.map((interrupt) => [constants_js_1.INTERRUPT, interrupt]));
                                 }
                             }
@@ -801,14 +810,12 @@ class Pregel extends runnables_1.Runnable {
                                 loop.putWrites(task.id, [
                                     [constants_js_1.ERROR, { message: error.message, name: error.name }],
                                 ]);
+                                throw error;
                             }
                         }
                         else {
                             loop.putWrites(task.id, task.writes);
                         }
-                        if (error !== undefined && !(0, errors_js_1.isGraphInterrupt)(error)) {
-                            throw error;
-                        }
                     }
                     if (debug) {
                         (0, debug_js_1.printStepWrites)(loop.step, Object.values(loop.tasks)

package/dist/pregel/index.d.ts

@@ -4,6 +4,7 @@ import { All, BaseCheckpointSaver, BaseStore, CheckpointListOptions, CheckpointT
 import { BaseChannel } from "../channels/base.js";
 import { PregelNode } from "./read.js";
 import { ChannelWrite } from "./write.js";
+import { Command } from "../constants.js";
 import { PregelInterface, PregelParams, StateSnapshot, StreamMode, PregelInputType, PregelOutputType, PregelOptions } from "./types.js";
 import { StrRecord } from "./algo.js";
 import { RetryPolicy } from "./utils/index.js";
@@ -102,14 +103,14 @@ export declare class Pregel<Nn extends StrRecord<string, PregelNode>, Cc extends
      * @param options.interruptAfter Nodes to interrupt after.
      * @param options.debug Whether to print debug information during execution.
      */
-    stream(input: PregelInputType, options?: Partial<PregelOptions<Nn, Cc, ConfigurableFieldType>>): Promise<IterableReadableStream<PregelOutputType>>;
+    stream(input: PregelInputType | Command, options?: Partial<PregelOptions<Nn, Cc, ConfigurableFieldType>>): Promise<IterableReadableStream<PregelOutputType>>;
     protected prepareSpecs(config: RunnableConfig, options?: {
         skipManaged?: boolean;
     }): Promise<{
         channelSpecs: Record<string, BaseChannel<unknown, unknown, unknown>>;
         managed: ManagedValueMapping;
     }>;
-    _streamIterator(input: PregelInputType, options?: Partial<PregelOptions<Nn, Cc>>): AsyncGenerator<PregelOutputType>;
+    _streamIterator(input: PregelInputType | Command, options?: Partial<PregelOptions<Nn, Cc>>): AsyncGenerator<PregelOutputType>;
     /**
      * Run the graph with a single input and config.
      * @param input The input to the graph.
@@ -125,5 +126,5 @@ export declare class Pregel<Nn extends StrRecord<string, PregelNode>, Cc extends
      * @param options.interruptAfter Nodes to interrupt after.
      * @param options.debug Whether to print debug information during execution.
      */
-    invoke(input: PregelInputType, options?: Partial<PregelOptions<Nn, Cc, ConfigurableFieldType>>): Promise<PregelOutputType>;
+    invoke(input: PregelInputType | Command, options?: Partial<PregelOptions<Nn, Cc, ConfigurableFieldType>>): Promise<PregelOutputType>;
 }

package/dist/pregel/index.js

@@ -8,7 +8,7 @@ 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 { GraphRecursionError, GraphValueError, InvalidUpdateError, isGraphInterrupt, } from "../errors.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";
 import { findSubgraphPregel } from "./utils/subgraph.js";
@@ -303,7 +303,7 @@ export class Pregel extends Runnable {
         // Pass `skipManaged: true` as managed values should not be returned in get state calls.
         const { managed } = await this.prepareSpecs(config, { skipManaged: true });
         const channels = emptyChannels(this.channels, saved.checkpoint);
-        const nextTasks = Object.values(_prepareNextTasks(saved.checkpoint, this.nodes, channels, managed, saved.config, false, { step: (saved.metadata?.step ?? -1) + 1 }));
+        const nextTasks = Object.values(_prepareNextTasks(saved.checkpoint, saved.pendingWrites, this.nodes, channels, managed, saved.config, false, { step: (saved.metadata?.step ?? -1) + 1 }));
         const subgraphs = await gatherIterator(this.getSubgraphsAsync());
         const parentNamespace = saved.config.configurable?.checkpoint_ns ?? "";
         const taskStates = {};
@@ -468,14 +468,23 @@ export class Pregel extends Runnable {
         let checkpointConfig = patchConfigurable(config, {
             checkpoint_ns: config.configurable?.checkpoint_ns ?? "",
         });
-        if (saved) {
+        if (saved?.config.configurable) {
             checkpointConfig = patchConfigurable(config, saved.config.configurable);
         }
         // Find last node that updated the state, if not provided
         if (values == null && asNode === undefined) {
             const nextConfig = await checkpointer.put(checkpointConfig, createCheckpoint(checkpoint, undefined, step), {
                 source: "update",
-                step,
+                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",
+                step: step + 1,
                 writes: {},
                 parents: saved?.metadata?.parents ?? {},
             }, {});
@@ -785,11 +794,11 @@ export class Pregel extends Runnable {
                     // Timeouts will be thrown
                     for await (const { task, error } of taskStream) {
                         if (error !== undefined) {
-                            if (isGraphInterrupt(error)) {
+                            if (isGraphBubbleUp(error)) {
                                 if (loop.isNested) {
                                     throw error;
                                 }
-                                if (error.interrupts.length) {
+                                if (isGraphInterrupt(error) && error.interrupts.length) {
                                     loop.putWrites(task.id, error.interrupts.map((interrupt) => [INTERRUPT, interrupt]));
                                 }
                             }
@@ -797,14 +806,12 @@ export class Pregel extends Runnable {
                                 loop.putWrites(task.id, [
                                     [ERROR, { message: error.message, name: error.name }],
                                 ]);
+                                throw error;
                             }
                         }
                         else {
                             loop.putWrites(task.id, task.writes);
                         }
-                        if (error !== undefined && !isGraphInterrupt(error)) {
-                            throw error;
-                        }
                     }
                     if (debug) {
                         printStepWrites(loop.step, Object.values(loop.tasks)

package/dist/pregel/io.cjs

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.single = exports.mapOutputUpdates = exports.mapOutputValues = exports.mapInput = exports.readChannels = exports.readChannel = void 0;
+exports.single = exports.mapOutputUpdates = exports.mapOutputValues = exports.mapInput = exports.mapCommand = exports.readChannels = exports.readChannel = void 0;
+const uuid_1 = require("uuid");
 const constants_js_1 = require("../constants.cjs");
 const errors_js_1 = require("../errors.cjs");
 function readChannel(channels, chan, catchErrors = true, returnException = false) {
@@ -45,6 +46,22 @@ function readChannels(channels, select, skipEmpty = true
     }
 }
 exports.readChannels = readChannels;
+function* mapCommand(cmd) {
+    if (cmd.resume) {
+        if (typeof cmd.resume === "object" &&
+            !!cmd.resume &&
+            Object.keys(cmd.resume).length &&
+            Object.keys(cmd.resume).every(uuid_1.validate)) {
+            for (const [tid, resume] of Object.entries(cmd.resume)) {
+                yield [tid, constants_js_1.RESUME, resume];
+            }
+        }
+        else {
+            yield [constants_js_1.NULL_TASK_ID, constants_js_1.RESUME, cmd.resume];
+        }
+    }
+}
+exports.mapCommand = mapCommand;
 /**
  * Map input chunk to a sequence of pending writes in the form [channel, value].
  */

package/dist/pregel/io.d.ts

@@ -1,8 +1,10 @@
 import type { PendingWrite } from "@langchain/langgraph-checkpoint";
 import type { BaseChannel } from "../channels/base.js";
 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;
+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,4 +1,5 @@
-import { TAG_HIDDEN } from "../constants.js";
+import { validate } from "uuid";
+import { NULL_TASK_ID, RESUME, TAG_HIDDEN } from "../constants.js";
 import { EmptyChannelError } from "../errors.js";
 export function readChannel(channels, chan, catchErrors = true, returnException = false) {
     try {
@@ -40,6 +41,21 @@ export function readChannels(channels, select, skipEmpty = true
         return readChannel(channels, select);
     }
 }
+export function* mapCommand(cmd) {
+    if (cmd.resume) {
+        if (typeof cmd.resume === "object" &&
+            !!cmd.resume &&
+            Object.keys(cmd.resume).length &&
+            Object.keys(cmd.resume).every(validate)) {
+            for (const [tid, resume] of Object.entries(cmd.resume)) {
+                yield [tid, RESUME, resume];
+            }
+        }
+        else {
+            yield [NULL_TASK_ID, RESUME, cmd.resume];
+        }
+    }
+}
 /**
  * Map input chunk to a sequence of pending writes in the form [channel, value].
  */

package/dist/pregel/loop.cjs

@@ -14,7 +14,6 @@ const debug_js_1 = require("./debug.cjs");
 const INPUT_DONE = Symbol.for("INPUT_DONE");
 const INPUT_RESUMING = Symbol.for("INPUT_RESUMING");
 const DEFAULT_LOOP_LIMIT = 25;
-const SPECIAL_CHANNELS = [constants_js_1.ERROR, constants_js_1.INTERRUPT];
 class IterableReadableWritableStream extends stream_1.IterableReadableStream {
     constructor(params) {
         let streamControllerPromiseResolver;
@@ -200,12 +199,6 @@ class PregelLoop {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "taskWritesLeft", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 0
-        });
         Object.defineProperty(this, "prevCheckpointConfig", {
             enumerable: true,
             configurable: true,
@@ -293,7 +286,9 @@ class PregelLoop {
             config.configurable?.[constants_js_1.CONFIG_KEY_STREAM] !== undefined) {
             stream = createDuplexStream(stream, config.configurable[constants_js_1.CONFIG_KEY_STREAM]);
         }
-        const skipDoneTasks = config.configurable?.checkpoint_id === undefined;
+        const skipDoneTasks = config.configurable
+            ? !("checkpoint_id" in config.configurable)
+            : true;
         const isNested = constants_js_1.CONFIG_KEY_READ in (config.configurable ?? {});
         if (!isNested &&
             config.configurable?.checkpoint_ns !== undefined &&
@@ -407,18 +402,6 @@ class PregelLoop {
         if (writes.length === 0) {
             return;
         }
-        // adjust taskWritesLeft
-        const firstChannel = writes[0][0];
-        const anyChannelIsSend = writes.find(([channel]) => channel === constants_js_1.TASKS);
-        const alwaysSave = anyChannelIsSend || SPECIAL_CHANNELS.includes(firstChannel);
-        if (!alwaysSave && !this.taskWritesLeft) {
-            return this._outputWrites(taskId, writes);
-        }
-        else if (firstChannel !== constants_js_1.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];
@@ -435,7 +418,9 @@ class PregelLoop {
         if (putWritePromise !== undefined) {
             this.checkpointerPromises.push(putWritePromise);
         }
-        this._outputWrites(taskId, writes);
+        if (this.tasks) {
+            this._outputWrites(taskId, writes);
+        }
     }
     _outputWrites(taskId, writes, cached = false) {
         const task = this.tasks[taskId];
@@ -506,7 +491,7 @@ class PregelLoop {
                 this.status = "out_of_steps";
                 return false;
             }
-            const nextTasks = (0, algo_js_1._prepareNextTasks)(this.checkpoint, this.nodes, this.channels, this.managed, this.config, true, {
+            const nextTasks = (0, algo_js_1._prepareNextTasks)(this.checkpoint, this.checkpointPendingWrites, this.nodes, this.channels, this.managed, this.config, true, {
                 step: this.step,
                 checkpointer: this.checkpointer,
                 isResuming: this.input === INPUT_RESUMING,
@@ -514,7 +499,6 @@ class PregelLoop {
                 store: this.store,
             });
             this.tasks = nextTasks;
-            this.taskWritesLeft = Object.values(this.tasks).length - 1;
             // Produce debug output
             if (this.checkpointer) {
                 this._emit(await (0, utils_js_1.gatherIterator)((0, utils_js_1.prefixGenerator)((0, debug_js_1.mapDebugCheckpoint)(this.step - 1, // printing checkpoint for previous step
@@ -527,7 +511,7 @@ class PregelLoop {
             // 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 === constants_js_1.ERROR || k === constants_js_1.INTERRUPT) {
+                    if (k === constants_js_1.ERROR || k === constants_js_1.INTERRUPT || k === constants_js_1.RESUME) {
                         continue;
                     }
                     const task = Object.values(this.tasks).find((t) => t.id === tid);
@@ -606,14 +590,31 @@ class PregelLoop {
             // 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);
-            // map inputs to channel updates
+        }
+        else 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)) {
+                if (writes[tid] === undefined) {
+                    writes[tid] = [];
+                }
+                writes[tid].push([key, value]);
+            }
+            if (Object.keys(writes).length === 0) {
+                throw new errors_js_1.EmptyInputError("Received empty Command input");
+            }
+            // save writes
+            for (const [tid, ws] of Object.entries(writes)) {
+                this.putWrites(tid, ws);
+            }
         }
         else {
+            // map inputs to channel updates
             const inputWrites = await (0, utils_js_1.gatherIterator)((0, io_js_1.mapInput)(inputKeys, this.input));
             if (inputWrites.length === 0) {
                 throw new errors_js_1.EmptyInputError(`Received no input writes for ${JSON.stringify(inputKeys, null, 2)}`);
             }
-            const discardTasks = (0, algo_js_1._prepareNextTasks)(this.checkpoint, this.nodes, this.channels, this.managed, this.config, true, { step: this.step });
+            const discardTasks = (0, algo_js_1._prepareNextTasks)(this.checkpoint, this.checkpointPendingWrites, this.nodes, this.channels, this.managed, this.config, true, { step: this.step });
             (0, algo_js_1._applyWrites)(this.checkpoint, this.channels, Object.values(discardTasks).concat([
                 {
                     name: constants_js_1.INPUT,

package/dist/pregel/loop.d.ts

@@ -4,12 +4,13 @@ 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 { 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];
 export type PregelLoopInitializeParams = {
-    input?: any;
+    input?: any | Command;
     config: RunnableConfig;
     checkpointer?: BaseCheckpointSaver;
     outputKeys: string | string[];
@@ -22,7 +23,7 @@ export type PregelLoopInitializeParams = {
     checkSubgraphs?: boolean;
 };
 type PregelLoopParams = {
-    input?: any;
+    input?: any | Command;
     config: RunnableConfig;
     checkpointer?: BaseCheckpointSaver;
     checkpoint: Checkpoint;
@@ -57,7 +58,7 @@ export declare class IterableReadableWritableStream extends IterableReadableStre
     error(e: any): void;
 }
 export declare class PregelLoop {
-    protected input?: any;
+    protected input?: any | Command;
     output: any;
     config: LangGraphRunnableConfig;
     protected checkpointer?: BaseCheckpointSaver;
@@ -76,7 +77,6 @@ export declare class PregelLoop {
     protected streamKeys: string | string[];
     protected nodes: Record<string, PregelNode>;
     protected skipDoneTasks: boolean;
-    protected taskWritesLeft: number;
     protected prevCheckpointConfig: RunnableConfig | undefined;
     status: "pending" | "done" | "interrupt_before" | "interrupt_after" | "out_of_steps";
     tasks: Record<string, PregelExecutableTask<any, any>>;

package/dist/pregel/loop.js

@@ -1,17 +1,16 @@
 import { IterableReadableStream } from "@langchain/core/utils/stream";
 import { copyCheckpoint, emptyCheckpoint, AsyncBatchedStore, } from "@langchain/langgraph-checkpoint";
 import { createCheckpoint, emptyChannels, } from "../channels/base.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 { _isCommand, CHECKPOINT_NAMESPACE_SEPARATOR, CONFIG_KEY_CHECKPOINT_MAP, CONFIG_KEY_READ, CONFIG_KEY_RESUMING, CONFIG_KEY_STREAM, ERROR, INPUT, INTERRUPT, RESUME, TAG_HIDDEN, } from "../constants.js";
 import { _applyWrites, _prepareNextTasks, increment, shouldInterrupt, } from "./algo.js";
 import { gatherIterator, gatherIteratorSync, prefixGenerator, } from "../utils.js";
-import { mapInput, mapOutputUpdates, mapOutputValues, readChannels, } from "./io.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";
 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 IterableReadableWritableStream extends IterableReadableStream {
     constructor(params) {
         let streamControllerPromiseResolver;
@@ -196,12 +195,6 @@ export class PregelLoop {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "taskWritesLeft", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 0
-        });
         Object.defineProperty(this, "prevCheckpointConfig", {
             enumerable: true,
             configurable: true,
@@ -289,7 +282,9 @@ export class PregelLoop {
             config.configurable?.[CONFIG_KEY_STREAM] !== undefined) {
             stream = createDuplexStream(stream, config.configurable[CONFIG_KEY_STREAM]);
         }
-        const skipDoneTasks = config.configurable?.checkpoint_id === undefined;
+        const skipDoneTasks = config.configurable
+            ? !("checkpoint_id" in config.configurable)
+            : true;
         const isNested = CONFIG_KEY_READ in (config.configurable ?? {});
         if (!isNested &&
             config.configurable?.checkpoint_ns !== undefined &&
@@ -403,18 +398,6 @@ export class PregelLoop {
         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];
@@ -431,7 +414,9 @@ export class PregelLoop {
         if (putWritePromise !== undefined) {
             this.checkpointerPromises.push(putWritePromise);
         }
-        this._outputWrites(taskId, writes);
+        if (this.tasks) {
+            this._outputWrites(taskId, writes);
+        }
     }
     _outputWrites(taskId, writes, cached = false) {
         const task = this.tasks[taskId];
@@ -502,7 +487,7 @@ export class PregelLoop {
                 this.status = "out_of_steps";
                 return false;
             }
-            const nextTasks = _prepareNextTasks(this.checkpoint, this.nodes, this.channels, this.managed, this.config, true, {
+            const nextTasks = _prepareNextTasks(this.checkpoint, this.checkpointPendingWrites, this.nodes, this.channels, this.managed, this.config, true, {
                 step: this.step,
                 checkpointer: this.checkpointer,
                 isResuming: this.input === INPUT_RESUMING,
@@ -510,7 +495,6 @@ export class PregelLoop {
                 store: this.store,
             });
             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
@@ -523,7 +507,7 @@ export class PregelLoop {
             // 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) {
+                    if (k === ERROR || k === INTERRUPT || k === RESUME) {
                         continue;
                     }
                     const task = Object.values(this.tasks).find((t) => t.id === tid);
@@ -602,14 +586,31 @@ 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 if (_isCommand(this.input)) {
+            const writes = {};
+            // group writes by task id
+            for (const [tid, key, value] of mapCommand(this.input)) {
+                if (writes[tid] === undefined) {
+                    writes[tid] = [];
+                }
+                writes[tid].push([key, value]);
+            }
+            if (Object.keys(writes).length === 0) {
+                throw new EmptyInputError("Received empty Command input");
+            }
+            // save writes
+            for (const [tid, ws] of Object.entries(writes)) {
+                this.putWrites(tid, ws);
+            }
         }
         else {
+            // map inputs to channel updates
             const inputWrites = await gatherIterator(mapInput(inputKeys, this.input));
             if (inputWrites.length === 0) {
                 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 });
+            const discardTasks = _prepareNextTasks(this.checkpoint, this.checkpointPendingWrites, this.nodes, this.channels, this.managed, this.config, true, { step: this.step });
             _applyWrites(this.checkpoint, this.channels, Object.values(discardTasks).concat([
                 {
                     name: INPUT,

package/dist/pregel/retry.cjs

@@ -103,7 +103,7 @@ pregelTask, retryPolicy) {
         catch (e) {
             error = e;
             error.pregelTaskId = pregelTask.id;
-            if ((0, errors_js_1.isGraphInterrupt)(error)) {
+            if ((0, errors_js_1.isGraphBubbleUp)(error)) {
                 break;
             }
             if (resolvedRetryPolicy === undefined) {

package/dist/pregel/retry.js

@@ -1,4 +1,4 @@
-import { getSubgraphsSeenSet, isGraphInterrupt } from "../errors.js";
+import { getSubgraphsSeenSet, isGraphBubbleUp } from "../errors.js";
 export const DEFAULT_INITIAL_INTERVAL = 500;
 export const DEFAULT_BACKOFF_FACTOR = 2;
 export const DEFAULT_MAX_INTERVAL = 128000;
@@ -99,7 +99,7 @@ pregelTask, retryPolicy) {
         catch (e) {
             error = e;
             error.pregelTaskId = pregelTask.id;
-            if (isGraphInterrupt(error)) {
+            if (isGraphBubbleUp(error)) {
                 break;
             }
             if (resolvedRetryPolicy === undefined) {

package/dist/web.cjs

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MessagesAnnotation = exports.InMemoryStore = exports.AsyncBatchedStore = exports.BaseStore = exports.BaseCheckpointSaver = exports.emptyCheckpoint = exports.copyCheckpoint = exports.MemorySaver = exports.Send = exports.BinaryOperatorAggregate = exports.BaseChannel = exports.Annotation = exports.messagesStateReducer = exports.MessageGraph = exports.CompiledStateGraph = exports.StateGraph = exports.START = exports.Graph = exports.END = void 0;
+exports.MessagesAnnotation = exports.InMemoryStore = exports.AsyncBatchedStore = exports.BaseStore = exports.BaseCheckpointSaver = exports.emptyCheckpoint = exports.copyCheckpoint = exports.MemorySaver = exports.interrupt = exports.Command = exports.Send = exports.BinaryOperatorAggregate = exports.BaseChannel = exports.Annotation = exports.messagesStateReducer = exports.MessageGraph = exports.CompiledStateGraph = exports.StateGraph = exports.START = exports.Graph = exports.END = void 0;
 var index_js_1 = require("./graph/index.cjs");
 Object.defineProperty(exports, "END", { enumerable: true, get: function () { return index_js_1.END; } });
 Object.defineProperty(exports, "Graph", { enumerable: true, get: function () { return index_js_1.Graph; } });
@@ -30,6 +30,9 @@ Object.defineProperty(exports, "BaseChannel", { enumerable: true, get: function
 Object.defineProperty(exports, "BinaryOperatorAggregate", { enumerable: true, get: function () { return index_js_2.BinaryOperatorAggregate; } });
 var constants_js_1 = require("./constants.cjs");
 Object.defineProperty(exports, "Send", { enumerable: true, get: function () { return constants_js_1.Send; } });
+Object.defineProperty(exports, "Command", { enumerable: true, get: function () { return constants_js_1.Command; } });
+var interrupt_js_1 = require("./interrupt.cjs");
+Object.defineProperty(exports, "interrupt", { enumerable: true, get: function () { return interrupt_js_1.interrupt; } });
 var langgraph_checkpoint_1 = require("@langchain/langgraph-checkpoint");
 Object.defineProperty(exports, "MemorySaver", { enumerable: true, get: function () { return langgraph_checkpoint_1.MemorySaver; } });
 Object.defineProperty(exports, "copyCheckpoint", { enumerable: true, get: function () { return langgraph_checkpoint_1.copyCheckpoint; } });

package/dist/web.d.ts

@@ -4,7 +4,8 @@ export * from "./errors.js";
 export { BaseChannel, type BinaryOperator, BinaryOperatorAggregate, type AnyValue, type WaitForNames, type DynamicBarrierValue, type LastValue, type NamedBarrierValue, type Topic, } from "./channels/index.js";
 export { type AnnotationRoot as _INTERNAL_ANNOTATION_ROOT } from "./graph/index.js";
 export { type RetryPolicy } from "./pregel/utils/index.js";
-export { Send } from "./constants.js";
+export { Send, Command, type Interrupt } from "./constants.js";
+export { interrupt } from "./interrupt.js";
 export { MemorySaver, type Checkpoint, type CheckpointMetadata, type CheckpointTuple, copyCheckpoint, emptyCheckpoint, BaseCheckpointSaver, type Item, type GetOperation, type SearchOperation, type PutOperation, type Operation, type OperationResults, BaseStore, AsyncBatchedStore, InMemoryStore, type NameSpacePath, type NamespaceMatchType, type MatchCondition, type ListNamespacesOperation, } from "@langchain/langgraph-checkpoint";
 export * from "./managed/index.js";
 export { MessagesAnnotation } from "./graph/messages_annotation.js";

package/dist/web.js

@@ -1,7 +1,8 @@
 export { END, Graph, START, StateGraph, CompiledStateGraph, MessageGraph, messagesStateReducer, Annotation, } from "./graph/index.js";
 export * from "./errors.js";
 export { BaseChannel, BinaryOperatorAggregate, } from "./channels/index.js";
-export { Send } from "./constants.js";
+export { Send, Command } from "./constants.js";
+export { interrupt } from "./interrupt.js";
 export { MemorySaver, copyCheckpoint, emptyCheckpoint, BaseCheckpointSaver, BaseStore, AsyncBatchedStore, InMemoryStore, } from "@langchain/langgraph-checkpoint";
 export * from "./managed/index.js";
 export { MessagesAnnotation } from "./graph/messages_annotation.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/langgraph",
-  "version": "0.2.21",
+  "version": "0.2.23",
   "description": "LangGraph",
   "type": "module",
   "engines": {
@@ -31,7 +31,7 @@
   "author": "LangChain",
   "license": "MIT",
   "dependencies": {
-    "@langchain/langgraph-checkpoint": "~0.0.10",
+    "@langchain/langgraph-checkpoint": "~0.0.12",
     "@langchain/langgraph-sdk": "~0.0.21",
     "uuid": "^10.0.0",
     "zod": "^3.23.8"
@@ -72,7 +72,7 @@
     "pg": "^8.13.0",
     "prettier": "^2.8.3",
     "release-it": "^17.6.0",
-    "rollup": "^4.23.0",
+    "rollup": "^4.22.4",
     "ts-jest": "^29.1.0",
     "tsx": "^4.7.0",
     "typescript": "^4.9.5 || ^5.4.5",