@langchain/langgraph 0.2.8 → 0.2.10-rc.0

package/dist/pregel/loop.cjs

@@ -1,10 +1,6 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PregelLoop = void 0;
-const double_ended_queue_1 = __importDefault(require("double-ended-queue"));
+exports.PregelLoop = exports.StreamProtocol = void 0;
 const langgraph_checkpoint_1 = require("@langchain/langgraph-checkpoint");
 const base_js_1 = require("../channels/base.cjs");
 const constants_js_1 = require("../constants.cjs");
@@ -12,12 +8,40 @@ const algo_js_1 = require("./algo.cjs");
 const utils_js_1 = require("../utils.cjs");
 const io_js_1 = require("./io.cjs");
 const errors_js_1 = require("../errors.cjs");
-const utils_js_2 = require("./utils.cjs");
+const index_js_1 = require("./utils/index.cjs");
 const debug_js_1 = require("./debug.cjs");
-const batch_js_1 = require("../store/batch.cjs");
 const INPUT_DONE = Symbol.for("INPUT_DONE");
 const INPUT_RESUMING = Symbol.for("INPUT_RESUMING");
 const DEFAULT_LOOP_LIMIT = 25;
+const SPECIAL_CHANNELS = [constants_js_1.ERROR, constants_js_1.INTERRUPT];
+class StreamProtocol {
+    constructor(pushFn, modes) {
+        Object.defineProperty(this, "push", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "modes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.push = pushFn;
+        this.modes = modes;
+    }
+}
+exports.StreamProtocol = StreamProtocol;
+function createDuplexStream(...streams) {
+    return new StreamProtocol((value) => {
+        for (const stream of streams) {
+            if (stream.modes.has(value[1])) {
+                stream.push(value);
+            }
+        }
+    }, new Set(streams.flatMap((s) => Array.from(s.modes))));
+}
 class PregelLoop {
     constructor(params) {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -27,6 +51,13 @@ class PregelLoop {
             writable: true,
             value: void 0
         });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        Object.defineProperty(this, "output", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "config", {
             enumerable: true,
             configurable: true,
@@ -75,6 +106,12 @@ class PregelLoop {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "checkpointNamespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "checkpointPendingWrites", {
             enumerable: true,
             configurable: true,
@@ -123,6 +160,12 @@ class PregelLoop {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "taskWritesLeft", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
         Object.defineProperty(this, "status", {
             enumerable: true,
             configurable: true,
@@ -134,14 +177,14 @@ class PregelLoop {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: []
+            value: {}
         });
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         Object.defineProperty(this, "stream", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: new double_ended_queue_1.default()
+            value: void 0
         });
         Object.defineProperty(this, "checkpointerPromises", {
             enumerable: true,
@@ -168,7 +211,6 @@ class PregelLoop {
             value: void 0
         });
         this.input = params.input;
-        this.config = params.config;
         this.checkpointer = params.checkpointer;
         // TODO: if managed values no longer needs graph we can replace with
         // managed_specs, channel_specs
@@ -179,7 +221,6 @@ class PregelLoop {
             this.checkpointerGetNextVersion = algo_js_1.increment;
         }
         this.checkpoint = params.checkpoint;
-        this.checkpointConfig = params.checkpointConfig;
         this.checkpointMetadata = params.checkpointMetadata;
         this.checkpointPreviousVersions = params.checkpointPreviousVersions;
         this.channels = params.channels;
@@ -187,29 +228,58 @@ class PregelLoop {
         this.checkpointPendingWrites = params.checkpointPendingWrites;
         this.step = params.step;
         this.stop = params.stop;
-        this.isNested = constants_js_1.CONFIG_KEY_READ in (this.config.configurable ?? {});
+        this.config = params.config;
+        this.checkpointConfig = params.checkpointConfig;
+        this.isNested = params.isNested;
         this.outputKeys = params.outputKeys;
         this.streamKeys = params.streamKeys;
         this.nodes = params.nodes;
-        this.skipDoneTasks = this.config.configurable?.checkpoint_id === undefined;
+        this.skipDoneTasks = params.skipDoneTasks;
         this.store = params.store;
+        this.stream = params.stream;
+        this.checkpointNamespace = params.checkpointNamespace;
     }
     static async initialize(params) {
-        const saved = (await params.checkpointer?.getTuple(params.config)) ?? {
-            config: params.config,
+        let { config, stream } = params;
+        if (stream !== undefined &&
+            config.configurable?.[constants_js_1.CONFIG_KEY_STREAM] !== undefined) {
+            stream = createDuplexStream(stream, config.configurable[constants_js_1.CONFIG_KEY_STREAM]);
+        }
+        const skipDoneTasks = config.configurable?.checkpoint_id === undefined;
+        const isNested = constants_js_1.CONFIG_KEY_READ in (config.configurable ?? {});
+        if (!isNested &&
+            config.configurable?.checkpoint_ns !== undefined &&
+            config.configurable?.checkpoint_ns !== "") {
+            config = (0, index_js_1.patchConfigurable)(config, {
+                checkpoint_ns: "",
+                checkpoint_id: undefined,
+            });
+        }
+        let checkpointConfig = config;
+        if (config.configurable?.[constants_js_1.CONFIG_KEY_CHECKPOINT_MAP] !== undefined &&
+            config.configurable?.[constants_js_1.CONFIG_KEY_CHECKPOINT_MAP]?.[config.configurable?.checkpoint_ns]) {
+            checkpointConfig = (0, index_js_1.patchConfigurable)(config, {
+                checkpoint_id: config.configurable[constants_js_1.CONFIG_KEY_CHECKPOINT_MAP][config.configurable?.checkpoint_ns],
+            });
+        }
+        const checkpointNamespace = config.configurable?.checkpoint_ns?.split(constants_js_1.CHECKPOINT_NAMESPACE_SEPARATOR) ?? [];
+        const saved = (await params.checkpointer?.getTuple(checkpointConfig)) ?? {
+            config,
             checkpoint: (0, langgraph_checkpoint_1.emptyCheckpoint)(),
             metadata: {
                 source: "input",
                 step: -2,
                 writes: null,
+                parents: {},
             },
             pendingWrites: [],
         };
-        const checkpointConfig = {
-            ...params.config,
+        checkpointConfig = {
+            ...config,
             ...saved.config,
             configurable: {
-                ...params.config.configurable,
+                checkpoint_ns: "",
+                ...config.configurable,
                 ...saved.config.configurable,
             },
         };
@@ -218,10 +288,10 @@ class PregelLoop {
         const checkpointPendingWrites = saved.pendingWrites ?? [];
         const channels = (0, base_js_1.emptyChannels)(params.channelSpecs, checkpoint);
         const step = (checkpointMetadata.step ?? 0) + 1;
-        const stop = step + (params.config.recursionLimit ?? DEFAULT_LOOP_LIMIT) + 1;
+        const stop = step + (config.recursionLimit ?? DEFAULT_LOOP_LIMIT) + 1;
         const checkpointPreviousVersions = { ...checkpoint.channel_versions };
         const store = params.store
-            ? new batch_js_1.AsyncBatchedStore(params.store)
+            ? new langgraph_checkpoint_1.AsyncBatchedStore(params.store)
             : undefined;
         if (store) {
             // Start the store. This is a batch store, so it will run continuously
@@ -229,13 +299,16 @@ class PregelLoop {
         }
         return new PregelLoop({
             input: params.input,
-            config: params.config,
+            config,
             checkpointer: params.checkpointer,
             checkpoint,
             checkpointMetadata,
             checkpointConfig,
+            checkpointNamespace,
             channels,
             managed: params.managed,
+            isNested,
+            skipDoneTasks,
             step,
             stop,
             checkpointPreviousVersions,
@@ -243,6 +316,7 @@ class PregelLoop {
             outputKeys: params.outputKeys ?? [],
             streamKeys: params.streamKeys ?? [],
             nodes: params.nodes,
+            stream,
             store,
         });
     }
@@ -265,6 +339,22 @@ class PregelLoop {
      * @param writes
      */
     putWrites(taskId, writes) {
+        if (writes.length === 0) {
+            return;
+        }
+        // adjust taskWritesLeft
+        const firstChannel = writes[0][0];
+        const anyChannelIsSend = writes.find(([channel]) => channel === constants_js_1.TASKS);
+        const alwaysSave = anyChannelIsSend || SPECIAL_CHANNELS.includes(firstChannel);
+        if (!alwaysSave && !this.taskWritesLeft) {
+            return this._outputWrites(taskId, writes);
+        }
+        else if (firstChannel !== constants_js_1.INTERRUPT) {
+            // INTERRUPT makes us want to save the last task's writes
+            // so we don't decrement tasksWritesLeft in that case
+            this.taskWritesLeft -= 1;
+        }
+        // save writes
         const pendingWrites = writes.map(([key, value]) => {
             return [taskId, key, value];
         });
@@ -280,10 +370,23 @@ class PregelLoop {
         if (putWritePromise !== undefined) {
             this.checkpointerPromises.push(putWritePromise);
         }
-        const task = this.tasks.find((task) => task.id === taskId);
+        this._outputWrites(taskId, writes);
+    }
+    _outputWrites(taskId, writes, cached = false) {
+        const task = this.tasks[taskId];
         if (task !== undefined) {
-            this.stream.push(...(0, utils_js_1.gatherIteratorSync)((0, utils_js_1.prefixGenerator)((0, io_js_1.mapOutputUpdates)(this.outputKeys, [task]), "updates")));
-            this.stream.push(...(0, utils_js_1.gatherIteratorSync)((0, utils_js_1.prefixGenerator)((0, debug_js_1.mapDebugTaskResults)(this.step, [[task, writes]], this.streamKeys), "debug")));
+            if (task.config !== undefined &&
+                (task.config.tags ?? []).includes(constants_js_1.TAG_HIDDEN)) {
+                return;
+            }
+            if (writes.length > 0 &&
+                writes[0][0] !== constants_js_1.ERROR &&
+                writes[0][0] !== constants_js_1.INTERRUPT) {
+                this._emit((0, utils_js_1.gatherIteratorSync)((0, utils_js_1.prefixGenerator)((0, io_js_1.mapOutputUpdates)(this.outputKeys, [[task, writes]], cached), "updates")));
+            }
+            if (!cached) {
+                this._emit((0, utils_js_1.gatherIteratorSync)((0, utils_js_1.prefixGenerator)((0, debug_js_1.mapDebugTaskResults)(this.step, [[task, writes]], this.streamKeys), "debug")));
+            }
         }
     }
     /**
@@ -292,35 +395,99 @@ class PregelLoop {
      * @param params
      */
     async tick(params) {
-        if (this.store && !this.store.isRunning) {
-            this.store?.start();
-        }
-        const { inputKeys = [], interruptAfter = [], interruptBefore = [], manager, } = params;
-        if (this.status !== "pending") {
-            throw new Error(`Cannot tick when status is no longer "pending". Current status: "${this.status}"`);
-        }
-        if (![INPUT_DONE, INPUT_RESUMING].includes(this.input)) {
-            await this._first(inputKeys);
-        }
-        else if (this.tasks.every((task) => task.writes.length > 0)) {
-            const writes = this.tasks.flatMap((t) => t.writes);
-            // All tasks have finished
-            const myWrites = (0, algo_js_1._applyWrites)(this.checkpoint, this.channels, this.tasks, this.checkpointerGetNextVersion);
-            for (const [key, values] of Object.entries(myWrites)) {
-                await this.updateManagedValues(key, values);
+        let tickError;
+        try {
+            if (this.store && !this.store.isRunning) {
+                this.store?.start();
             }
-            // produce values output
-            const valuesOutput = await (0, utils_js_1.gatherIterator)((0, utils_js_1.prefixGenerator)((0, io_js_1.mapOutputValues)(this.outputKeys, writes, this.channels), "values"));
-            this.stream.push(...valuesOutput);
-            // clear pending writes
-            this.checkpointPendingWrites = [];
-            await this._putCheckpoint({
-                source: "loop",
-                writes: (0, io_js_1.mapOutputUpdates)(this.outputKeys, this.tasks).next().value ?? null,
+            const { inputKeys = [], interruptAfter = [], interruptBefore = [], manager, } = params;
+            if (this.status !== "pending") {
+                throw new Error(`Cannot tick when status is no longer "pending". Current status: "${this.status}"`);
+            }
+            if (![INPUT_DONE, INPUT_RESUMING].includes(this.input)) {
+                await this._first(inputKeys);
+            }
+            else if (Object.values(this.tasks).every((task) => task.writes.length > 0)) {
+                const writes = Object.values(this.tasks).flatMap((t) => t.writes);
+                // All tasks have finished
+                const managedValueWrites = (0, algo_js_1._applyWrites)(this.checkpoint, this.channels, Object.values(this.tasks), this.checkpointerGetNextVersion);
+                for (const [key, values] of Object.entries(managedValueWrites)) {
+                    await this.updateManagedValues(key, values);
+                }
+                // produce values output
+                const valuesOutput = await (0, utils_js_1.gatherIterator)((0, utils_js_1.prefixGenerator)((0, io_js_1.mapOutputValues)(this.outputKeys, writes, this.channels), "values"));
+                this._emit(valuesOutput);
+                // clear pending writes
+                this.checkpointPendingWrites = [];
+                await this._putCheckpoint({
+                    source: "loop",
+                    writes: (0, io_js_1.mapOutputUpdates)(this.outputKeys, Object.values(this.tasks).map((task) => [task, task.writes])).next().value ?? null,
+                });
+                // after execution, check if we should interrupt
+                if ((0, algo_js_1.shouldInterrupt)(this.checkpoint, interruptAfter, Object.values(this.tasks))) {
+                    this.status = "interrupt_after";
+                    if (this.isNested) {
+                        throw new errors_js_1.GraphInterrupt();
+                    }
+                    else {
+                        return false;
+                    }
+                }
+            }
+            else {
+                return false;
+            }
+            if (this.step > this.stop) {
+                this.status = "out_of_steps";
+                return false;
+            }
+            const nextTasks = (0, algo_js_1._prepareNextTasks)(this.checkpoint, this.nodes, this.channels, this.managed, this.config, true, {
+                step: this.step,
+                checkpointer: this.checkpointer,
+                isResuming: this.input === INPUT_RESUMING,
+                manager,
+                store: this.store,
             });
-            // after execution, check if we should interrupt
-            if ((0, algo_js_1.shouldInterrupt)(this.checkpoint, interruptAfter, this.tasks)) {
-                this.status = "interrupt_after";
+            this.tasks = nextTasks;
+            this.taskWritesLeft = Object.values(this.tasks).length - 1;
+            // Produce debug output
+            if (this.checkpointer) {
+                this._emit(await (0, utils_js_1.gatherIterator)((0, utils_js_1.prefixGenerator)((0, debug_js_1.mapDebugCheckpoint)(this.step - 1, // printing checkpoint for previous step
+                this.checkpointConfig, this.channels, this.streamKeys, this.checkpointMetadata, Object.values(this.tasks), this.checkpointPendingWrites), "debug")));
+            }
+            if (Object.values(this.tasks).length === 0) {
+                this.status = "done";
+                return false;
+            }
+            // if there are pending writes from a previous loop, apply them
+            if (this.skipDoneTasks && this.checkpointPendingWrites.length > 0) {
+                for (const [tid, k, v] of this.checkpointPendingWrites) {
+                    if (k === constants_js_1.ERROR || k === constants_js_1.INTERRUPT) {
+                        continue;
+                    }
+                    const task = Object.values(this.tasks).find((t) => t.id === tid);
+                    if (task) {
+                        task.writes.push([k, v]);
+                    }
+                }
+                for (const task of Object.values(this.tasks)) {
+                    if (task.writes.length > 0) {
+                        this._outputWrites(task.id, task.writes, true);
+                    }
+                }
+            }
+            // if all tasks have finished, re-tick
+            if (Object.values(this.tasks).every((task) => task.writes.length > 0)) {
+                return this.tick({
+                    inputKeys,
+                    interruptAfter,
+                    interruptBefore,
+                    manager,
+                });
+            }
+            // Before execution, check if we should interrupt
+            if ((0, algo_js_1.shouldInterrupt)(this.checkpoint, interruptBefore, Object.values(this.tasks))) {
+                this.status = "interrupt_before";
                 if (this.isNested) {
                     throw new errors_js_1.GraphInterrupt();
                 }
@@ -328,65 +495,29 @@ class PregelLoop {
                     return false;
                 }
             }
+            // Produce debug output
+            const debugOutput = await (0, utils_js_1.gatherIterator)((0, utils_js_1.prefixGenerator)((0, debug_js_1.mapDebugTasks)(this.step, Object.values(this.tasks)), "debug"));
+            this._emit(debugOutput);
+            return true;
         }
-        else {
-            return false;
-        }
-        if (this.step > this.stop) {
-            this.status = "out_of_steps";
-            return false;
-        }
-        const nextTasks = (0, algo_js_1._prepareNextTasks)(this.checkpoint, this.nodes, this.channels, this.managed, this.config, true, {
-            step: this.step,
-            checkpointer: this.checkpointer,
-            isResuming: this.input === INPUT_RESUMING,
-            manager,
-        });
-        this.tasks = nextTasks;
-        // Produce debug output
-        if (this.checkpointer) {
-            this.stream.push(...(await (0, utils_js_1.gatherIterator)((0, utils_js_1.prefixGenerator)((0, debug_js_1.mapDebugCheckpoint)(this.step - 1, // printing checkpoint for previous step
-            this.checkpointConfig, this.channels, this.streamKeys, this.checkpointMetadata, this.tasks, this.checkpointPendingWrites), "debug"))));
-        }
-        if (this.tasks.length === 0) {
-            this.status = "done";
-            return false;
-        }
-        // if there are pending writes from a previous loop, apply them
-        if (this.checkpointPendingWrites.length > 0 && this.skipDoneTasks) {
-            for (const [tid, k, v] of this.checkpointPendingWrites) {
-                if (k === constants_js_1.ERROR || k === constants_js_1.INTERRUPT) {
-                    continue;
-                }
-                const task = this.tasks.find((t) => t.id === tid);
-                if (task) {
-                    task.writes.push([k, v]);
-                }
-            }
-        }
-        // if all tasks have finished, re-tick
-        if (this.tasks.every((task) => task.writes.length > 0)) {
-            return this.tick({
-                inputKeys,
-                interruptAfter,
-                interruptBefore,
-                manager,
-            });
-        }
-        // Before execution, check if we should interrupt
-        if ((0, algo_js_1.shouldInterrupt)(this.checkpoint, interruptBefore, this.tasks)) {
-            this.status = "interrupt_before";
-            if (this.isNested) {
-                throw new errors_js_1.GraphInterrupt();
+        catch (e) {
+            tickError = e;
+            if (!this._suppressInterrupt(tickError)) {
+                throw tickError;
             }
             else {
-                return false;
+                this.output = (0, io_js_1.readChannels)(this.channels, this.outputKeys);
+            }
+            return false;
+        }
+        finally {
+            if (tickError === undefined) {
+                this.output = (0, io_js_1.readChannels)(this.channels, this.outputKeys);
             }
         }
-        // Produce debug output
-        const debugOutput = await (0, utils_js_1.gatherIterator)((0, utils_js_1.prefixGenerator)((0, debug_js_1.mapDebugTasks)(this.step, this.tasks), "debug"));
-        this.stream.push(...debugOutput);
-        return true;
+    }
+    _suppressInterrupt(e) {
+        return (0, errors_js_1.isGraphInterrupt)(e) && !this.isNested;
     }
     /**
      * Resuming from previous checkpoint requires
@@ -394,9 +525,9 @@ class PregelLoop {
      * - receiving None input (outer graph) or RESUMING flag (subgraph)
      */
     async _first(inputKeys) {
-        const isResuming = (Object.keys(this.checkpoint.channel_versions).length !== 0 &&
-            this.config.configurable?.[constants_js_1.CONFIG_KEY_RESUMING] !== undefined) ||
-            this.input === null;
+        const isResuming = Object.keys(this.checkpoint.channel_versions).length !== 0 &&
+            (this.config.configurable?.[constants_js_1.CONFIG_KEY_RESUMING] !== undefined ||
+                this.input === null);
         if (isResuming) {
             for (const channelName of Object.keys(this.channels)) {
                 if (this.checkpoint.channel_versions[channelName] !== undefined) {
@@ -407,6 +538,9 @@ class PregelLoop {
                     };
                 }
             }
+            // produce values output
+            const valuesOutput = await (0, utils_js_1.gatherIterator)((0, utils_js_1.prefixGenerator)((0, io_js_1.mapOutputValues)(this.outputKeys, true, this.channels), "values"));
+            this._emit(valuesOutput);
             // map inputs to channel updates
         }
         else {
@@ -415,7 +549,7 @@ class PregelLoop {
                 throw new errors_js_1.EmptyInputError(`Received no input writes for ${JSON.stringify(inputKeys, null, 2)}`);
             }
             const discardTasks = (0, algo_js_1._prepareNextTasks)(this.checkpoint, this.nodes, this.channels, this.managed, this.config, true, { step: this.step });
-            (0, algo_js_1._applyWrites)(this.checkpoint, this.channels, discardTasks.concat([
+            (0, algo_js_1._applyWrites)(this.checkpoint, this.channels, Object.values(discardTasks).concat([
                 {
                     name: constants_js_1.INPUT,
                     writes: inputWrites,
@@ -430,12 +564,25 @@ class PregelLoop {
         }
         // done with input
         this.input = isResuming ? INPUT_RESUMING : INPUT_DONE;
+        if (!this.isNested) {
+            this.config = (0, index_js_1.patchConfigurable)(this.config, {
+                [constants_js_1.CONFIG_KEY_RESUMING]: isResuming,
+            });
+        }
+    }
+    _emit(values) {
+        for (const chunk of values) {
+            if (this.stream.modes.has(chunk[0])) {
+                this.stream.push([this.checkpointNamespace, ...chunk]);
+            }
+        }
     }
     async _putCheckpoint(inputMetadata) {
         // Assign step
         const metadata = {
             ...inputMetadata,
             step: this.step,
+            parents: this.config.configurable?.[constants_js_1.CONFIG_KEY_CHECKPOINT_MAP] ?? {},
         };
         // Bail if no checkpointer
         if (this.checkpointer !== undefined) {
@@ -445,9 +592,7 @@ class PregelLoop {
             // this is achieved by writing child checkpoints as progress is made
             // (so that error recovery / resuming from interrupt don't lose work)
             // but doing so always with an id equal to that of the parent checkpoint
-            this.checkpoint = (0, base_js_1.createCheckpoint)(this.checkpoint, this.channels, this.step
-            // id: this.isNested ? this.config.configurable?.checkpoint_id : undefined,
-            );
+            this.checkpoint = (0, base_js_1.createCheckpoint)(this.checkpoint, this.channels, this.step);
             this.checkpointConfig = {
                 ...this.checkpointConfig,
                 configurable: {
@@ -456,7 +601,7 @@ class PregelLoop {
                 },
             };
             const channelVersions = { ...this.checkpoint.channel_versions };
-            const newVersions = (0, utils_js_2.getNewChannelVersions)(this.checkpointPreviousVersions, channelVersions);
+            const newVersions = (0, index_js_1.getNewChannelVersions)(this.checkpointPreviousVersions, channelVersions);
             this.checkpointPreviousVersions = channelVersions;
             // save it, without blocking
             // if there's a previous checkpoint save in progress, wait for it

package/dist/pregel/loop.d.ts

@@ -1,13 +1,12 @@
-import Deque from "double-ended-queue";
 import type { RunnableConfig } from "@langchain/core/runnables";
 import type { CallbackManagerForChainRun } from "@langchain/core/callbacks/manager";
-import { BaseCheckpointSaver, Checkpoint, PendingWrite, CheckpointPendingWrite, CheckpointMetadata, All } from "@langchain/langgraph-checkpoint";
+import { BaseCheckpointSaver, Checkpoint, PendingWrite, CheckpointPendingWrite, CheckpointMetadata, All, BaseStore, AsyncBatchedStore } from "@langchain/langgraph-checkpoint";
 import { BaseChannel } from "../channels/base.js";
 import { PregelExecutableTask, StreamMode } from "./types.js";
 import { PregelNode } from "./read.js";
-import { BaseStore } from "../store/base.js";
-import { AsyncBatchedStore } from "../store/batch.js";
 import { ManagedValueMapping } from "../managed/base.js";
+import { LangGraphRunnableConfig } from "./runnable_types.js";
+export type StreamChunk = [string[], StreamMode, unknown];
 export type PregelLoopInitializeParams = {
     input?: any;
     config: RunnableConfig;
@@ -17,6 +16,7 @@ export type PregelLoopInitializeParams = {
     nodes: Record<string, PregelNode>;
     channelSpecs: Record<string, BaseChannel>;
     managed: ManagedValueMapping;
+    stream: StreamProtocol;
     store?: BaseStore;
 };
 type PregelLoopParams = {
@@ -35,11 +35,21 @@ type PregelLoopParams = {
     outputKeys: string | string[];
     streamKeys: string | string[];
     nodes: Record<string, PregelNode>;
+    checkpointNamespace: string[];
+    skipDoneTasks: boolean;
+    isNested: boolean;
+    stream: StreamProtocol;
     store?: AsyncBatchedStore;
 };
+export declare class StreamProtocol {
+    push: (chunk: StreamChunk) => void;
+    modes: Set<StreamMode>;
+    constructor(pushFn: (chunk: StreamChunk) => void, modes: Set<StreamMode>);
+}
 export declare class PregelLoop {
     protected input?: any;
-    config: RunnableConfig;
+    output: any;
+    config: LangGraphRunnableConfig;
     protected checkpointer?: BaseCheckpointSaver;
     protected checkpointerGetNextVersion: (current: number | undefined, channel: BaseChannel) => number;
     channels: Record<string, BaseChannel>;
@@ -47,6 +57,7 @@ export declare class PregelLoop {
     protected checkpoint: Checkpoint;
     protected checkpointConfig: RunnableConfig;
     checkpointMetadata: CheckpointMetadata;
+    protected checkpointNamespace: string[];
     protected checkpointPendingWrites: CheckpointPendingWrite[];
     protected checkpointPreviousVersions: Record<string, string | number>;
     step: number;
@@ -55,11 +66,12 @@ export declare class PregelLoop {
     protected streamKeys: string | string[];
     protected nodes: Record<string, PregelNode>;
     protected skipDoneTasks: boolean;
+    protected taskWritesLeft: number;
     status: "pending" | "done" | "interrupt_before" | "interrupt_after" | "out_of_steps";
-    tasks: PregelExecutableTask<any, any>[];
-    stream: Deque<[StreamMode, any]>;
+    tasks: Record<string, PregelExecutableTask<any, any>>;
+    stream: StreamProtocol;
     checkpointerPromises: Promise<unknown>[];
-    protected isNested: boolean;
+    isNested: boolean;
     protected _checkpointerChainedPromise: Promise<unknown>;
     store?: AsyncBatchedStore;
     constructor(params: PregelLoopParams);
@@ -77,6 +89,7 @@ export declare class PregelLoop {
      * @param writes
      */
     putWrites(taskId: string, writes: PendingWrite<string>[]): void;
+    _outputWrites(taskId: string, writes: [string, unknown][], cached?: boolean): void;
     /**
      * Execute a single iteration of the Pregel loop.
      * Returns true if more iterations are needed.
@@ -88,12 +101,14 @@ export declare class PregelLoop {
         interruptBefore: string[] | All;
         manager?: CallbackManagerForChainRun;
     }): Promise<boolean>;
+    protected _suppressInterrupt(e?: Error): boolean;
     /**
      * Resuming from previous checkpoint requires
      * - finding a previous checkpoint
      * - receiving None input (outer graph) or RESUMING flag (subgraph)
      */
     protected _first(inputKeys: string | string[]): Promise<void>;
-    protected _putCheckpoint(inputMetadata: Omit<CheckpointMetadata, "step">): Promise<void>;
+    protected _emit(values: [StreamMode, unknown][]): void;
+    protected _putCheckpoint(inputMetadata: Omit<CheckpointMetadata, "step" | "parents">): Promise<void>;
 }
 export {};