@langchain/langgraph 0.2.19 → 0.2.20

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/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/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.19",
+  "version": "0.2.20",
   "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",