@langchain/langgraph 0.2.20-rc.0 → 0.2.21

package/README.md

@@ -185,7 +185,7 @@ Is there anything else you'd like to know about the weather in New York or any o
     <summary>Initialize the model and tools.</summary>
 
     - We use `ChatAnthropic` as our LLM. **NOTE:** We need make sure the model knows that it has these tools available to call. We can do this by converting the LangChain tools into the format for Anthropic tool calling using the `.bindTools()` method.
-    - We define the tools we want to use -- a weather tool in our case. See the documentation [here](https://js.langchain.com/docs/modules/agents/tools/dynamic) on how to create your own tools.
+    - We define the tools we want to use -- a weather tool in our case. See the documentation [here](https://js.langchain.com/docs/how_to/custom_tools/) on how to create your own tools.
    </details>
 
 2. <details>

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,
         ];
     }
     /**
@@ -643,7 +648,16 @@ class Pregel extends runnables_1.Runnable {
      * @param options.debug Whether to print debug information during execution.
      */
     async stream(input, options) {
-        return super.stream(input, options);
+        // The ensureConfig method called internally defaults recursionLimit to 25 if not
+        // passed directly in `options`.
+        // There is currently no way in _streamIterator to determine whether this was
+        // set by by ensureConfig or manually by the user, so we specify the bound value here
+        // and override if it is passed as an explicit param in `options`.
+        const config = {
+            recursionLimit: this.config?.recursionLimit,
+            ...options,
+        };
+        return super.stream(input, config);
     }
     async prepareSpecs(config, options) {
         const configForManaged = {
@@ -701,15 +715,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 +844,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 +866,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,
         ];
     }
     /**
@@ -639,7 +644,16 @@ export class Pregel extends Runnable {
      * @param options.debug Whether to print debug information during execution.
      */
     async stream(input, options) {
-        return super.stream(input, options);
+        // The ensureConfig method called internally defaults recursionLimit to 25 if not
+        // passed directly in `options`.
+        // There is currently no way in _streamIterator to determine whether this was
+        // set by by ensureConfig or manually by the user, so we specify the bound value here
+        // and override if it is passed as an explicit param in `options`.
+        const config = {
+            recursionLimit: this.config?.recursionLimit,
+            ...options,
+        };
+        return super.stream(input, config);
     }
     async prepareSpecs(config, options) {
         const configForManaged = {
@@ -697,15 +711,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 +840,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 +862,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/remote.cjs

@@ -420,7 +420,6 @@ class RemoteGraph extends runnables_1.Runnable {
             xray: config?.xray,
         });
         return new graph_1.Graph({
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             nodes: this._getDrawableNodes(graph.nodes),
             edges: graph.edges,
         });

package/dist/pregel/remote.js

@@ -417,7 +417,6 @@ export class RemoteGraph extends Runnable {
             xray: config?.xray,
         });
         return new DrawableGraph({
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             nodes: this._getDrawableNodes(graph.nodes),
             edges: graph.edges,
         });

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.21",
   "description": "LangGraph",
   "type": "module",
   "engines": {
@@ -32,7 +32,7 @@
   "license": "MIT",
   "dependencies": {
     "@langchain/langgraph-checkpoint": "~0.0.10",
-    "@langchain/langgraph-sdk": "~0.0.20",
+    "@langchain/langgraph-sdk": "~0.0.21",
     "uuid": "^10.0.0",
     "zod": "^3.23.8"
   },