@langchain/langgraph 0.0.33 → 0.0.34

package/README.md

@@ -249,7 +249,7 @@ Is there anything else you'd like to know about the weather in New York or any o
 - [Conceptual Guides](https://langchain-ai.github.io/langgraphjs/concepts/): In-depth explanations of the key concepts and principles behind LangGraph, such as nodes, edges, state and more.
 - [API Reference](https://langchain-ai.github.io/langgraphjs/reference/graphs/): Review important classes and methods, simple examples of how to use the graph and checkpointing APIs, higher-level prebuilt components and more.
 
-## Running Example Juypter Notebooks
+## Running Example Jupyter Notebooks
 
 Please note that the *.ipynb notebooks in the `examples/` folder require [tslab](https://github.com/yunabe/tslab?tab=readme-ov-file) to be installed. In order to run these notebooks in VSCode, you will also need the [Jupyter](https://marketplace.visualstudio.com/items?itemName=ms-toolsai.jupyter) VSCode Extension installed. After cloning this repository, you can run `yarn build` in the root. You should then be all set!
 

package/dist/channels/base.cjs

@@ -56,6 +56,7 @@ function createCheckpoint(checkpoint, channels, step) {
         channel_values: values,
         channel_versions: { ...checkpoint.channel_versions },
         versions_seen: (0, base_js_1.deepCopy)(checkpoint.versions_seen),
+        pending_sends: checkpoint.pending_sends ?? [],
     };
 }
 exports.createCheckpoint = createCheckpoint;

package/dist/channels/base.js

@@ -51,5 +51,6 @@ export function createCheckpoint(checkpoint, channels, step) {
         channel_values: values,
         channel_versions: { ...checkpoint.channel_versions },
         versions_seen: deepCopy(checkpoint.versions_seen),
+        pending_sends: checkpoint.pending_sends ?? [],
     };
 }

package/dist/channels/ephemeral_value.cjs

@@ -30,7 +30,7 @@ class EphemeralValue extends index_js_1.BaseChannel {
         this.guard = guard;
     }
     fromCheckpoint(checkpoint) {
-        const empty = new EphemeralValue();
+        const empty = new EphemeralValue(this.guard);
         if (checkpoint) {
             empty.value = checkpoint;
         }

package/dist/channels/ephemeral_value.js

@@ -27,7 +27,7 @@ export class EphemeralValue extends BaseChannel {
         this.guard = guard;
     }
     fromCheckpoint(checkpoint) {
-        const empty = new EphemeralValue();
+        const empty = new EphemeralValue(this.guard);
         if (checkpoint) {
             empty.value = checkpoint;
         }

package/dist/checkpoint/base.cjs

@@ -32,6 +32,7 @@ function emptyCheckpoint() {
         channel_values: {},
         channel_versions: {},
         versions_seen: {},
+        pending_sends: [],
     };
 }
 exports.emptyCheckpoint = emptyCheckpoint;
@@ -43,6 +44,7 @@ function copyCheckpoint(checkpoint) {
         channel_values: { ...checkpoint.channel_values },
         channel_versions: { ...checkpoint.channel_versions },
         versions_seen: deepCopy(checkpoint.versions_seen),
+        pending_sends: [...checkpoint.pending_sends],
     };
 }
 exports.copyCheckpoint = copyCheckpoint;

package/dist/checkpoint/base.d.ts

@@ -1,5 +1,6 @@
 import { RunnableConfig } from "@langchain/core/runnables";
 import { SerializerProtocol } from "../serde/base.js";
+import { SendInterface } from "../constants.js";
 export interface CheckpointMetadata {
     source: "input" | "loop" | "update";
     /**
@@ -40,6 +41,11 @@ export interface Checkpoint<N extends string = string, C extends string = string
      * @default {}
      */
     versions_seen: Record<N, Record<C, number>>;
+    /**
+     * List of packets sent to nodes but not yet processed.
+     * Cleared by the next checkpoint.
+     */
+    pending_sends: SendInterface[];
 }
 export interface ReadonlyCheckpoint extends Readonly<Checkpoint> {
     readonly channel_values: Readonly<Record<string, unknown>>;

package/dist/checkpoint/base.js

@@ -26,6 +26,7 @@ export function emptyCheckpoint() {
         channel_values: {},
         channel_versions: {},
         versions_seen: {},
+        pending_sends: [],
     };
 }
 export function copyCheckpoint(checkpoint) {
@@ -36,6 +37,7 @@ export function copyCheckpoint(checkpoint) {
         channel_values: { ...checkpoint.channel_values },
         channel_versions: { ...checkpoint.channel_versions },
         versions_seen: deepCopy(checkpoint.versions_seen),
+        pending_sends: [...checkpoint.pending_sends],
     };
 }
 export class BaseCheckpointSaver {

package/dist/constants.cjs

@@ -1,8 +1,87 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TASKS = exports.TAG_HIDDEN = exports.INTERRUPT = exports.CONFIG_KEY_READ = exports.CONFIG_KEY_SEND = void 0;
+exports._isSend = exports.Send = exports._isSendInterface = exports.TASKS = exports.TAG_HIDDEN = exports.INTERRUPT = exports.CONFIG_KEY_READ = exports.CONFIG_KEY_SEND = void 0;
 exports.CONFIG_KEY_SEND = "__pregel_send";
 exports.CONFIG_KEY_READ = "__pregel_read";
 exports.INTERRUPT = "__interrupt__";
 exports.TAG_HIDDEN = "langsmith:hidden";
 exports.TASKS = "__pregel_tasks";
+function _isSendInterface(x) {
+    const operation = x;
+    return typeof operation.node === "string" && operation.args !== undefined;
+}
+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
+ * dynamically invoke a node with a custom state at the next step.
+ *
+ * Importantly, the sent state can differ from the core graph's state,
+ * allowing for flexible and dynamic workflow management.
+ *
+ * One such example is a "map-reduce" workflow where your graph invokes
+ * the same node multiple times in parallel with different states,
+ * before aggregating the results back into the main graph's state.
+ *
+ * @example
+ * ```typescript
+ * import { Annotation, Send, StateGraph } from "@langchain/langgraph";
+ *
+ * const ChainState = Annotation.Root({
+ *   subjects: Annotation<string[]>,
+ *   jokes: Annotation<string[]>({
+ *     reducer: (a, b) => a.concat(b),
+ *   }),
+ * });
+ *
+ * const continueToJokes = async (state: typeof ChainState.State) => {
+ *   return state.subjects.map((subject) => {
+ *     return new Send("generate_joke", { subjects: [subject] });
+ *   });
+ * };
+ *
+ * const graph = new StateGraph(ChainState)
+ *   .addNode("generate_joke", (state) => ({
+ *     jokes: [`Joke about ${state.subjects}`],
+ *   }))
+ *   .addConditionalEdges("__start__", continueToJokes)
+ *   .addEdge("generate_joke", "__end__")
+ *   .compile();
+ *
+ * const res = await graph.invoke({ subjects: ["cats", "dogs"] });
+ * console.log(res);
+ *
+ * // Invoking with two subjects results in a generated joke for each
+ * // { subjects: ["cats", "dogs"], jokes: [`Joke about cats`, `Joke about dogs`] }
+ * ```
+ */
+class Send {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    constructor(node, args) {
+        Object.defineProperty(this, "node", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: node
+        });
+        Object.defineProperty(this, "args", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: args
+        });
+        Object.defineProperty(this, "lg_name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "Send"
+        });
+    }
+}
+exports.Send = Send;
+function _isSend(x) {
+    const operation = x;
+    return operation.lg_name === "Send";
+}
+exports._isSend = _isSend;

