@langchain/langgraph 0.2.31 → 0.2.33

package/dist/graph/state.js

@@ -2,12 +2,12 @@
 import { _coerceToRunnable, Runnable, } from "@langchain/core/runnables";
 import { isBaseChannel } from "../channels/base.js";
 import { END, CompiledGraph, Graph, START, Branch, } from "./graph.js";
-import { ChannelWrite, PASSTHROUGH, SKIP_WRITE, } from "../pregel/write.js";
+import { ChannelWrite, PASSTHROUGH, } from "../pregel/write.js";
 import { ChannelRead, PregelNode } from "../pregel/read.js";
 import { NamedBarrierValue } from "../channels/named_barrier_value.js";
 import { EphemeralValue } from "../channels/ephemeral_value.js";
 import { RunnableCallable } from "../utils.js";
-import { _isCommand, _isSend, CHECKPOINT_NAMESPACE_END, CHECKPOINT_NAMESPACE_SEPARATOR, Command, SELF, TAG_HIDDEN, } from "../constants.js";
+import { isCommand, _isSend, CHECKPOINT_NAMESPACE_END, CHECKPOINT_NAMESPACE_SEPARATOR, Command, SELF, TAG_HIDDEN, } from "../constants.js";
 import { InvalidUpdateError, ParentCommand } from "../errors.js";
 import { getChannel, } from "./annotation.js";
 import { isConfiguredManagedValue } from "../managed/base.js";
