@langchain/langgraph 0.2.19 → 0.2.20-rc.0

package/dist/pregel/index.cjs

@@ -1,13 +1,9 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Pregel = exports.Channel = void 0;
 /* eslint-disable no-param-reassign */
 const runnables_1 = require("@langchain/core/runnables");
 const langgraph_checkpoint_1 = require("@langchain/langgraph-checkpoint");
-const double_ended_queue_1 = __importDefault(require("double-ended-queue"));
 const base_js_1 = require("../channels/base.cjs");
 const read_js_1 = require("./read.cjs");
 const validate_js_1 = require("./validate.cjs");
@@ -711,15 +707,125 @@ class Pregel extends runnables_1.Runnable {
         // assign defaults
         const [debug, streamMode, , outputKeys, config, interruptBefore, interruptAfter, checkpointer, store,] = this._defaults(inputConfig);
         const { channelSpecs, managed } = await this.prepareSpecs(config);
+        const stream = new loop_js_1.IterableReadableWritableStream({
+            modes: new Set(streamMode),
+        });
         let loop;
-        const stream = new double_ended_queue_1.default();
-        function* emitCurrentLoopOutputs() {
-            while (loop !== undefined && stream.length > 0) {
-                const nextItem = stream.shift();
-                if (nextItem === undefined) {
+        let loopError;
+        const runLoop = async () => {
+            try {
+                loop = await loop_js_1.PregelLoop.initialize({
+                    input,
+                    config,
+                    checkpointer,
+                    nodes: this.nodes,
+                    channelSpecs,
+                    managed,
+                    outputKeys,
+                    streamKeys: this.streamChannelsAsIs,
+                    store,
+                    stream,
+                });
+                if (options?.subgraphs) {
+                    loop.config.configurable = {
+                        ...loop.config.configurable,
+                        [constants_js_1.CONFIG_KEY_STREAM]: loop.stream,
+                    };
+                }
+                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,
+                    });
+                    // Timeouts will be thrown
+                    for await (const { task, error } of taskStream) {
+                        if (error !== undefined) {
+                            if ((0, errors_js_1.isGraphInterrupt)(error)) {
+                                if (loop.isNested) {
+                                    throw error;
+                                }
+                                if (error.interrupts.length) {
+                                    loop.putWrites(task.id, error.interrupts.map((interrupt) => [constants_js_1.INTERRUPT, interrupt]));
+                                }
+                            }
+                            else {
+                                loop.putWrites(task.id, [
+                                    [constants_js_1.ERROR, { message: error.message, name: error.name }],
+                                ]);
+                            }
+                        }
+                        else {
+                            loop.putWrites(task.id, task.writes);
+                        }
+                        if (error !== undefined && !(0, errors_js_1.isGraphInterrupt)(error)) {
+                            throw error;
+                        }
+                    }
+                    if (debug) {
+                        (0, debug_js_1.printStepWrites)(loop.step, Object.values(loop.tasks)
+                            .map((task) => task.writes)
+                            .flat(), this.streamChannelsList);
+                    }
+                }
+                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) {
+                loopError = e;
+            }
+            finally {
+                try {
+                    // Call `.stop()` again incase it was not called in the loop, e.g due to an error.
+                    if (loop) {
+                        await loop.store?.stop();
+                    }
+                    await Promise.all([
+                        ...(loop?.checkpointerPromises ?? []),
+                        ...Array.from(managed.values()).map((mv) => mv.promises()),
+                    ]);
+                }
+                catch (e) {
+                    loopError = loopError ?? e;
+                }
+                if (loopError) {
+                    // Will throw an error outside of this method
+                    stream.error(loopError);
+                }
+                else {
+                    // Will end the iterator outside of this method
+                    stream.close();
+                }
+            }
+        };
+        const runLoopPromise = runLoop();
+        try {
+            for await (const chunk of stream) {
+                if (chunk === undefined) {
                     throw new Error("Data structure error.");
                 }
-                const [namespace, mode, payload] = nextItem;
+                const [namespace, mode, payload] = chunk;
                 if (streamMode.includes(mode)) {
                     if (streamSubgraphs && streamMode.length > 1) {
                         yield [namespace, mode, payload];
@@ -736,104 +842,14 @@ class Pregel extends runnables_1.Runnable {
                 }
             }
         }
-        try {
-            loop = await loop_js_1.PregelLoop.initialize({
-                input,
-                config,
-                checkpointer,
-                nodes: this.nodes,
-                channelSpecs,
-                managed,
-                outputKeys,
-                streamKeys: this.streamChannelsAsIs,
-                store,
-                stream: new loop_js_1.StreamProtocol((chunk) => stream.push(chunk), new Set(streamMode)),
-            });
-            if (options?.subgraphs) {
-                loop.config.configurable = {
-                    ...loop.config.configurable,
-                    [constants_js_1.CONFIG_KEY_STREAM]: loop.stream,
-                };
-            }
-            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);
-                }
-                yield* emitCurrentLoopOutputs();
-                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,
-                });
-                // Timeouts will be thrown
-                for await (const { task, error } of taskStream) {
-                    if (error !== undefined) {
-                        if ((0, errors_js_1.isGraphInterrupt)(error)) {
-                            if (loop.isNested) {
-                                throw error;
-                            }
-                            if (error.interrupts.length) {
-                                loop.putWrites(task.id, error.interrupts.map((interrupt) => [constants_js_1.INTERRUPT, interrupt]));
-                            }
-                        }
-                        else {
-                            loop.putWrites(task.id, [
-                                [constants_js_1.ERROR, { message: error.message, name: error.name }],
-                            ]);
-                        }
-                    }
-                    else {
-                        loop.putWrites(task.id, task.writes);
-                    }
-                    yield* emitCurrentLoopOutputs();
-                    if (error !== undefined && !(0, errors_js_1.isGraphInterrupt)(error)) {
-                        throw error;
-                    }
-                }
-                if (debug) {
-                    (0, debug_js_1.printStepWrites)(loop.step, Object.values(loop.tasks)
-                        .map((task) => task.writes)
-                        .flat(), this.streamChannelsList);
-                }
-            }
-            yield* emitCurrentLoopOutputs();
-            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",
-                });
-            }
-            await Promise.all(loop?.checkpointerPromises ?? []);
-            await runManager?.handleChainEnd(loop.output);
-        }
         catch (e) {
-            await runManager?.handleChainError(e);
+            await runManager?.handleChainError(loopError);
             throw e;
         }
         finally {
-            // Call `.stop()` again incase it was not called in the loop, e.g due to an error.
-            if (loop) {
-                await loop.store?.stop();
-            }
-            await Promise.all([
-                ...(loop?.checkpointerPromises ?? []),
-                ...Array.from(managed.values()).map((mv) => mv.promises()),
-            ]);
+            await runLoopPromise;
         }
