@langchain/langgraph 0.2.41 → 0.2.43-rc.0

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.");
+}

package/dist/pregel/index.cjs

@@ -16,11 +16,12 @@ const algo_js_1 = require("./algo.cjs");
 const index_js_1 = require("./utils/index.cjs");
 const subgraph_js_1 = require("./utils/subgraph.cjs");
 const loop_js_1 = require("./loop.cjs");
-const retry_js_1 = require("./retry.cjs");
 const base_js_2 = require("../managed/base.cjs");
 const utils_js_1 = require("../utils.cjs");
 const config_js_1 = require("./utils/config.cjs");
 const messages_js_1 = require("./messages.cjs");
+const runner_js_1 = require("./runner.cjs");
+const stream_js_1 = require("./stream.cjs");
 function isString(value) {
     return typeof value === "string";
 }
@@ -824,92 +825,6 @@ class Pregel extends runnables_1.Runnable {
             managed,
         };
     }
-    async _runLoop(params) {
-        const { loop, interruptAfter, interruptBefore, runManager, debug, config } = params;
-        let tickError;
-        try {
-            while (await loop.tick({
-                inputKeys: this.inputChannels,
-                interruptAfter,
-                interruptBefore,
-                manager: runManager,
-            })) {
-                if (debug) {
-                    (0, debug_js_1.printStepCheckpoint)(loop.checkpointMetadata.step, loop.channels, this.streamChannelsList);
-                }
-                if (debug) {
-                    (0, debug_js_1.printStepTasks)(loop.step, Object.values(loop.tasks));
-                }
-                // execute tasks, and wait for one to fail or all to finish.
-                // each task is independent from all other concurrent tasks
-                // yield updates/debug output as each task finishes
-                const taskStream = (0, retry_js_1.executeTasksWithRetry)(Object.values(loop.tasks).filter((task) => task.writes.length === 0), {
-                    stepTimeout: this.stepTimeout,
-                    signal: config.signal,
-                    retryPolicy: this.retryPolicy,
-                });
-                let graphInterrupt;
-                for await (const { task, error } of taskStream) {
-                    if (error !== undefined) {
-                        if ((0, errors_js_1.isGraphBubbleUp)(error)) {
-                            if (loop.isNested) {
-                                throw error;
-                            }
-                            if ((0, errors_js_1.isGraphInterrupt)(error)) {
-                                graphInterrupt = error;
-                                if (error.interrupts.length) {
-                                    const interrupts = error.interrupts.map((interrupt) => [constants_js_1.INTERRUPT, interrupt]);
-                                    const resumes = task.writes.filter((w) => w[0] === constants_js_1.RESUME);
-                                    if (resumes.length) {
-                                        interrupts.push(...resumes);
-                                    }
-                                    loop.putWrites(task.id, interrupts);
-                                }
-                            }
-                        }
-                        else {
-                            loop.putWrites(task.id, [
-                                [constants_js_1.ERROR, { message: error.message, name: error.name }],
-                            ]);
-                            throw error;
-                        }
-                    }
-                    else {
-                        loop.putWrites(task.id, task.writes);
-                    }
-                }
-                if (debug) {
-                    (0, debug_js_1.printStepWrites)(loop.step, Object.values(loop.tasks)
-                        .map((task) => task.writes)
-                        .flat(), this.streamChannelsList);
-                }
-                if (graphInterrupt !== undefined) {
-                    throw graphInterrupt;
-                }
-            }
-            if (loop.status === "out_of_steps") {
-                throw new errors_js_1.GraphRecursionError([
-                    `Recursion limit of ${config.recursionLimit} reached`,
-                    "without hitting a stop condition. You can increase the",
-                    `limit by setting the "recursionLimit" config key.`,
-                ].join(" "), {
-                    lc_error_code: "GRAPH_RECURSION_LIMIT",
-                });
-            }
-        }
-        catch (e) {
-            tickError = e;
-            const suppress = await loop.finishAndHandleError(tickError);
-            if (!suppress) {
-                throw e;
-            }
-        }
-        finally {
-            if (tickError === undefined) {
-                await loop.finishAndHandleError();
-            }
-        }
-    }
     async *_streamIterator(input, options) {
         const streamSubgraphs = options?.subgraphs;
         const inputConfig = (0, config_js_1.ensureLangGraphConfig)(this.config, options);
@@ -925,7 +840,7 @@ class Pregel extends runnables_1.Runnable {
         const { runId, ...restConfig } = inputConfig;
         // assign defaults
         const [debug, streamMode, , outputKeys, config, interruptBefore, interruptAfter, checkpointer, store, streamModeSingle,] = this._defaults(restConfig);
-        const stream = new loop_js_1.IterableReadableWritableStream({
+        const stream = new stream_js_1.IterableReadableWritableStream({
             modes: new Set(streamMode),
         });
         // set up messages stream mode
@@ -974,6 +889,14 @@ class Pregel extends runnables_1.Runnable {
                     streamKeys: this.streamChannelsAsIs,
                     store,
                     stream,
+                    interruptAfter,
+                    interruptBefore,
+                    manager: runManager,
+                    debug: this.debug,
+                });
+                const runner = new runner_js_1.PregelRunner({
+                    loop,
+                    nodeFinished: config.configurable?.nodeFinished,
                 });
                 if (options?.subgraphs) {
                     loop.config.configurable = {
@@ -981,14 +904,7 @@ class Pregel extends runnables_1.Runnable {
                         [constants_js_1.CONFIG_KEY_STREAM]: loop.stream,
                     };
                 }
-                await this._runLoop({
-                    loop,
-                    interruptAfter,
-                    interruptBefore,
-                    runManager,
-                    debug,
-                    config,
-                });
+                await this._runLoop({ loop, runner, debug, config });
             }
             catch (e) {
                 loopError = e;
@@ -1086,5 +1002,52 @@ class Pregel extends runnables_1.Runnable {
         }
         return chunks;
     }
+    async _runLoop(params) {
+        const { loop, runner, debug, config } = params;
+        let tickError;
+        try {
+            while (await loop.tick({
+                inputKeys: this.inputChannels,
+            })) {
+                if (debug) {
+                    (0, debug_js_1.printStepCheckpoint)(loop.checkpointMetadata.step, loop.channels, this.streamChannelsList);
+                }
+                if (debug) {
+                    (0, debug_js_1.printStepTasks)(loop.step, Object.values(loop.tasks));
+                }
+                await runner.tick({
+                    timeout: this.stepTimeout,
+                    retryPolicy: this.retryPolicy,
+                    onStepWrite: (step, writes) => {
+                        if (debug) {
+                            (0, debug_js_1.printStepWrites)(step, writes, this.streamChannelsList);
+                        }
+                    },
+                    signal: config.signal,
+                });
+            }
+            if (loop.status === "out_of_steps") {
+                throw new errors_js_1.GraphRecursionError([
+                    `Recursion limit of ${config.recursionLimit} reached`,
+                    "without hitting a stop condition. You can increase the",
+                    `limit by setting the "recursionLimit" config key.`,
+                ].join(" "), {
+                    lc_error_code: "GRAPH_RECURSION_LIMIT",
+                });
+            }
+        }
+        catch (e) {
+            tickError = e;
+            const suppress = await loop.finishAndHandleError(tickError);
+            if (!suppress) {
+                throw e;
+            }
+        }
+        finally {
+            if (tickError === undefined) {
+                await loop.finishAndHandleError();
+            }
+        }
+    }
 }
 exports.Pregel = Pregel;

package/dist/pregel/index.d.ts

@@ -1,6 +1,5 @@
 import { Runnable, RunnableConfig, RunnableFunc } from "@langchain/core/runnables";
 import { IterableReadableStream } from "@langchain/core/utils/stream";
-import type { CallbackManagerForChainRun } from "@langchain/core/callbacks/manager";
 import { All, BaseCheckpointSaver, BaseStore, CheckpointListOptions, CheckpointTuple } from "@langchain/langgraph-checkpoint";
 import { BaseChannel } from "../channels/base.js";
 import { PregelNode } from "./read.js";
@@ -9,7 +8,6 @@ import { Command } from "../constants.js";
 import { PregelInterface, PregelParams, StateSnapshot, StreamMode, PregelInputType, PregelOutputType, PregelOptions } from "./types.js";
 import { StrRecord } from "./algo.js";
 import { RetryPolicy } from "./utils/index.js";
-import { PregelLoop } from "./loop.js";
 import { ManagedValueMapping, type ManagedValueSpec } from "../managed/base.js";
 import { LangGraphRunnableConfig } from "./runnable_types.js";
 type WriteValue = Runnable | RunnableFunc<unknown, unknown> | unknown;
@@ -112,14 +110,6 @@ export declare class Pregel<Nn extends StrRecord<string, PregelNode>, Cc extends
         channelSpecs: Record<string, BaseChannel<unknown, unknown, unknown>>;
         managed: ManagedValueMapping;
     }>;
-    _runLoop(params: {
-        loop: PregelLoop;
-        interruptAfter: string[] | "*";
-        interruptBefore: string[] | "*";
-        runManager?: CallbackManagerForChainRun;
-        debug: boolean;
-        config: LangGraphRunnableConfig;
-    }): Promise<void>;
     _streamIterator(input: PregelInputType | Command, options?: Partial<PregelOptions<Nn, Cc>>): AsyncGenerator<PregelOutputType>;
     /**
      * Run the graph with a single input and config.
@@ -137,4 +127,5 @@ export declare class Pregel<Nn extends StrRecord<string, PregelNode>, Cc extends
      * @param options.debug Whether to print debug information during execution.
      */
     invoke(input: InputType | Command | null, options?: Partial<PregelOptions<Nn, Cc, ConfigurableFieldType>>): Promise<OutputType>;
+    private _runLoop;
 }