@langchain/langgraph 0.2.19 → 0.2.20

package/dist/constants.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._isSend = exports.Send = exports._isSendInterface = exports.CHECKPOINT_NAMESPACE_END = exports.CHECKPOINT_NAMESPACE_SEPARATOR = exports.RESERVED = exports.TASK_NAMESPACE = exports.PULL = exports.PUSH = exports.TASKS = exports.TAG_HIDDEN = exports.RECURSION_LIMIT_DEFAULT = exports.RUNTIME_PLACEHOLDER = exports.INTERRUPT = exports.CONFIG_KEY_CHECKPOINT_MAP = exports.CONFIG_KEY_STREAM = exports.CONFIG_KEY_TASK_ID = exports.CONFIG_KEY_RESUMING = exports.CONFIG_KEY_CHECKPOINTER = exports.CONFIG_KEY_READ = exports.CONFIG_KEY_SEND = exports.ERROR = exports.INPUT = void 0;
+exports._isSend = exports.Send = exports._isSendInterface = exports.CHECKPOINT_NAMESPACE_END = exports.CHECKPOINT_NAMESPACE_SEPARATOR = exports.RESERVED = exports.TASK_NAMESPACE = exports.PULL = exports.PUSH = exports.TASKS = exports.TAG_NOSTREAM = exports.TAG_HIDDEN = exports.RECURSION_LIMIT_DEFAULT = exports.RUNTIME_PLACEHOLDER = exports.INTERRUPT = exports.CONFIG_KEY_CHECKPOINT_MAP = exports.CONFIG_KEY_STREAM = exports.CONFIG_KEY_TASK_ID = exports.CONFIG_KEY_RESUMING = exports.CONFIG_KEY_CHECKPOINTER = exports.CONFIG_KEY_READ = exports.CONFIG_KEY_SEND = exports.ERROR = exports.INPUT = void 0;
 exports.INPUT = "__input__";
 exports.ERROR = "__error__";
 exports.CONFIG_KEY_SEND = "__pregel_send";
@@ -15,6 +15,7 @@ exports.INTERRUPT = "__interrupt__";
 exports.RUNTIME_PLACEHOLDER = "__pregel_runtime_placeholder__";
 exports.RECURSION_LIMIT_DEFAULT = 25;
 exports.TAG_HIDDEN = "langsmith:hidden";
+exports.TAG_NOSTREAM = "langsmith:nostream";
 exports.TASKS = "__pregel_tasks";
 exports.PUSH = "__pregel_push";
 exports.PULL = "__pregel_pull";

package/dist/constants.d.ts

@@ -11,6 +11,7 @@ export declare const INTERRUPT = "__interrupt__";
 export declare const RUNTIME_PLACEHOLDER = "__pregel_runtime_placeholder__";
 export declare const RECURSION_LIMIT_DEFAULT = 25;
 export declare const TAG_HIDDEN = "langsmith:hidden";
+export declare const TAG_NOSTREAM = "langsmith:nostream";
 export declare const TASKS = "__pregel_tasks";
 export declare const PUSH = "__pregel_push";
 export declare const PULL = "__pregel_pull";

package/dist/constants.js

@@ -12,6 +12,7 @@ export const INTERRUPT = "__interrupt__";
 export const RUNTIME_PLACEHOLDER = "__pregel_runtime_placeholder__";
 export const RECURSION_LIMIT_DEFAULT = 25;
 export const TAG_HIDDEN = "langsmith:hidden";
+export const TAG_NOSTREAM = "langsmith:nostream";
 export const TASKS = "__pregel_tasks";
 export const PUSH = "__pregel_push";
 export const PULL = "__pregel_pull";

package/dist/pregel/algo.cjs

