@langchain/langgraph 0.2.29 → 0.2.31

package/dist/constants.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-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.SELF = 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._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.SELF = 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_CHECKPOINT_NS = exports.CONFIG_KEY_SCRATCHPAD = exports.CONFIG_KEY_WRITES = 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__";
@@ -11,6 +11,9 @@ 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";
+exports.CONFIG_KEY_WRITES = "__pregel_writes";
+exports.CONFIG_KEY_SCRATCHPAD = "__pregel_scratchpad";
+exports.CONFIG_KEY_CHECKPOINT_NS = "checkpoint_ns";
 // this one is part of public API
 exports.CONFIG_KEY_CHECKPOINT_MAP = "checkpoint_map";
 exports.INTERRUPT = "__interrupt__";

package/dist/constants.d.ts

@@ -8,6 +8,9 @@ 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_WRITES = "__pregel_writes";
+export declare const CONFIG_KEY_SCRATCHPAD = "__pregel_scratchpad";
+export declare const CONFIG_KEY_CHECKPOINT_NS = "checkpoint_ns";
 export declare const CONFIG_KEY_CHECKPOINT_MAP = "checkpoint_map";
 export declare const INTERRUPT = "__interrupt__";
 export declare const RESUME = "__resume__";

package/dist/constants.js

@@ -8,6 +8,9 @@ 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";
+export const CONFIG_KEY_WRITES = "__pregel_writes";
+export const CONFIG_KEY_SCRATCHPAD = "__pregel_scratchpad";
+export const CONFIG_KEY_CHECKPOINT_NS = "checkpoint_ns";
 // this one is part of public API
 export const CONFIG_KEY_CHECKPOINT_MAP = "checkpoint_map";
 export const INTERRUPT = "__interrupt__";

package/dist/interrupt.cjs

@@ -4,24 +4,98 @@ 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");
+/**
+ * Interrupts the execution of a graph node.
+ * This function can be used to pause execution of a node, and return the value of the `resume`
+ * input when the graph is re-invoked using `Command`.
+ * Multiple interrupts can be called within a single node, and each will be handled sequentially.
+ *
+ * When an interrupt is called:
+ * 1. If there's a `resume` value available (from a previous `Command`), it returns that value.
+ * 2. Otherwise, it throws a `GraphInterrupt` with the provided value
+ * 3. The graph can be resumed by passing a `Command` with a `resume` value
+ *
+ * @param value - The value to include in the interrupt. This will be available in task.interrupts[].value
+ * @returns The `resume` value provided when the graph is re-invoked with a Command
+ *
+ * @example
+ * ```typescript
+ * // Define a node that uses multiple interrupts
+ * const nodeWithInterrupts = () => {
+ *   // First interrupt - will pause execution and include {value: 1} in task values
+ *   const answer1 = interrupt({ value: 1 });
+ *
+ *   // Second interrupt - only called after first interrupt is resumed
+ *   const answer2 = interrupt({ value: 2 });
+ *
+ *   // Use the resume values
+ *   return { myKey: answer1 + " " + answer2 };
+ * };
+ *
+ * // Resume the graph after first interrupt
+ * await graph.stream(new Command({ resume: "answer 1" }));
+ *
+ * // Resume the graph after second interrupt
+ * await graph.stream(new Command({ resume: "answer 2" }));
+ * // Final result: { myKey: "answer 1 answer 2" }
+ * ```
+ *
+ * @throws {Error} If called outside the context of a graph
+ * @throws {GraphInterrupt} When no resume value is available
+ */
 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;
+    // Track interrupt index
+    const scratchpad = config.configurable?.[constants_js_1.CONFIG_KEY_SCRATCHPAD];
+    if (scratchpad.interruptCounter === undefined) {
+        scratchpad.interruptCounter = 0;
     }
     else {
-        throw new errors_js_1.GraphInterrupt([
-            {
-                value,
-                when: "during",
-                resumable: true,
-                ns: config.configurable?.checkpoint_ns?.split("|"),
-            },
-        ]);
+        scratchpad.interruptCounter += 1;
     }