package/dist/constants.d.ts

@@ -3,3 +3,60 @@ export declare const CONFIG_KEY_READ = "__pregel_read";
 export declare const INTERRUPT = "__interrupt__";
 export declare const TAG_HIDDEN = "langsmith:hidden";
 export declare const TASKS = "__pregel_tasks";
+export interface SendInterface {
+    node: string;
+    args: any;
+}
+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
+ * dynamically invoke a node with a custom state at the next step.
+ *
+ * Importantly, the sent state can differ from the core graph's state,
+ * allowing for flexible and dynamic workflow management.
+ *
+ * One such example is a "map-reduce" workflow where your graph invokes
+ * the same node multiple times in parallel with different states,
+ * before aggregating the results back into the main graph's state.
+ *
+ * @example
+ * ```typescript
+ * import { Annotation, Send, StateGraph } from "@langchain/langgraph";
+ *
+ * const ChainState = Annotation.Root({
+ *   subjects: Annotation<string[]>,
+ *   jokes: Annotation<string[]>({
+ *     reducer: (a, b) => a.concat(b),
+ *   }),
+ * });
+ *
+ * const continueToJokes = async (state: typeof ChainState.State) => {
+ *   return state.subjects.map((subject) => {
+ *     return new Send("generate_joke", { subjects: [subject] });
+ *   });
+ * };
+ *
+ * const graph = new StateGraph(ChainState)
+ *   .addNode("generate_joke", (state) => ({
+ *     jokes: [`Joke about ${state.subjects}`],
+ *   }))
+ *   .addConditionalEdges("__start__", continueToJokes)
+ *   .addEdge("generate_joke", "__end__")
+ *   .compile();
+ *
+ * const res = await graph.invoke({ subjects: ["cats", "dogs"] });
+ * console.log(res);
+ *
+ * // Invoking with two subjects results in a generated joke for each
+ * // { subjects: ["cats", "dogs"], jokes: [`Joke about cats`, `Joke about dogs`] }
+ * ```
+ */
+export declare class Send implements SendInterface {
+    node: string;
+    args: any;
+    lg_name: string;
+    constructor(node: string, args: any);
+}
+export declare function _isSend(x: unknown): x is Send;