@@ -343,59 +343,101 @@ function _getChannels(schema) {
  */
 export class CompiledStateGraph extends CompiledGraph {
     attachNode(key, node) {
-        const stateKeys = Object.keys(this.builder.channels);
+        let outputKeys;
+        if (key === START) {
+            // Get input schema keys excluding managed values
+            outputKeys = Object.entries(this.builder._schemaDefinitions.get(this.builder._inputDefinition))
+                .filter(([_, v]) => !isConfiguredManagedValue(v))
+                .map(([k]) => k);
+        }
+        else {
+            outputKeys = Object.keys(this.builder.channels);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         function _getRoot(input) {
-            if (_isCommand(input)) {
+            if (isCommand(input)) {
                 if (input.graph === Command.PARENT) {
-                    return SKIP_WRITE;
+                    return null;
+                }
+                return input._updateAsTuples();
+            }
+            else if (Array.isArray(input) &&
+                input.length > 0 &&
+                input.some((i) => isCommand(i))) {
+                const updates = [];
+                for (const i of input) {
+                    if (isCommand(i)) {
+                        if (i.graph === Command.PARENT) {
+                            continue;
+                        }
+                        updates.push(...i._updateAsTuples());
+                    }
+                    else {
+                        updates.push([ROOT, i]);
+                    }
                 }
-                return input.update;
+                return updates;
             }
-            return input;
+            else if (input != null) {
+                return [[ROOT, input]];
+            }
+            return null;
         }
         // to avoid name collision below
         const nodeKey = key;
-        function getStateKey(key, input) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        function _getUpdates(input) {
             if (!input) {
-                return SKIP_WRITE;
+                return null;
             }
-            else if (_isCommand(input)) {
+            else if (isCommand(input)) {
                 if (input.graph === Command.PARENT) {
-                    return SKIP_WRITE;
+                    return null;
                 }
-                return getStateKey(key, input.update);
+                return input._updateAsTuples();
             }
-            else if (typeof input !== "object" || Array.isArray(input)) {
+            else if (Array.isArray(input) &&
+                input.length > 0 &&
+                input.some(isCommand)) {
+                const updates = [];
+                for (const item of input) {
+                    if (isCommand(item)) {
+                        if (item.graph === Command.PARENT) {
+                            continue;
+                        }
+                        updates.push(...item._updateAsTuples());
+                    }
+                    else {
+                        const itemUpdates = _getUpdates(item);
+                        if (itemUpdates) {
+                            updates.push(...(itemUpdates ?? []));
+                        }
+                    }
+                }
+                return updates;
+            }
+            else if (typeof input === "object" && !Array.isArray(input)) {
+                return Object.entries(input).filter(([k]) => outputKeys.includes(k));
+            }
+            else {
                 const typeofInput = Array.isArray(input) ? "array" : typeof input;
                 throw new InvalidUpdateError(`Expected node "${nodeKey.toString()}" to return an object, received ${typeofInput}`, {
                     lc_error_code: "INVALID_GRAPH_NODE_RETURN_VALUE",
                 });
             }
-            else {
-                return key in input ? input[key] : SKIP_WRITE;
-            }
         }
-        // state updaters
-        const stateWriteEntries = stateKeys.map((key) => key === ROOT
-            ? {
-                channel: key,
+        const stateWriteEntries = [
+            {
                 value: PASSTHROUGH,
-                skipNone: true,
                 mapper: new RunnableCallable({
-                    func: _getRoot,
+                    func: outputKeys.length && outputKeys[0] === ROOT
+                        ? _getRoot
+                        : _getUpdates,
                     trace: false,
                     recurse: false,
                 }),
-            }
-            : {
-                channel: key,
-                value: PASSTHROUGH,
-                mapper: new RunnableCallable({
-                    func: getStateKey.bind(null, key),
-                    trace: false,
-                    recurse: false,
-                }),
-            });
+            },
+        ];
         // add node and output channel
         if (key === START) {
             this.nodes[key] = new PregelNode({
@@ -536,7 +578,7 @@ function _controlBranch(value) {
     if (_isSend(value)) {
         return [value];
     }
-    if (!_isCommand(value)) {
+    if (!isCommand(value)) {
         return [];
     }
     if (value.graph === Command.PARENT) {

package/dist/prebuilt/react_agent_executor.cjs

@@ -108,7 +108,7 @@ function _getModelPreprocessingRunnable(stateModifier, messageModifier) {
  * ```
  */
 function createReactAgent(params) {
-    const { llm, tools, messageModifier, stateModifier, checkpointSaver, interruptBefore, interruptAfter, store, } = params;
+    const { llm, tools, messageModifier, stateModifier, stateSchema, checkpointSaver, interruptBefore, interruptAfter, store, } = params;
     let toolClasses;
     if (!Array.isArray(tools)) {
         toolClasses = tools.tools;
@@ -138,7 +138,7 @@ function createReactAgent(params) {
         // TODO: Auto-promote streaming.
         return { messages: [await modelRunnable.invoke(state, config)] };
     };
-    const workflow = new index_js_1.StateGraph(messages_annotation_js_1.MessagesAnnotation)
+    const workflow = new index_js_1.StateGraph(stateSchema ?? messages_annotation_js_1.MessagesAnnotation)
         .addNode("agent", callModel)
         .addNode("tools", new tool_node_js_1.ToolNode(toolClasses))
         .addEdge(index_js_1.START, "agent")

package/dist/prebuilt/react_agent_executor.d.ts

@@ -3,7 +3,7 @@ import { BaseMessage, BaseMessageLike, SystemMessage } from "@langchain/core/mes
 import { Runnable, RunnableToolLike } from "@langchain/core/runnables";
 import { StructuredToolInterface } from "@langchain/core/tools";
 import { All, BaseCheckpointSaver, BaseStore } from "@langchain/langgraph-checkpoint";
-import { START, CompiledStateGraph } from "../graph/index.js";
+import { START, CompiledStateGraph, AnnotationRoot } from "../graph/index.js";
 import { MessagesAnnotation } from "../graph/messages_annotation.js";
 import { ToolNode } from "./tool_node.js";
 import { LangGraphRunnableConfig } from "../pregel/runnable_types.js";
@@ -14,11 +14,11 @@ export type N = typeof START | "agent" | "tools";
 export type StateModifier = SystemMessage | string | ((state: typeof MessagesAnnotation.State, config: LangGraphRunnableConfig) => BaseMessageLike[]) | ((state: typeof MessagesAnnotation.State, config: LangGraphRunnableConfig) => Promise<BaseMessageLike[]>) | Runnable;
 /** @deprecated Use StateModifier instead. */
 export type MessageModifier = SystemMessage | string | ((messages: BaseMessage[]) => BaseMessage[]) | ((messages: BaseMessage[]) => Promise<BaseMessage[]>) | Runnable;
-export type CreateReactAgentParams = {
+export type CreateReactAgentParams<A extends AnnotationRoot<any> = AnnotationRoot<any>> = {
     /** The chat model that can utilize OpenAI-style tool calling. */
     llm: BaseChatModel;
     /** A list of tools or a ToolNode. */
-    tools: ToolNode<typeof MessagesAnnotation.State> | (StructuredToolInterface | RunnableToolLike)[];
+    tools: ToolNode | (StructuredToolInterface | RunnableToolLike)[];
     /**
      * @deprecated
      * Use stateModifier instead. stateModifier works the same as
@@ -73,6 +73,7 @@ export type CreateReactAgentParams = {
      * - Runnable: This runnable should take in full graph state and the output is then passed to the language model.
      */
     stateModifier?: StateModifier;
+    stateSchema?: A;
     /** An optional checkpoint saver to persist the agent's state. */
     checkpointSaver?: BaseCheckpointSaver;
     /** An optional list of node names to interrupt before running. */
@@ -123,4 +124,4 @@ export type CreateReactAgentParams = {
  * // Returns the messages in the state at each step of execution
  * ```
  */
-export declare function createReactAgent(params: CreateReactAgentParams): CompiledStateGraph<(typeof MessagesAnnotation)["State"], (typeof MessagesAnnotation)["Update"], typeof START | "agent" | "tools">;
+export declare function createReactAgent<A extends AnnotationRoot<any> = AnnotationRoot<any>>(params: CreateReactAgentParams<A>): CompiledStateGraph<(typeof MessagesAnnotation)["State"], (typeof MessagesAnnotation)["Update"], typeof START | "agent" | "tools", typeof MessagesAnnotation.spec & A["spec"], typeof MessagesAnnotation.spec & A["spec"]>;

package/dist/prebuilt/react_agent_executor.js

@@ -1,6 +1,6 @@
 import { isAIMessage, isBaseMessage, SystemMessage, } from "@langchain/core/messages";
 import { Runnable, RunnableLambda, } from "@langchain/core/runnables";
-import { END, START, StateGraph } from "../graph/index.js";
+import { END, START, StateGraph, } from "../graph/index.js";
 import { MessagesAnnotation } from "../graph/messages_annotation.js";
 import { ToolNode } from "./tool_node.js";
 function _convertMessageModifierToStateModifier(messageModifier) {
@@ -105,7 +105,7 @@ function _getModelPreprocessingRunnable(stateModifier, messageModifier) {
  * ```
  */
 export function createReactAgent(params) {
-    const { llm, tools, messageModifier, stateModifier, checkpointSaver, interruptBefore, interruptAfter, store, } = params;
+    const { llm, tools, messageModifier, stateModifier, stateSchema, checkpointSaver, interruptBefore, interruptAfter, store, } = params;
     let toolClasses;
     if (!Array.isArray(tools)) {
         toolClasses = tools.tools;
@@ -135,7 +135,7 @@ export function createReactAgent(params) {
         // TODO: Auto-promote streaming.
         return { messages: [await modelRunnable.invoke(state, config)] };
     };
-    const workflow = new StateGraph(MessagesAnnotation)
+    const workflow = new StateGraph(stateSchema ?? MessagesAnnotation)
         .addNode("agent", callModel)
         .addNode("tools", new ToolNode(toolClasses))
         .addEdge(START, "agent")

package/dist/prebuilt/tool_node.cjs

@@ -5,6 +5,7 @@ const messages_1 = require("@langchain/core/messages");
 const utils_js_1 = require("../utils.cjs");
 const graph_js_1 = require("../graph/graph.cjs");
 const errors_js_1 = require("../errors.cjs");
+const constants_js_1 = require("../constants.cjs");
 /**
  * A node that runs the tools requested in the last AIMessage. It can be used
  * either in StateGraph with a "messages" key or in MessageGraph. If multiple
@@ -163,7 +164,8 @@ class ToolNode extends utils_js_1.RunnableCallable {
                     throw new Error(`Tool "${call.name}" not found.`);
                 }
                 const output = await tool.invoke({ ...call, type: "tool_call" }, config);
-                if ((0, messages_1.isBaseMessage)(output) && output._getType() === "tool") {
+                if (((0, messages_1.isBaseMessage)(output) && output._getType() === "tool") ||
+                    (0, constants_js_1.isCommand)(output)) {
                     return output;
                 }
                 else {
@@ -192,7 +194,18 @@ class ToolNode extends utils_js_1.RunnableCallable {
                 });
             }
         }) ?? []);
-        return (Array.isArray(input) ? outputs : { messages: outputs });
+        // Preserve existing behavior for non-command tool outputs for backwards compatibility
+        if (!outputs.some(constants_js_1.isCommand)) {
+            return (Array.isArray(input) ? outputs : { messages: outputs });
+        }
+        // Handle mixed Command and non-Command outputs
+        const combinedOutputs = outputs.map((output) => {
+            if ((0, constants_js_1.isCommand)(output)) {
+                return output;
+            }
+            return Array.isArray(input) ? [output] : { messages: [output] };
+        });
+        return combinedOutputs;
     }
 }
 exports.ToolNode = ToolNode;

package/dist/prebuilt/tool_node.js

@@ -2,6 +2,7 @@ import { ToolMessage, isBaseMessage, } from "@langchain/core/messages";
 import { RunnableCallable } from "../utils.js";
 import { END } from "../graph/graph.js";
 import { isGraphInterrupt } from "../errors.js";
+import { isCommand } from "../constants.js";
 /**
  * A node that runs the tools requested in the last AIMessage. It can be used
  * either in StateGraph with a "messages" key or in MessageGraph. If multiple
@@ -160,7 +161,8 @@ export class ToolNode extends RunnableCallable {
                     throw new Error(`Tool "${call.name}" not found.`);
                 }
                 const output = await tool.invoke({ ...call, type: "tool_call" }, config);
-                if (isBaseMessage(output) && output._getType() === "tool") {
+                if ((isBaseMessage(output) && output._getType() === "tool") ||
+                    isCommand(output)) {
                     return output;
                 }
                 else {
@@ -189,7 +191,18 @@ export class ToolNode extends RunnableCallable {
                 });
             }
         }) ?? []);
-        return (Array.isArray(input) ? outputs : { messages: outputs });
+        // Preserve existing behavior for non-command tool outputs for backwards compatibility
+        if (!outputs.some(isCommand)) {
+            return (Array.isArray(input) ? outputs : { messages: outputs });
+        }
+        // Handle mixed Command and non-Command outputs
+        const combinedOutputs = outputs.map((output) => {
+            if (isCommand(output)) {
+                return output;
+            }
+            return Array.isArray(input) ? [output] : { messages: [output] };
+        });
+        return combinedOutputs;
     }
 }
 export function toolsCondition(state) {

package/dist/pregel/index.cjs

@@ -345,6 +345,19 @@ class Pregel extends runnables_1.Runnable {
                 });
             }
         }
+        // apply pending writes
+        const nullWrites = (saved.pendingWrites ?? [])
+            .filter((w) => w[0] === constants_js_1.NULL_TASK_ID)
+            .map((w) => w.slice(1));
+        if (nullWrites.length > 0) {
+            (0, algo_js_1._applyWrites)(saved.checkpoint, channels, [
+                {
+                    name: constants_js_1.INPUT,
+                    writes: nullWrites,
+                    triggers: [],
+                },
+            ]);
+        }
         // assemble the state snapshot
         return {
             values: (0, io_js_1.readChannels)(channels, this.streamChannelsAsIs),
@@ -505,7 +518,7 @@ class Pregel extends runnables_1.Runnable {
                 // apply null writes
                 const nullWrites = (saved.pendingWrites || [])
                     .filter((w) => w[0] === constants_js_1.NULL_TASK_ID)
-                    .flatMap((w) => w.slice(1));
+                    .map((w) => w.slice(1));
                 if (nullWrites.length > 0) {
                     (0, algo_js_1._applyWrites)(saved.checkpoint, channels, [
                         {
@@ -547,6 +560,45 @@ class Pregel extends runnables_1.Runnable {
             }, {});
             return (0, index_js_1.patchCheckpointMap)(nextConfig, saved ? saved.metadata : undefined);
         }
+        // apply pending writes, if not on specific checkpoint
+        if (config.configurable?.checkpoint_id === undefined &&
+            saved?.pendingWrites !== undefined &&
+            saved.pendingWrites.length > 0) {
+            // tasks for this checkpoint
+            const nextTasks = (0, algo_js_1._prepareNextTasks)(checkpoint, saved.pendingWrites, this.nodes, channels, managed, saved.config, true, {
+                store: this.store,
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                checkpointer: this.checkpointer,
+                step: (saved.metadata?.step ?? -1) + 1,
+            });
+            // apply null writes
+            const nullWrites = (saved.pendingWrites ?? [])
+                .filter((w) => w[0] === constants_js_1.NULL_TASK_ID)
+                .map((w) => w.slice(1));
+            if (nullWrites.length > 0) {
+                (0, algo_js_1._applyWrites)(saved.checkpoint, channels, [
+                    {
+                        name: constants_js_1.INPUT,
+                        writes: nullWrites,
+                        triggers: [],
+                    },
+                ]);
+            }
+            // apply writes
+            for (const [tid, k, v] of saved.pendingWrites) {
+                if ([constants_js_1.ERROR, constants_js_1.INTERRUPT, langgraph_checkpoint_1.SCHEDULED].includes(k) ||
+                    nextTasks[tid] === undefined) {
+                    continue;
+                }
+                nextTasks[tid].writes.push([k, v]);
+            }
+            const tasks = Object.values(nextTasks).filter((task) => {
+                return task.writes.length > 0;
+            });
+            if (tasks.length > 0) {
+                (0, algo_js_1._applyWrites)(checkpoint, channels, tasks);
+            }
+        }
         const nonNullVersion = Object.values(checkpoint.versions_seen)
             .map((seenVersions) => {
             return Object.values(seenVersions);

package/dist/pregel/index.js

@@ -341,6 +341,19 @@ export class Pregel extends Runnable {
                 });
             }
         }
+        // apply pending writes
+        const nullWrites = (saved.pendingWrites ?? [])
+            .filter((w) => w[0] === NULL_TASK_ID)
+            .map((w) => w.slice(1));
+        if (nullWrites.length > 0) {
+            _applyWrites(saved.checkpoint, channels, [
+                {
+                    name: INPUT,
+                    writes: nullWrites,
+                    triggers: [],
+                },
+            ]);
+        }
         // assemble the state snapshot
         return {
             values: readChannels(channels, this.streamChannelsAsIs),
@@ -501,7 +514,7 @@ export class Pregel extends Runnable {
                 // apply null writes
                 const nullWrites = (saved.pendingWrites || [])
                     .filter((w) => w[0] === NULL_TASK_ID)
-                    .flatMap((w) => w.slice(1));
+                    .map((w) => w.slice(1));
                 if (nullWrites.length > 0) {
                     _applyWrites(saved.checkpoint, channels, [
                         {
@@ -543,6 +556,45 @@ export class Pregel extends Runnable {
             }, {});
             return patchCheckpointMap(nextConfig, saved ? saved.metadata : undefined);
         }
+        // apply pending writes, if not on specific checkpoint
+        if (config.configurable?.checkpoint_id === undefined &&
+            saved?.pendingWrites !== undefined &&
+            saved.pendingWrites.length > 0) {
+            // tasks for this checkpoint
+            const nextTasks = _prepareNextTasks(checkpoint, saved.pendingWrites, this.nodes, channels, managed, saved.config, true, {
+                store: this.store,
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                checkpointer: this.checkpointer,
+                step: (saved.metadata?.step ?? -1) + 1,
+            });
+            // apply null writes
+            const nullWrites = (saved.pendingWrites ?? [])
+                .filter((w) => w[0] === NULL_TASK_ID)
+                .map((w) => w.slice(1));
+            if (nullWrites.length > 0) {
+                _applyWrites(saved.checkpoint, channels, [
+                    {
+                        name: INPUT,
+                        writes: nullWrites,
+                        triggers: [],
+                    },
+                ]);
+            }
+            // apply writes
+            for (const [tid, k, v] of saved.pendingWrites) {
+                if ([ERROR, INTERRUPT, SCHEDULED].includes(k) ||
+                    nextTasks[tid] === undefined) {
+                    continue;
+                }
+                nextTasks[tid].writes.push([k, v]);
+            }
+            const tasks = Object.values(nextTasks).filter((task) => {
+                return task.writes.length > 0;
+            });
+            if (tasks.length > 0) {
+                _applyWrites(checkpoint, channels, tasks);
+            }
+        }
         const nonNullVersion = Object.values(checkpoint.versions_seen)
             .map((seenVersions) => {
             return Object.values(seenVersions);

package/dist/pregel/io.cjs

@@ -72,17 +72,16 @@ function* mapCommand(cmd, pendingWrites) {
                 throw new Error(`In Command.send, expected Send or string, got ${typeof send}`);
             }
         }
-        // TODO: handle goto str for state graph
     }
     if (cmd.resume) {
         if (typeof cmd.resume === "object" &&
-            !!cmd.resume &&
             Object.keys(cmd.resume).length &&
             Object.keys(cmd.resume).every(uuid_1.validate)) {
             for (const [tid, resume] of Object.entries(cmd.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
+                const existing = pendingWrites
+                    .filter((w) => w[0] === tid && w[1] === constants_js_1.RESUME)
+                    .map((w) => w[2])
+                    .slice(0, 1) ?? [];
                 existing.push(resume);
                 yield [tid, constants_js_1.RESUME, existing];
             }

package/dist/pregel/io.d.ts

@@ -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, pendingWrites: CheckpointPendingWrite<string>[]): Generator<[string, string, unknown]>;
+export declare function mapCommand(cmd: Command, pendingWrites: CheckpointPendingWrite[]): Generator<[string, string, unknown]>;
 /**
  * Map input chunk to a sequence of pending writes in the form [channel, value].
  */

package/dist/pregel/io.js

@@ -67,17 +67,16 @@ export function* mapCommand(cmd, pendingWrites) {
                 throw new Error(`In Command.send, expected Send or string, got ${typeof send}`);
             }
         }
-        // TODO: handle goto str for state graph
     }
     if (cmd.resume) {
         if (typeof cmd.resume === "object" &&
-            !!cmd.resume &&
             Object.keys(cmd.resume).length &&
             Object.keys(cmd.resume).every(validate)) {
             for (const [tid, resume] of Object.entries(cmd.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
+                const existing = pendingWrites
+                    .filter((w) => w[0] === tid && w[1] === RESUME)
+                    .map((w) => w[2])
+                    .slice(0, 1) ?? [];
                 existing.push(resume);
                 yield [tid, RESUME, existing];
             }

package/dist/pregel/loop.cjs

@@ -409,14 +409,9 @@ class PregelLoop {
         }
         // save writes
         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]);
-                }
+            const idx = this.checkpointPendingWrites.findIndex((w) => w[0] === taskId && w[1] === c);
+            if (c in langgraph_checkpoint_1.WRITES_IDX_MAP && idx !== -1) {
+                this.checkpointPendingWrites[idx] = [taskId, c, v];
             }
             else {
                 this.checkpointPendingWrites.push([taskId, c, v]);
@@ -586,14 +581,14 @@ class PregelLoop {
     /**
      * Resuming from previous checkpoint requires
      * - finding a previous checkpoint
-     * - receiving None input (outer graph) or RESUMING flag (subgraph)
+     * - receiving null input (outer graph) or RESUMING flag (subgraph)
      */
     async _first(inputKeys) {
         const isResuming = Object.keys(this.checkpoint.channel_versions).length !== 0 &&
             (this.config.configurable?.[constants_js_1.CONFIG_KEY_RESUMING] !== undefined ||
                 this.input === null ||
-                (0, constants_js_1._isCommand)(this.input));
-        if ((0, constants_js_1._isCommand)(this.input)) {
+                (0, constants_js_1.isCommand)(this.input));
+        if ((0, constants_js_1.isCommand)(this.input)) {
             const writes = {};
             // group writes by task id
             for (const [tid, key, value] of (0, io_js_1.mapCommand)(this.input, this.checkpointPendingWrites)) {
@@ -610,6 +605,19 @@ class PregelLoop {
                 this.putWrites(tid, ws);
             }
         }
+        // apply null writes
+        const nullWrites = (this.checkpointPendingWrites ?? [])
+            .filter((w) => w[0] === constants_js_1.NULL_TASK_ID)
+            .map((w) => w.slice(1));
+        if (nullWrites.length > 0) {
+            (0, algo_js_1._applyWrites)(this.checkpoint, this.channels, [
+                {
+                    name: constants_js_1.INPUT,
+                    writes: nullWrites,
+                    triggers: [],
+                },
+            ], this.checkpointerGetNextVersion);
+        }
         if (isResuming) {
             for (const channelName of Object.keys(this.channels)) {
                 if (this.checkpoint.channel_versions[channelName] !== undefined) {

package/dist/pregel/loop.d.ts

@@ -116,7 +116,7 @@ export declare class PregelLoop {
     /**
      * Resuming from previous checkpoint requires
      * - finding a previous checkpoint
-     * - receiving None input (outer graph) or RESUMING flag (subgraph)
+     * - receiving null input (outer graph) or RESUMING flag (subgraph)
      */
     protected _first(inputKeys: string | string[]): Promise<void>;
     protected _emit(values: [StreamMode, unknown][]): void;

package/dist/pregel/loop.js

@@ -1,7 +1,7 @@
 import { IterableReadableStream } from "@langchain/core/utils/stream";
 import { copyCheckpoint, emptyCheckpoint, AsyncBatchedStore, WRITES_IDX_MAP, } from "@langchain/langgraph-checkpoint";
 import { createCheckpoint, emptyChannels, } from "../channels/base.js";
-import { _isCommand, CHECKPOINT_NAMESPACE_SEPARATOR, CONFIG_KEY_CHECKPOINT_MAP, CONFIG_KEY_READ, CONFIG_KEY_RESUMING, CONFIG_KEY_STREAM, ERROR, INPUT, INTERRUPT, RESUME, TAG_HIDDEN, } from "../constants.js";
+import { isCommand, CHECKPOINT_NAMESPACE_SEPARATOR, CONFIG_KEY_CHECKPOINT_MAP, CONFIG_KEY_READ, CONFIG_KEY_RESUMING, CONFIG_KEY_STREAM, ERROR, INPUT, INTERRUPT, NULL_TASK_ID, RESUME, TAG_HIDDEN, } from "../constants.js";
 import { _applyWrites, _prepareNextTasks, increment, shouldInterrupt, } from "./algo.js";
 import { gatherIterator, gatherIteratorSync, prefixGenerator, } from "../utils.js";
 import { mapCommand, mapInput, mapOutputUpdates, mapOutputValues, readChannels, } from "./io.js";
@@ -405,14 +405,9 @@ export class PregelLoop {
         }
         // save writes
         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]);
-                }
+            const idx = this.checkpointPendingWrites.findIndex((w) => w[0] === taskId && w[1] === c);
+            if (c in WRITES_IDX_MAP && idx !== -1) {
+                this.checkpointPendingWrites[idx] = [taskId, c, v];
             }
             else {
                 this.checkpointPendingWrites.push([taskId, c, v]);
@@ -582,14 +577,14 @@ export class PregelLoop {
     /**
      * Resuming from previous checkpoint requires
      * - finding a previous checkpoint
-     * - receiving None input (outer graph) or RESUMING flag (subgraph)
+     * - receiving null input (outer graph) or RESUMING flag (subgraph)
      */
     async _first(inputKeys) {
         const isResuming = Object.keys(this.checkpoint.channel_versions).length !== 0 &&
             (this.config.configurable?.[CONFIG_KEY_RESUMING] !== undefined ||
                 this.input === null ||
-                _isCommand(this.input));
-        if (_isCommand(this.input)) {
+                isCommand(this.input));
+        if (isCommand(this.input)) {
             const writes = {};
             // group writes by task id
             for (const [tid, key, value] of mapCommand(this.input, this.checkpointPendingWrites)) {
@@ -606,6 +601,19 @@ export class PregelLoop {
                 this.putWrites(tid, ws);
             }
         }
+        // apply null writes
+        const nullWrites = (this.checkpointPendingWrites ?? [])
+            .filter((w) => w[0] === NULL_TASK_ID)
+            .map((w) => w.slice(1));
+        if (nullWrites.length > 0) {
+            _applyWrites(this.checkpoint, this.channels, [
+                {
+                    name: INPUT,
+                    writes: nullWrites,
+                    triggers: [],
+                },
+            ], this.checkpointerGetNextVersion);
+        }
         if (isResuming) {
             for (const channelName of Object.keys(this.channels)) {
                 if (this.checkpoint.channel_versions[channelName] !== undefined) {