+    const idx = scratchpad.interruptCounter;
+    // Find previous resume values
+    const taskId = config.configurable?.[constants_js_1.CONFIG_KEY_TASK_ID];
+    const writes = config.configurable?.[constants_js_1.CONFIG_KEY_WRITES] ?? [];
+    if (!scratchpad.resume) {
+        const newResume = (writes.find((w) => w[0] === taskId && w[1] === constants_js_1.RESUME)?.[2] || []);
+        scratchpad.resume = Array.isArray(newResume) ? newResume : [newResume];
+    }
+    if (scratchpad.resume) {
+        if (idx < scratchpad.resume.length) {
+            return scratchpad.resume[idx];
+        }
+    }
+    // Find current resume value
+    if (!scratchpad.usedNullResume) {
+        scratchpad.usedNullResume = true;
+        const sortedWrites = [...writes].sort((a, b) => b[0].localeCompare(a[0]) // Sort in reverse order
+        );
+        for (const [tid, c, v] of sortedWrites) {
+            if (tid === constants_js_1.NULL_TASK_ID && c === constants_js_1.RESUME) {
+                if (scratchpad.resume.length !== idx) {
+                    throw new Error(`Resume length mismatch: ${scratchpad.resume.length} !== ${idx}`);
+                }
+                scratchpad.resume.push(v);
+                const send = config.configurable?.[constants_js_1.CONFIG_KEY_SEND];
+                if (send) {
+                    send([[constants_js_1.RESUME, scratchpad.resume]]);
+                }
+                return v;
+            }
+        }
+    }
+    // No resume value found
+    throw new errors_js_1.GraphInterrupt([
+        {
+            value,
+            when: "during",
+            resumable: true,
+            ns: config.configurable?.[constants_js_1.CONFIG_KEY_CHECKPOINT_NS]?.split(constants_js_1.CHECKPOINT_NAMESPACE_SEPARATOR),
+        },
+    ]);
 }
 exports.interrupt = interrupt;

package/dist/interrupt.d.ts

@@ -1 +1,40 @@
+/**
+ * Interrupts the execution of a graph node.
+ * This function can be used to pause execution of a node, and return the value of the `resume`
+ * input when the graph is re-invoked using `Command`.
+ * Multiple interrupts can be called within a single node, and each will be handled sequentially.
+ *
+ * When an interrupt is called:
+ * 1. If there's a `resume` value available (from a previous `Command`), it returns that value.
+ * 2. Otherwise, it throws a `GraphInterrupt` with the provided value
+ * 3. The graph can be resumed by passing a `Command` with a `resume` value
+ *
+ * @param value - The value to include in the interrupt. This will be available in task.interrupts[].value
+ * @returns The `resume` value provided when the graph is re-invoked with a Command
+ *
+ * @example
+ * ```typescript
+ * // Define a node that uses multiple interrupts
+ * const nodeWithInterrupts = () => {
+ *   // First interrupt - will pause execution and include {value: 1} in task values
+ *   const answer1 = interrupt({ value: 1 });
+ *
+ *   // Second interrupt - only called after first interrupt is resumed
+ *   const answer2 = interrupt({ value: 2 });
+ *
+ *   // Use the resume values
+ *   return { myKey: answer1 + " " + answer2 };
+ * };
+ *
+ * // Resume the graph after first interrupt
+ * await graph.stream(new Command({ resume: "answer 1" }));
+ *
+ * // Resume the graph after second interrupt
+ * await graph.stream(new Command({ resume: "answer 2" }));
+ * // Final result: { myKey: "answer 1 answer 2" }
+ * ```
+ *
+ * @throws {Error} If called outside the context of a graph
+ * @throws {GraphInterrupt} When no resume value is available
+ */
 export declare function interrupt<I = unknown, R = unknown>(value: I): R;

package/dist/interrupt.js

@@ -1,23 +1,97 @@
 import { AsyncLocalStorageProviderSingleton } from "@langchain/core/singletons";
 import { GraphInterrupt } from "./errors.js";
