@langchain/langgraph 0.2.40 → 0.2.42

package/dist/pregel/algo.cjs

@@ -7,8 +7,10 @@ const langgraph_checkpoint_1 = require("@langchain/langgraph-checkpoint");
 const base_js_1 = require("../channels/base.cjs");
 const io_js_1 = require("./io.cjs");
 const constants_js_1 = require("../constants.cjs");
+const types_js_1 = require("./types.cjs");
 const errors_js_1 = require("../errors.cjs");
 const index_js_1 = require("./utils/index.cjs");
+const call_js_1 = require("./call.cjs");
 const increment = (current) => {
     return current !== undefined ? current + 1 : 1;
 };
@@ -79,7 +81,7 @@ commit, processes, managed,
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 writes) {
     for (const [chan, value] of writes) {
-        if (chan === constants_js_1.TASKS) {
+        if (chan === constants_js_1.TASKS && value != null) {
             if (!(0, constants_js_1._isSend)(value)) {
                 throw new errors_js_1.InvalidUpdateError(`Invalid packet type, expected SendProtocol, got ${JSON.stringify(value)}`);
             }
@@ -93,7 +95,14 @@ writes) {
     commit(writes);
 }
 exports._localWrite = _localWrite;
-const IGNORE = new Set([constants_js_1.PUSH, constants_js_1.RESUME, constants_js_1.INTERRUPT]);
+const IGNORE = new Set([
+    constants_js_1.NO_WRITES,
+    constants_js_1.PUSH,
+    constants_js_1.RESUME,
+    constants_js_1.INTERRUPT,
+    constants_js_1.RETURN,
+    constants_js_1.ERROR,
+]);
 function _applyWrites(checkpoint, channels, tasks, 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 getNextVersion) {
@@ -260,7 +269,84 @@ function _prepareSingleTask(taskPath, checkpoint, pendingWrites, processes, chan
     const { step, checkpointer, manager } = extra;
     const configurable = config.configurable ?? {};
     const parentNamespace = configurable.checkpoint_ns ?? "";
-    if (taskPath[0] === constants_js_1.PUSH) {
+    if (taskPath[0] === constants_js_1.PUSH && (0, types_js_1.isCall)(taskPath[taskPath.length - 1])) {
+        const call = taskPath[taskPath.length - 1];
+        const proc = (0, call_js_1.getRunnableForFunc)(call.name, call.func);
+        const triggers = [constants_js_1.PUSH];
+        const checkpointNamespace = parentNamespace === ""
+            ? call.name
+            : `${parentNamespace}${constants_js_1.CHECKPOINT_NAMESPACE_SEPARATOR}${call.name}`;
+        const id = (0, langgraph_checkpoint_1.uuid5)(JSON.stringify([
+            checkpointNamespace,
+            step.toString(),
+            call.name,
+            constants_js_1.PUSH,
+            taskPath[1],
+            taskPath[2],
+        ]), checkpoint.id);
+        const taskCheckpointNamespace = `${checkpointNamespace}${constants_js_1.CHECKPOINT_NAMESPACE_END}${id}`;
+        const metadata = {
+            langgraph_step: step,
+            langgraph_node: call.name,
+            langgraph_triggers: triggers,
+            langgraph_path: taskPath.slice(0, 3),
+            langgraph_checkpoint_ns: taskCheckpointNamespace,
+        };
+        if (forExecution) {
+            const writes = [];
+            const task = {
+                name: call.name,
+                input: call.input,
+                proc,
+                writes,
+                config: (0, runnables_1.patchConfig)((0, runnables_1.mergeConfigs)(config, {
+                    metadata,
+                    store: extra.store ?? config.store,
+                }), {
+                    runName: call.name,
+                    callbacks: manager?.getChild(`graph:step:${step}`),
+                    configurable: {
+                        [constants_js_1.CONFIG_KEY_TASK_ID]: id,
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        [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: call.name,
+                            writes: writes,
+                            triggers,
+                            path: taskPath.slice(0, 3),
+                        }, select_, fresh_),
+                        [constants_js_1.CONFIG_KEY_CHECKPOINTER]: checkpointer ?? configurable[constants_js_1.CONFIG_KEY_CHECKPOINTER],
+                        [constants_js_1.CONFIG_KEY_CHECKPOINT_MAP]: {
+                            ...configurable[constants_js_1.CONFIG_KEY_CHECKPOINT_MAP],
+                            [parentNamespace]: checkpoint.id,
+                        },
+                        [constants_js_1.CONFIG_KEY_SCRATCHPAD]: _scratchpad([
+                            ...(pendingWrites || []),
+                            ...(configurable[constants_js_1.CONFIG_KEY_SCRATCHPAD]?.resume || []).map((v) => [id, constants_js_1.RESUME, v]),
+                        ], id),
+                        [constants_js_1.CONFIG_KEY_PREVIOUS_STATE]: checkpoint.channel_values[constants_js_1.PREVIOUS],
+                        checkpoint_id: undefined,
+                        checkpoint_ns: taskCheckpointNamespace,
+                    },
+                }),
+                triggers,
+                retry_policy: call.retry,
+                id,
+                path: taskPath.slice(0, 3),
+                writers: [],
+            };
+            return task;
+        }
+        else {
+            return {
+                id,
+                name: call.name,
+                interrupts: [],
+                path: taskPath.slice(0, 3),
+            };
+        }
+    }
+    else if (taskPath[0] === constants_js_1.PUSH) {
         const index = typeof taskPath[1] === "number"
             ? taskPath[1]
             : parseInt(taskPath[1], 10);
@@ -332,11 +418,15 @@ function _prepareSingleTask(taskPath, checkpoint, pendingWrites, processes, chan
                                 ...configurable[constants_js_1.CONFIG_KEY_CHECKPOINT_MAP],
                                 [parentNamespace]: checkpoint.id,
                             },
-                            [constants_js_1.CONFIG_KEY_WRITES]: [
+                            [constants_js_1.CONFIG_KEY_SCRATCHPAD]: _scratchpad([
                                 ...(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]: {},
+                                ...(configurable[constants_js_1.CONFIG_KEY_SCRATCHPAD]?.resume || []).map((v) => [
+                                    taskId,
+                                    constants_js_1.RESUME,
+                                    v,
+                                ]),
+                            ], taskId),
+                            [constants_js_1.CONFIG_KEY_PREVIOUS_STATE]: checkpoint.channel_values[constants_js_1.PREVIOUS],
                             checkpoint_id: undefined,
                             checkpoint_ns: taskCheckpointNamespace,
                         },
@@ -350,7 +440,12 @@ function _prepareSingleTask(taskPath, checkpoint, pendingWrites, processes, chan
             }
         }
         else {
-            return { id: taskId, name: packet.node, interrupts: [], path: taskPath };
+            return {
+                id: taskId,
+                name: packet.node,
+                interrupts: [],
+                path: taskPath,
+            };
         }
     }
     else if (taskPath[0] === constants_js_1.PULL) {
@@ -438,11 +533,15 @@ function _prepareSingleTask(taskPath, checkpoint, pendingWrites, processes, chan
                                     ...configurable[constants_js_1.CONFIG_KEY_CHECKPOINT_MAP],
                                     [parentNamespace]: checkpoint.id,
                                 },
-                                [constants_js_1.CONFIG_KEY_WRITES]: [
+                                [constants_js_1.CONFIG_KEY_SCRATCHPAD]: _scratchpad([
                                     ...(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]: {},
+                                    ...(configurable[constants_js_1.CONFIG_KEY_SCRATCHPAD]?.resume || []).map((v) => [
+                                        taskId,
+                                        constants_js_1.RESUME,
+                                        v,
+                                    ]),
+                                ], taskId),
+                                [constants_js_1.CONFIG_KEY_PREVIOUS_STATE]: checkpoint.channel_values[constants_js_1.PREVIOUS],
                                 checkpoint_id: undefined,
                                 checkpoint_ns: taskCheckpointNamespace,
                             },
@@ -533,3 +632,13 @@ function _procInput(step, proc, managed, channels, forExecution) {
     }
     return val;
 }
+function _scratchpad(pendingWrites, taskId) {
+    return {
+        callCounter: 0,
+        interruptCounter: -1,
+        resume: pendingWrites
+            .filter(([writeTaskId, chan]) => writeTaskId === taskId && chan === constants_js_1.RESUME)
+            .flatMap(([_writeTaskId, _chan, resume]) => resume),
+        nullResume: pendingWrites.find(([writeTaskId, chan]) => writeTaskId === constants_js_1.NULL_TASK_ID && chan === constants_js_1.RESUME)?.[2],
+    };
+}

package/dist/pregel/algo.d.ts

@@ -1,10 +1,11 @@
 import { RunnableConfig } from "@langchain/core/runnables";
 import { CallbackManagerForChainRun } from "@langchain/core/callbacks/manager";
-import { All, BaseCheckpointSaver, Checkpoint, ReadonlyCheckpoint, type PendingWrite, type PendingWriteValue, BaseStore } from "@langchain/langgraph-checkpoint";
+import { All, BaseCheckpointSaver, Checkpoint, ReadonlyCheckpoint, type PendingWrite, type PendingWriteValue, BaseStore, CheckpointPendingWrite } from "@langchain/langgraph-checkpoint";
 import { BaseChannel } from "../channels/base.js";
 import { PregelNode } from "./read.js";
-import { PregelExecutableTask, PregelTaskDescription } from "./types.js";
+import { PregelExecutableTask, PregelTaskDescription, SimpleTaskPath, TaskPath } from "./types.js";
 import { ManagedValueMapping } from "../managed/base.js";
+import { IterableReadableWritableStream } from "./stream.js";
 /**
  * Construct a type with a set of properties K of type T
  */
@@ -15,7 +16,7 @@ export type WritesProtocol<C = string> = {
     name: string;
     writes: PendingWrite<C>[];
     triggers: string[];
-    path?: [string, ...(string | number)[]];
+    path?: TaskPath;
 };
 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;
@@ -28,6 +29,7 @@ export type NextTaskExtraFields = {
     checkpointer?: BaseCheckpointSaver;
     manager?: CallbackManagerForChainRun;
     store?: BaseStore;
+    stream?: IterableReadableWritableStream;
 };
 export type NextTaskExtraFieldsWithStore = NextTaskExtraFields & {
     store?: BaseStore;
@@ -37,6 +39,6 @@ export type NextTaskExtraFieldsWithoutStore = NextTaskExtraFields & {
 };
 export declare function _prepareNextTasks<Nn extends StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel>>(checkpoint: ReadonlyCheckpoint, pendingWrites: [string, string, unknown][] | undefined, processes: Nn, channels: Cc, managed: ManagedValueMapping, config: RunnableConfig, forExecution: false, extra: NextTaskExtraFieldsWithoutStore): Record<string, PregelTaskDescription>;
 export declare function _prepareNextTasks<Nn extends StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel>>(checkpoint: ReadonlyCheckpoint, pendingWrites: [string, string, unknown][] | undefined, processes: Nn, channels: Cc, managed: ManagedValueMapping, config: RunnableConfig, forExecution: true, extra: NextTaskExtraFieldsWithStore): Record<string, PregelExecutableTask<keyof Nn, keyof Cc>>;
-export declare function _prepareSingleTask<Nn extends StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel>>(taskPath: [string, string | number], checkpoint: ReadonlyCheckpoint, pendingWrites: [string, string, unknown][] | undefined, processes: Nn, channels: Cc, managed: ManagedValueMapping, config: RunnableConfig, forExecution: false, extra: NextTaskExtraFields): PregelTaskDescription | undefined;
-export declare function _prepareSingleTask<Nn extends StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel>>(taskPath: [string, ...(string | number)[]], checkpoint: ReadonlyCheckpoint, pendingWrites: [string, string, unknown][] | undefined, processes: Nn, channels: Cc, managed: ManagedValueMapping, config: RunnableConfig, forExecution: true, extra: NextTaskExtraFields): PregelExecutableTask<keyof Nn, keyof Cc> | undefined;
-export declare function _prepareSingleTask<Nn extends StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel>>(taskPath: [string, ...(string | number)[]], checkpoint: ReadonlyCheckpoint, pendingWrites: [string, string, unknown][] | undefined, processes: Nn, channels: Cc, managed: ManagedValueMapping, config: RunnableConfig, forExecution: boolean, extra: NextTaskExtraFieldsWithStore): PregelTaskDescription | PregelExecutableTask<keyof Nn, keyof Cc> | undefined;
+export declare function _prepareSingleTask<Nn extends StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel>>(taskPath: SimpleTaskPath, checkpoint: ReadonlyCheckpoint, pendingWrites: CheckpointPendingWrite[] | undefined, processes: Nn, channels: Cc, managed: ManagedValueMapping, config: RunnableConfig, forExecution: false, extra: NextTaskExtraFields): PregelTaskDescription | undefined;
+export declare function _prepareSingleTask<Nn extends StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel>>(taskPath: TaskPath, checkpoint: ReadonlyCheckpoint, pendingWrites: CheckpointPendingWrite[] | undefined, processes: Nn, channels: Cc, managed: ManagedValueMapping, config: RunnableConfig, forExecution: true, extra: NextTaskExtraFields): PregelExecutableTask<keyof Nn, keyof Cc> | undefined;
+export declare function _prepareSingleTask<Nn extends StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel>>(taskPath: TaskPath, checkpoint: ReadonlyCheckpoint, pendingWrites: CheckpointPendingWrite[] | undefined, processes: Nn, channels: Cc, managed: ManagedValueMapping, config: RunnableConfig, forExecution: boolean, extra: NextTaskExtraFieldsWithStore): PregelTaskDescription | PregelExecutableTask<keyof Nn, keyof Cc> | undefined;

package/dist/pregel/algo.js

@@ -3,9 +3,11 @@ 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, NULL_TASK_ID, CONFIG_KEY_SCRATCHPAD, CONFIG_KEY_WRITES, } 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, RETURN, ERROR, NO_WRITES, CONFIG_KEY_PREVIOUS_STATE, PREVIOUS, } from "../constants.js";
+import { isCall, } from "./types.js";
 import { EmptyChannelError, InvalidUpdateError } from "../errors.js";
 import { getNullChannelVersion } from "./utils/index.js";
+import { getRunnableForFunc } from "./call.js";
 export const increment = (current) => {
     return current !== undefined ? current + 1 : 1;
 };
@@ -73,7 +75,7 @@ commit, processes, managed,
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 writes) {
     for (const [chan, value] of writes) {
-        if (chan === TASKS) {
+        if (chan === TASKS && value != null) {
             if (!_isSend(value)) {
                 throw new InvalidUpdateError(`Invalid packet type, expected SendProtocol, got ${JSON.stringify(value)}`);
             }
@@ -86,7 +88,14 @@ writes) {
     }
     commit(writes);
 }
-const IGNORE = new Set([PUSH, RESUME, INTERRUPT]);
+const IGNORE = new Set([
+    NO_WRITES,
+    PUSH,
+    RESUME,
+    INTERRUPT,
+    RETURN,
+    ERROR,
+]);
 export function _applyWrites(checkpoint, channels, tasks, 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 getNextVersion) {
@@ -251,7 +260,84 @@ export function _prepareSingleTask(taskPath, checkpoint, pendingWrites, processe
     const { step, checkpointer, manager } = extra;
     const configurable = config.configurable ?? {};
     const parentNamespace = configurable.checkpoint_ns ?? "";
-    if (taskPath[0] === PUSH) {
+    if (taskPath[0] === PUSH && isCall(taskPath[taskPath.length - 1])) {
+        const call = taskPath[taskPath.length - 1];
+        const proc = getRunnableForFunc(call.name, call.func);
+        const triggers = [PUSH];
+        const checkpointNamespace = parentNamespace === ""
+            ? call.name
+            : `${parentNamespace}${CHECKPOINT_NAMESPACE_SEPARATOR}${call.name}`;
+        const id = uuid5(JSON.stringify([
+            checkpointNamespace,
+            step.toString(),
+            call.name,
+            PUSH,
+            taskPath[1],
+            taskPath[2],
+        ]), checkpoint.id);
+        const taskCheckpointNamespace = `${checkpointNamespace}${CHECKPOINT_NAMESPACE_END}${id}`;
+        const metadata = {
+            langgraph_step: step,
+            langgraph_node: call.name,
+            langgraph_triggers: triggers,
+            langgraph_path: taskPath.slice(0, 3),
+            langgraph_checkpoint_ns: taskCheckpointNamespace,
+        };
+        if (forExecution) {
+            const writes = [];
+            const task = {
+                name: call.name,
+                input: call.input,
+                proc,
+                writes,
+                config: patchConfig(mergeConfigs(config, {
+                    metadata,
+                    store: extra.store ?? config.store,
+                }), {
+                    runName: call.name,
+                    callbacks: manager?.getChild(`graph:step:${step}`),
+                    configurable: {
+                        [CONFIG_KEY_TASK_ID]: id,
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        [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: call.name,
+                            writes: writes,
+                            triggers,
+                            path: taskPath.slice(0, 3),
+                        }, select_, fresh_),
+                        [CONFIG_KEY_CHECKPOINTER]: checkpointer ?? configurable[CONFIG_KEY_CHECKPOINTER],
+                        [CONFIG_KEY_CHECKPOINT_MAP]: {
+                            ...configurable[CONFIG_KEY_CHECKPOINT_MAP],
+                            [parentNamespace]: checkpoint.id,
+                        },
+                        [CONFIG_KEY_SCRATCHPAD]: _scratchpad([
+                            ...(pendingWrites || []),
+                            ...(configurable[CONFIG_KEY_SCRATCHPAD]?.resume || []).map((v) => [id, RESUME, v]),
+                        ], id),
+                        [CONFIG_KEY_PREVIOUS_STATE]: checkpoint.channel_values[PREVIOUS],
+                        checkpoint_id: undefined,
+                        checkpoint_ns: taskCheckpointNamespace,
+                    },
+                }),
+                triggers,
+                retry_policy: call.retry,
+                id,
+                path: taskPath.slice(0, 3),
+                writers: [],
+            };
+            return task;
+        }
+        else {
+            return {
+                id,
+                name: call.name,
+                interrupts: [],
+                path: taskPath.slice(0, 3),
+            };
+        }
+    }
+    else if (taskPath[0] === PUSH) {
         const index = typeof taskPath[1] === "number"
             ? taskPath[1]
             : parseInt(taskPath[1], 10);
@@ -323,11 +409,15 @@ export function _prepareSingleTask(taskPath, checkpoint, pendingWrites, processe
                                 ...configurable[CONFIG_KEY_CHECKPOINT_MAP],
                                 [parentNamespace]: checkpoint.id,
                             },
-                            [CONFIG_KEY_WRITES]: [
+                            [CONFIG_KEY_SCRATCHPAD]: _scratchpad([
                                 ...(pendingWrites || []),
-                                ...(configurable[CONFIG_KEY_WRITES] || []),
-                            ].filter((w) => w[0] === NULL_TASK_ID || w[0] === taskId),
-                            [CONFIG_KEY_SCRATCHPAD]: {},
+                                ...(configurable[CONFIG_KEY_SCRATCHPAD]?.resume || []).map((v) => [
+                                    taskId,
+                                    RESUME,
+                                    v,
+                                ]),
+                            ], taskId),
+                            [CONFIG_KEY_PREVIOUS_STATE]: checkpoint.channel_values[PREVIOUS],
                             checkpoint_id: undefined,
                             checkpoint_ns: taskCheckpointNamespace,
                         },
@@ -341,7 +431,12 @@ export function _prepareSingleTask(taskPath, checkpoint, pendingWrites, processe
             }
         }
         else {
-            return { id: taskId, name: packet.node, interrupts: [], path: taskPath };
+            return {
+                id: taskId,
+                name: packet.node,
+                interrupts: [],
+                path: taskPath,
+            };
         }
     }
     else if (taskPath[0] === PULL) {
@@ -429,11 +524,15 @@ export function _prepareSingleTask(taskPath, checkpoint, pendingWrites, processe
                                     ...configurable[CONFIG_KEY_CHECKPOINT_MAP],
                                     [parentNamespace]: checkpoint.id,
                                 },
-                                [CONFIG_KEY_WRITES]: [
+                                [CONFIG_KEY_SCRATCHPAD]: _scratchpad([
                                     ...(pendingWrites || []),
-                                    ...(configurable[CONFIG_KEY_WRITES] || []),
-                                ].filter((w) => w[0] === NULL_TASK_ID || w[0] === taskId),
-                                [CONFIG_KEY_SCRATCHPAD]: {},
+                                    ...(configurable[CONFIG_KEY_SCRATCHPAD]?.resume || []).map((v) => [
+                                        taskId,
+                                        RESUME,
+                                        v,
+                                    ]),
+                                ], taskId),
+                                [CONFIG_KEY_PREVIOUS_STATE]: checkpoint.channel_values[PREVIOUS],
                                 checkpoint_id: undefined,
                                 checkpoint_ns: taskCheckpointNamespace,
                             },
@@ -523,3 +622,13 @@ function _procInput(step, proc, managed, channels, forExecution) {
     }
     return val;
 }
+function _scratchpad(pendingWrites, taskId) {
+    return {
+        callCounter: 0,
+        interruptCounter: -1,
+        resume: pendingWrites
+            .filter(([writeTaskId, chan]) => writeTaskId === taskId && chan === RESUME)
+            .flatMap(([_writeTaskId, _chan, resume]) => resume),
+        nullResume: pendingWrites.find(([writeTaskId, chan]) => writeTaskId === NULL_TASK_ID && chan === RESUME)?.[2],
+    };
+}

package/dist/pregel/call.cjs

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.call = exports.getRunnableForEntrypoint = exports.getRunnableForFunc = void 0;
+const runnables_1 = require("@langchain/core/runnables");
+const singletons_1 = require("@langchain/core/singletons");
+const constants_js_1 = require("../constants.cjs");
+const write_js_1 = require("./write.cjs");
+const utils_js_1 = require("../utils.cjs");
+const types_js_1 = require("../func/types.cjs");
+/**
+ * Wraps a user function in a Runnable that writes the returned value to the RETURN channel.
+ */
+function getRunnableForFunc(name, func) {
+    const run = new utils_js_1.RunnableCallable({
+        func: (input) => func(...input),
+        name,
+        trace: false,
+        recurse: false,
+    });
+    return new runnables_1.RunnableSequence({
+        name,
+        first: run,
+        last: new write_js_1.ChannelWrite([{ channel: constants_js_1.RETURN, value: write_js_1.PASSTHROUGH }], [constants_js_1.TAG_HIDDEN]),
+    });
+}
+exports.getRunnableForFunc = getRunnableForFunc;
+function getRunnableForEntrypoint(name, func) {
+    const run = new utils_js_1.RunnableCallable({
+        func: (input, config) => {
+            return func(input, config);
+        },
+        name,
+        trace: false,
+        recurse: false,
+    });
+    return new runnables_1.RunnableSequence({
+        name,
+        first: run,
+        middle: [
+            new write_js_1.ChannelWrite([
+                {
+                    channel: constants_js_1.END,
+                    value: write_js_1.PASSTHROUGH,
+                    mapper: new utils_js_1.RunnableCallable({
+                        func: (value) => ((0, types_js_1.isEntrypointFinal)(value) ? value.value : value),
+                    }),
+                },
+            ], [constants_js_1.TAG_HIDDEN]),
+            new write_js_1.ChannelWrite([
+                {
+                    channel: constants_js_1.PREVIOUS,
+                    value: write_js_1.PASSTHROUGH,
+                    mapper: new utils_js_1.RunnableCallable({
+                        func: (value) => {
+                            return (0, types_js_1.isEntrypointFinal)(value) ? value.save : value;
+                        },
+                    }),
+                },
+            ]),
+        ],
+        last: new utils_js_1.RunnableCallable({
+            func: (final) => (0, types_js_1.isEntrypointFinal)(final) ? final.value : final,
+        }),
+    });
+}
+exports.getRunnableForEntrypoint = getRunnableForEntrypoint;
+function call({ func, name, retry }, ...args) {
+    const config = singletons_1.AsyncLocalStorageProviderSingleton.getRunnableConfig();
+    if (typeof config.configurable?.[constants_js_1.CONFIG_KEY_CALL] === "function") {
+        return config.configurable[constants_js_1.CONFIG_KEY_CALL](func, name, args, {
+            retry,
+            callbacks: config.callbacks,
+        });
+    }
+    throw new Error("Async local storage not initialized. Please call initializeAsyncLocalStorageSingleton() before using this function.");
+}
+exports.call = call;

package/dist/pregel/call.d.ts

@@ -0,0 +1,15 @@
+import { Runnable } from "@langchain/core/runnables";
+import { RetryPolicy } from "./utils/index.js";
+import { EntrypointFunc, EntrypointReturnT, TaskFunc } from "../func/types.js";
+import { LangGraphRunnableConfig } from "./runnable_types.js";
+/**
+ * Wraps a user function in a Runnable that writes the returned value to the RETURN channel.
+ */
+export declare function getRunnableForFunc<ArgsT extends unknown[], OutputT>(name: string, func: TaskFunc<ArgsT, OutputT>): Runnable<ArgsT, OutputT, LangGraphRunnableConfig>;
+export declare function getRunnableForEntrypoint<InputT, OutputT>(name: string, func: EntrypointFunc<InputT, OutputT>): Runnable<InputT, EntrypointReturnT<OutputT>, LangGraphRunnableConfig>;
+export type CallWrapperOptions<ArgsT extends unknown[], OutputT> = {
+    func: TaskFunc<ArgsT, OutputT>;
+    name: string;
+    retry?: RetryPolicy;
+};
+export declare function call<ArgsT extends unknown[], OutputT>({ func, name, retry }: CallWrapperOptions<ArgsT, OutputT>, ...args: ArgsT): Promise<OutputT>;

package/dist/pregel/call.js

@@ -0,0 +1,71 @@
+import { RunnableSequence, } from "@langchain/core/runnables";
+import { AsyncLocalStorageProviderSingleton } from "@langchain/core/singletons";
+import { CONFIG_KEY_CALL, END, PREVIOUS, RETURN, TAG_HIDDEN, } from "../constants.js";
+import { ChannelWrite, PASSTHROUGH } from "./write.js";
+import { RunnableCallable } from "../utils.js";
+import { isEntrypointFinal, } from "../func/types.js";
+/**
+ * Wraps a user function in a Runnable that writes the returned value to the RETURN channel.
+ */
+export function getRunnableForFunc(name, func) {
+    const run = new RunnableCallable({
+        func: (input) => func(...input),
+        name,
+        trace: false,
+        recurse: false,
+    });
+    return new RunnableSequence({
+        name,
+        first: run,
+        last: new ChannelWrite([{ channel: RETURN, value: PASSTHROUGH }], [TAG_HIDDEN]),
+    });
+}
+export function getRunnableForEntrypoint(name, func) {
+    const run = new RunnableCallable({
+        func: (input, config) => {
+            return func(input, config);
+        },
+        name,
+        trace: false,
+        recurse: false,
+    });
+    return new RunnableSequence({
+        name,
+        first: run,
+        middle: [
+            new ChannelWrite([
+                {
+                    channel: END,
+                    value: PASSTHROUGH,
+                    mapper: new RunnableCallable({
+                        func: (value) => (isEntrypointFinal(value) ? value.value : value),
+                    }),
+                },
+            ], [TAG_HIDDEN]),
+            new ChannelWrite([
+                {
+                    channel: PREVIOUS,
+                    value: PASSTHROUGH,
+                    mapper: new RunnableCallable({
+                        func: (value) => {
+                            return isEntrypointFinal(value) ? value.save : value;
+                        },
+                    }),
+                },
+            ]),
+        ],
+        last: new RunnableCallable({
+            func: (final) => isEntrypointFinal(final) ? final.value : final,
+        }),
+    });
+}
+export function call({ func, name, retry }, ...args) {
+    const config = AsyncLocalStorageProviderSingleton.getRunnableConfig();
+    if (typeof config.configurable?.[CONFIG_KEY_CALL] === "function") {
+        return config.configurable[CONFIG_KEY_CALL](func, name, args, {
+            retry,
+            callbacks: config.callbacks,
+        });
+    }
+    throw new Error("Async local storage not initialized. Please call initializeAsyncLocalStorageSingleton() before using this function.");
+}