package/dist/constants.js

@@ -3,3 +3,79 @@ export const CONFIG_KEY_READ = "__pregel_read";
 export const INTERRUPT = "__interrupt__";
 export const TAG_HIDDEN = "langsmith:hidden";
 export const TASKS = "__pregel_tasks";
+export function _isSendInterface(x) {
+    const operation = 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
+ * dynamically invoke a node with a custom state at the next step.
+ *
+ * Importantly, the sent state can differ from the core graph's state,
+ * allowing for flexible and dynamic workflow management.
+ *
+ * One such example is a "map-reduce" workflow where your graph invokes
+ * the same node multiple times in parallel with different states,
+ * before aggregating the results back into the main graph's state.
+ *
+ * @example
+ * ```typescript
+ * import { Annotation, Send, StateGraph } from "@langchain/langgraph";
+ *
+ * const ChainState = Annotation.Root({
+ *   subjects: Annotation<string[]>,
+ *   jokes: Annotation<string[]>({
+ *     reducer: (a, b) => a.concat(b),
+ *   }),
+ * });
+ *
+ * const continueToJokes = async (state: typeof ChainState.State) => {
+ *   return state.subjects.map((subject) => {
+ *     return new Send("generate_joke", { subjects: [subject] });
+ *   });
+ * };
+ *
+ * const graph = new StateGraph(ChainState)
+ *   .addNode("generate_joke", (state) => ({
+ *     jokes: [`Joke about ${state.subjects}`],
+ *   }))
+ *   .addConditionalEdges("__start__", continueToJokes)
+ *   .addEdge("generate_joke", "__end__")
+ *   .compile();
+ *
+ * const res = await graph.invoke({ subjects: ["cats", "dogs"] });
+ * console.log(res);
+ *
+ * // Invoking with two subjects results in a generated joke for each
+ * // { subjects: ["cats", "dogs"], jokes: [`Joke about cats`, `Joke about dogs`] }
+ * ```
+ */
+export class Send {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    constructor(node, args) {
+        Object.defineProperty(this, "node", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: node
+        });
+        Object.defineProperty(this, "args", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: args
+        });
+        Object.defineProperty(this, "lg_name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "Send"
+        });
+    }
+}
+export function _isSend(x) {
+    const operation = x;
+    return operation.lg_name === "Send";
+}

package/dist/graph/annotation.cjs