-import { CONFIG_KEY_RESUME_VALUE, MISSING } from "./constants.js";
+import { CONFIG_KEY_CHECKPOINT_NS, CONFIG_KEY_SCRATCHPAD, CONFIG_KEY_TASK_ID, CONFIG_KEY_WRITES, CONFIG_KEY_SEND, CHECKPOINT_NAMESPACE_SEPARATOR, NULL_TASK_ID, RESUME, } from "./constants.js";
+/**
+ * Interrupts the execution of a graph node.
+ * This function can be used to pause execution of a node, and return the value of the `resume`
+ * input when the graph is re-invoked using `Command`.
+ * Multiple interrupts can be called within a single node, and each will be handled sequentially.
+ *
+ * When an interrupt is called:
+ * 1. If there's a `resume` value available (from a previous `Command`), it returns that value.
+ * 2. Otherwise, it throws a `GraphInterrupt` with the provided value
+ * 3. The graph can be resumed by passing a `Command` with a `resume` value
+ *
+ * @param value - The value to include in the interrupt. This will be available in task.interrupts[].value
+ * @returns The `resume` value provided when the graph is re-invoked with a Command
+ *
+ * @example
+ * ```typescript
+ * // Define a node that uses multiple interrupts
+ * const nodeWithInterrupts = () => {
+ *   // First interrupt - will pause execution and include {value: 1} in task values
+ *   const answer1 = interrupt({ value: 1 });
+ *
+ *   // Second interrupt - only called after first interrupt is resumed
+ *   const answer2 = interrupt({ value: 2 });
+ *
+ *   // Use the resume values
+ *   return { myKey: answer1 + " " + answer2 };
+ * };
+ *
+ * // Resume the graph after first interrupt
+ * await graph.stream(new Command({ resume: "answer 1" }));
+ *
+ * // Resume the graph after second interrupt
+ * await graph.stream(new Command({ resume: "answer 2" }));
+ * // Final result: { myKey: "answer 1 answer 2" }
+ * ```
+ *
+ * @throws {Error} If called outside the context of a graph
+ * @throws {GraphInterrupt} When no resume value is available
+ */
 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;
+    // Track interrupt index
+    const scratchpad = config.configurable?.[CONFIG_KEY_SCRATCHPAD];
+    if (scratchpad.interruptCounter === undefined) {
+        scratchpad.interruptCounter = 0;
     }
     else {
-        throw new GraphInterrupt([
-            {
-                value,
-                when: "during",
-                resumable: true,
-                ns: config.configurable?.checkpoint_ns?.split("|"),
-            },
-        ]);
+        scratchpad.interruptCounter += 1;
     }
+    const idx = scratchpad.interruptCounter;
+    // Find previous resume values
+    const taskId = config.configurable?.[CONFIG_KEY_TASK_ID];
+    const writes = config.configurable?.[CONFIG_KEY_WRITES] ?? [];
+    if (!scratchpad.resume) {
+        const newResume = (writes.find((w) => w[0] === taskId && w[1] === RESUME)?.[2] || []);
+        scratchpad.resume = Array.isArray(newResume) ? newResume : [newResume];
+    }
+    if (scratchpad.resume) {
+        if (idx < scratchpad.resume.length) {
+            return scratchpad.resume[idx];
+        }
+    }
+    // Find current resume value
+    if (!scratchpad.usedNullResume) {
+        scratchpad.usedNullResume = true;
+        const sortedWrites = [...writes].sort((a, b) => b[0].localeCompare(a[0]) // Sort in reverse order
+        );
+        for (const [tid, c, v] of sortedWrites) {
+            if (tid === NULL_TASK_ID && c === RESUME) {
+                if (scratchpad.resume.length !== idx) {
+                    throw new Error(`Resume length mismatch: ${scratchpad.resume.length} !== ${idx}`);
+                }
+                scratchpad.resume.push(v);
+                const send = config.configurable?.[CONFIG_KEY_SEND];
+                if (send) {
+                    send([[RESUME, scratchpad.resume]]);
+                }
+                return v;
+            }
+        }
+    }
+    // No resume value found
+    throw new GraphInterrupt([
+        {
+            value,
+            when: "during",
+            resumable: true,
+            ns: config.configurable?.[CONFIG_KEY_CHECKPOINT_NS]?.split(CHECKPOINT_NAMESPACE_SEPARATOR),
+        },
+    ]);
 }

package/dist/pregel/algo.cjs

@@ -75,7 +75,7 @@ function _localRead(step, checkpoint, channels, managed, task, select, fresh = f
 exports._localRead = _localRead;
 function _localWrite(step, 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-commit, processes, channels, managed, 
+commit, processes, managed, 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 writes) {
     for (const [chan, value] of writes) {
@@ -89,9 +89,6 @@ writes) {
             // replace any runtime values with placeholders
             managed.replaceRuntimeValues(step, value.args);
         }
-        else if (!(chan in channels) && !managed.get(chan)) {
-            console.warn(`Skipping write for channel '${chan}' which has no readers`);
-        }
     }
     commit(writes);
 }
