@langchain/langgraph 0.2.20-rc.0 → 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

@@ -20,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";
 }
@@ -575,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) {
@@ -595,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) {
@@ -625,6 +629,7 @@ class Pregel extends runnables_1.Runnable {
             defaultInterruptAfter,
             defaultCheckpointer,
             defaultStore,
+            streamModeSingle,
         ];
     }
     /**
@@ -701,15 +706,35 @@ 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 { channelSpecs, managed } = await this.prepareSpecs(config);
+        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;
         let loopError;
         const runLoop = async () => {
@@ -810,11 +835,16 @@ class Pregel extends runnables_1.Runnable {
                     loopError = loopError ?? e;
                 }
                 if (loopError) {
-                    // Will throw an error outside of this method
+                    // "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
+                    // 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();
                 }
             }
@@ -827,10 +857,10 @@ class Pregel extends runnables_1.Runnable {
                 }
                 const [namespace, mode, payload] = chunk;
                 if (streamMode.includes(mode)) {
-                    if (streamSubgraphs && streamMode.length > 1) {
+                    if (streamSubgraphs && !streamModeSingle) {
                         yield [namespace, mode, payload];
                     }
-                    else if (streamMode.length > 1) {
+                    else if (!streamModeSingle) {
                         yield [mode, payload];
                     }
                     else if (streamSubgraphs) {

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.

package/dist/pregel/index.js

@@ -17,6 +17,7 @@ import { executeTasksWithRetry } from "./retry.js";
 import { ChannelKeyPlaceholder, isConfiguredManagedValue, ManagedValueMapping, NoopManagedValue, } from "../managed/base.js";
 import { gatherIterator, patchConfigurable } from "../utils.js";
 import { ensureLangGraphConfig } from "./utils/config.js";
+import { StreamMessagesHandler } from "./messages.js";
 function isString(value) {
     return typeof value === "string";
 }
@@ -571,6 +572,7 @@ export class Pregel extends 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) {
@@ -591,9 +593,11 @@ export class Pregel extends 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?.[CONFIG_KEY_TASK_ID] !== undefined) {
@@ -621,6 +625,7 @@ export class Pregel extends Runnable {
             defaultInterruptAfter,
             defaultCheckpointer,
             defaultStore,
+            streamModeSingle,
         ];
     }
     /**
@@ -697,15 +702,35 @@ export class Pregel extends 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 getCallbackManagerForConfig(inputConfig);
-        const runManager = await callbackManager?.handleChainStart(this.toJSON(), _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 { channelSpecs, managed } = await this.prepareSpecs(config);
+        const [debug, streamMode, , outputKeys, config, interruptBefore, interruptAfter, checkpointer, store, streamModeSingle,] = this._defaults(restConfig);
         const stream = new IterableReadableWritableStream({
             modes: new Set(streamMode),
         });
+        // set up messages stream mode
+        if (streamMode.includes("messages")) {
+            const messageStreamer = new 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 getCallbackManagerForConfig(config);
+        const runManager = await callbackManager?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), runId, undefined, undefined, undefined, config?.runName ?? this.getName());
+        const { channelSpecs, managed } = await this.prepareSpecs(config);
         let loop;
         let loopError;
         const runLoop = async () => {
@@ -806,11 +831,16 @@ export class Pregel extends Runnable {
                     loopError = loopError ?? e;
                 }
                 if (loopError) {
-                    // Will throw an error outside of this method
+                    // "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
+                    // 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();
                 }
             }
@@ -823,10 +853,10 @@ export class Pregel extends Runnable {
                 }
                 const [namespace, mode, payload] = chunk;
                 if (streamMode.includes(mode)) {
-                    if (streamSubgraphs && streamMode.length > 1) {
+                    if (streamSubgraphs && !streamModeSingle) {
                         yield [namespace, mode, payload];
                     }
-                    else if (streamMode.length > 1) {
+                    else if (!streamModeSingle) {
                         yield [mode, payload];
                     }
                     else if (streamSubgraphs) {

package/dist/pregel/loop.cjs

@@ -18,7 +18,7 @@ const SPECIAL_CHANNELS = [constants_js_1.ERROR, constants_js_1.INTERRUPT];
 class IterableReadableWritableStream extends stream_1.IterableReadableStream {
     constructor(params) {
         let streamControllerPromiseResolver;
-        let streamControllerPromise = new Promise((resolve) => {
+        const streamControllerPromise = new Promise((resolve) => {
             streamControllerPromiseResolver = resolve;
         });
         super({
@@ -46,7 +46,7 @@ class IterableReadableWritableStream extends stream_1.IterableReadableStream {
         });
         // .start() will always be called before the stream can be interacted
         // with anyway
-        streamControllerPromise.then((controller) => {
+        void streamControllerPromise.then((controller) => {
             this.controller = controller;
         });
         this.passthroughFn = params.passthroughFn;

package/dist/pregel/loop.js

@@ -15,7 +15,7 @@ const SPECIAL_CHANNELS = [ERROR, INTERRUPT];
 export class IterableReadableWritableStream extends IterableReadableStream {
     constructor(params) {
         let streamControllerPromiseResolver;
-        let streamControllerPromise = new Promise((resolve) => {
+        const streamControllerPromise = new Promise((resolve) => {
             streamControllerPromiseResolver = resolve;
         });
         super({
@@ -43,7 +43,7 @@ export class IterableReadableWritableStream extends IterableReadableStream {
         });
         // .start() will always be called before the stream can be interacted
         // with anyway
-        streamControllerPromise.then((controller) => {
+        void streamControllerPromise.then((controller) => {
             this.controller = controller;
         });
         this.passthroughFn = params.passthroughFn;

package/dist/pregel/messages.cjs

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamMessagesHandler = void 0;
+const uuid_1 = require("uuid");
+const base_1 = require("@langchain/core/callbacks/base");
+const messages_1 = require("@langchain/core/messages");
+const constants_js_1 = require("../constants.cjs");
+function isChatGenerationChunk(x) {
+    return (0, messages_1.isBaseMessage)(x?.message);
+}
+/**
+ * A callback handler that implements stream_mode=messages.
+ * Collects messages from (1) chat model stream events and (2) node outputs.
+ */
+class StreamMessagesHandler extends base_1.BaseCallbackHandler {
+    constructor(streamFn) {
+        super();
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "StreamMessagesHandler"
+        });
+        Object.defineProperty(this, "streamFn", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "metadatas", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "seen", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "emittedChatModelRunIds", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        this.streamFn = streamFn;
+    }
+    _emit(meta, message, dedupe = false) {
+        if (dedupe &&
+            message.id !== undefined &&
+            this.seen[message.id] !== undefined) {
+            return;
+        }
+        if (message.id === undefined) {
+            const id = (0, uuid_1.v4)();
+            // eslint-disable-next-line no-param-reassign
+            message.id = id;
+            // eslint-disable-next-line no-param-reassign
+            message.lc_kwargs.id = id;
+        }
+        this.seen[message.id] = message;
+        this.streamFn([meta[0], "messages", [message, meta[1]]]);
+    }
+    handleChatModelStart(_llm, _messages, runId, _parentRunId, _extraParams, tags, metadata, name) {
+        if (metadata &&
+            // Include legacy LangGraph SDK tag
+            (!tags || !(tags.includes(constants_js_1.TAG_NOSTREAM) && tags.includes("nostream")))) {
+            this.metadatas[runId] = [
+                metadata.langgraph_checkpoint_ns.split("NS_SEP"),
+                { tags, name, ...metadata },
+            ];
+        }
+    }
+    handleLLMNewToken(token, _idx, runId, _parentRunId, _tags, fields) {
+        const chunk = fields?.chunk;
+        this.emittedChatModelRunIds[runId] = true;
+        if (isChatGenerationChunk(chunk) && this.metadatas[runId] !== undefined) {
+            this._emit(this.metadatas[runId], chunk.message);
+        }
+        else {
+            this._emit(this.metadatas[runId], new messages_1.AIMessageChunk({
+                content: token,
+            }));
+        }
+    }
+    handleLLMEnd(output, runId) {
+        // In JS, non-streaming runs do not call handleLLMNewToken at the model level
+        if (!this.emittedChatModelRunIds[runId]) {
+            const chatGeneration = output.generations?.[0]?.[0];
+            if ((0, messages_1.isBaseMessage)(chatGeneration?.message)) {
+                this._emit(this.metadatas[runId], chatGeneration?.message, true);
+            }
+            delete this.emittedChatModelRunIds[runId];
+        }
+        delete this.metadatas[runId];
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    handleLLMError(_err, runId) {
+        delete this.metadatas[runId];
+    }
+    handleChainStart(_chain, _inputs, runId, _parentRunId, tags, metadata, _runType, name) {
+        if (metadata !== undefined &&
+            name === metadata.langgraph_node &&
+            (tags === undefined || !tags.includes(constants_js_1.TAG_HIDDEN))) {
+            this.metadatas[runId] = [
+                metadata.langgraph_checkpoint_ns.split("NS_SEP"),
+                { tags, name, ...metadata },
+            ];
+        }
+    }
+    handleChainEnd(outputs, runId) {
+        const metadata = this.metadatas[runId];
+        delete this.metadatas[runId];
+        if (metadata !== undefined) {
+            if ((0, messages_1.isBaseMessage)(outputs)) {
+                this._emit(metadata, outputs, true);
+            }
+            else if (Array.isArray(outputs)) {
+                for (const value of outputs) {
+                    if ((0, messages_1.isBaseMessage)(value)) {
+                        this._emit(metadata, value, true);
+                    }
+                }
+            }
+            else if (outputs != null && typeof outputs === "object") {
+                for (const value of Object.values(outputs)) {
+                    if ((0, messages_1.isBaseMessage)(value)) {
+                        this._emit(metadata, value, true);
+                    }
+                    else if (Array.isArray(value)) {
+                        for (const item of value) {
+                            if ((0, messages_1.isBaseMessage)(item)) {
+                                this._emit(metadata, item, true);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    handleChainError(_err, runId) {
+        delete this.metadatas[runId];
+    }
+}
+exports.StreamMessagesHandler = StreamMessagesHandler;

package/dist/pregel/messages.d.ts

@@ -0,0 +1,28 @@
+import { BaseCallbackHandler, HandleLLMNewTokenCallbackFields, NewTokenIndices } from "@langchain/core/callbacks/base";
+import { BaseMessage } from "@langchain/core/messages";
+import { Serialized } from "@langchain/core/load/serializable";
+import { LLMResult } from "@langchain/core/outputs";
+import { ChainValues } from "@langchain/core/utils/types";
+import { StreamChunk } from "./loop.js";
+type Meta = [string[], Record<string, any>];
+/**
+ * A callback handler that implements stream_mode=messages.
+ * Collects messages from (1) chat model stream events and (2) node outputs.
+ */
+export declare class StreamMessagesHandler extends BaseCallbackHandler {
+    name: string;
+    streamFn: (streamChunk: StreamChunk) => void;
+    metadatas: Record<string, Meta>;
+    seen: Record<string, BaseMessage>;
+    emittedChatModelRunIds: Record<string, boolean>;
+    constructor(streamFn: (streamChunk: StreamChunk) => void);
+    _emit(meta: Meta, message: BaseMessage, dedupe?: boolean): void;
+    handleChatModelStart(_llm: Serialized, _messages: BaseMessage[][], runId: string, _parentRunId?: string, _extraParams?: Record<string, unknown>, tags?: string[], metadata?: Record<string, unknown>, name?: string): void;
+    handleLLMNewToken(token: string, _idx: NewTokenIndices, runId: string, _parentRunId?: string, _tags?: string[], fields?: HandleLLMNewTokenCallbackFields): void;
+    handleLLMEnd(output: LLMResult, runId: string): void;
+    handleLLMError(_err: any, runId: string): void;
+    handleChainStart(_chain: Serialized, _inputs: ChainValues, runId: string, _parentRunId?: string, tags?: string[], metadata?: Record<string, unknown>, _runType?: string, name?: string): void;
+    handleChainEnd(outputs: ChainValues, runId: string): void;
+    handleChainError(_err: any, runId: string): void;
+}
+export {};

package/dist/pregel/messages.js

@@ -0,0 +1,144 @@
+import { v4 } from "uuid";
+import { BaseCallbackHandler, } from "@langchain/core/callbacks/base";
+import { AIMessageChunk, isBaseMessage, } from "@langchain/core/messages";
+import { TAG_HIDDEN, TAG_NOSTREAM } from "../constants.js";
+function isChatGenerationChunk(x) {
+    return isBaseMessage(x?.message);
+}
+/**
+ * A callback handler that implements stream_mode=messages.
+ * Collects messages from (1) chat model stream events and (2) node outputs.
+ */
+export class StreamMessagesHandler extends BaseCallbackHandler {
+    constructor(streamFn) {
+        super();
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "StreamMessagesHandler"
+        });
+        Object.defineProperty(this, "streamFn", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "metadatas", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "seen", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "emittedChatModelRunIds", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        this.streamFn = streamFn;
+    }
+    _emit(meta, message, dedupe = false) {
+        if (dedupe &&
+            message.id !== undefined &&
+            this.seen[message.id] !== undefined) {
+            return;
+        }
+        if (message.id === undefined) {
+            const id = v4();
+            // eslint-disable-next-line no-param-reassign
+            message.id = id;
+            // eslint-disable-next-line no-param-reassign
+            message.lc_kwargs.id = id;
+        }
+        this.seen[message.id] = message;
+        this.streamFn([meta[0], "messages", [message, meta[1]]]);
+    }
+    handleChatModelStart(_llm, _messages, runId, _parentRunId, _extraParams, tags, metadata, name) {
+        if (metadata &&
+            // Include legacy LangGraph SDK tag
+            (!tags || !(tags.includes(TAG_NOSTREAM) && tags.includes("nostream")))) {
+            this.metadatas[runId] = [
+                metadata.langgraph_checkpoint_ns.split("NS_SEP"),
+                { tags, name, ...metadata },
+            ];
+        }
+    }
+    handleLLMNewToken(token, _idx, runId, _parentRunId, _tags, fields) {
+        const chunk = fields?.chunk;
+        this.emittedChatModelRunIds[runId] = true;
+        if (isChatGenerationChunk(chunk) && this.metadatas[runId] !== undefined) {
+            this._emit(this.metadatas[runId], chunk.message);
+        }
+        else {
+            this._emit(this.metadatas[runId], new AIMessageChunk({
+                content: token,
+            }));
+        }
+    }
+    handleLLMEnd(output, runId) {
+        // In JS, non-streaming runs do not call handleLLMNewToken at the model level
+        if (!this.emittedChatModelRunIds[runId]) {
+            const chatGeneration = output.generations?.[0]?.[0];
+            if (isBaseMessage(chatGeneration?.message)) {
+                this._emit(this.metadatas[runId], chatGeneration?.message, true);
+            }
+            delete this.emittedChatModelRunIds[runId];
+        }
+        delete this.metadatas[runId];
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    handleLLMError(_err, runId) {
+        delete this.metadatas[runId];
+    }
+    handleChainStart(_chain, _inputs, runId, _parentRunId, tags, metadata, _runType, name) {
+        if (metadata !== undefined &&
+            name === metadata.langgraph_node &&
+            (tags === undefined || !tags.includes(TAG_HIDDEN))) {
+            this.metadatas[runId] = [
+                metadata.langgraph_checkpoint_ns.split("NS_SEP"),
+                { tags, name, ...metadata },
+            ];
+        }
+    }
+    handleChainEnd(outputs, runId) {
+        const metadata = this.metadatas[runId];
+        delete this.metadatas[runId];
+        if (metadata !== undefined) {
+            if (isBaseMessage(outputs)) {
+                this._emit(metadata, outputs, true);
+            }
+            else if (Array.isArray(outputs)) {
+                for (const value of outputs) {
+                    if (isBaseMessage(value)) {
+                        this._emit(metadata, value, true);
+                    }
+                }
+            }
+            else if (outputs != null && typeof outputs === "object") {
+                for (const value of Object.values(outputs)) {
+                    if (isBaseMessage(value)) {
+                        this._emit(metadata, value, true);
+                    }
+                    else if (Array.isArray(value)) {
+                        for (const item of value) {
+                            if (isBaseMessage(item)) {
+                                this._emit(metadata, item, true);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    handleChainError(_err, runId) {
+        delete this.metadatas[runId];
+    }
+}

package/dist/pregel/runnable_types.d.ts

@@ -2,4 +2,5 @@ import { RunnableConfig } from "@langchain/core/runnables";
 import { BaseStore } from "@langchain/langgraph-checkpoint";
 export interface LangGraphRunnableConfig<ConfigurableType extends Record<string, any> = Record<string, any>> extends RunnableConfig<ConfigurableType> {
     store?: BaseStore;
+    writer?: (chunk: unknown) => void;
 }

package/dist/pregel/types.d.ts

@@ -8,7 +8,7 @@ import { RetryPolicy } from "./utils/index.js";
 import { Interrupt } from "../constants.js";
 import { type ManagedValueSpec } from "../managed/base.js";
 import { LangGraphRunnableConfig } from "./runnable_types.js";
-export type StreamMode = "values" | "updates" | "debug";
+export type StreamMode = "values" | "updates" | "debug" | "messages" | "custom";
 export type PregelInputType = any;
 export type PregelOutputType = any;
 /**
@@ -103,7 +103,7 @@ export interface PregelTaskDescription {
 export interface PregelExecutableTask<N extends PropertyKey, C extends PropertyKey> {
     readonly name: N;
     readonly input: unknown;
-    readonly proc: Runnable;
+    readonly proc: Runnable<any, any, LangGraphRunnableConfig>;
     readonly writes: PendingWrite<C>[];
     readonly config?: LangGraphRunnableConfig;
     readonly triggers: Array<string>;

package/dist/pregel/utils/config.cjs

@@ -15,6 +15,7 @@ const CONFIG_KEYS = [
     "outputKeys",
     "streamMode",
     "store",
+    "writer",
 ];
 const DEFAULT_RECURSION_LIMIT = 25;
 function ensureLangGraphConfig(...configs) {

package/dist/pregel/utils/config.js

@@ -12,6 +12,7 @@ const CONFIG_KEYS = [
     "outputKeys",
     "streamMode",
     "store",
+    "writer",
 ];
 const DEFAULT_RECURSION_LIMIT = 25;
 export function ensureLangGraphConfig(...configs) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/langgraph",
-  "version": "0.2.20-rc.0",
+  "version": "0.2.20",
   "description": "LangGraph",
   "type": "module",
   "engines": {