@langchain/langgraph 0.2.26 → 0.2.27

package/dist/errors.cjs

@@ -64,6 +64,7 @@ class GraphInterrupt extends GraphBubbleUp {
 exports.GraphInterrupt = GraphInterrupt;
 /** Raised by a node to interrupt execution. */
 class NodeInterrupt extends GraphInterrupt {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     constructor(message, fields) {
         super([
             {

package/dist/errors.d.ts

@@ -24,7 +24,7 @@ export declare class GraphInterrupt extends GraphBubbleUp {
 }
 /** Raised by a node to interrupt execution. */
 export declare class NodeInterrupt extends GraphInterrupt {
-    constructor(message: string, fields?: BaseLangGraphErrorFields);
+    constructor(message: any, fields?: BaseLangGraphErrorFields);
     static get unminifiable_name(): string;
 }
 export declare function isGraphBubbleUp(e?: Error): e is GraphBubbleUp;

package/dist/errors.js

@@ -56,6 +56,7 @@ export class GraphInterrupt extends GraphBubbleUp {
 }
 /** Raised by a node to interrupt execution. */
 export class NodeInterrupt extends GraphInterrupt {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     constructor(message, fields) {
         super([
             {

package/dist/prebuilt/index.d.ts

@@ -1,5 +1,5 @@
 export { type AgentExecutorState, createAgentExecutor, } from "./agent_executor.js";
 export { type FunctionCallingExecutorState, createFunctionCallingExecutor, } from "./chat_agent_executor.js";
-export { type AgentState, createReactAgent } from "./react_agent_executor.js";
+export { type AgentState, type CreateReactAgentParams, createReactAgent, } from "./react_agent_executor.js";
 export { type ToolExecutorArgs, type ToolInvocationInterface, ToolExecutor, } from "./tool_executor.js";
 export { ToolNode, toolsCondition, type ToolNodeOptions } from "./tool_node.js";

package/dist/prebuilt/index.js

@@ -1,5 +1,5 @@
 export { createAgentExecutor, } from "./agent_executor.js";
 export { createFunctionCallingExecutor, } from "./chat_agent_executor.js";
-export { createReactAgent } from "./react_agent_executor.js";
+export { createReactAgent, } from "./react_agent_executor.js";
 export { ToolExecutor, } from "./tool_executor.js";
 export { ToolNode, toolsCondition } from "./tool_node.js";

package/dist/prebuilt/react_agent_executor.cjs

@@ -3,20 +3,70 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createReactAgent = void 0;
 const messages_1 = require("@langchain/core/messages");
 const runnables_1 = require("@langchain/core/runnables");
-const prompts_1 = require("@langchain/core/prompts");
 const index_js_1 = require("../graph/index.cjs");
 const messages_annotation_js_1 = require("../graph/messages_annotation.cjs");
 const tool_node_js_1 = require("./tool_node.cjs");
+function _convertMessageModifierToStateModifier(messageModifier) {
+    // Handle string or SystemMessage
+    if (typeof messageModifier === "string" ||
+        ((0, messages_1.isBaseMessage)(messageModifier) && messageModifier._getType() === "system")) {
+        return messageModifier;
+    }
+    // Handle callable function
+    if (typeof messageModifier === "function") {
+        return async (state) => messageModifier(state.messages);
+    }
+    // Handle Runnable
+    if (runnables_1.Runnable.isRunnable(messageModifier)) {
+        return runnables_1.RunnableLambda.from((state) => state.messages).pipe(messageModifier);
+    }
+    throw new Error(`Unexpected type for messageModifier: ${typeof messageModifier}`);
+}
+function _getStateModifierRunnable(stateModifier) {
+    let stateModifierRunnable;
+    if (stateModifier == null) {
+        stateModifierRunnable = runnables_1.RunnableLambda.from((state) => state.messages).withConfig({ runName: "state_modifier" });
+    }
+    else if (typeof stateModifier === "string") {
+        const systemMessage = new messages_1.SystemMessage(stateModifier);
+        stateModifierRunnable = runnables_1.RunnableLambda.from((state) => {
+            return [systemMessage, ...(state.messages ?? [])];
+        }).withConfig({ runName: "state_modifier" });
+    }
+    else if ((0, messages_1.isBaseMessage)(stateModifier) &&
+        stateModifier._getType() === "system") {
+        stateModifierRunnable = runnables_1.RunnableLambda.from((state) => [
+            stateModifier,
+            ...state.messages,
+        ]).withConfig({ runName: "state_modifier" });
+    }
+    else if (typeof stateModifier === "function") {
+        stateModifierRunnable = runnables_1.RunnableLambda.from(stateModifier).withConfig({
+            runName: "state_modifier",
+        });
+    }
+    else if (runnables_1.Runnable.isRunnable(stateModifier)) {
+        stateModifierRunnable = stateModifier;
+    }
+    else {
+        throw new Error(`Got unexpected type for 'stateModifier': ${typeof stateModifier}`);
+    }
+    return stateModifierRunnable;
+}
+function _getModelPreprocessingRunnable(stateModifier, messageModifier) {
+    // Check if both modifiers exist
+    if (stateModifier != null && messageModifier != null) {
+        throw new Error("Expected value for either stateModifier or messageModifier, got values for both");
+    }
+    // Convert message modifier to state modifier if necessary
+    if (stateModifier == null && messageModifier != null) {
+        // eslint-disable-next-line no-param-reassign
+        stateModifier = _convertMessageModifierToStateModifier(messageModifier);
+    }
+    return _getStateModifierRunnable(stateModifier);
+}
 /**
  * Creates a StateGraph agent that relies on a chat model utilizing tool calling.
- * @param params.llm The chat model that can utilize OpenAI-style tool calling.
- * @param params.tools A list of tools or a ToolNode.
- * @param params.messageModifier An optional message modifier to apply to messages before being passed to the LLM.
- * Can be a SystemMessage, string, function that takes and returns a list of messages, or a Runnable.
- * @param params.checkpointer An optional checkpoint saver to persist the agent's state.
- * @param params.interruptBefore An optional list of node names to interrupt before running.
- * @param params.interruptAfter An optional list of node names to interrupt after running.
- * @returns A prebuilt compiled graph.
  *
  * @example
  * ```ts
@@ -58,7 +108,7 @@ const tool_node_js_1 = require("./tool_node.cjs");
  * ```
  */
 function createReactAgent(params) {
-    const { llm, tools, messageModifier, checkpointSaver, interruptBefore, interruptAfter, } = params;
+    const { llm, tools, messageModifier, stateModifier, checkpointSaver, interruptBefore, interruptAfter, store, } = params;
     let toolClasses;
     if (!Array.isArray(tools)) {
         toolClasses = tools.tools;
@@ -70,7 +120,9 @@ function createReactAgent(params) {
         throw new Error(`llm ${llm} must define bindTools method.`);
     }
     const modelWithTools = llm.bindTools(toolClasses);
-    const modelRunnable = _createModelWrapper(modelWithTools, messageModifier);
+    // we're passing store here for validation
+    const preprocessor = _getModelPreprocessingRunnable(stateModifier, messageModifier);
+    const modelRunnable = preprocessor.pipe(modelWithTools);
     const shouldContinue = (state) => {
         const { messages } = state;
         const lastMessage = messages[messages.length - 1];
@@ -83,9 +135,8 @@ function createReactAgent(params) {
         }
     };
     const callModel = async (state, config) => {
-        const { messages } = state;
         // TODO: Auto-promote streaming.
-        return { messages: [await modelRunnable.invoke(messages, config)] };
+        return { messages: [await modelRunnable.invoke(state, config)] };
     };
     const workflow = new index_js_1.StateGraph(messages_annotation_js_1.MessagesAnnotation)
         .addNode("agent", callModel)
@@ -100,39 +151,7 @@ function createReactAgent(params) {
         checkpointer: checkpointSaver,
         interruptBefore,
         interruptAfter,
+        store,
     });
 }
 exports.createReactAgent = createReactAgent;
-function _createModelWrapper(modelWithTools, messageModifier) {
-    if (!messageModifier) {
-        return modelWithTools;
-    }
-    const endict = runnables_1.RunnableLambda.from((messages) => ({
-        messages,
-    }));
-    if (typeof messageModifier === "string") {
-        const systemMessage = new messages_1.SystemMessage(messageModifier);
-        const prompt = prompts_1.ChatPromptTemplate.fromMessages([
-            systemMessage,
-            ["placeholder", "{messages}"],
-        ]);
-        return endict.pipe(prompt).pipe(modelWithTools);
-    }
-    if (typeof messageModifier === "function") {
-        const lambda = runnables_1.RunnableLambda.from(messageModifier).withConfig({
-            runName: "message_modifier",
-        });
-        return lambda.pipe(modelWithTools);
-    }
-    if (runnables_1.Runnable.isRunnable(messageModifier)) {
-        return messageModifier.pipe(modelWithTools);
-    }
-    if (messageModifier._getType() === "system") {
-        const prompt = prompts_1.ChatPromptTemplate.fromMessages([
-            messageModifier,
-            ["placeholder", "{messages}"],
-        ]);
-        return endict.pipe(prompt).pipe(modelWithTools);
-    }
-    throw new Error(`Unsupported message modifier type: ${typeof messageModifier}`);
-}

package/dist/prebuilt/react_agent_executor.d.ts

@@ -1,34 +1,88 @@
 import { BaseChatModel } from "@langchain/core/language_models/chat_models";
-import { BaseMessage, SystemMessage } from "@langchain/core/messages";
+import { BaseMessage, BaseMessageLike, SystemMessage } from "@langchain/core/messages";
 import { Runnable, RunnableToolLike } from "@langchain/core/runnables";
 import { StructuredToolInterface } from "@langchain/core/tools";
-import { All, BaseCheckpointSaver } from "@langchain/langgraph-checkpoint";
-import { START } from "../graph/index.js";
+import { All, BaseCheckpointSaver, BaseStore } from "@langchain/langgraph-checkpoint";
+import { START, CompiledStateGraph } from "../graph/index.js";
 import { MessagesAnnotation } from "../graph/messages_annotation.js";
-import { CompiledStateGraph } from "../graph/state.js";
 import { ToolNode } from "./tool_node.js";
+import { LangGraphRunnableConfig } from "../pregel/runnable_types.js";
 export interface AgentState {
     messages: BaseMessage[];
 }
 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 = {
+    /** 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)[];
-    messageModifier?: SystemMessage | string | ((messages: BaseMessage[]) => BaseMessage[]) | ((messages: BaseMessage[]) => Promise<BaseMessage[]>) | Runnable;
+    /**
+     * @deprecated
+     * Use stateModifier instead. stateModifier works the same as
+     * messageModifier in that it runs right before calling the chat model,
+     * but if passed as a function, it takes the full graph state as
+     * input whenever a tool is called rather than a list of messages.
+     *
+     * If a function is passed, it should return a list of messages to
+     * pass directly to the chat model.
+     *
+     * @example
+     * ```ts
+     * import { ChatOpenAI } from "@langchain/openai";
+     * import { MessagesAnnotation } from "@langchain/langgraph";
+     * import { createReactAgent } from "@langchain/langgraph/prebuilt";
+     * import { type BaseMessage, SystemMessage } from "@langchain/core/messages";
+     *
+     * const model = new ChatOpenAI({
+     *   model: "gpt-4o-mini",
+     * });
+     *
+     * const tools = [...];
+     *
+     * // Deprecated style with messageModifier
+     * const deprecated = createReactAgent({
+     *   llm,
+     *   tools,
+     *   messageModifier: async (messages: BaseMessage[]) => {
+     *     return [new SystemMessage("You are a pirate")].concat(messages);
+     *   }
+     * });
+     *
+     * // New style with stateModifier
+     * const agent = createReactAgent({
+     *   llm,
+     *   tools,
+     *   stateModifier: async (state: typeof MessagesAnnotation.State) => {
+     *     return [new SystemMessage("You are a pirate.")].concat(messages);
+     *   }
+     * });
+     * ```
+     */
+    messageModifier?: MessageModifier;
+    /**
+     * An optional state modifier. This takes full graph state BEFORE the LLM is called and prepares the input to LLM.
+     *
+     * Can take a few different forms:
+     *
+     * - SystemMessage: this is added to the beginning of the list of messages in state["messages"].
+     * - str: This is converted to a SystemMessage and added to the beginning of the list of messages in state["messages"].
+     * - Function: This function should take in full graph state and the output is then passed to the language model.
+     * - Runnable: This runnable should take in full graph state and the output is then passed to the language model.
+     */
+    stateModifier?: StateModifier;
+    /** An optional checkpoint saver to persist the agent's state. */
     checkpointSaver?: BaseCheckpointSaver;
+    /** An optional list of node names to interrupt before running. */
     interruptBefore?: N[] | All;
+    /** An optional list of node names to interrupt after running. */
     interruptAfter?: N[] | All;
+    store?: BaseStore;
 };
 /**
  * Creates a StateGraph agent that relies on a chat model utilizing tool calling.
- * @param params.llm The chat model that can utilize OpenAI-style tool calling.
- * @param params.tools A list of tools or a ToolNode.
- * @param params.messageModifier An optional message modifier to apply to messages before being passed to the LLM.
- * Can be a SystemMessage, string, function that takes and returns a list of messages, or a Runnable.
- * @param params.checkpointer An optional checkpoint saver to persist the agent's state.
- * @param params.interruptBefore An optional list of node names to interrupt before running.
- * @param params.interruptAfter An optional list of node names to interrupt after running.
- * @returns A prebuilt compiled graph.
  *
  * @example
  * ```ts

package/dist/prebuilt/react_agent_executor.js

@@ -1,19 +1,69 @@
-import { isAIMessage, SystemMessage, } from "@langchain/core/messages";
+import { isAIMessage, isBaseMessage, SystemMessage, } from "@langchain/core/messages";
 import { Runnable, RunnableLambda, } from "@langchain/core/runnables";
-import { ChatPromptTemplate } from "@langchain/core/prompts";
 import { END, START, StateGraph } from "../graph/index.js";
 import { MessagesAnnotation } from "../graph/messages_annotation.js";
 import { ToolNode } from "./tool_node.js";
+function _convertMessageModifierToStateModifier(messageModifier) {
+    // Handle string or SystemMessage
+    if (typeof messageModifier === "string" ||
+        (isBaseMessage(messageModifier) && messageModifier._getType() === "system")) {
+        return messageModifier;
+    }
+    // Handle callable function
+    if (typeof messageModifier === "function") {
+        return async (state) => messageModifier(state.messages);
+    }
+    // Handle Runnable
+    if (Runnable.isRunnable(messageModifier)) {
+        return RunnableLambda.from((state) => state.messages).pipe(messageModifier);
+    }
+    throw new Error(`Unexpected type for messageModifier: ${typeof messageModifier}`);
+}
+function _getStateModifierRunnable(stateModifier) {
+    let stateModifierRunnable;
+    if (stateModifier == null) {
+        stateModifierRunnable = RunnableLambda.from((state) => state.messages).withConfig({ runName: "state_modifier" });
+    }
+    else if (typeof stateModifier === "string") {
+        const systemMessage = new SystemMessage(stateModifier);
+        stateModifierRunnable = RunnableLambda.from((state) => {
+            return [systemMessage, ...(state.messages ?? [])];
+        }).withConfig({ runName: "state_modifier" });
+    }
+    else if (isBaseMessage(stateModifier) &&
+        stateModifier._getType() === "system") {
+        stateModifierRunnable = RunnableLambda.from((state) => [
+            stateModifier,
+            ...state.messages,
+        ]).withConfig({ runName: "state_modifier" });
+    }
+    else if (typeof stateModifier === "function") {
+        stateModifierRunnable = RunnableLambda.from(stateModifier).withConfig({
+            runName: "state_modifier",
+        });
+    }
+    else if (Runnable.isRunnable(stateModifier)) {
+        stateModifierRunnable = stateModifier;
+    }
+    else {
+        throw new Error(`Got unexpected type for 'stateModifier': ${typeof stateModifier}`);
+    }
+    return stateModifierRunnable;
+}
+function _getModelPreprocessingRunnable(stateModifier, messageModifier) {
+    // Check if both modifiers exist
+    if (stateModifier != null && messageModifier != null) {
+        throw new Error("Expected value for either stateModifier or messageModifier, got values for both");
+    }
+    // Convert message modifier to state modifier if necessary
+    if (stateModifier == null && messageModifier != null) {
+        // eslint-disable-next-line no-param-reassign
+        stateModifier = _convertMessageModifierToStateModifier(messageModifier);
+    }
+    return _getStateModifierRunnable(stateModifier);
+}
 /**
  * Creates a StateGraph agent that relies on a chat model utilizing tool calling.
- * @param params.llm The chat model that can utilize OpenAI-style tool calling.
- * @param params.tools A list of tools or a ToolNode.
- * @param params.messageModifier An optional message modifier to apply to messages before being passed to the LLM.
- * Can be a SystemMessage, string, function that takes and returns a list of messages, or a Runnable.
- * @param params.checkpointer An optional checkpoint saver to persist the agent's state.
- * @param params.interruptBefore An optional list of node names to interrupt before running.
- * @param params.interruptAfter An optional list of node names to interrupt after running.
- * @returns A prebuilt compiled graph.
  *
  * @example
  * ```ts
@@ -55,7 +105,7 @@ import { ToolNode } from "./tool_node.js";
  * ```
  */
 export function createReactAgent(params) {
-    const { llm, tools, messageModifier, checkpointSaver, interruptBefore, interruptAfter, } = params;
+    const { llm, tools, messageModifier, stateModifier, checkpointSaver, interruptBefore, interruptAfter, store, } = params;
     let toolClasses;
     if (!Array.isArray(tools)) {
         toolClasses = tools.tools;
@@ -67,7 +117,9 @@ export function createReactAgent(params) {
         throw new Error(`llm ${llm} must define bindTools method.`);
     }
     const modelWithTools = llm.bindTools(toolClasses);
-    const modelRunnable = _createModelWrapper(modelWithTools, messageModifier);
+    // we're passing store here for validation
+    const preprocessor = _getModelPreprocessingRunnable(stateModifier, messageModifier);
+    const modelRunnable = preprocessor.pipe(modelWithTools);
     const shouldContinue = (state) => {
         const { messages } = state;
         const lastMessage = messages[messages.length - 1];
@@ -80,9 +132,8 @@ export function createReactAgent(params) {
         }
     };
     const callModel = async (state, config) => {
-        const { messages } = state;
         // TODO: Auto-promote streaming.
-        return { messages: [await modelRunnable.invoke(messages, config)] };
+        return { messages: [await modelRunnable.invoke(state, config)] };
     };
     const workflow = new StateGraph(MessagesAnnotation)
         .addNode("agent", callModel)
@@ -97,38 +148,6 @@ export function createReactAgent(params) {
         checkpointer: checkpointSaver,
         interruptBefore,
         interruptAfter,
+        store,
     });
 }
-function _createModelWrapper(modelWithTools, messageModifier) {
-    if (!messageModifier) {
-        return modelWithTools;
-    }
-    const endict = RunnableLambda.from((messages) => ({
-        messages,
-    }));
-    if (typeof messageModifier === "string") {
-        const systemMessage = new SystemMessage(messageModifier);
-        const prompt = ChatPromptTemplate.fromMessages([
-            systemMessage,
-            ["placeholder", "{messages}"],
-        ]);
-        return endict.pipe(prompt).pipe(modelWithTools);
-    }
-    if (typeof messageModifier === "function") {
-        const lambda = RunnableLambda.from(messageModifier).withConfig({
-            runName: "message_modifier",
-        });
-        return lambda.pipe(modelWithTools);
-    }
-    if (Runnable.isRunnable(messageModifier)) {
-        return messageModifier.pipe(modelWithTools);
-    }
-    if (messageModifier._getType() === "system") {
-        const prompt = ChatPromptTemplate.fromMessages([
-            messageModifier,
-            ["placeholder", "{messages}"],
-        ]);
-        return endict.pipe(prompt).pipe(modelWithTools);
-    }
-    throw new Error(`Unsupported message modifier type: ${typeof messageModifier}`);
-}

package/dist/pregel/index.cjs

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

package/dist/pregel/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/langgraph",
-  "version": "0.2.26",
+  "version": "0.2.27",
   "description": "LangGraph",
   "type": "module",
   "engines": {