@@ -307,7 +304,6 @@ function _prepareSingleTask(taskPath, checkpoint, pendingWrites, processes, chan
                     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,
@@ -324,7 +320,7 @@ function _prepareSingleTask(taskPath, checkpoint, pendingWrites, processes, chan
                         configurable: {
                             [constants_js_1.CONFIG_KEY_TASK_ID]: taskId,
                             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                            [constants_js_1.CONFIG_KEY_SEND]: (writes_) => _localWrite(step, (items) => writes.push(...items), processes, channels, managed, writes_),
+                            [constants_js_1.CONFIG_KEY_SEND]: (writes_) => _localWrite(step, (items) => writes.push(...items), processes, managed, writes_),
                             [constants_js_1.CONFIG_KEY_READ]: (select_, fresh_ = false) => _localRead(step, checkpoint, channels, managed, {
                                 name: packet.node,
                                 writes: writes,
@@ -336,9 +332,11 @@ function _prepareSingleTask(taskPath, checkpoint, pendingWrites, processes, chan
                                 ...configurable[constants_js_1.CONFIG_KEY_CHECKPOINT_MAP],
                                 [parentNamespace]: checkpoint.id,
                             },
-                            [constants_js_1.CONFIG_KEY_RESUME_VALUE]: resume
-                                ? resume[2]
-                                : configurable[constants_js_1.CONFIG_KEY_RESUME_VALUE] ?? constants_js_1.MISSING,
+                            [constants_js_1.CONFIG_KEY_WRITES]: [
+                                ...(pendingWrites || []),
+                                ...(configurable[constants_js_1.CONFIG_KEY_WRITES] || []),
+                            ].filter((w) => w[0] === constants_js_1.NULL_TASK_ID || w[0] === taskId),
+                            [constants_js_1.CONFIG_KEY_SCRATCHPAD]: {},
                             checkpoint_id: undefined,
                             checkpoint_ns: taskCheckpointNamespace,
                         },
@@ -409,7 +407,6 @@ function _prepareSingleTask(taskPath, checkpoint, pendingWrites, processes, chan
                         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,
@@ -429,7 +426,7 @@ function _prepareSingleTask(taskPath, checkpoint, pendingWrites, processes, chan
                                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
                                 [constants_js_1.CONFIG_KEY_SEND]: (writes_) => _localWrite(step, (items) => {
                                     writes.push(...items);
-                                }, processes, channels, managed, writes_),
+                                }, processes, managed, writes_),
                                 [constants_js_1.CONFIG_KEY_READ]: (select_, fresh_ = false) => _localRead(step, checkpoint, channels, managed, {
                                     name,
                                     writes: writes,
@@ -441,9 +438,11 @@ function _prepareSingleTask(taskPath, checkpoint, pendingWrites, processes, chan
                                     ...configurable[constants_js_1.CONFIG_KEY_CHECKPOINT_MAP],
                                     [parentNamespace]: checkpoint.id,
                                 },
-                                [constants_js_1.CONFIG_KEY_RESUME_VALUE]: resume
-                                    ? resume[2]
-                                    : configurable[constants_js_1.CONFIG_KEY_RESUME_VALUE] ?? constants_js_1.MISSING,
+                                [constants_js_1.CONFIG_KEY_WRITES]: [
+                                    ...(pendingWrites || []),
+                                    ...(configurable[constants_js_1.CONFIG_KEY_WRITES] || []),
+                                ].filter((w) => w[0] === constants_js_1.NULL_TASK_ID || w[0] === taskId),
+                                [constants_js_1.CONFIG_KEY_SCRATCHPAD]: {},
                                 checkpoint_id: undefined,
                                 checkpoint_ns: taskCheckpointNamespace,
                             },

package/dist/pregel/algo.d.ts

@@ -20,7 +20,7 @@ export type WritesProtocol<C = string> = {
 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;
 export declare function _localRead<Cc extends Record<string, BaseChannel>>(step: number, checkpoint: ReadonlyCheckpoint, channels: Cc, managed: ManagedValueMapping, task: WritesProtocol<keyof Cc>, select: Array<keyof Cc> | keyof Cc, fresh?: boolean): Record<string, unknown> | unknown;
-export declare function _localWrite(step: number, commit: (writes: [string, any][]) => any, processes: Record<string, PregelNode>, channels: Record<string, BaseChannel>, managed: ManagedValueMapping, writes: [string, any][]): void;
+export declare function _localWrite(step: number, commit: (writes: [string, any][]) => any, processes: Record<string, PregelNode>, managed: ManagedValueMapping, writes: [string, any][]): void;
 export declare function _applyWrites<Cc extends Record<string, BaseChannel>>(checkpoint: Checkpoint, channels: Cc, tasks: WritesProtocol<keyof Cc>[], getNextVersion?: (version: any, channel: BaseChannel) => any): Record<string, PendingWriteValue[]>;
 export type NextTaskExtraFields = {
     step: number;

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, RESUME, CONFIG_KEY_RESUME_VALUE, NULL_TASK_ID, MISSING, } 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, NULL_TASK_ID, CONFIG_KEY_SCRATCHPAD, CONFIG_KEY_WRITES, } from "../constants.js";
 import { EmptyChannelError, InvalidUpdateError } from "../errors.js";
 import { getNullChannelVersion } from "./utils/index.js";
 export const increment = (current) => {
@@ -69,7 +69,7 @@ export function _localRead(step, checkpoint, channels, managed, task, select, fr
 }
 export function _localWrite(step, 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-commit, processes, channels, managed, 
+commit, processes, managed, 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 writes) {
     for (const [chan, value] of writes) {
@@ -83,9 +83,6 @@ writes) {
             // replace any runtime values with placeholders
             managed.replaceRuntimeValues(step, value.args);
         }
-        else if (!(chan in channels) && !managed.get(chan)) {
-            console.warn(`Skipping write for channel '${chan}' which has no readers`);
-        }
     }
     commit(writes);
 }
@@ -298,7 +295,6 @@ export function _prepareSingleTask(taskPath, checkpoint, pendingWrites, processe
                     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,
@@ -315,7 +311,7 @@ export function _prepareSingleTask(taskPath, checkpoint, pendingWrites, processe
                         configurable: {
                             [CONFIG_KEY_TASK_ID]: taskId,
                             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                            [CONFIG_KEY_SEND]: (writes_) => _localWrite(step, (items) => writes.push(...items), processes, channels, managed, writes_),
+                            [CONFIG_KEY_SEND]: (writes_) => _localWrite(step, (items) => writes.push(...items), processes, managed, writes_),
                             [CONFIG_KEY_READ]: (select_, fresh_ = false) => _localRead(step, checkpoint, channels, managed, {
                                 name: packet.node,
                                 writes: writes,
@@ -327,9 +323,11 @@ export function _prepareSingleTask(taskPath, checkpoint, pendingWrites, processe
                                 ...configurable[CONFIG_KEY_CHECKPOINT_MAP],
                                 [parentNamespace]: checkpoint.id,
                             },
-                            [CONFIG_KEY_RESUME_VALUE]: resume
-                                ? resume[2]
-                                : configurable[CONFIG_KEY_RESUME_VALUE] ?? MISSING,
+                            [CONFIG_KEY_WRITES]: [
+                                ...(pendingWrites || []),
+                                ...(configurable[CONFIG_KEY_WRITES] || []),
+                            ].filter((w) => w[0] === NULL_TASK_ID || w[0] === taskId),
+                            [CONFIG_KEY_SCRATCHPAD]: {},
                             checkpoint_id: undefined,
                             checkpoint_ns: taskCheckpointNamespace,
                         },
@@ -400,7 +398,6 @@ export function _prepareSingleTask(taskPath, checkpoint, pendingWrites, processe
                         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,
@@ -420,7 +417,7 @@ export function _prepareSingleTask(taskPath, checkpoint, pendingWrites, processe
                                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
                                 [CONFIG_KEY_SEND]: (writes_) => _localWrite(step, (items) => {
                                     writes.push(...items);
-                                }, processes, channels, managed, writes_),
+                                }, processes, managed, writes_),
                                 [CONFIG_KEY_READ]: (select_, fresh_ = false) => _localRead(step, checkpoint, channels, managed, {
                                     name,
                                     writes: writes,
@@ -432,9 +429,11 @@ export function _prepareSingleTask(taskPath, checkpoint, pendingWrites, processe
                                     ...configurable[CONFIG_KEY_CHECKPOINT_MAP],
                                     [parentNamespace]: checkpoint.id,
                                 },
-                                [CONFIG_KEY_RESUME_VALUE]: resume
-                                    ? resume[2]
-                                    : configurable[CONFIG_KEY_RESUME_VALUE] ?? MISSING,
+                                [CONFIG_KEY_WRITES]: [
+                                    ...(pendingWrites || []),
+                                    ...(configurable[CONFIG_KEY_WRITES] || []),
+                                ].filter((w) => w[0] === NULL_TASK_ID || w[0] === taskId),
+                                [CONFIG_KEY_SCRATCHPAD]: {},
                                 checkpoint_id: undefined,
                                 checkpoint_ns: taskCheckpointNamespace,
                             },

package/dist/pregel/index.cjs

@@ -863,7 +863,12 @@ class Pregel extends runnables_1.Runnable {
                                     throw error;
                                 }
                                 if ((0, errors_js_1.isGraphInterrupt)(error) && error.interrupts.length) {
-                                    loop.putWrites(task.id, error.interrupts.map((interrupt) => [constants_js_1.INTERRUPT, interrupt]));
+                                    const interrupts = error.interrupts.map((interrupt) => [constants_js_1.INTERRUPT, interrupt]);
+                                    const resumes = task.writes.filter((w) => w[0] === constants_js_1.RESUME);
+                                    if (resumes.length) {
+                                        interrupts.push(...resumes);
+                                    }
+                                    loop.putWrites(task.id, interrupts);
                                 }
                             }
                             else {

package/dist/pregel/index.js

@@ -7,7 +7,7 @@ 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, NULL_TASK_ID, INPUT, PUSH, } 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, RESUME, 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";
@@ -859,7 +859,12 @@ export class Pregel extends Runnable {
                                     throw error;
                                 }
                                 if (isGraphInterrupt(error) && error.interrupts.length) {
-                                    loop.putWrites(task.id, error.interrupts.map((interrupt) => [INTERRUPT, interrupt]));
+                                    const interrupts = error.interrupts.map((interrupt) => [INTERRUPT, interrupt]);
+                                    const resumes = task.writes.filter((w) => w[0] === RESUME);
+                                    if (resumes.length) {
+                                        interrupts.push(...resumes);
+                                    }
+                                    loop.putWrites(task.id, interrupts);
                                 }
                             }
                             else {

package/dist/pregel/io.cjs

@@ -49,7 +49,7 @@ exports.readChannels = readChannels;
 /**
  * Map input chunk to a sequence of pending writes in the form (channel, value).
  */
-function* mapCommand(cmd) {
+function* mapCommand(cmd, pendingWrites) {
     if (cmd.graph === constants_js_1.Command.PARENT) {
         throw new errors_js_1.InvalidUpdateError("There is no parent graph.");
     }
@@ -80,7 +80,11 @@ function* mapCommand(cmd) {
             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];
+                // Find existing resume values for this task ID
+                const existing = (pendingWrites.find(([id, type]) => id === tid && type === constants_js_1.RESUME)?.[2] ?? []);
+                // Ensure we have an array and append the resume value
+                existing.push(resume);
+                yield [tid, constants_js_1.RESUME, existing];
             }
         }
         else {

package/dist/pregel/io.d.ts

@@ -1,4 +1,4 @@
-import type { PendingWrite } from "@langchain/langgraph-checkpoint";
+import type { CheckpointPendingWrite, PendingWrite } from "@langchain/langgraph-checkpoint";
 import type { BaseChannel } from "../channels/base.js";
 import type { PregelExecutableTask } from "./types.js";
 import { Command } from "../constants.js";
@@ -7,7 +7,7 @@ export declare function readChannels<C extends PropertyKey>(channels: Record<C,
 /**
  * Map input chunk to a sequence of pending writes in the form (channel, value).
  */
-export declare function mapCommand(cmd: Command): Generator<[string, string, unknown]>;
+export declare function mapCommand(cmd: Command, pendingWrites: CheckpointPendingWrite<string>[]): Generator<[string, string, unknown]>;
 /**
  * Map input chunk to a sequence of pending writes in the form [channel, value].
  */

package/dist/pregel/io.js

@@ -44,7 +44,7 @@ export function readChannels(channels, select, skipEmpty = true
 /**
  * Map input chunk to a sequence of pending writes in the form (channel, value).
  */
-export function* mapCommand(cmd) {
+export function* mapCommand(cmd, pendingWrites) {
     if (cmd.graph === Command.PARENT) {
         throw new InvalidUpdateError("There is no parent graph.");
     }
@@ -75,7 +75,11 @@ export function* mapCommand(cmd) {
             Object.keys(cmd.resume).length &&
             Object.keys(cmd.resume).every(validate)) {
             for (const [tid, resume] of Object.entries(cmd.resume)) {
-                yield [tid, RESUME, resume];
+                // Find existing resume values for this task ID
+                const existing = (pendingWrites.find(([id, type]) => id === tid && type === RESUME)?.[2] ?? []);
+                // Ensure we have an array and append the resume value
+                existing.push(resume);
+                yield [tid, RESUME, existing];
             }
         }
         else {

package/dist/pregel/loop.cjs

@@ -399,14 +399,29 @@ class PregelLoop {
      * @param writes
      */
     putWrites(taskId, writes) {
-        if (writes.length === 0) {
+        let writesCopy = writes;
+        if (writesCopy.length === 0) {
             return;
         }
+        // deduplicate writes to special channels, last write wins
+        if (writesCopy.every(([key]) => key in langgraph_checkpoint_1.WRITES_IDX_MAP)) {
+            writesCopy = Array.from(new Map(writesCopy.map((w) => [w[0], w])).values());
+        }
         // save writes
-        const pendingWrites = writes.map(([key, value]) => {
-            return [taskId, key, value];
-        });
-        this.checkpointPendingWrites.push(...pendingWrites);
+        for (const [c, v] of writesCopy) {
+            if (c in langgraph_checkpoint_1.WRITES_IDX_MAP) {
+                const idx = this.checkpointPendingWrites.findIndex((w) => w[0] === taskId && w[1] === c);
+                if (idx !== -1) {
+                    this.checkpointPendingWrites[idx] = [taskId, c, v];
+                }
+                else {
+                    this.checkpointPendingWrites.push([taskId, c, v]);
+                }
+            }
+            else {
+                this.checkpointPendingWrites.push([taskId, c, v]);
+            }
+        }
         const putWritePromise = this.checkpointer?.putWrites({
             ...this.checkpointConfig,
             configurable: {
@@ -414,12 +429,12 @@ class PregelLoop {
                 checkpoint_ns: this.config.configurable?.checkpoint_ns ?? "",
                 checkpoint_id: this.checkpoint.id,
             },
-        }, writes, taskId);
+        }, writesCopy, taskId);
         if (putWritePromise !== undefined) {
             this.checkpointerPromises.push(putWritePromise);
         }
         if (this.tasks) {
-            this._outputWrites(taskId, writes);
+            this._outputWrites(taskId, writesCopy);
         }
     }
     _outputWrites(taskId, writes, cached = false) {
@@ -457,7 +472,7 @@ class PregelLoop {
             if (![INPUT_DONE, INPUT_RESUMING].includes(this.input)) {
                 await this._first(inputKeys);
             }
-            else if (Object.values(this.tasks).every((task) => task.writes.length > 0)) {
+            else if (Object.values(this.tasks).every((task) => task.writes.filter(([c]) => !(c in langgraph_checkpoint_1.WRITES_IDX_MAP)).length > 0)) {
                 const writes = Object.values(this.tasks).flatMap((t) => t.writes);
                 // All tasks have finished
                 const managedValueWrites = (0, algo_js_1._applyWrites)(this.checkpoint, this.channels, Object.values(this.tasks), this.checkpointerGetNextVersion);
@@ -581,7 +596,7 @@ class PregelLoop {
         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)) {
+            for (const [tid, key, value] of (0, io_js_1.mapCommand)(this.input, this.checkpointPendingWrites)) {
                 if (writes[tid] === undefined) {
                     writes[tid] = [];
                 }

package/dist/pregel/loop.js

@@ -1,5 +1,5 @@
 import { IterableReadableStream } from "@langchain/core/utils/stream";
-import { copyCheckpoint, emptyCheckpoint, AsyncBatchedStore, } from "@langchain/langgraph-checkpoint";
+import { copyCheckpoint, emptyCheckpoint, AsyncBatchedStore, WRITES_IDX_MAP, } from "@langchain/langgraph-checkpoint";
 import { createCheckpoint, emptyChannels, } from "../channels/base.js";
 import { _isCommand, CHECKPOINT_NAMESPACE_SEPARATOR, CONFIG_KEY_CHECKPOINT_MAP, CONFIG_KEY_READ, CONFIG_KEY_RESUMING, CONFIG_KEY_STREAM, ERROR, INPUT, INTERRUPT, RESUME, TAG_HIDDEN, } from "../constants.js";
 import { _applyWrites, _prepareNextTasks, increment, shouldInterrupt, } from "./algo.js";
@@ -395,14 +395,29 @@ export class PregelLoop {
      * @param writes
      */
     putWrites(taskId, writes) {
-        if (writes.length === 0) {
+        let writesCopy = writes;
+        if (writesCopy.length === 0) {
             return;
         }
+        // deduplicate writes to special channels, last write wins
+        if (writesCopy.every(([key]) => key in WRITES_IDX_MAP)) {
+            writesCopy = Array.from(new Map(writesCopy.map((w) => [w[0], w])).values());
+        }
         // save writes
-        const pendingWrites = writes.map(([key, value]) => {
-            return [taskId, key, value];
-        });
-        this.checkpointPendingWrites.push(...pendingWrites);
+        for (const [c, v] of writesCopy) {
+            if (c in WRITES_IDX_MAP) {
+                const idx = this.checkpointPendingWrites.findIndex((w) => w[0] === taskId && w[1] === c);
+                if (idx !== -1) {
+                    this.checkpointPendingWrites[idx] = [taskId, c, v];
+                }
+                else {
+                    this.checkpointPendingWrites.push([taskId, c, v]);
+                }
+            }
+            else {
+                this.checkpointPendingWrites.push([taskId, c, v]);
+            }
+        }
         const putWritePromise = this.checkpointer?.putWrites({
             ...this.checkpointConfig,
             configurable: {
@@ -410,12 +425,12 @@ export class PregelLoop {
                 checkpoint_ns: this.config.configurable?.checkpoint_ns ?? "",
                 checkpoint_id: this.checkpoint.id,
             },
-        }, writes, taskId);
+        }, writesCopy, taskId);
         if (putWritePromise !== undefined) {
             this.checkpointerPromises.push(putWritePromise);
         }
         if (this.tasks) {
-            this._outputWrites(taskId, writes);
+            this._outputWrites(taskId, writesCopy);
         }
     }
     _outputWrites(taskId, writes, cached = false) {
@@ -453,7 +468,7 @@ export class PregelLoop {
             if (![INPUT_DONE, INPUT_RESUMING].includes(this.input)) {
                 await this._first(inputKeys);
             }
-            else if (Object.values(this.tasks).every((task) => task.writes.length > 0)) {
+            else if (Object.values(this.tasks).every((task) => task.writes.filter(([c]) => !(c in WRITES_IDX_MAP)).length > 0)) {
                 const writes = Object.values(this.tasks).flatMap((t) => t.writes);
                 // All tasks have finished
                 const managedValueWrites = _applyWrites(this.checkpoint, this.channels, Object.values(this.tasks), this.checkpointerGetNextVersion);
@@ -577,7 +592,7 @@ export class PregelLoop {
         if (_isCommand(this.input)) {
             const writes = {};
             // group writes by task id
-            for (const [tid, key, value] of mapCommand(this.input)) {
+            for (const [tid, key, value] of mapCommand(this.input, this.checkpointPendingWrites)) {
                 if (writes[tid] === undefined) {
                     writes[tid] = [];
                 }

package/dist/pregel/types.d.ts

@@ -144,4 +144,9 @@ export interface StateSnapshot {
      */
     readonly tasks: PregelTaskDescription[];
 }
+export type PregelScratchpad<Resume> = {
+    interruptCounter: number;
+    usedNullResume: boolean;
+    resume: Resume[];
+};
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/langgraph",
-  "version": "0.2.29",
+  "version": "0.2.31",
   "description": "LangGraph",
   "type": "module",
   "engines": {
@@ -31,7 +31,7 @@
   "author": "LangChain",
   "license": "MIT",
   "dependencies": {
-    "@langchain/langgraph-checkpoint": "~0.0.12",
+    "@langchain/langgraph-checkpoint": "~0.0.13",
     "@langchain/langgraph-sdk": "~0.0.21",
     "uuid": "^10.0.0",
     "zod": "^3.23.8"