@@ -377,7 +377,7 @@ function _prepareSingleTask(taskPath, checkpoint, processes, channels, managed,
                         config: (0, runnables_1.patchConfig)((0, runnables_1.mergeConfigs)(config, {
                             metadata,
                             tags: proc.tags,
-                            store: extra.store ?? config?.store,
+                            store: extra.store ?? config.store,
                         }), {
                             runName: name,
                             callbacks: manager?.getChild(`graph:step:${step}`),

package/dist/pregel/algo.js

@@ -368,7 +368,7 @@ export function _prepareSingleTask(taskPath, checkpoint, processes, channels, ma
                         config: patchConfig(mergeConfigs(config, {
                             metadata,
                             tags: proc.tags,
-                            store: extra.store ?? config?.store,
+                            store: extra.store ?? config.store,
                         }), {
                             runName: name,
                             callbacks: manager?.getChild(`graph:step:${step}`),

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");
@@ -24,6 +20,7 @@ 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");
 function isString(value) {
     return typeof value === "string";
 }
@@ -579,6 +576,7 @@ class Pregel extends runnables_1.Runnable {
     }
     _defaults(config) {
         const { debug, streamMode, inputKeys, outputKeys, interruptAfter, interruptBefore, ...rest } = config;
+        let streamModeSingle = true;
         const defaultDebug = debug !== undefined ? debug : this.debug;
         let defaultOutputKeys = outputKeys;
         if (defaultOutputKeys === undefined) {
@@ -599,9 +597,11 @@ class Pregel extends runnables_1.Runnable {
         let defaultStreamMode;
         if (streamMode !== undefined) {
             defaultStreamMode = Array.isArray(streamMode) ? streamMode : [streamMode];
+            streamModeSingle = typeof streamMode === "string";
         }
         else {
             defaultStreamMode = this.streamMode;
+            streamModeSingle = true;
         }
         // if being called as a node in another graph, always use values mode
         if (config.configurable?.[constants_js_1.CONFIG_KEY_TASK_ID] !== undefined) {
@@ -629,6 +629,7 @@ class Pregel extends runnables_1.Runnable {
             defaultInterruptAfter,
             defaultCheckpointer,
             defaultStore,
+            streamModeSingle,
         ];
     }
     /**
@@ -705,135 +706,180 @@ class Pregel extends runnables_1.Runnable {
             inputConfig.configurable === undefined) {
             throw new Error(`Checkpointer requires one or more of the following "configurable" keys: "thread_id", "checkpoint_ns", "checkpoint_id"`);
         }
-        const callbackManager = await (0, runnables_1.getCallbackManagerForConfig)(inputConfig);
-        const runManager = await callbackManager?.handleChainStart(this.toJSON(), (0, index_js_1._coerceToDict)(input, "input"), inputConfig.runId, undefined, undefined, undefined, inputConfig?.runName ?? this.getName());
-        delete inputConfig.runId;
+        const { runId, ...restConfig } = inputConfig;
         // assign defaults
-        const [debug, streamMode, , outputKeys, config, interruptBefore, interruptAfter, checkpointer, store,] = this._defaults(inputConfig);
+        const [debug, streamMode, , outputKeys, config, interruptBefore, interruptAfter, checkpointer, store, streamModeSingle,] = this._defaults(restConfig);
+        const stream = new loop_js_1.IterableReadableWritableStream({
+            modes: new Set(streamMode),
+        });
+        // set up messages stream mode
+        if (streamMode.includes("messages")) {
+            const messageStreamer = new messages_js_1.StreamMessagesHandler((chunk) => stream.push(chunk));
+            const { callbacks } = config;
+            if (callbacks === undefined) {
+                config.callbacks = [messageStreamer];
+            }
+            else if (Array.isArray(callbacks)) {
+                config.callbacks = callbacks.concat(messageStreamer);
+            }
+            else {
+                const copiedCallbacks = callbacks.copy();
+                copiedCallbacks.addHandler(messageStreamer, true);
+                config.callbacks = copiedCallbacks;
+            }
+        }
+        // setup custom stream mode
+        if (streamMode.includes("custom")) {
+            config.writer = (chunk) => stream.push([[], "custom", chunk]);
+        }
+        const callbackManager = await (0, runnables_1.getCallbackManagerForConfig)(config);
+        const runManager = await callbackManager?.handleChainStart(this.toJSON(), (0, index_js_1._coerceToDict)(input, "input"), runId, undefined, undefined, undefined, config?.runName ?? this.getName());
         const { channelSpecs, managed } = await this.prepareSpecs(config);
         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) {
-                    throw new Error("Data structure error.");
+        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,
+                    };
                 }
-                const [namespace, mode, payload] = nextItem;
-                if (streamMode.includes(mode)) {
-                    if (streamSubgraphs && streamMode.length > 1) {
-                        yield [namespace, mode, payload];
-                    }
-                    else if (streamMode.length > 1) {
-                        yield [mode, payload];
-                    }
-                    else if (streamSubgraphs) {
-                        yield [namespace, payload];
+                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);
                     }
-                    else {
-                        yield payload;
+                    if (debug) {
+                        (0, debug_js_1.printStepTasks)(loop.step, Object.values(loop.tasks));
                     }
-                }
-            }
-        }
-        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;
+                    // 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]));
+                                }
                             }
-                            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, [
-                                [constants_js_1.ERROR, { message: error.message, name: error.name }],
-                            ]);
+                            loop.putWrites(task.id, task.writes);
+                        }
+                        if (error !== undefined && !(0, errors_js_1.isGraphInterrupt)(error)) {
+                            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);
                     }
-                    yield* emitCurrentLoopOutputs();
-                    if (error !== undefined && !(0, errors_js_1.isGraphInterrupt)(error)) {
-                        throw error;
+                }
+                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()),
+                    ]);
                 }
-                if (debug) {
-                    (0, debug_js_1.printStepWrites)(loop.step, Object.values(loop.tasks)
-                        .map((task) => task.writes)
-                        .flat(), this.streamChannelsList);
+                catch (e) {
+                    loopError = loopError ?? e;
+                }
+                if (loopError) {
+                    // "Causes any future interactions with the associated stream to error".
+                    // Wraps ReadableStreamDefaultController#error:
+                    // https://developer.mozilla.org/en-US/docs/Web/API/ReadableStreamDefaultController/error
+                    stream.error(loopError);
+                }
+                else {
+                    // Will end the iterator outside of this method,
+                    // keeping previously enqueued chunks.
+                    // Wraps ReadableStreamDefaultController#close:
+                    // https://developer.mozilla.org/en-US/docs/Web/API/ReadableStreamDefaultController/close
+                    stream.close();
                 }
             }
-            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",
-                });
+        };
+        const runLoopPromise = runLoop();
+        try {
+            for await (const chunk of stream) {
+                if (chunk === undefined) {
+                    throw new Error("Data structure error.");
+                }
+                const [namespace, mode, payload] = chunk;
+                if (streamMode.includes(mode)) {
+                    if (streamSubgraphs && !streamModeSingle) {
+                        yield [namespace, mode, payload];
+                    }
+                    else if (!streamModeSingle) {
+                        yield [mode, payload];
+                    }
+                    else if (streamSubgraphs) {
+                        yield [namespace, payload];
+                    }
+                    else {
+                        yield payload;
+                    }
+                }
             }
-            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.d.ts

@@ -77,14 +77,15 @@ export declare class Pregel<Nn extends StrRecord<string, PregelNode>, Cc extends
         string | string[],
         // input keys
         string | string[],
-        RunnableConfig,
+        LangGraphRunnableConfig,
         // config without pregel keys
         All | string[],
         // interrupt before
         All | string[],
         // interrupt after
         BaseCheckpointSaver | undefined,
-        BaseStore | undefined
+        BaseStore | undefined,
+        boolean
     ];
     /**
      * Stream graph steps for a single input.