@@ -0,0 +1,51 @@
+"use strict";
+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");
+class AnnotationRoot {
+    constructor(s) {
+        Object.defineProperty(this, "lc_graph_name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "AnnotationRoot"
+        });
+        Object.defineProperty(this, "spec", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.spec = s;
+    }
+}
+exports.AnnotationRoot = AnnotationRoot;
+function Annotation(annotation) {
+    if (annotation) {
+        return getChannel(annotation);
+    }
+    else {
+        // @ts-expect-error - Annotation without reducer
+        return new last_value_js_1.LastValue();
+    }
+}
+exports.Annotation = Annotation;
+Annotation.Root = (sd) => new AnnotationRoot(sd);
+function getChannel(reducer) {
+    if (typeof reducer === "object" &&
+        reducer &&
+        "reducer" in reducer &&
+        reducer.reducer) {
+        return new binop_js_1.BinaryOperatorAggregate(reducer.reducer, reducer.default);
+    }
+    if (typeof reducer === "object" &&
+        reducer &&
+        "value" in reducer &&
+        reducer.value) {
+        return new binop_js_1.BinaryOperatorAggregate(reducer.value, reducer.default);
+    }
+    // @ts-expect-error - Annotation without reducer
+    return new last_value_js_1.LastValue();
+}
+exports.getChannel = getChannel;

package/dist/graph/annotation.d.ts

@@ -0,0 +1,41 @@
+import { RunnableLike } from "@langchain/core/runnables";
+import { BaseChannel } from "../channels/base.js";
+import { BinaryOperator, BinaryOperatorAggregate } from "../channels/binop.js";
+import { LastValue } from "../channels/last_value.js";
+export type SingleReducer<ValueType, UpdateType = ValueType> = {
+    reducer: BinaryOperator<ValueType, UpdateType>;
+    default?: () => ValueType;
+} | {
+    /**
+     * @deprecated Use `reducer` instead
+     */
+    value: BinaryOperator<ValueType, UpdateType>;
+    default?: () => ValueType;
+} | null;
+export interface StateDefinition {
+    [key: string]: BaseChannel | (() => BaseChannel);
+}
+type ExtractValueType<C> = C extends BaseChannel ? C["ValueType"] : C extends () => BaseChannel ? ReturnType<C>["ValueType"] : never;
+type ExtractUpdateType<C> = C extends BaseChannel ? C["UpdateType"] : C extends () => BaseChannel ? ReturnType<C>["UpdateType"] : never;
+export type StateType<SD extends StateDefinition> = {
+    [key in keyof SD]: ExtractValueType<SD[key]>;
+};
+export type UpdateType<SD extends StateDefinition> = {
+    [key in keyof SD]?: ExtractUpdateType<SD[key]>;
+};
+export type NodeType<SD extends StateDefinition> = RunnableLike<StateType<SD>, UpdateType<SD>>;
+export declare class AnnotationRoot<SD extends StateDefinition> {
+    lc_graph_name: string;
+    State: StateType<SD>;
+    Update: UpdateType<SD>;
+    Node: NodeType<SD>;
+    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>;
+}
+export declare function getChannel<V, U = V>(reducer: SingleReducer<V, U>): BaseChannel<V, U>;
+export {};

package/dist/graph/annotation.js

@@ -0,0 +1,45 @@
+import { BinaryOperatorAggregate } from "../channels/binop.js";
+import { LastValue } from "../channels/last_value.js";
+export class AnnotationRoot {
+    constructor(s) {
+        Object.defineProperty(this, "lc_graph_name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "AnnotationRoot"
+        });
+        Object.defineProperty(this, "spec", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.spec = s;
+    }
+}
+export function Annotation(annotation) {
+    if (annotation) {
+        return getChannel(annotation);
+    }
+    else {
+        // @ts-expect-error - Annotation without reducer
+        return new LastValue();
+    }
+}
+Annotation.Root = (sd) => new AnnotationRoot(sd);
+export function getChannel(reducer) {
+    if (typeof reducer === "object" &&
+        reducer &&
+        "reducer" in reducer &&
+        reducer.reducer) {
+        return new BinaryOperatorAggregate(reducer.reducer, reducer.default);
+    }
+    if (typeof reducer === "object" &&
+        reducer &&
+        "value" in reducer &&
+        reducer.value) {
+        return new BinaryOperatorAggregate(reducer.value, reducer.default);
+    }
+    // @ts-expect-error - Annotation without reducer
+    return new LastValue();
+}

package/dist/graph/graph.cjs

