@langchain/langgraph 0.2.8 → 0.2.9

package/dist/pregel/algo.js

@@ -3,9 +3,9 @@ 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, CHECKPOINT_NAMESPACE_SEPARATOR, CONFIG_KEY_CHECKPOINTER, CONFIG_KEY_READ, CONFIG_KEY_RESUMING, CONFIG_KEY_SEND, INTERRUPT, RESERVED, TAG_HIDDEN, TASKS, } 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, } from "../constants.js";
 import { EmptyChannelError, InvalidUpdateError } from "../errors.js";
-import { _getIdMetadata, getNullChannelVersion } from "./utils.js";
+import { getNullChannelVersion } from "./utils/index.js";
 export const increment = (current) => {
     return current !== undefined ? current + 1 : 1;
 };
@@ -196,48 +196,83 @@ getNextVersion) {
     return pendingWritesByManaged;
 }
 export function _prepareNextTasks(checkpoint, processes, channels, managed, config, forExecution, extra) {
-    const parentNamespace = config.configurable?.checkpoint_ns ?? "";
-    const tasks = [];
-    const taskDescriptions = [];
-    const { step, isResuming = false, checkpointer, manager } = extra;
-    for (const packet of checkpoint.pending_sends) {
+    const tasks = {};
+    // Consume pending packets
+    for (let i = 0; i < checkpoint.pending_sends.length; i += 1) {
+        const task = _prepareSingleTask([PUSH, i], checkpoint, processes, channels, managed, config, forExecution, extra);
+        if (task !== undefined) {
+            tasks[task.id] = task;
+        }
+    }
+    // Check if any processes should be run in next step
+    // If so, prepare the values to be passed to them
+    for (const name of Object.keys(processes)) {
+        const task = _prepareSingleTask([PULL, name], checkpoint, processes, channels, managed, config, forExecution, extra);
+        if (task !== undefined) {
+            tasks[task.id] = task;
+        }
+    }
+    return tasks;
+}
+export function _prepareSingleTask(taskPath, checkpoint, processes, channels, managed, config, forExecution, extra) {
+    const { step, checkpointer, manager } = extra;
+    const configurable = config.configurable ?? {};
+    const parentNamespace = configurable.checkpoint_ns ?? "";
+    if (taskPath[0] === PUSH) {
+        const index = typeof taskPath[1] === "number" ? taskPath[1] : parseInt(taskPath[1], 10);
+        if (index >= checkpoint.pending_sends.length) {
+            return undefined;
+        }
+        const packet = checkpoint.pending_sends[index];
         if (!_isSendInterface(packet)) {
             console.warn(`Ignoring invalid packet ${JSON.stringify(packet)} in pending sends.`);
-            continue;
+            return undefined;
         }
         if (!(packet.node in processes)) {
             console.warn(`Ignoring unknown node name ${packet.node} in pending sends.`);
-            continue;
+            return undefined;
         }
-        const triggers = [TASKS];
-        const metadata = _getIdMetadata({
-            langgraph_step: step,
-            langgraph_node: packet.node,
-            langgraph_triggers: triggers,
-            langgraph_task_idx: forExecution ? tasks.length : taskDescriptions.length,
-        });
+        const triggers = [PUSH];
         const checkpointNamespace = parentNamespace === ""
             ? packet.node
             : `${parentNamespace}${CHECKPOINT_NAMESPACE_SEPARATOR}${packet.node}`;
-        const taskId = uuid5(JSON.stringify([checkpointNamespace, metadata]), checkpoint.id);
+        const taskId = uuid5(JSON.stringify([
+            checkpointNamespace,
+            step.toString(),
+            packet.node,
+            PUSH,
+            index.toString(),
+        ]), checkpoint.id);
+        const taskCheckpointNamespace = `${checkpointNamespace}${CHECKPOINT_NAMESPACE_END}${taskId}`;
+        let metadata = {
+            langgraph_step: step,
+            langgraph_node: packet.node,
+            langgraph_triggers: triggers,
+            langgraph_path: taskPath,
+            langgraph_checkpoint_ns: taskCheckpointNamespace,
+        };
         if (forExecution) {
             const proc = processes[packet.node];
             const node = proc.getNode();
             if (node !== undefined) {
-                const writes = [];
                 managed.replaceRuntimePlaceholders(step, packet.args);
-                tasks.push({
+                if (proc.metadata !== undefined) {
+                    metadata = { ...metadata, ...proc.metadata };
+                }
+                const writes = [];
+                return {
                     name: packet.node,
                     input: packet.args,
                     proc: node,
                     writes,
-                    triggers,
-                    config: patchConfig(mergeConfigs(config, processes[packet.node].config, {
+                    config: patchConfig(mergeConfigs(config, {
                         metadata,
+                        tags: proc.tags,
                     }), {
                         runName: packet.node,
                         callbacks: manager?.getChild(`graph:step:${step}`),
                         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_READ]: (select_, fresh_ = false) => _localRead(step, checkpoint, channels, managed, {
@@ -245,24 +280,36 @@ export function _prepareNextTasks(checkpoint, processes, channels, managed, conf
                                 writes: writes,
                                 triggers,
                             }, select_, fresh_),
+                            [CONFIG_KEY_CHECKPOINTER]: checkpointer ?? configurable[CONFIG_KEY_CHECKPOINTER],
+                            [CONFIG_KEY_CHECKPOINT_MAP]: {
+                                ...configurable[CONFIG_KEY_CHECKPOINT_MAP],
+                                [parentNamespace]: checkpoint.id,
+                            },
+                            checkpoint_id: undefined,
+                            checkpoint_ns: taskCheckpointNamespace,
                         },
                     }),
-                    id: taskId,
+                    triggers,
                     retry_policy: proc.retryPolicy,
-                });
+                    id: taskId,
+                    path: taskPath,
+                };
             }
         }
         else {
-            taskDescriptions.push({ id: taskId, name: packet.node, interrupts: [] });
+            return { id: taskId, name: packet.node, interrupts: [], path: taskPath };
         }
     }
-    // Check if any processes should be run in next step
-    // If so, prepare the values to be passed to them
-    const nullVersion = getNullChannelVersion(checkpoint.channel_versions);
-    if (nullVersion === undefined) {
-        return forExecution ? tasks : taskDescriptions;
-    }
-    for (const [name, proc] of Object.entries(processes)) {
+    else if (taskPath[0] === PULL) {
+        const name = taskPath[1].toString();
+        const proc = processes[name];
+        if (proc === undefined) {
+            return undefined;
+        }
+        const nullVersion = getNullChannelVersion(checkpoint.channel_versions);
+        if (nullVersion === undefined) {
+            return undefined;
+        }
         const seen = checkpoint.versions_seen[name] ?? {};
         const triggers = proc.triggers
             .filter((chan) => {
@@ -280,58 +327,75 @@ export function _prepareNextTasks(checkpoint, processes, channels, managed, conf
         if (triggers.length > 0) {
             const val = _procInput(step, proc, managed, channels, forExecution);
             if (val === undefined) {
-                continue;
+                return undefined;
             }
-            const metadata = _getIdMetadata({
-                langgraph_step: step,
-                langgraph_node: name,
-                langgraph_triggers: triggers,
-                langgraph_task_idx: forExecution
-                    ? tasks.length
-                    : taskDescriptions.length,
-            });
             const checkpointNamespace = parentNamespace === ""
                 ? name
                 : `${parentNamespace}${CHECKPOINT_NAMESPACE_SEPARATOR}${name}`;
-            const taskId = uuid5(JSON.stringify([checkpointNamespace, metadata]), checkpoint.id);
+            const taskId = uuid5(JSON.stringify([
+                checkpointNamespace,
+                step.toString(),
+                name,
+                PULL,
+                triggers,
+            ]), checkpoint.id);
+            const taskCheckpointNamespace = `${checkpointNamespace}${CHECKPOINT_NAMESPACE_END}${taskId}`;
+            let metadata = {
+                langgraph_step: step,
+                langgraph_node: name,
+                langgraph_triggers: triggers,
+                langgraph_path: taskPath,
+                langgraph_checkpoint_ns: taskCheckpointNamespace,
+            };
             if (forExecution) {
                 const node = proc.getNode();
                 if (node !== undefined) {
+                    if (proc.metadata !== undefined) {
+                        metadata = { ...metadata, ...proc.metadata };
+                    }
                     const writes = [];
-                    tasks.push({
+                    const taskCheckpointNamespace = `${checkpointNamespace}${CHECKPOINT_NAMESPACE_END}${taskId}`;
+                    return {
                         name,
                         input: val,
                         proc: node,
                         writes,
-                        triggers,
-                        config: patchConfig(mergeConfigs(config, proc.config, { metadata }), {
+                        config: patchConfig(mergeConfigs(config, { metadata, tags: proc.tags }), {
                             runName: name,
                             callbacks: manager?.getChild(`graph:step:${step}`),
                             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, channels, managed, writes_),
                                 [CONFIG_KEY_READ]: (select_, fresh_ = false) => _localRead(step, checkpoint, channels, managed, {
                                     name,
                                     writes: writes,
                                     triggers,
                                 }, select_, fresh_),
-                                [CONFIG_KEY_CHECKPOINTER]: checkpointer,
-                                [CONFIG_KEY_RESUMING]: isResuming,
-                                checkpoint_id: checkpoint.id,
-                                checkpoint_ns: checkpointNamespace,
+                                [CONFIG_KEY_CHECKPOINTER]: checkpointer ?? configurable[CONFIG_KEY_CHECKPOINTER],
+                                [CONFIG_KEY_CHECKPOINT_MAP]: {
+                                    ...configurable[CONFIG_KEY_CHECKPOINT_MAP],
+                                    [parentNamespace]: checkpoint.id,
+                                },
+                                checkpoint_id: undefined,
+                                checkpoint_ns: taskCheckpointNamespace,
                             },
                         }),
-                        id: taskId,
+                        triggers,
                         retry_policy: proc.retryPolicy,
-                    });
+                        id: taskId,
+                        path: taskPath,
+                    };
                 }
             }
             else {
-                taskDescriptions.push({ id: taskId, name, interrupts: [] });
+                return { id: taskId, name, interrupts: [], path: taskPath };
             }
         }
     }
-    return forExecution ? tasks : taskDescriptions;
+    return undefined;
 }
 function _procInput(step, proc, managed, channels, forExecution) {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any

package/dist/pregel/debug.cjs

@@ -1,11 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.printStepWrites = exports.printStepTasks = exports.printStepCheckpoint = exports.tasksWithWrites = exports.mapDebugCheckpoint = exports.mapDebugTaskResults = exports.mapDebugTasks = exports.printCheckpoint = void 0;
-const langgraph_checkpoint_1 = require("@langchain/langgraph-checkpoint");
 const constants_js_1 = require("../constants.cjs");
 const errors_js_1 = require("../errors.cjs");
 const io_js_1 = require("./io.cjs");
-const utils_js_1 = require("./utils.cjs");
 const COLORS_MAP = {
     blue: {
         start: "\x1b[34m",
@@ -56,13 +54,6 @@ function* mapDebugTasks(step, tasks) {
     for (const { id, name, input, config, triggers, writes } of tasks) {
         if (config?.tags?.includes(constants_js_1.TAG_HIDDEN))
             continue;
-        const metadata = { ...config?.metadata };
-        const idMetadata = (0, utils_js_1._getIdMetadata)({
-            langgraph_step: metadata.langgraph_step,
-            langgraph_node: metadata.langgraph_node,
-            langgraph_triggers: metadata.langgraph_triggers,
-            langgraph_task_idx: metadata.langgraph_task_idx,
-        });
         const interrupts = writes
             .filter(([writeId, n]) => {
             return writeId === id && n === constants_js_1.INTERRUPT;
@@ -75,7 +66,7 @@ function* mapDebugTasks(step, tasks) {
             timestamp: ts,
             step,
             payload: {
-                id: (0, langgraph_checkpoint_1.uuid5)(JSON.stringify([name, step, idMetadata]), constants_js_1.TASK_NAMESPACE),
+                id,
                 name,
                 input,
                 triggers,
@@ -87,21 +78,24 @@ function* mapDebugTasks(step, tasks) {
 exports.mapDebugTasks = mapDebugTasks;
 function* mapDebugTaskResults(step, tasks, streamChannels) {
     const ts = new Date().toISOString();
-    for (const [{ name, config }, writes] of tasks) {
+    for (const [{ id, name, config }, writes] of tasks) {
         if (config?.tags?.includes(constants_js_1.TAG_HIDDEN))
             continue;
-        const metadata = { ...config?.metadata };
-        const idMetadata = (0, utils_js_1._getIdMetadata)(metadata);
         yield {
             type: "task_result",
             timestamp: ts,
             step,
             payload: {
-                id: (0, langgraph_checkpoint_1.uuid5)(JSON.stringify([name, step, idMetadata]), constants_js_1.TASK_NAMESPACE),
+                id,
                 name,
-                result: writes.filter(([channel]) => Array.isArray(streamChannels)
-                    ? streamChannels.includes(channel)
-                    : channel === streamChannels),
+                result: writes.filter(([channel]) => {
+                    return Array.isArray(streamChannels)
+                        ? streamChannels.includes(channel)
+                        : channel === streamChannels;
+                }),
+                interrupts: writes.filter(([channel]) => {
+                    return channel === constants_js_1.INTERRUPT;
+                }),
             },
         };
     }
@@ -148,7 +142,7 @@ function* mapDebugCheckpoint(step, config, channels, streamChannels, metadata, t
     };
 }
 exports.mapDebugCheckpoint = mapDebugCheckpoint;
-function tasksWithWrites(tasks, pendingWrites) {
+function tasksWithWrites(tasks, pendingWrites, states) {
     return tasks.map((task) => {
         const error = pendingWrites.find(([id, n]) => id === task.id && n === constants_js_1.ERROR)?.[2];
         const interrupts = pendingWrites
@@ -162,6 +156,7 @@ function tasksWithWrites(tasks, pendingWrites) {
             return {
                 id: task.id,
                 name: task.name,
+                path: task.path,
                 error,
                 interrupts,
             };
@@ -169,7 +164,9 @@ function tasksWithWrites(tasks, pendingWrites) {
         return {
             id: task.id,
             name: task.name,
+            path: task.path,
             interrupts,
+            state: states?.[task.id],
         };
     });
 }

package/dist/pregel/debug.d.ts

@@ -1,7 +1,7 @@
 import { RunnableConfig } from "@langchain/core/runnables";
 import { CheckpointMetadata, CheckpointPendingWrite, PendingWrite } from "@langchain/langgraph-checkpoint";
 import { BaseChannel } from "../channels/base.js";
-import { PregelExecutableTask, PregelTaskDescription } from "./types.js";
+import { PregelExecutableTask, PregelTaskDescription, StateSnapshot } from "./types.js";
 export declare function printCheckpoint<Value>(step: number, channels: Record<string, BaseChannel<Value>>): void;
 export declare function mapDebugTasks<N extends PropertyKey, C extends PropertyKey>(step: number, tasks: readonly PregelExecutableTask<N, C>[]): Generator<{
     type: string;
@@ -23,6 +23,7 @@ export declare function mapDebugTaskResults<N extends PropertyKey, C extends Pro
         id: string;
         name: N;
         result: PendingWrite<C>[];
+        interrupts: PendingWrite<C>[];
     };
 }, void, unknown>;
 export declare function mapDebugCheckpoint<N extends PropertyKey, C extends PropertyKey>(step: number, config: RunnableConfig, channels: Record<string, BaseChannel>, streamChannels: string | string[], metadata: CheckpointMetadata, tasks: readonly PregelExecutableTask<N, C>[], pendingWrites: CheckpointPendingWrite[]): Generator<{
@@ -37,7 +38,7 @@ export declare function mapDebugCheckpoint<N extends PropertyKey, C extends Prop
         tasks: PregelTaskDescription[];
     };
 }, void, unknown>;
-export declare function tasksWithWrites<N extends PropertyKey, C extends PropertyKey>(tasks: PregelTaskDescription[] | readonly PregelExecutableTask<N, C>[], pendingWrites: CheckpointPendingWrite[]): PregelTaskDescription[];
+export declare function tasksWithWrites<N extends PropertyKey, C extends PropertyKey>(tasks: PregelTaskDescription[] | readonly PregelExecutableTask<N, C>[], pendingWrites: CheckpointPendingWrite[], states?: Record<string, RunnableConfig | StateSnapshot>): PregelTaskDescription[];
 export declare function printStepCheckpoint(step: number, channels: Record<string, BaseChannel<unknown>>, whitelist: string[]): void;
 export declare function printStepTasks<N extends PropertyKey, C extends PropertyKey>(step: number, nextTasks: readonly PregelExecutableTask<N, C>[]): void;
 export declare function printStepWrites(step: number, writes: PendingWrite[], whitelist: string[]): void;

package/dist/pregel/debug.js

@@ -1,8 +1,6 @@
-import { uuid5, } from "@langchain/langgraph-checkpoint";
-import { ERROR, INTERRUPT, TAG_HIDDEN, TASK_NAMESPACE, } from "../constants.js";
+import { ERROR, INTERRUPT, TAG_HIDDEN } from "../constants.js";
 import { EmptyChannelError } from "../errors.js";
 import { readChannels } from "./io.js";
-import { _getIdMetadata } from "./utils.js";
 const COLORS_MAP = {
     blue: {
         start: "\x1b[34m",
@@ -52,13 +50,6 @@ export function* mapDebugTasks(step, tasks) {
     for (const { id, name, input, config, triggers, writes } of tasks) {
         if (config?.tags?.includes(TAG_HIDDEN))
             continue;
-        const metadata = { ...config?.metadata };
-        const idMetadata = _getIdMetadata({
-            langgraph_step: metadata.langgraph_step,
-            langgraph_node: metadata.langgraph_node,
-            langgraph_triggers: metadata.langgraph_triggers,
-            langgraph_task_idx: metadata.langgraph_task_idx,
-        });
         const interrupts = writes
             .filter(([writeId, n]) => {
             return writeId === id && n === INTERRUPT;
@@ -71,7 +62,7 @@ export function* mapDebugTasks(step, tasks) {
             timestamp: ts,
             step,
             payload: {
-                id: uuid5(JSON.stringify([name, step, idMetadata]), TASK_NAMESPACE),
+                id,
                 name,
                 input,
                 triggers,
@@ -82,21 +73,24 @@ export function* mapDebugTasks(step, tasks) {
 }
 export function* mapDebugTaskResults(step, tasks, streamChannels) {
     const ts = new Date().toISOString();
-    for (const [{ name, config }, writes] of tasks) {
+    for (const [{ id, name, config }, writes] of tasks) {
         if (config?.tags?.includes(TAG_HIDDEN))
             continue;
-        const metadata = { ...config?.metadata };
-        const idMetadata = _getIdMetadata(metadata);
         yield {
             type: "task_result",
             timestamp: ts,
             step,
             payload: {
-                id: uuid5(JSON.stringify([name, step, idMetadata]), TASK_NAMESPACE),
+                id,
                 name,
-                result: writes.filter(([channel]) => Array.isArray(streamChannels)
-                    ? streamChannels.includes(channel)
-                    : channel === streamChannels),
+                result: writes.filter(([channel]) => {
+                    return Array.isArray(streamChannels)
+                        ? streamChannels.includes(channel)
+                        : channel === streamChannels;
+                }),
+                interrupts: writes.filter(([channel]) => {
+                    return channel === INTERRUPT;
+                }),
             },
         };
     }
@@ -141,7 +135,7 @@ export function* mapDebugCheckpoint(step, config, channels, streamChannels, meta
         },
     };
 }
-export function tasksWithWrites(tasks, pendingWrites) {
+export function tasksWithWrites(tasks, pendingWrites, states) {
     return tasks.map((task) => {
         const error = pendingWrites.find(([id, n]) => id === task.id && n === ERROR)?.[2];
         const interrupts = pendingWrites
@@ -155,6 +149,7 @@ export function tasksWithWrites(tasks, pendingWrites) {
             return {
                 id: task.id,
                 name: task.name,
+                path: task.path,
                 error,
                 interrupts,
             };
@@ -162,7 +157,9 @@ export function tasksWithWrites(tasks, pendingWrites) {
         return {
             id: task.id,
             name: task.name,
+            path: task.path,
             interrupts,
+            state: states?.[task.id],
         };
     });
 }