+        await runManager?.handleChainEnd(loop?.output ?? {});
     }
     /**
      * Run the graph with a single input and config.

package/dist/pregel/index.js

@@ -1,7 +1,6 @@
 /* eslint-disable no-param-reassign */
 import { Runnable, RunnableSequence, getCallbackManagerForConfig, mergeConfigs, patchConfig, _coerceToRunnable, } from "@langchain/core/runnables";
 import { compareChannelVersions, copyCheckpoint, emptyCheckpoint, uuid5, } from "@langchain/langgraph-checkpoint";
-import Deque from "double-ended-queue";
 import { createCheckpoint, emptyChannels, isBaseChannel, } from "../channels/base.js";
 import { PregelNode } from "./read.js";
 import { validateGraph, validateKeys } from "./validate.js";
@@ -13,7 +12,7 @@ import { GraphRecursionError, GraphValueError, InvalidUpdateError, isGraphInterr
 import { _prepareNextTasks, _localRead, _applyWrites, } from "./algo.js";
 import { _coerceToDict, getNewChannelVersions, patchCheckpointMap, } from "./utils/index.js";
 import { findSubgraphPregel } from "./utils/subgraph.js";
-import { PregelLoop, StreamProtocol } from "./loop.js";
+import { PregelLoop, IterableReadableWritableStream } from "./loop.js";
 import { executeTasksWithRetry } from "./retry.js";
 import { ChannelKeyPlaceholder, isConfiguredManagedValue, ManagedValueMapping, NoopManagedValue, } from "../managed/base.js";
 import { gatherIterator, patchConfigurable } from "../utils.js";
@@ -704,15 +703,125 @@ export class Pregel extends Runnable {
         // assign defaults
         const [debug, streamMode, , outputKeys, config, interruptBefore, interruptAfter, checkpointer, store,] = this._defaults(inputConfig);
         const { channelSpecs, managed } = await this.prepareSpecs(config);
+        const stream = new IterableReadableWritableStream({
+            modes: new Set(streamMode),
+        });
         let loop;
-        const stream = new Deque();
-        function* emitCurrentLoopOutputs() {
-            while (loop !== undefined && stream.length > 0) {
-                const nextItem = stream.shift();
-                if (nextItem === undefined) {
+        let loopError;
+        const runLoop = async () => {
+            try {
+                loop = await PregelLoop.initialize({
+                    input,
+                    config,
+                    checkpointer,
+                    nodes: this.nodes,
+                    channelSpecs,
+                    managed,
+                    outputKeys,
+                    streamKeys: this.streamChannelsAsIs,
+                    store,
+                    stream,
+                });
+                if (options?.subgraphs) {
+                    loop.config.configurable = {
+                        ...loop.config.configurable,
+                        [CONFIG_KEY_STREAM]: loop.stream,
+                    };
+                }
+                while (await loop.tick({
+                    inputKeys: this.inputChannels,
+                    interruptAfter,
+                    interruptBefore,
+                    manager: runManager,
+                })) {
+                    if (debug) {
+                        printStepCheckpoint(loop.checkpointMetadata.step, loop.channels, this.streamChannelsList);
+                    }
+                    if (debug) {
+                        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 = executeTasksWithRetry(Object.values(loop.tasks).filter((task) => task.writes.length === 0), {
+                        stepTimeout: this.stepTimeout,
+                        signal: config.signal,
+                        retryPolicy: this.retryPolicy,
+                    });
+                    // Timeouts will be thrown
+                    for await (const { task, error } of taskStream) {
+                        if (error !== undefined) {
+                            if (isGraphInterrupt(error)) {
+                                if (loop.isNested) {
+                                    throw error;
+                                }
+                                if (error.interrupts.length) {
+                                    loop.putWrites(task.id, error.interrupts.map((interrupt) => [INTERRUPT, interrupt]));
+                                }
+                            }
+                            else {
+                                loop.putWrites(task.id, [
+                                    [ERROR, { message: error.message, name: error.name }],
+                                ]);
+                            }
+                        }
+                        else {
+                            loop.putWrites(task.id, task.writes);
+                        }
+                        if (error !== undefined && !isGraphInterrupt(error)) {
+                            throw error;
+                        }
+                    }
+                    if (debug) {
+                        printStepWrites(loop.step, Object.values(loop.tasks)
+                            .map((task) => task.writes)
+                            .flat(), this.streamChannelsList);
+                    }
+                }
+                if (loop.status === "out_of_steps") {
+                    throw new 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) {
+                loopError = e;
+            }
+            finally {
+                try {
+                    // Call `.stop()` again incase it was not called in the loop, e.g due to an error.
+                    if (loop) {
+                        await loop.store?.stop();
+                    }
+                    await Promise.all([
+                        ...(loop?.checkpointerPromises ?? []),
+                        ...Array.from(managed.values()).map((mv) => mv.promises()),
+                    ]);
+                }
+                catch (e) {
+                    loopError = loopError ?? e;
+                }
+                if (loopError) {
+                    // Will throw an error outside of this method
+                    stream.error(loopError);
+                }
+                else {
+                    // Will end the iterator outside of this method
+                    stream.close();
+                }
+            }
+        };
+        const runLoopPromise = runLoop();
+        try {
+            for await (const chunk of stream) {
+                if (chunk === undefined) {
                     throw new Error("Data structure error.");
                 }
-                const [namespace, mode, payload] = nextItem;
+                const [namespace, mode, payload] = chunk;
                 if (streamMode.includes(mode)) {
                     if (streamSubgraphs && streamMode.length > 1) {
                         yield [namespace, mode, payload];
@@ -729,104 +838,14 @@ export class Pregel extends Runnable {
                 }
             }
         }
-        try {
-            loop = await PregelLoop.initialize({
-                input,
-                config,
-                checkpointer,
-                nodes: this.nodes,
-                channelSpecs,
-                managed,
-                outputKeys,
-                streamKeys: this.streamChannelsAsIs,
-                store,
-                stream: new StreamProtocol((chunk) => stream.push(chunk), new Set(streamMode)),
-            });
-            if (options?.subgraphs) {
-                loop.config.configurable = {
-                    ...loop.config.configurable,
-                    [CONFIG_KEY_STREAM]: loop.stream,
-                };
-            }
-            while (await loop.tick({
-                inputKeys: this.inputChannels,
-                interruptAfter,
-                interruptBefore,
-                manager: runManager,
-            })) {
-                if (debug) {
-                    printStepCheckpoint(loop.checkpointMetadata.step, loop.channels, this.streamChannelsList);
-                }
-                yield* emitCurrentLoopOutputs();
-                if (debug) {
-                    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 = executeTasksWithRetry(Object.values(loop.tasks).filter((task) => task.writes.length === 0), {
-                    stepTimeout: this.stepTimeout,
-                    signal: config.signal,
-                    retryPolicy: this.retryPolicy,
-                });
-                // Timeouts will be thrown
-                for await (const { task, error } of taskStream) {
-                    if (error !== undefined) {
-                        if (isGraphInterrupt(error)) {
-                            if (loop.isNested) {
-                                throw error;
-                            }
-                            if (error.interrupts.length) {
-                                loop.putWrites(task.id, error.interrupts.map((interrupt) => [INTERRUPT, interrupt]));
-                            }
-                        }
-                        else {
-                            loop.putWrites(task.id, [
-                                [ERROR, { message: error.message, name: error.name }],
-                            ]);
-                        }
-                    }
-                    else {
-                        loop.putWrites(task.id, task.writes);
-                    }
-                    yield* emitCurrentLoopOutputs();
-                    if (error !== undefined && !isGraphInterrupt(error)) {
-                        throw error;
-                    }
-                }
-                if (debug) {
-                    printStepWrites(loop.step, Object.values(loop.tasks)
-                        .map((task) => task.writes)
-                        .flat(), this.streamChannelsList);
-                }
-            }
-            yield* emitCurrentLoopOutputs();
-            if (loop.status === "out_of_steps") {
-                throw new 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",
-                });
-            }
-            await Promise.all(loop?.checkpointerPromises ?? []);
-            await runManager?.handleChainEnd(loop.output);
-        }
         catch (e) {
-            await runManager?.handleChainError(e);
+            await runManager?.handleChainError(loopError);
             throw e;
         }
         finally {
-            // Call `.stop()` again incase it was not called in the loop, e.g due to an error.
-            if (loop) {
-                await loop.store?.stop();
-            }
-            await Promise.all([
-                ...(loop?.checkpointerPromises ?? []),
-                ...Array.from(managed.values()).map((mv) => mv.promises()),
-            ]);
+            await runLoopPromise;
         }
+        await runManager?.handleChainEnd(loop?.output ?? {});
     }
     /**
      * Run the graph with a single input and config.

package/dist/pregel/loop.cjs

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PregelLoop = exports.StreamProtocol = void 0;
+exports.PregelLoop = exports.IterableReadableWritableStream = void 0;
+const stream_1 = require("@langchain/core/utils/stream");
 const langgraph_checkpoint_1 = require("@langchain/langgraph-checkpoint");
 const base_js_1 = require("../channels/base.cjs");
 const constants_js_1 = require("../constants.cjs");
@@ -14,33 +15,72 @@ 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", {
+class IterableReadableWritableStream extends stream_1.IterableReadableStream {
+    constructor(params) {
+        let streamControllerPromiseResolver;
+        let streamControllerPromise = new Promise((resolve) => {
+            streamControllerPromiseResolver = resolve;
+        });
+        super({
+            start: (controller) => {
+                streamControllerPromiseResolver(controller);
+            },
+        });
+        Object.defineProperty(this, "modes", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "modes", {
+        Object.defineProperty(this, "controller", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "passthroughFn", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        this.push = pushFn;
-        this.modes = modes;
+        // .start() will always be called before the stream can be interacted
+        // with anyway
+        streamControllerPromise.then((controller) => {
+            this.controller = controller;
+        });
+        this.passthroughFn = params.passthroughFn;
+        this.modes = params.modes;
+    }
+    push(chunk) {
+        this.passthroughFn?.(chunk);
+        this.controller.enqueue(chunk);
+    }
+    close() {
+        try {
+            this.controller.close();
+        }
+        catch (e) {
+            // pass
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    error(e) {
+        this.controller.error(e);
     }
 }
-exports.StreamProtocol = StreamProtocol;
+exports.IterableReadableWritableStream = IterableReadableWritableStream;
 function createDuplexStream(...streams) {
-    return new StreamProtocol((value) => {
-        for (const stream of streams) {
-            if (stream.modes.has(value[1])) {
-                stream.push(value);
+    return new IterableReadableWritableStream({
+        passthroughFn: (value) => {
+            for (const stream of streams) {
+                if (stream.modes.has(value[1])) {
+                    stream.push(value);
+                }
             }
-        }
-    }, new Set(streams.flatMap((s) => Array.from(s.modes))));
+        },
+        modes: new Set(streams.flatMap((s) => Array.from(s.modes))),
+    });
 }
 class PregelLoop {
     constructor(params) {

package/dist/pregel/loop.d.ts

@@ -1,5 +1,6 @@
 import type { RunnableConfig } from "@langchain/core/runnables";
 import type { CallbackManagerForChainRun } from "@langchain/core/callbacks/manager";
+import { IterableReadableStream } from "@langchain/core/utils/stream";
 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";
@@ -16,7 +17,7 @@ export type PregelLoopInitializeParams = {
     nodes: Record<string, PregelNode>;
     channelSpecs: Record<string, BaseChannel>;
     managed: ManagedValueMapping;
-    stream: StreamProtocol;
+    stream: IterableReadableWritableStream;
     store?: BaseStore;
     checkSubgraphs?: boolean;
 };
@@ -39,14 +40,21 @@ type PregelLoopParams = {
     checkpointNamespace: string[];
     skipDoneTasks: boolean;
     isNested: boolean;
-    stream: StreamProtocol;
+    stream: IterableReadableWritableStream;
     store?: AsyncBatchedStore;
     prevCheckpointConfig: RunnableConfig | undefined;
 };
-export declare class StreamProtocol {
-    push: (chunk: StreamChunk) => void;
+export declare class IterableReadableWritableStream extends IterableReadableStream<StreamChunk> {
     modes: Set<StreamMode>;
-    constructor(pushFn: (chunk: StreamChunk) => void, modes: Set<StreamMode>);
+    private controller;
+    private passthroughFn?;
+    constructor(params: {
+        passthroughFn?: (chunk: StreamChunk) => void;
+        modes: Set<StreamMode>;
+    });
+    push(chunk: StreamChunk): void;
+    close(): void;
+    error(e: any): void;
 }
 export declare class PregelLoop {
     protected input?: any;
@@ -72,7 +80,7 @@ export declare class PregelLoop {
     protected prevCheckpointConfig: RunnableConfig | undefined;
     status: "pending" | "done" | "interrupt_before" | "interrupt_after" | "out_of_steps";
     tasks: Record<string, PregelExecutableTask<any, any>>;
-    stream: StreamProtocol;
+    stream: IterableReadableWritableStream;
     checkpointerPromises: Promise<unknown>[];
     isNested: boolean;
     protected _checkpointerChainedPromise: Promise<unknown>;

package/dist/pregel/loop.js

@@ -1,3 +1,4 @@
+import { IterableReadableStream } from "@langchain/core/utils/stream";
 import { copyCheckpoint, emptyCheckpoint, AsyncBatchedStore, } from "@langchain/langgraph-checkpoint";
 import { createCheckpoint, emptyChannels, } from "../channels/base.js";
 import { CHECKPOINT_NAMESPACE_SEPARATOR, CONFIG_KEY_CHECKPOINT_MAP, CONFIG_KEY_READ, CONFIG_KEY_RESUMING, CONFIG_KEY_STREAM, ERROR, INPUT, INTERRUPT, TAG_HIDDEN, TASKS, } from "../constants.js";
@@ -11,32 +12,71 @@ const INPUT_DONE = Symbol.for("INPUT_DONE");
 const INPUT_RESUMING = Symbol.for("INPUT_RESUMING");
 const DEFAULT_LOOP_LIMIT = 25;
 const SPECIAL_CHANNELS = [ERROR, INTERRUPT];
-export class StreamProtocol {
-    constructor(pushFn, modes) {
-        Object.defineProperty(this, "push", {
+export class IterableReadableWritableStream extends IterableReadableStream {
+    constructor(params) {
+        let streamControllerPromiseResolver;
+        let streamControllerPromise = new Promise((resolve) => {
+            streamControllerPromiseResolver = resolve;
+        });
+        super({
+            start: (controller) => {
+                streamControllerPromiseResolver(controller);
+            },
+        });
+        Object.defineProperty(this, "modes", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "modes", {
+        Object.defineProperty(this, "controller", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "passthroughFn", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        this.push = pushFn;
-        this.modes = modes;
+        // .start() will always be called before the stream can be interacted
+        // with anyway
+        streamControllerPromise.then((controller) => {
+            this.controller = controller;
+        });
+        this.passthroughFn = params.passthroughFn;
+        this.modes = params.modes;
+    }
+    push(chunk) {
+        this.passthroughFn?.(chunk);
+        this.controller.enqueue(chunk);
+    }
+    close() {
+        try {
+            this.controller.close();
+        }
+        catch (e) {
+            // pass
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    error(e) {
+        this.controller.error(e);
     }
 }
 function createDuplexStream(...streams) {
-    return new StreamProtocol((value) => {
-        for (const stream of streams) {
-            if (stream.modes.has(value[1])) {
-                stream.push(value);
+    return new IterableReadableWritableStream({
+        passthroughFn: (value) => {
+            for (const stream of streams) {
+                if (stream.modes.has(value[1])) {
+                    stream.push(value);
+                }
             }
-        }
-    }, new Set(streams.flatMap((s) => Array.from(s.modes))));
+        },
+        modes: new Set(streams.flatMap((s) => Array.from(s.modes))),
+    });
 }
 export class PregelLoop {
     constructor(params) {

package/dist/pregel/retry.cjs

@@ -130,7 +130,7 @@ pregelTask, retryPolicy) {
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 error.constructor.unminifiable_name ??
                 error.constructor.name;
-            console.log(`Retrying task "${pregelTask.name}" after ${interval.toFixed(2)} seconds (attempt ${attempts}) after ${errorName}: ${error}`);
+            console.log(`Retrying task "${pregelTask.name}" after ${interval.toFixed(2)}ms (attempt ${attempts}) after ${errorName}: ${error}`);
         }
         finally {
             // Clear checkpoint_ns seen (for subgraph detection)

package/dist/pregel/retry.js

@@ -126,7 +126,7 @@ pregelTask, retryPolicy) {
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 error.constructor.unminifiable_name ??
                 error.constructor.name;
-            console.log(`Retrying task "${pregelTask.name}" after ${interval.toFixed(2)} seconds (attempt ${attempts}) after ${errorName}: ${error}`);
+            console.log(`Retrying task "${pregelTask.name}" after ${interval.toFixed(2)}ms (attempt ${attempts}) after ${errorName}: ${error}`);
         }
         finally {
             // Clear checkpoint_ns seen (for subgraph detection)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/langgraph",
-  "version": "0.2.19",
+  "version": "0.2.20-rc.0",
   "description": "LangGraph",
   "type": "module",
   "engines": {
@@ -33,7 +33,6 @@
   "dependencies": {
     "@langchain/langgraph-checkpoint": "~0.0.10",
     "@langchain/langgraph-sdk": "~0.0.20",
-    "double-ended-queue": "^2.1.0-0",
     "uuid": "^10.0.0",
     "zod": "^3.23.8"
   },
@@ -44,7 +43,7 @@
     "@jest/globals": "^29.5.0",
     "@langchain/anthropic": "^0.3.5",
     "@langchain/community": "^0.3.9",
-    "@langchain/core": "^0.3.15",
+    "@langchain/core": "^0.3.16",
     "@langchain/langgraph-checkpoint-postgres": "workspace:*",
     "@langchain/langgraph-checkpoint-sqlite": "workspace:*",
     "@langchain/openai": "^0.3.11",
@@ -52,7 +51,6 @@
     "@swc/core": "^1.3.90",
     "@swc/jest": "^0.2.29",
     "@tsconfig/recommended": "^1.0.3",
-    "@types/double-ended-queue": "^2",
     "@types/pg": "^8",
     "@types/uuid": "^10",
     "@typescript-eslint/eslint-plugin": "^6.12.0",