@@ -11,6 +11,7 @@ const ephemeral_value_js_1 = require("../channels/ephemeral_value.cjs");
 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");
 exports.START = "__start__";
 exports.END = "__end__";
 class Branch {
@@ -47,7 +48,8 @@ class Branch {
         }
         let destinations;
         if (this.ends) {
-            destinations = result.map((r) => this.ends[r]);
+            // destinations = [r if isinstance(r, Send) else self.ends[r] for r in result]
+            destinations = result.map((r) => ((0, constants_js_1._isSend)(r) ? r : this.ends[r]));
         }
         else {
             destinations = result;
@@ -55,6 +57,9 @@ class Branch {
         if (destinations.some((dest) => !dest)) {
             throw new Error("Branch condition returned unknown or null destination");
         }
+        if (destinations.filter(constants_js_1._isSend).some((packet) => packet.node === exports.END)) {
+            throw new errors_js_1.InvalidUpdateError("Cannot send a packet to the END node");
+        }
         return writer(destinations);
     }
 }
@@ -117,7 +122,9 @@ class Graph {
         if (key === exports.END) {
             throw new Error(`Node \`${key}\` is reserved.`);
         }
-        this.nodes[key] = (0, runnables_1._coerceToRunnable)(action);
+        this.nodes[key] = (0, runnables_1._coerceToRunnable)(
+        // Account for arbitrary state due to Send API
+        action);
         return this;
     }
     addEdge(startKey, endKey) {
@@ -301,8 +308,16 @@ class CompiledGraph extends index_js_1.Pregel {
         }
         // attach branch writer
         this.nodes[start].pipe(branch.compile((dests) => {
-            const channels = dests.map((dest) => dest === exports.END ? exports.END : `branch:${start}:${name}:${dest}`);
-            return new write_js_1.ChannelWrite(channels.map((channel) => ({ channel, value: write_js_1.PASSTHROUGH })), [constants_js_1.TAG_HIDDEN]);
+            const writes = dests.map((dest) => {
+                if ((0, constants_js_1._isSend)(dest)) {
+                    return dest;
+                }
+                return {
+                    channel: dest === exports.END ? exports.END : `branch:${start}:${name}:${dest}`,
+                    value: write_js_1.PASSTHROUGH,
+                };
+            });
+            return new write_js_1.ChannelWrite(writes, [constants_js_1.TAG_HIDDEN]);
         }));
         // attach branch readers
         const ends = branch.ends

package/dist/graph/graph.d.ts

@@ -5,6 +5,7 @@ import { Pregel, PregelInterface } from "../pregel/index.js";
 import { BaseCheckpointSaver } from "../checkpoint/base.js";
 import { BaseChannel } from "../channels/base.js";
 import { All } from "../pregel/types.js";
+import { Send } from "../constants.js";
 import { RunnableCallable } from "../utils.js";
 export declare const START = "__start__";
 export declare const END = "__end__";
@@ -14,11 +15,11 @@ export interface BranchOptions<IO, N extends string> {
     pathMap?: Record<string, N | typeof END> | N[];
 }
 export declare class Branch<IO, N extends string> {
-    condition: (input: IO, config?: RunnableConfig) => string | string[] | Promise<string> | Promise<string[]>;
+    condition: (input: IO, config?: RunnableConfig) => string | Send | (string | Send)[] | Promise<string | Send | (string | Send)[]>;
     ends?: Record<string, N | typeof END>;
     constructor(options: Omit<BranchOptions<IO, N>, "source">);
-    compile(writer: (dests: string[]) => Runnable | undefined, reader?: (config: RunnableConfig) => IO): RunnableCallable<unknown, unknown>;
-    _route(input: IO, config: RunnableConfig, writer: (dests: string[]) => Runnable | undefined, reader?: (config: RunnableConfig) => IO): Promise<Runnable | undefined>;
+    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>>;
@@ -30,7 +31,7 @@ export declare class Graph<N extends string = typeof END, RunInput = any, RunOut
     constructor();
     private warnIfCompiled;
     get allEdges(): Set<[string, string]>;
-    addNode<K extends string>(key: K, action: RunnableLike<RunInput, RunOutput>): Graph<N | K, RunInput, RunOutput>;
+    addNode<K extends string, NodeInput = RunInput>(key: K, action: RunnableLike<NodeInput, RunOutput>): 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;

package/dist/graph/graph.js

@@ -6,8 +6,9 @@ import { PregelNode } from "../pregel/read.js";
 import { Channel, Pregel } from "../pregel/index.js";
 import { EphemeralValue } from "../channels/ephemeral_value.js";
 import { ChannelWrite, PASSTHROUGH } from "../pregel/write.js";
-import { TAG_HIDDEN } from "../constants.js";
+import { _isSend, TAG_HIDDEN } from "../constants.js";
 import { RunnableCallable } from "../utils.js";
+import { InvalidUpdateError } from "../errors.js";
 export const START = "__start__";
 export const END = "__end__";
 export class Branch {
@@ -44,7 +45,8 @@ export class Branch {
         }
         let destinations;
         if (this.ends) {
-            destinations = result.map((r) => this.ends[r]);
+            // destinations = [r if isinstance(r, Send) else self.ends[r] for r in result]
+            destinations = result.map((r) => (_isSend(r) ? r : this.ends[r]));
         }
         else {
             destinations = result;
@@ -52,6 +54,9 @@ export class Branch {
         if (destinations.some((dest) => !dest)) {
             throw new Error("Branch condition returned unknown or null destination");
         }
+        if (destinations.filter(_isSend).some((packet) => packet.node === END)) {
+            throw new InvalidUpdateError("Cannot send a packet to the END node");
+        }
         return writer(destinations);
     }
 }
@@ -113,7 +118,9 @@ export class Graph {
         if (key === END) {
             throw new Error(`Node \`${key}\` is reserved.`);
         }
-        this.nodes[key] = _coerceToRunnable(action);
+        this.nodes[key] = _coerceToRunnable(
+        // Account for arbitrary state due to Send API
+        action);
         return this;
     }
     addEdge(startKey, endKey) {
@@ -296,8 +303,16 @@ export class CompiledGraph extends Pregel {
         }
         // attach branch writer
         this.nodes[start].pipe(branch.compile((dests) => {
-            const channels = dests.map((dest) => dest === END ? END : `branch:${start}:${name}:${dest}`);
-            return new ChannelWrite(channels.map((channel) => ({ channel, value: PASSTHROUGH })), [TAG_HIDDEN]);
+            const writes = dests.map((dest) => {
+                if (_isSend(dest)) {
+                    return dest;
+                }
+                return {
+                    channel: dest === END ? END : `branch:${start}:${name}:${dest}`,
+                    value: PASSTHROUGH,
+                };
+            });
+            return new ChannelWrite(writes, [TAG_HIDDEN]);
         }));
         // attach branch readers
         const ends = branch.ends

package/dist/graph/index.cjs

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.messagesStateReducer = exports.MessageGraph = exports.StateGraph = exports.Graph = exports.START = exports.END = void 0;
+exports.messagesStateReducer = exports.MessageGraph = exports.StateGraph = exports.Graph = exports.START = exports.END = exports.Annotation = void 0;
+var annotation_js_1 = require("./annotation.cjs");
+Object.defineProperty(exports, "Annotation", { enumerable: true, get: function () { return annotation_js_1.Annotation; } });
 var graph_js_1 = require("./graph.cjs");
 Object.defineProperty(exports, "END", { enumerable: true, get: function () { return graph_js_1.END; } });
 Object.defineProperty(exports, "START", { enumerable: true, get: function () { return graph_js_1.START; } });

package/dist/graph/index.d.ts

@@ -1,3 +1,4 @@
+export { Annotation, type StateType, type UpdateType } from "./annotation.js";
 export { END, START, Graph } from "./graph.js";
 export { type StateGraphArgs, StateGraph, type CompiledStateGraph, } from "./state.js";
 export { MessageGraph, messagesStateReducer } from "./message.js";

package/dist/graph/index.js

@@ -1,3 +1,4 @@
+export { Annotation } from "./annotation.js";
 export { END, START, Graph } from "./graph.js";
 export { StateGraph, } from "./state.js";
 export { MessageGraph, messagesStateReducer } from "./message.js";

package/dist/graph/message.d.ts

@@ -1,7 +1,7 @@
 import { BaseMessage, BaseMessageLike } from "@langchain/core/messages";
 import { StateGraph } from "./state.js";
 type Messages = Array<BaseMessage | BaseMessageLike> | BaseMessage | BaseMessageLike;
-export declare function messagesStateReducer(left: Messages, right: Messages): BaseMessage[];
+export declare function messagesStateReducer(left: BaseMessage[], right: Messages): BaseMessage[];
 export declare class MessageGraph extends StateGraph<BaseMessage[], BaseMessage[], Messages> {
     constructor();
 }