@langchain/langgraph 0.1.1 → 0.1.3

package/README.md

@@ -9,7 +9,7 @@
 
 ## Overview
 
-[LangGraph.js](https://langchain-ai.github.io/langgraphjs/) is a library for building stateful, multi-actor applications with LLMs, used to create agent and multi-agent workflows. Built on top of [LangChain.js](https://github.com/langchain-ai/langchainjs), it offers these core benefits compared to other LLM frameworks: cycles, controllability, and persistence. LangGraph allows you to define flows that involve cycles, essential for most agentic architectures, differentiating it from DAG-based solutions. As a very low-level framework, it provides fine-grained control over both the flow and state of your application, crucial for creating reliable agents. Additionally, LangGraph includes built-in persistence, enabling advanced human-in-the-loop and memory features.
+[LangGraph.js](https://langchain-ai.github.io/langgraphjs/) is a library for building stateful, multi-actor applications with LLMs, used to create agent and multi-agent workflows. Compared to other LLM frameworks, it offers these core benefits: cycles, controllability, and persistence. LangGraph allows you to define flows that involve cycles, essential for most agentic architectures, differentiating it from DAG-based solutions. As a very low-level framework, it provides fine-grained control over both the flow and state of your application, crucial for creating reliable agents. Additionally, LangGraph includes built-in persistence, enabling advanced human-in-the-loop and memory features.
 
 LangGraph is inspired by [Pregel](https://research.google/pubs/pub37252/) and [Apache Beam](https://beam.apache.org/). The public interface draws inspiration from [NetworkX](https://networkx.org/documentation/latest/). LangGraph is built by LangChain Inc, the creators of LangChain, but can be used without LangChain.
 
@@ -19,7 +19,7 @@ LangGraph is inspired by [Pregel](https://research.google/pubs/pub37252/) and [A
 - **Persistence**: Automatically save state after each step in the graph. Pause and resume the graph execution at any point to support error recovery, human-in-the-loop workflows, time travel and more.
 - **Human-in-the-Loop**: Interrupt graph execution to approve or edit next action planned by the agent.
 - **Streaming Support**: Stream outputs as they are produced by each node (including token streaming).
-- **Integration with LangChain**: LangGraph integrates seamlessly with [LangChain](https://github.com/langchain-ai/langchainjs/) and [LangSmith](https://docs.smith.langchain.com/) (but does not require them).
+- **Integration with LangChain**: LangGraph integrates seamlessly with [LangChain.js](https://github.com/langchain-ai/langchainjs/) and [LangSmith](https://docs.smith.langchain.com/) (but does not require them).
 
 ## Installation
 

package/dist/constants.cjs

@@ -28,6 +28,7 @@ function _isSendInterface(x) {
 }
 exports._isSendInterface = _isSendInterface;
 /**
+ *
  * A message or packet to send to a specific node in the graph.
  *
  * The `Send` class is used within a `StateGraph`'s conditional edges to

package/dist/constants.d.ts

@@ -16,6 +16,7 @@ export interface SendInterface {
 }
 export declare function _isSendInterface(x: unknown): x is SendInterface;
 /**
+ *
  * A message or packet to send to a specific node in the graph.
  *
  * The `Send` class is used within a `StateGraph`'s conditional edges to

package/dist/constants.js

@@ -24,6 +24,7 @@ export function _isSendInterface(x) {
     return typeof operation.node === "string" && operation.args !== undefined;
 }
 /**
+ *
  * A message or packet to send to a specific node in the graph.
  *
  * The `Send` class is used within a `StateGraph`'s conditional edges to

package/dist/graph/annotation.cjs

@@ -3,6 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getChannel = exports.Annotation = exports.AnnotationRoot = void 0;
 const binop_js_1 = require("../channels/binop.cjs");
 const last_value_js_1 = require("../channels/last_value.cjs");
+/**
+ * Should not be instantiated directly. See {@link Annotation}.
+ * @internal
+ */
 class AnnotationRoot {
     constructor(s) {
         Object.defineProperty(this, "lc_graph_name", {
@@ -21,7 +25,78 @@ class AnnotationRoot {
     }
 }
 exports.AnnotationRoot = AnnotationRoot;
-function Annotation(annotation) {
+/**
+ * Helper that instantiates channels within a StateGraph state.
+ *
+ * Can be used as a field in an {@link Annotation.Root} wrapper in one of two ways:
+ * 1. **Directly**: Creates a channel that stores the most recent value returned from a node.
+ * 2. **With a reducer**: Creates a channel that applies the reducer on a node's return value.
+ *
+ * @example
+ * ```ts
+ * import { StateGraph, Annotation } from "@langchain/langgraph";
+ *
+ * // Define a state with a single string key named "currentOutput"
+ * const SimpleAnnotation = Annotation.Root({
+ *   currentOutput: Annotation<string>,
+ * });
+ *
+ * const graphBuilder = new StateGraph(SimpleAnnotation);
+ *
+ * // A node in the graph that returns an object with a "currentOutput" key
+ * // replaces the value in the state. You can get the state type as shown below:
+ * const myNode = (state: typeof SimpleAnnotation.State) => {
+ *   return {
+ *     currentOutput: "some_new_value",
+ *   };
+ * }
+ *
+ * const graph = graphBuilder
+ *   .addNode("myNode", myNode)
+ *   ...
+ *   .compile();
+ * ```
+ *
+ * @example
+ * ```ts
+ * import { type BaseMessage, AIMessage } from "@langchain/core/messages";
+ * import { StateGraph, Annotation } from "@langchain/langgraph";
+ *
+ * // Define a state with a single key named "messages" that will
+ * // combine a returned BaseMessage or arrays of BaseMessages
+ * const AnnotationWithReducer = Annotation.Root({
+ *   messages: Annotation<BaseMessage[]>({
+ *     // Different types are allowed for updates
+ *     reducer: (left: BaseMessage[], right: BaseMessage | BaseMessage[]) => {
+ *       if (Array.isArray(right)) {
+ *         return left.concat(right);
+ *       }
+ *       return left.concat([right]);
+ *     },
+ *     default: () => [],
+ *   }),
+ * });
+ *
+ * const graphBuilder = new StateGraph(AnnotationWithReducer);
+ *
+ * // A node in the graph that returns an object with a "messages" key
+ * // will update the state by combining the existing value with the returned one.
+ * const myNode = (state: typeof AnnotationWithReducer.State) => {
+ *   return {
+ *     messages: [new AIMessage("Some new response")],
+ *   };
+ * };
+ *
+ * const graph = graphBuilder
+ *   .addNode("myNode", myNode)
+ *   ...
+ *   .compile();
+ * ```
+ * @namespace
+ * @property Root
+ * Helper function that instantiates a StateGraph state. See {@link Annotation} for usage.
+ */
+exports.Annotation = function (annotation) {
     if (annotation) {
         return getChannel(annotation);
     }
@@ -29,9 +104,8 @@ function Annotation(annotation) {
         // @ts-expect-error - Annotation without reducer
         return new last_value_js_1.LastValue();
     }
-}
-exports.Annotation = Annotation;
-Annotation.Root = (sd) => new AnnotationRoot(sd);
+};
+exports.Annotation.Root = (sd) => new AnnotationRoot(sd);
 function getChannel(reducer) {
     if (typeof reducer === "object" &&
         reducer &&

package/dist/graph/annotation.d.ts

@@ -24,6 +24,16 @@ export type UpdateType<SD extends StateDefinition> = {
     [key in keyof SD]?: ExtractUpdateType<SD[key]>;
 };
 export type NodeType<SD extends StateDefinition> = RunnableLike<StateType<SD>, UpdateType<SD>>;
+/** @ignore */
+export interface AnnotationFunction {
+    <ValueType>(): LastValue<ValueType>;
+    <ValueType, UpdateType = ValueType>(annotation: SingleReducer<ValueType, UpdateType>): BinaryOperatorAggregate<ValueType, UpdateType>;
+    Root: <S extends StateDefinition>(sd: S) => AnnotationRoot<S>;
+}
+/**
+ * Should not be instantiated directly. See {@link Annotation}.
+ * @internal
+ */
 export declare class AnnotationRoot<SD extends StateDefinition> {
     lc_graph_name: string;
     State: StateType<SD>;
@@ -32,10 +42,77 @@ export declare class AnnotationRoot<SD extends StateDefinition> {
     spec: SD;
     constructor(s: SD);
 }
-export declare function Annotation<ValueType>(): LastValue<ValueType>;
-export declare function Annotation<ValueType, UpdateType = ValueType>(annotation: SingleReducer<ValueType, UpdateType>): BinaryOperatorAggregate<ValueType, UpdateType>;
-export declare namespace Annotation {
-    var Root: <S extends StateDefinition>(sd: S) => AnnotationRoot<S>;
-}
+/**
+ * Helper that instantiates channels within a StateGraph state.
+ *
+ * Can be used as a field in an {@link Annotation.Root} wrapper in one of two ways:
+ * 1. **Directly**: Creates a channel that stores the most recent value returned from a node.
+ * 2. **With a reducer**: Creates a channel that applies the reducer on a node's return value.
+ *
+ * @example
+ * ```ts
+ * import { StateGraph, Annotation } from "@langchain/langgraph";
+ *
+ * // Define a state with a single string key named "currentOutput"
+ * const SimpleAnnotation = Annotation.Root({
+ *   currentOutput: Annotation<string>,
+ * });
+ *
+ * const graphBuilder = new StateGraph(SimpleAnnotation);
+ *
+ * // A node in the graph that returns an object with a "currentOutput" key
+ * // replaces the value in the state. You can get the state type as shown below:
+ * const myNode = (state: typeof SimpleAnnotation.State) => {
+ *   return {
+ *     currentOutput: "some_new_value",
+ *   };
+ * }
+ *
+ * const graph = graphBuilder
+ *   .addNode("myNode", myNode)
+ *   ...
+ *   .compile();
+ * ```
+ *
+ * @example
+ * ```ts
+ * import { type BaseMessage, AIMessage } from "@langchain/core/messages";
+ * import { StateGraph, Annotation } from "@langchain/langgraph";
+ *
+ * // Define a state with a single key named "messages" that will
+ * // combine a returned BaseMessage or arrays of BaseMessages
+ * const AnnotationWithReducer = Annotation.Root({
+ *   messages: Annotation<BaseMessage[]>({
+ *     // Different types are allowed for updates
+ *     reducer: (left: BaseMessage[], right: BaseMessage | BaseMessage[]) => {
+ *       if (Array.isArray(right)) {
+ *         return left.concat(right);
+ *       }
+ *       return left.concat([right]);
+ *     },
+ *     default: () => [],
+ *   }),
+ * });
+ *
+ * const graphBuilder = new StateGraph(AnnotationWithReducer);
+ *
+ * // A node in the graph that returns an object with a "messages" key
+ * // will update the state by combining the existing value with the returned one.
+ * const myNode = (state: typeof AnnotationWithReducer.State) => {
+ *   return {
+ *     messages: [new AIMessage("Some new response")],
+ *   };
+ * };
+ *
+ * const graph = graphBuilder
+ *   .addNode("myNode", myNode)
+ *   ...
+ *   .compile();
+ * ```
+ * @namespace
+ * @property Root
+ * Helper function that instantiates a StateGraph state. See {@link Annotation} for usage.
+ */
+export declare const Annotation: AnnotationFunction;
 export declare function getChannel<V, U = V>(reducer: SingleReducer<V, U>): BaseChannel<V, U>;
 export {};

package/dist/graph/annotation.js

@@ -1,5 +1,9 @@
 import { BinaryOperatorAggregate } from "../channels/binop.js";
 import { LastValue } from "../channels/last_value.js";
+/**
+ * Should not be instantiated directly. See {@link Annotation}.
+ * @internal
+ */
 export class AnnotationRoot {
     constructor(s) {
         Object.defineProperty(this, "lc_graph_name", {
@@ -17,7 +21,78 @@ export class AnnotationRoot {
         this.spec = s;
     }
 }
-export function Annotation(annotation) {
+/**
+ * Helper that instantiates channels within a StateGraph state.
+ *
+ * Can be used as a field in an {@link Annotation.Root} wrapper in one of two ways:
+ * 1. **Directly**: Creates a channel that stores the most recent value returned from a node.
+ * 2. **With a reducer**: Creates a channel that applies the reducer on a node's return value.
+ *
+ * @example
+ * ```ts
+ * import { StateGraph, Annotation } from "@langchain/langgraph";
+ *
+ * // Define a state with a single string key named "currentOutput"
+ * const SimpleAnnotation = Annotation.Root({
+ *   currentOutput: Annotation<string>,
+ * });
+ *
+ * const graphBuilder = new StateGraph(SimpleAnnotation);
+ *
+ * // A node in the graph that returns an object with a "currentOutput" key
+ * // replaces the value in the state. You can get the state type as shown below:
+ * const myNode = (state: typeof SimpleAnnotation.State) => {
+ *   return {
+ *     currentOutput: "some_new_value",
+ *   };
+ * }
+ *
+ * const graph = graphBuilder
+ *   .addNode("myNode", myNode)
+ *   ...
+ *   .compile();
+ * ```
+ *
+ * @example
+ * ```ts
+ * import { type BaseMessage, AIMessage } from "@langchain/core/messages";
+ * import { StateGraph, Annotation } from "@langchain/langgraph";
+ *
+ * // Define a state with a single key named "messages" that will
+ * // combine a returned BaseMessage or arrays of BaseMessages
+ * const AnnotationWithReducer = Annotation.Root({
+ *   messages: Annotation<BaseMessage[]>({
+ *     // Different types are allowed for updates
+ *     reducer: (left: BaseMessage[], right: BaseMessage | BaseMessage[]) => {
+ *       if (Array.isArray(right)) {
+ *         return left.concat(right);
+ *       }
+ *       return left.concat([right]);
+ *     },
+ *     default: () => [],
+ *   }),
+ * });
+ *
+ * const graphBuilder = new StateGraph(AnnotationWithReducer);
+ *
+ * // A node in the graph that returns an object with a "messages" key
+ * // will update the state by combining the existing value with the returned one.
+ * const myNode = (state: typeof AnnotationWithReducer.State) => {
+ *   return {
+ *     messages: [new AIMessage("Some new response")],
+ *   };
+ * };
+ *
+ * const graph = graphBuilder
+ *   .addNode("myNode", myNode)
+ *   ...
+ *   .compile();
+ * ```
+ * @namespace
+ * @property Root
+ * Helper function that instantiates a StateGraph state. See {@link Annotation} for usage.
+ */
+export const Annotation = function (annotation) {
     if (annotation) {
         return getChannel(annotation);
     }
@@ -25,7 +100,7 @@ export function Annotation(annotation) {
         // @ts-expect-error - Annotation without reducer
         return new LastValue();
     }
-}
+};
 Annotation.Root = (sd) => new AnnotationRoot(sd);
 export function getChannel(reducer) {
     if (typeof reducer === "object" &&

package/dist/graph/graph.cjs

@@ -12,7 +12,9 @@ const write_js_1 = require("../pregel/write.cjs");
 const constants_js_1 = require("../constants.cjs");
 const utils_js_1 = require("../utils.cjs");
 const errors_js_1 = require("../errors.cjs");
+/** Special reserved node name denoting the start of a graph. */
 exports.START = "__start__";
+/** Special reserved node name denoting the end of a graph. */
 exports.END = "__end__";
 class Branch {
     constructor(options) {
@@ -114,7 +116,7 @@ class Graph {
     get allEdges() {
         return this.edges;
     }
-    addNode(key, action) {
+    addNode(key, action, options) {
         if (key.includes(constants_js_1.CHECKPOINT_NAMESPACE_SEPARATOR)) {
             throw new Error(`"${constants_js_1.CHECKPOINT_NAMESPACE_SEPARATOR}" is a reserved character and is not allowed in node names.`);
         }
@@ -125,9 +127,12 @@ class Graph {
         if (key === exports.END) {
             throw new Error(`Node \`${key}\` is reserved.`);
         }
-        this.nodes[key] = (0, runnables_1._coerceToRunnable)(
-        // Account for arbitrary state due to Send API
-        action);
+        this.nodes[key] = {
+            runnable: (0, runnables_1._coerceToRunnable)(
+            // Account for arbitrary state due to Send API
+            action),
+            metadata: options?.metadata,
+        };
         return this;
     }
     addEdge(startKey, endKey) {
@@ -287,8 +292,9 @@ class CompiledGraph extends index_js_1.Pregel {
         this.nodes[key] = new read_js_1.PregelNode({
             channels: [],
             triggers: [],
+            metadata: node.metadata,
         })
-            .pipe(node)
+            .pipe(node.runnable)
             .pipe(new write_js_1.ChannelWrite([{ channel: key, value: write_js_1.PASSTHROUGH }], [constants_js_1.TAG_HIDDEN]));
         this.streamChannels.push(key);
     }
@@ -359,7 +365,7 @@ class CompiledGraph extends index_js_1.Pregel {
                         ...config,
                         xray: typeof xray === "number" && xray > 0 ? xray - 1 : xray,
                     })
-                    : node.getGraph(config);
+                    : node.runnable.getGraph(config);
                 subgraph.trimFirstNode();
                 subgraph.trimLastNode();
                 if (Object.keys(subgraph.nodes).length > 1) {
@@ -372,13 +378,13 @@ class CompiledGraph extends index_js_1.Pregel {
                     }
                 }
                 else {
-                    const newNode = graph.addNode(node, key);
+                    const newNode = graph.addNode(node.runnable, key);
                     startNodes[key] = newNode;
                     endNodes[key] = newNode;
                 }
             }
             else {
-                const newNode = graph.addNode(node, key);
+                const newNode = graph.addNode(node.runnable, key);
                 startNodes[key] = newNode;
                 endNodes[key] = newNode;
             }

package/dist/graph/graph.d.ts

@@ -8,7 +8,9 @@ import { BaseChannel } from "../channels/base.js";
 import { All } from "../pregel/types.js";
 import { Send } from "../constants.js";
 import { RunnableCallable } from "../utils.js";
+/** Special reserved node name denoting the start of a graph. */
 export declare const START = "__start__";
+/** Special reserved node name denoting the end of a graph. */
 export declare const END = "__end__";
 export interface BranchOptions<IO, N extends string> {
     source: N;
@@ -22,17 +24,24 @@ export declare class Branch<IO, N extends string> {
     compile(writer: (dests: (string | Send)[]) => Runnable | undefined, reader?: (config: RunnableConfig) => IO): RunnableCallable<unknown, unknown>;
     _route(input: IO, config: RunnableConfig, writer: (dests: (string | Send)[]) => Runnable | undefined, reader?: (config: RunnableConfig) => IO): Promise<Runnable | undefined>;
 }
-export declare class Graph<N extends string = typeof END, RunInput = any, RunOutput = any> {
-    nodes: Record<N, Runnable<RunInput, RunOutput>>;
+export type NodeSpec<RunInput, RunOutput> = {
+    runnable: Runnable<RunInput, RunOutput>;
+    metadata?: Record<string, unknown>;
+};
+export type AddNodeOptions = {
+    metadata?: Record<string, unknown>;
+};
+export declare class Graph<N extends string = typeof END, RunInput = any, RunOutput = any, NodeSpecType extends NodeSpec<RunInput, RunOutput> = NodeSpec<RunInput, RunOutput>> {
+    nodes: Record<N, NodeSpecType>;
     edges: Set<[N | typeof START, N | typeof END]>;
     branches: Record<string, Record<string, Branch<RunInput, N>>>;
     entryPoint?: string;
     compiled: boolean;
     supportMultipleEdges: boolean;
     constructor();
-    private warnIfCompiled;
+    protected warnIfCompiled(message: string): void;
     get allEdges(): Set<[string, string]>;
-    addNode<K extends string, NodeInput = RunInput>(key: K, action: RunnableLike<NodeInput, RunOutput>): Graph<N | K, RunInput, RunOutput>;
+    addNode<K extends string, NodeInput = RunInput>(key: K, action: RunnableLike<NodeInput, RunOutput>, options?: AddNodeOptions): Graph<N | K, RunInput, RunOutput>;
     addEdge(startKey: N | typeof START, endKey: N | typeof END): this;
     addConditionalEdges(source: BranchOptions<RunInput, N>): this;
     addConditionalEdges(source: N, path: Branch<RunInput, N>["condition"], pathMap?: BranchOptions<RunInput, N>["pathMap"]): this;
@@ -59,7 +68,7 @@ export declare class CompiledGraph<N extends string, RunInput = any, RunOutput =
     constructor({ builder, ...rest }: {
         builder: Graph<N, RunInput, RunOutput>;
     } & PregelParams<Record<N | typeof START, PregelNode<RunInput, RunOutput>>, Record<N | typeof START | typeof END | string, BaseChannel>>);
-    attachNode(key: N, node: Runnable<RunInput, RunOutput>): void;
+    attachNode(key: N, node: NodeSpec<RunInput, RunOutput>): void;
     attachEdge(start: N | typeof START, end: N | typeof END): void;
     attachBranch(start: N | typeof START, name: string, branch: Branch<RunInput, N>): void;
     /**

package/dist/graph/graph.js

@@ -9,7 +9,9 @@ import { ChannelWrite, PASSTHROUGH } from "../pregel/write.js";
 import { _isSend, CHECKPOINT_NAMESPACE_SEPARATOR, TAG_HIDDEN, } from "../constants.js";
 import { RunnableCallable } from "../utils.js";
 import { InvalidUpdateError } from "../errors.js";
+/** Special reserved node name denoting the start of a graph. */
 export const START = "__start__";
+/** Special reserved node name denoting the end of a graph. */
 export const END = "__end__";
 export class Branch {
     constructor(options) {
@@ -110,7 +112,7 @@ export class Graph {
     get allEdges() {
         return this.edges;
     }
-    addNode(key, action) {
+    addNode(key, action, options) {
         if (key.includes(CHECKPOINT_NAMESPACE_SEPARATOR)) {
             throw new Error(`"${CHECKPOINT_NAMESPACE_SEPARATOR}" is a reserved character and is not allowed in node names.`);
         }
@@ -121,9 +123,12 @@ export class Graph {
         if (key === END) {
             throw new Error(`Node \`${key}\` is reserved.`);
         }
-        this.nodes[key] = _coerceToRunnable(
-        // Account for arbitrary state due to Send API
-        action);
+        this.nodes[key] = {
+            runnable: _coerceToRunnable(
+            // Account for arbitrary state due to Send API
+            action),
+            metadata: options?.metadata,
+        };
         return this;
     }
     addEdge(startKey, endKey) {
@@ -282,8 +287,9 @@ export class CompiledGraph extends Pregel {
         this.nodes[key] = new PregelNode({
             channels: [],
             triggers: [],
+            metadata: node.metadata,
         })
-            .pipe(node)
+            .pipe(node.runnable)
             .pipe(new ChannelWrite([{ channel: key, value: PASSTHROUGH }], [TAG_HIDDEN]));
         this.streamChannels.push(key);
     }
@@ -354,7 +360,7 @@ export class CompiledGraph extends Pregel {
                         ...config,
                         xray: typeof xray === "number" && xray > 0 ? xray - 1 : xray,
                     })
-                    : node.getGraph(config);
+                    : node.runnable.getGraph(config);
                 subgraph.trimFirstNode();
                 subgraph.trimLastNode();
                 if (Object.keys(subgraph.nodes).length > 1) {
@@ -367,13 +373,13 @@ export class CompiledGraph extends Pregel {
                     }
                 }
                 else {
-                    const newNode = graph.addNode(node, key);
+                    const newNode = graph.addNode(node.runnable, key);
                     startNodes[key] = newNode;
                     endNodes[key] = newNode;
                 }
             }
             else {
-                const newNode = graph.addNode(node, key);
+                const newNode = graph.addNode(node.runnable, key);
                 startNodes[key] = newNode;
                 endNodes[key] = newNode;
             }

package/dist/graph/message.cjs

@@ -4,6 +4,11 @@ exports.MessageGraph = exports.messagesStateReducer = void 0;
 const messages_1 = require("@langchain/core/messages");
 const uuid_1 = require("uuid");
 const state_js_1 = require("./state.cjs");
+/**
+ * Prebuilt reducer that combines returned messages.
+ * Can handle standard messages and special modifiers like {@link RemoveMessage}
+ * instances.
+ */
 function messagesStateReducer(left, right) {
     const leftArray = Array.isArray(left) ? left : [left];
     const rightArray = Array.isArray(right) ? right : [right];
@@ -45,6 +50,7 @@ function messagesStateReducer(left, right) {
     return merged.filter((m) => !idsToRemove.has(m.id));
 }
 exports.messagesStateReducer = messagesStateReducer;
+/** @ignore */
 class MessageGraph extends state_js_1.StateGraph {
     constructor() {
         super({

package/dist/graph/message.d.ts

@@ -1,7 +1,13 @@
 import { BaseMessage, BaseMessageLike } from "@langchain/core/messages";
 import { StateGraph } from "./state.js";
 type Messages = Array<BaseMessage | BaseMessageLike> | BaseMessage | BaseMessageLike;
+/**
+ * Prebuilt reducer that combines returned messages.
+ * Can handle standard messages and special modifiers like {@link RemoveMessage}
+ * instances.
+ */
 export declare function messagesStateReducer(left: BaseMessage[], right: Messages): BaseMessage[];
+/** @ignore */
 export declare class MessageGraph extends StateGraph<BaseMessage[], BaseMessage[], Messages> {
     constructor();
 }

package/dist/graph/message.js

@@ -1,6 +1,11 @@
 import { coerceMessageLikeToMessage, } from "@langchain/core/messages";
 import { v4 } from "uuid";
 import { StateGraph } from "./state.js";
+/**
+ * Prebuilt reducer that combines returned messages.
+ * Can handle standard messages and special modifiers like {@link RemoveMessage}
+ * instances.
+ */
 export function messagesStateReducer(left, right) {
     const leftArray = Array.isArray(left) ? left : [left];
     const rightArray = Array.isArray(right) ? right : [right];
@@ -41,6 +46,7 @@ export function messagesStateReducer(left, right) {
     }
     return merged.filter((m) => !idsToRemove.has(m.id));
 }
+/** @ignore */
 export class MessageGraph extends StateGraph {
     constructor() {
         super({

package/dist/graph/messages_annotation.cjs

@@ -4,6 +4,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MessagesAnnotation = void 0;
 const annotation_js_1 = require("./annotation.cjs");
 const message_js_1 = require("./message.cjs");
+/**
+ * Prebuilt state annotation that combines returned messages.
+ * Can handle standard messages and special modifiers like {@link RemoveMessage}
+ * instances.
+ */
 exports.MessagesAnnotation = annotation_js_1.Annotation.Root({
     messages: (0, annotation_js_1.Annotation)({
         reducer: message_js_1.messagesStateReducer,

package/dist/graph/messages_annotation.d.ts

@@ -1,4 +1,9 @@
 import { BaseMessage } from "@langchain/core/messages";
+/**
+ * Prebuilt state annotation that combines returned messages.
+ * Can handle standard messages and special modifiers like {@link RemoveMessage}
+ * instances.
+ */
 export declare const MessagesAnnotation: import("./annotation.js").AnnotationRoot<{
     messages: import("../channels/binop.js").BinaryOperatorAggregate<BaseMessage[], BaseMessage[]>;
 }>;

package/dist/graph/messages_annotation.js

@@ -1,6 +1,11 @@
 /* __LC_ALLOW_ENTRYPOINT_SIDE_EFFECTS__ */
 import { Annotation } from "./annotation.js";
 import { messagesStateReducer } from "./message.js";
+/**
+ * Prebuilt state annotation that combines returned messages.
+ * Can handle standard messages and special modifiers like {@link RemoveMessage}
+ * instances.
+ */
 export const MessagesAnnotation = Annotation.Root({
     messages: Annotation({
         reducer: messagesStateReducer,