@langchain/langgraph 0.2.32 → 0.2.33

package/dist/constants.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._isCommand = exports.Command = exports._isSend = exports.Send = exports._isSendInterface = exports.CHECKPOINT_NAMESPACE_END = exports.CHECKPOINT_NAMESPACE_SEPARATOR = exports.RESERVED = exports.NULL_TASK_ID = exports.TASK_NAMESPACE = exports.PULL = exports.PUSH = exports.TASKS = exports.SELF = exports.TAG_NOSTREAM = exports.TAG_HIDDEN = exports.RECURSION_LIMIT_DEFAULT = exports.RUNTIME_PLACEHOLDER = exports.RESUME = exports.INTERRUPT = exports.CONFIG_KEY_CHECKPOINT_MAP = exports.CONFIG_KEY_CHECKPOINT_NS = exports.CONFIG_KEY_SCRATCHPAD = exports.CONFIG_KEY_WRITES = exports.CONFIG_KEY_RESUME_VALUE = 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 = exports.MISSING = void 0;
+exports.isCommand = exports.Command = exports._isSend = exports.Send = exports._isSendInterface = exports.CHECKPOINT_NAMESPACE_END = exports.CHECKPOINT_NAMESPACE_SEPARATOR = exports.RESERVED = exports.NULL_TASK_ID = exports.TASK_NAMESPACE = exports.PULL = exports.PUSH = exports.TASKS = exports.SELF = exports.TAG_NOSTREAM = exports.TAG_HIDDEN = exports.RECURSION_LIMIT_DEFAULT = exports.RUNTIME_PLACEHOLDER = exports.RESUME = exports.INTERRUPT = exports.CONFIG_KEY_CHECKPOINT_MAP = exports.CONFIG_KEY_CHECKPOINT_NS = exports.CONFIG_KEY_SCRATCHPAD = exports.CONFIG_KEY_WRITES = exports.CONFIG_KEY_RESUME_VALUE = 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 = exports.MISSING = void 0;
 exports.MISSING = Symbol.for("__missing__");
 exports.INPUT = "__input__";
 exports.ERROR = "__error__";
@@ -126,6 +126,65 @@ function _isSend(x) {
 exports._isSend = _isSend;
 /**
  * One or more commands to update the graph's state and send messages to nodes.
+ * Can be used to combine routing logic with state updates in lieu of conditional edges
+ *
+ * @example
+ * ```ts
+ * import { Annotation, Command } from "@langchain/langgraph";
+ *
+ * // Define graph state
+ * const StateAnnotation = Annotation.Root({
+ *   foo: Annotation<string>,
+ * });
+ *
+ * // Define the nodes
+ * const nodeA = async (_state: typeof StateAnnotation.State) => {
+ *   console.log("Called A");
+ *   // this is a replacement for a real conditional edge function
+ *   const goto = Math.random() > .5 ? "nodeB" : "nodeC";
+ *   // note how Command allows you to BOTH update the graph state AND route to the next node
+ *   return new Command({
+ *     // this is the state update
+ *     update: {
+ *       foo: "a",
+ *     },
+ *     // this is a replacement for an edge
+ *     goto,
+ *   });
+ * };
+ *
+ * // Nodes B and C are unchanged
+ * const nodeB = async (state: typeof StateAnnotation.State) => {
+ *   console.log("Called B");
+ *   return {
+ *     foo: state.foo + "|b",
+ *   };
+ * }
+ *
+ * const nodeC = async (state: typeof StateAnnotation.State) => {
+ *   console.log("Called C");
+ *   return {
+ *     foo: state.foo + "|c",
+ *   };
+ * }
+ *
+ * import { StateGraph } from "@langchain/langgraph";
+
+ * // NOTE: there are no edges between nodes A, B and C!
+ * const graph = new StateGraph(StateAnnotation)
+ *   .addNode("nodeA", nodeA, {
+ *     ends: ["nodeB", "nodeC"],
+ *   })
+ *   .addNode("nodeB", nodeB)
+ *   .addNode("nodeC", nodeC)
+ *   .addEdge("__start__", "nodeA")
+ *   .compile();
+ *
+ * await graph.invoke({ foo: "" });
+ *
+ * // Randomly oscillates between
+ * // { foo: 'a|c' } and { foo: 'a|b' }
+ * ```
  */
 class Command {
     constructor(args) {
@@ -135,11 +194,11 @@ class Command {
             writable: true,
             value: "Command"
         });
-        Object.defineProperty(this, "resume", {
+        Object.defineProperty(this, "lc_direct_tool_output", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: true
         });
         Object.defineProperty(this, "graph", {
             enumerable: true,
@@ -149,6 +208,12 @@ class Command {
         });
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         Object.defineProperty(this, "update", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "resume", {
             enumerable: true,
             configurable: true,
             writable: true,
@@ -167,6 +232,20 @@ class Command {
             this.goto = Array.isArray(args.goto) ? args.goto : [args.goto];
         }
     }
+    _updateAsTuples() {
+        if (this.update &&
+            typeof this.update === "object" &&
+            !Array.isArray(this.update)) {
+            return Object.entries(this.update);
+        }
+        else if (Array.isArray(this.update) &&
+            this.update.every((t) => Array.isArray(t) && t.length === 2 && typeof t[0] === "string")) {
+            return this.update;
+        }
+        else {
+            return [["__root__", this.update]];
+        }
+    }
 }
 exports.Command = Command;
 Object.defineProperty(Command, "PARENT", {
@@ -175,7 +254,7 @@ Object.defineProperty(Command, "PARENT", {
     writable: true,
     value: "__parent__"
 });
-function _isCommand(x) {
+function isCommand(x) {
     return typeof x === "object" && !!x && x.lg_name === "Command";
 }
-exports._isCommand = _isCommand;
+exports.isCommand = isCommand;

package/dist/constants.d.ts

@@ -117,14 +117,75 @@ export type CommandParams<R> = {
 };
 /**
  * One or more commands to update the graph's state and send messages to nodes.
+ * Can be used to combine routing logic with state updates in lieu of conditional edges
+ *
+ * @example
+ * ```ts
+ * import { Annotation, Command } from "@langchain/langgraph";
+ *
+ * // Define graph state
+ * const StateAnnotation = Annotation.Root({
+ *   foo: Annotation<string>,
+ * });
+ *
+ * // Define the nodes
+ * const nodeA = async (_state: typeof StateAnnotation.State) => {
+ *   console.log("Called A");
+ *   // this is a replacement for a real conditional edge function
+ *   const goto = Math.random() > .5 ? "nodeB" : "nodeC";
+ *   // note how Command allows you to BOTH update the graph state AND route to the next node
+ *   return new Command({
+ *     // this is the state update
+ *     update: {
+ *       foo: "a",
+ *     },
+ *     // this is a replacement for an edge
+ *     goto,
+ *   });
+ * };
+ *
+ * // Nodes B and C are unchanged
+ * const nodeB = async (state: typeof StateAnnotation.State) => {
+ *   console.log("Called B");
+ *   return {
+ *     foo: state.foo + "|b",
+ *   };
+ * }
+ *
+ * const nodeC = async (state: typeof StateAnnotation.State) => {
+ *   console.log("Called C");
+ *   return {
+ *     foo: state.foo + "|c",
+ *   };
+ * }
+ *
+ * import { StateGraph } from "@langchain/langgraph";
+
+ * // NOTE: there are no edges between nodes A, B and C!
+ * const graph = new StateGraph(StateAnnotation)
+ *   .addNode("nodeA", nodeA, {
+ *     ends: ["nodeB", "nodeC"],
+ *   })
+ *   .addNode("nodeB", nodeB)
+ *   .addNode("nodeC", nodeC)
+ *   .addEdge("__start__", "nodeA")
+ *   .compile();
+ *
+ * await graph.invoke({ foo: "" });
+ *
+ * // Randomly oscillates between
+ * // { foo: 'a|c' } and { foo: 'a|b' }
+ * ```
  */
 export declare class Command<R = unknown> {
     lg_name: string;
-    resume?: R;
+    lc_direct_tool_output: boolean;
     graph?: string;
-    update?: Record<string, any>;
+    update?: Record<string, any> | [string, any][];
+    resume?: R;
     goto: string | Send | (string | Send)[];
     static PARENT: string;
     constructor(args: CommandParams<R>);
+    _updateAsTuples(): [string, unknown][];
 }
-export declare function _isCommand(x: unknown): x is Command;
+export declare function isCommand(x: unknown): x is Command;

package/dist/constants.js

@@ -120,6 +120,65 @@ export function _isSend(x) {
 }
 /**
  * One or more commands to update the graph's state and send messages to nodes.
+ * Can be used to combine routing logic with state updates in lieu of conditional edges
+ *
+ * @example
+ * ```ts
+ * import { Annotation, Command } from "@langchain/langgraph";
+ *
+ * // Define graph state
+ * const StateAnnotation = Annotation.Root({
+ *   foo: Annotation<string>,
+ * });
+ *
+ * // Define the nodes
+ * const nodeA = async (_state: typeof StateAnnotation.State) => {
+ *   console.log("Called A");
+ *   // this is a replacement for a real conditional edge function
+ *   const goto = Math.random() > .5 ? "nodeB" : "nodeC";
+ *   // note how Command allows you to BOTH update the graph state AND route to the next node
+ *   return new Command({
+ *     // this is the state update
+ *     update: {
+ *       foo: "a",
+ *     },
+ *     // this is a replacement for an edge
+ *     goto,
+ *   });
+ * };
+ *
+ * // Nodes B and C are unchanged
+ * const nodeB = async (state: typeof StateAnnotation.State) => {
+ *   console.log("Called B");
+ *   return {
+ *     foo: state.foo + "|b",
+ *   };
+ * }
+ *
+ * const nodeC = async (state: typeof StateAnnotation.State) => {
+ *   console.log("Called C");
+ *   return {
+ *     foo: state.foo + "|c",
+ *   };
+ * }
+ *
+ * import { StateGraph } from "@langchain/langgraph";
+
+ * // NOTE: there are no edges between nodes A, B and C!
+ * const graph = new StateGraph(StateAnnotation)
+ *   .addNode("nodeA", nodeA, {
+ *     ends: ["nodeB", "nodeC"],
+ *   })
+ *   .addNode("nodeB", nodeB)
+ *   .addNode("nodeC", nodeC)
+ *   .addEdge("__start__", "nodeA")
+ *   .compile();
+ *
+ * await graph.invoke({ foo: "" });
+ *
+ * // Randomly oscillates between
+ * // { foo: 'a|c' } and { foo: 'a|b' }
+ * ```
  */
 export class Command {
     constructor(args) {
@@ -129,11 +188,11 @@ export class Command {
             writable: true,
             value: "Command"
         });
-        Object.defineProperty(this, "resume", {
+        Object.defineProperty(this, "lc_direct_tool_output", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: true
         });
         Object.defineProperty(this, "graph", {
             enumerable: true,
@@ -143,6 +202,12 @@ export class Command {
         });
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         Object.defineProperty(this, "update", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "resume", {
             enumerable: true,
             configurable: true,
             writable: true,
@@ -161,6 +226,20 @@ export class Command {
             this.goto = Array.isArray(args.goto) ? args.goto : [args.goto];
         }
     }
+    _updateAsTuples() {
+        if (this.update &&
+            typeof this.update === "object" &&
+            !Array.isArray(this.update)) {
+            return Object.entries(this.update);
+        }
+        else if (Array.isArray(this.update) &&
+            this.update.every((t) => Array.isArray(t) && t.length === 2 && typeof t[0] === "string")) {
+            return this.update;
+        }
+        else {
+            return [["__root__", this.update]];
+        }
+    }
 }
 Object.defineProperty(Command, "PARENT", {
     enumerable: true,
@@ -168,6 +247,6 @@ Object.defineProperty(Command, "PARENT", {
     writable: true,
     value: "__parent__"
 });
-export function _isCommand(x) {
+export function isCommand(x) {
     return typeof x === "object" && !!x && x.lg_name === "Command";
 }

package/dist/errors.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSubgraphsSeenSet = exports.RemoteException = exports.MultipleSubgraphsError = exports.InvalidUpdateError = exports.EmptyChannelError = exports.EmptyInputError = exports.isGraphInterrupt = exports.isGraphBubbleUp = exports.isParentCommand = exports.ParentCommand = exports.NodeInterrupt = exports.GraphInterrupt = exports.GraphValueError = exports.GraphRecursionError = exports.GraphBubbleUp = exports.BaseLangGraphError = void 0;
+exports.getSubgraphsSeenSet = exports.RemoteException = exports.UnreachableNodeError = exports.MultipleSubgraphsError = exports.InvalidUpdateError = exports.EmptyChannelError = exports.EmptyInputError = exports.isGraphInterrupt = exports.isGraphBubbleUp = exports.isParentCommand = exports.ParentCommand = exports.NodeInterrupt = exports.GraphInterrupt = exports.GraphValueError = exports.GraphRecursionError = exports.GraphBubbleUp = exports.BaseLangGraphError = void 0;
 // TODO: Merge with base LangChain error class when we drop support for core@0.2.0
 class BaseLangGraphError extends Error {
     constructor(message, fields) {
@@ -153,6 +153,16 @@ class MultipleSubgraphsError extends BaseLangGraphError {
     }
 }
 exports.MultipleSubgraphsError = MultipleSubgraphsError;
+class UnreachableNodeError extends BaseLangGraphError {
+    constructor(message, fields) {
+        super(message, fields);
+        this.name = "UnreachableNodeError";
+    }
+    static get unminifiable_name() {
+        return "UnreachableNodeError";
+    }
+}
+exports.UnreachableNodeError = UnreachableNodeError;
 /**
  * Exception raised when an error occurs in the remote graph.
  */

package/dist/errors.d.ts

@@ -51,6 +51,10 @@ export declare class MultipleSubgraphsError extends BaseLangGraphError {
     constructor(message?: string, fields?: BaseLangGraphErrorFields);
     static get unminifiable_name(): string;
 }
+export declare class UnreachableNodeError extends BaseLangGraphError {
+    constructor(message?: string, fields?: BaseLangGraphErrorFields);
+    static get unminifiable_name(): string;
+}
 /**
  * Exception raised when an error occurs in the remote graph.
  */

package/dist/errors.js

@@ -136,6 +136,15 @@ export class MultipleSubgraphsError extends BaseLangGraphError {
         return "MultipleSubgraphError";
     }
 }
+export class UnreachableNodeError extends BaseLangGraphError {
+    constructor(message, fields) {
+        super(message, fields);
+        this.name = "UnreachableNodeError";
+    }
+    static get unminifiable_name() {
+        return "UnreachableNodeError";
+    }
+}
 /**
  * Exception raised when an error occurs in the remote graph.
  */

package/dist/graph/graph.cjs

@@ -299,7 +299,15 @@ class Graph {
         // validate targets
         for (const node of Object.keys(this.nodes)) {
             if (!allTargets.has(node)) {
-                throw new Error(`Node \`${node}\` is not reachable`);
+                throw new errors_js_1.UnreachableNodeError([
+                    `Node \`${node}\` is not reachable.`,
+                    "",
+                    "If you are returning Command objects from your node,",
+                    'make sure you are passing names of potential destination nodes as an "ends" array',
+                    'into ".addNode(..., { ends: ["node1", "node2"] })".',
+                ].join("\n"), {
+                    lc_error_code: "UNREACHABLE_NODE",
+                });
             }
         }
         for (const target of allTargets) {

package/dist/graph/graph.js

@@ -9,7 +9,7 @@ import { EphemeralValue } from "../channels/ephemeral_value.js";
 import { ChannelWrite, PASSTHROUGH } from "../pregel/write.js";
 import { _isSend, CHECKPOINT_NAMESPACE_END, CHECKPOINT_NAMESPACE_SEPARATOR, TAG_HIDDEN, } from "../constants.js";
 import { gatherIterator, gatherIteratorSync, RunnableCallable, } from "../utils.js";
-import { InvalidUpdateError, NodeInterrupt } from "../errors.js";
+import { InvalidUpdateError, NodeInterrupt, UnreachableNodeError, } from "../errors.js";
 import { isPregelLike } from "../pregel/utils/subgraph.js";
 /** Special reserved node name denoting the start of a graph. */
 export const START = "__start__";
@@ -295,7 +295,15 @@ export class Graph {
         // validate targets
         for (const node of Object.keys(this.nodes)) {
             if (!allTargets.has(node)) {
-                throw new Error(`Node \`${node}\` is not reachable`);
+                throw new UnreachableNodeError([
+                    `Node \`${node}\` is not reachable.`,
+                    "",
+                    "If you are returning Command objects from your node,",
+                    'make sure you are passing names of potential destination nodes as an "ends" array',
+                    'into ".addNode(..., { ends: ["node1", "node2"] })".',
+                ].join("\n"), {
+                    lc_error_code: "UNREACHABLE_NODE",
+                });
             }
         }
         for (const target of allTargets) {

package/dist/graph/state.cjs

@@ -347,59 +347,101 @@ function _getChannels(schema) {
  */
 class CompiledStateGraph extends graph_js_1.CompiledGraph {
     attachNode(key, node) {
-        const stateKeys = Object.keys(this.builder.channels);
+        let outputKeys;
+        if (key === graph_js_1.START) {
+            // Get input schema keys excluding managed values
+            outputKeys = Object.entries(this.builder._schemaDefinitions.get(this.builder._inputDefinition))
+                .filter(([_, v]) => !(0, base_js_2.isConfiguredManagedValue)(v))
+                .map(([k]) => k);
+        }
+        else {
+            outputKeys = Object.keys(this.builder.channels);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         function _getRoot(input) {
-            if ((0, constants_js_1._isCommand)(input)) {
+            if ((0, constants_js_1.isCommand)(input)) {
                 if (input.graph === constants_js_1.Command.PARENT) {
-                    return write_js_1.SKIP_WRITE;
+                    return null;
+                }
+                return input._updateAsTuples();
+            }
+            else if (Array.isArray(input) &&
+                input.length > 0 &&
+                input.some((i) => (0, constants_js_1.isCommand)(i))) {
+                const updates = [];
+                for (const i of input) {
+                    if ((0, constants_js_1.isCommand)(i)) {
+                        if (i.graph === constants_js_1.Command.PARENT) {
+                            continue;
+                        }
+                        updates.push(...i._updateAsTuples());
+                    }
+                    else {
+                        updates.push([ROOT, i]);
+                    }
                 }
-                return input.update;
+                return updates;
             }
-            return input;
+            else if (input != null) {
+                return [[ROOT, input]];
+            }
+            return null;
         }
         // to avoid name collision below
         const nodeKey = key;
-        function getStateKey(key, input) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        function _getUpdates(input) {
             if (!input) {
-                return write_js_1.SKIP_WRITE;
+                return null;
             }
-            else if ((0, constants_js_1._isCommand)(input)) {
+            else if ((0, constants_js_1.isCommand)(input)) {
                 if (input.graph === constants_js_1.Command.PARENT) {
-                    return write_js_1.SKIP_WRITE;
+                    return null;
                 }
-                return getStateKey(key, input.update);
+                return input._updateAsTuples();
             }
-            else if (typeof input !== "object" || Array.isArray(input)) {
+            else if (Array.isArray(input) &&
+                input.length > 0 &&
+                input.some(constants_js_1.isCommand)) {
+                const updates = [];
+                for (const item of input) {
+                    if ((0, constants_js_1.isCommand)(item)) {
+                        if (item.graph === constants_js_1.Command.PARENT) {
+                            continue;
+                        }
+                        updates.push(...item._updateAsTuples());
+                    }
+                    else {
+                        const itemUpdates = _getUpdates(item);
+                        if (itemUpdates) {
+                            updates.push(...(itemUpdates ?? []));
+                        }
+                    }
+                }
+                return updates;
+            }
+            else if (typeof input === "object" && !Array.isArray(input)) {
+                return Object.entries(input).filter(([k]) => outputKeys.includes(k));
+            }
+            else {
                 const typeofInput = Array.isArray(input) ? "array" : typeof input;
                 throw new errors_js_1.InvalidUpdateError(`Expected node "${nodeKey.toString()}" to return an object, received ${typeofInput}`, {
                     lc_error_code: "INVALID_GRAPH_NODE_RETURN_VALUE",
                 });
             }
-            else {
-                return key in input ? input[key] : write_js_1.SKIP_WRITE;
-            }
         }
-        // state updaters
-        const stateWriteEntries = stateKeys.map((key) => key === ROOT
-            ? {
-                channel: key,
+        const stateWriteEntries = [
+            {
                 value: write_js_1.PASSTHROUGH,
-                skipNone: true,
                 mapper: new utils_js_1.RunnableCallable({
-                    func: _getRoot,
+                    func: outputKeys.length && outputKeys[0] === ROOT
+                        ? _getRoot
+                        : _getUpdates,
                     trace: false,
                     recurse: false,
                 }),
-            }
-            : {
-                channel: key,
-                value: write_js_1.PASSTHROUGH,
-                mapper: new utils_js_1.RunnableCallable({
-                    func: getStateKey.bind(null, key),
-                    trace: false,
-                    recurse: false,
-                }),
-            });
+            },
+        ];
         // add node and output channel
         if (key === graph_js_1.START) {
             this.nodes[key] = new read_js_1.PregelNode({
@@ -541,7 +583,7 @@ function _controlBranch(value) {
     if ((0, constants_js_1._isSend)(value)) {
         return [value];
     }
-    if (!(0, constants_js_1._isCommand)(value)) {
+    if (!(0, constants_js_1.isCommand)(value)) {
         return [];
     }
     if (value.graph === constants_js_1.Command.PARENT) {

package/dist/graph/state.js

@@ -2,12 +2,12 @@
 import { _coerceToRunnable, Runnable, } from "@langchain/core/runnables";
 import { isBaseChannel } from "../channels/base.js";
 import { END, CompiledGraph, Graph, START, Branch, } from "./graph.js";
-import { ChannelWrite, PASSTHROUGH, SKIP_WRITE, } from "../pregel/write.js";
+import { ChannelWrite, PASSTHROUGH, } from "../pregel/write.js";
 import { ChannelRead, PregelNode } from "../pregel/read.js";
 import { NamedBarrierValue } from "../channels/named_barrier_value.js";
 import { EphemeralValue } from "../channels/ephemeral_value.js";
 import { RunnableCallable } from "../utils.js";
-import { _isCommand, _isSend, CHECKPOINT_NAMESPACE_END, CHECKPOINT_NAMESPACE_SEPARATOR, Command, SELF, TAG_HIDDEN, } from "../constants.js";
+import { isCommand, _isSend, CHECKPOINT_NAMESPACE_END, CHECKPOINT_NAMESPACE_SEPARATOR, Command, SELF, TAG_HIDDEN, } from "../constants.js";
 import { InvalidUpdateError, ParentCommand } from "../errors.js";
 import { getChannel, } from "./annotation.js";
 import { isConfiguredManagedValue } from "../managed/base.js";
@@ -343,59 +343,101 @@ function _getChannels(schema) {
  */
 export class CompiledStateGraph extends CompiledGraph {
     attachNode(key, node) {
-        const stateKeys = Object.keys(this.builder.channels);
+        let outputKeys;
+        if (key === START) {
+            // Get input schema keys excluding managed values
+            outputKeys = Object.entries(this.builder._schemaDefinitions.get(this.builder._inputDefinition))
+                .filter(([_, v]) => !isConfiguredManagedValue(v))
+                .map(([k]) => k);
+        }
+        else {
+            outputKeys = Object.keys(this.builder.channels);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         function _getRoot(input) {
-            if (_isCommand(input)) {
+            if (isCommand(input)) {
                 if (input.graph === Command.PARENT) {
-                    return SKIP_WRITE;
+                    return null;
+                }
+                return input._updateAsTuples();
+            }
+            else if (Array.isArray(input) &&
+                input.length > 0 &&
+                input.some((i) => isCommand(i))) {
+                const updates = [];
+                for (const i of input) {
+                    if (isCommand(i)) {
+                        if (i.graph === Command.PARENT) {
+                            continue;
+                        }
+                        updates.push(...i._updateAsTuples());
+                    }
+                    else {
+                        updates.push([ROOT, i]);
+                    }
                 }
-                return input.update;
+                return updates;
             }
-            return input;
+            else if (input != null) {
+                return [[ROOT, input]];
+            }
+            return null;
         }
         // to avoid name collision below
         const nodeKey = key;
-        function getStateKey(key, input) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        function _getUpdates(input) {
             if (!input) {
-                return SKIP_WRITE;
+                return null;
             }
-            else if (_isCommand(input)) {
+            else if (isCommand(input)) {
                 if (input.graph === Command.PARENT) {
-                    return SKIP_WRITE;
+                    return null;
                 }
-                return getStateKey(key, input.update);
+                return input._updateAsTuples();
             }
-            else if (typeof input !== "object" || Array.isArray(input)) {
+            else if (Array.isArray(input) &&
+                input.length > 0 &&
+                input.some(isCommand)) {
+                const updates = [];
+                for (const item of input) {
+                    if (isCommand(item)) {
+                        if (item.graph === Command.PARENT) {
+                            continue;
+                        }
+                        updates.push(...item._updateAsTuples());
+                    }
+                    else {
+                        const itemUpdates = _getUpdates(item);
+                        if (itemUpdates) {
+                            updates.push(...(itemUpdates ?? []));
+                        }
+                    }
+                }
+                return updates;
+            }
+            else if (typeof input === "object" && !Array.isArray(input)) {
+                return Object.entries(input).filter(([k]) => outputKeys.includes(k));
+            }
+            else {
                 const typeofInput = Array.isArray(input) ? "array" : typeof input;
                 throw new InvalidUpdateError(`Expected node "${nodeKey.toString()}" to return an object, received ${typeofInput}`, {
                     lc_error_code: "INVALID_GRAPH_NODE_RETURN_VALUE",
                 });
             }
-            else {
-                return key in input ? input[key] : SKIP_WRITE;
-            }
         }
-        // state updaters
-        const stateWriteEntries = stateKeys.map((key) => key === ROOT
-            ? {
-                channel: key,
+        const stateWriteEntries = [
+            {
                 value: PASSTHROUGH,
-                skipNone: true,
                 mapper: new RunnableCallable({
-                    func: _getRoot,
+                    func: outputKeys.length && outputKeys[0] === ROOT
+                        ? _getRoot
+                        : _getUpdates,
                     trace: false,
                     recurse: false,
                 }),
-            }
-            : {
-                channel: key,
-                value: PASSTHROUGH,
-                mapper: new RunnableCallable({
-                    func: getStateKey.bind(null, key),
-                    trace: false,
-                    recurse: false,
-                }),
-            });
+            },
+        ];
         // add node and output channel
         if (key === START) {
             this.nodes[key] = new PregelNode({
@@ -536,7 +578,7 @@ function _controlBranch(value) {
     if (_isSend(value)) {
         return [value];
     }
-    if (!_isCommand(value)) {
+    if (!isCommand(value)) {
         return [];
     }
     if (value.graph === Command.PARENT) {

package/dist/prebuilt/react_agent_executor.cjs

@@ -108,7 +108,7 @@ function _getModelPreprocessingRunnable(stateModifier, messageModifier) {
  * ```
  */
 function createReactAgent(params) {
-    const { llm, tools, messageModifier, stateModifier, checkpointSaver, interruptBefore, interruptAfter, store, } = params;
+    const { llm, tools, messageModifier, stateModifier, stateSchema, checkpointSaver, interruptBefore, interruptAfter, store, } = params;
     let toolClasses;
     if (!Array.isArray(tools)) {
         toolClasses = tools.tools;
@@ -138,7 +138,7 @@ function createReactAgent(params) {
         // TODO: Auto-promote streaming.
         return { messages: [await modelRunnable.invoke(state, config)] };
     };
-    const workflow = new index_js_1.StateGraph(messages_annotation_js_1.MessagesAnnotation)
+    const workflow = new index_js_1.StateGraph(stateSchema ?? messages_annotation_js_1.MessagesAnnotation)
         .addNode("agent", callModel)
         .addNode("tools", new tool_node_js_1.ToolNode(toolClasses))
         .addEdge(index_js_1.START, "agent")

package/dist/prebuilt/react_agent_executor.d.ts

@@ -3,7 +3,7 @@ import { BaseMessage, BaseMessageLike, SystemMessage } from "@langchain/core/mes
 import { Runnable, RunnableToolLike } from "@langchain/core/runnables";
 import { StructuredToolInterface } from "@langchain/core/tools";
 import { All, BaseCheckpointSaver, BaseStore } from "@langchain/langgraph-checkpoint";
-import { START, CompiledStateGraph } from "../graph/index.js";
+import { START, CompiledStateGraph, AnnotationRoot } from "../graph/index.js";
 import { MessagesAnnotation } from "../graph/messages_annotation.js";
 import { ToolNode } from "./tool_node.js";
 import { LangGraphRunnableConfig } from "../pregel/runnable_types.js";
@@ -14,11 +14,11 @@ export type N = typeof START | "agent" | "tools";
 export type StateModifier = SystemMessage | string | ((state: typeof MessagesAnnotation.State, config: LangGraphRunnableConfig) => BaseMessageLike[]) | ((state: typeof MessagesAnnotation.State, config: LangGraphRunnableConfig) => Promise<BaseMessageLike[]>) | Runnable;
 /** @deprecated Use StateModifier instead. */
 export type MessageModifier = SystemMessage | string | ((messages: BaseMessage[]) => BaseMessage[]) | ((messages: BaseMessage[]) => Promise<BaseMessage[]>) | Runnable;
-export type CreateReactAgentParams = {
+export type CreateReactAgentParams<A extends AnnotationRoot<any> = AnnotationRoot<any>> = {
     /** The chat model that can utilize OpenAI-style tool calling. */
     llm: BaseChatModel;
     /** A list of tools or a ToolNode. */
-    tools: ToolNode<typeof MessagesAnnotation.State> | (StructuredToolInterface | RunnableToolLike)[];
+    tools: ToolNode | (StructuredToolInterface | RunnableToolLike)[];
     /**
      * @deprecated
      * Use stateModifier instead. stateModifier works the same as
@@ -73,6 +73,7 @@ export type CreateReactAgentParams = {
      * - Runnable: This runnable should take in full graph state and the output is then passed to the language model.
      */
     stateModifier?: StateModifier;
+    stateSchema?: A;
     /** An optional checkpoint saver to persist the agent's state. */
     checkpointSaver?: BaseCheckpointSaver;
     /** An optional list of node names to interrupt before running. */
@@ -123,4 +124,4 @@ export type CreateReactAgentParams = {
  * // Returns the messages in the state at each step of execution
  * ```
  */
-export declare function createReactAgent(params: CreateReactAgentParams): CompiledStateGraph<(typeof MessagesAnnotation)["State"], (typeof MessagesAnnotation)["Update"], typeof START | "agent" | "tools">;
+export declare function createReactAgent<A extends AnnotationRoot<any> = AnnotationRoot<any>>(params: CreateReactAgentParams<A>): CompiledStateGraph<(typeof MessagesAnnotation)["State"], (typeof MessagesAnnotation)["Update"], typeof START | "agent" | "tools", typeof MessagesAnnotation.spec & A["spec"], typeof MessagesAnnotation.spec & A["spec"]>;

package/dist/prebuilt/react_agent_executor.js

@@ -1,6 +1,6 @@
 import { isAIMessage, isBaseMessage, SystemMessage, } from "@langchain/core/messages";
 import { Runnable, RunnableLambda, } from "@langchain/core/runnables";
-import { END, START, StateGraph } from "../graph/index.js";
+import { END, START, StateGraph, } from "../graph/index.js";
 import { MessagesAnnotation } from "../graph/messages_annotation.js";
 import { ToolNode } from "./tool_node.js";
 function _convertMessageModifierToStateModifier(messageModifier) {
@@ -105,7 +105,7 @@ function _getModelPreprocessingRunnable(stateModifier, messageModifier) {
  * ```
  */
 export function createReactAgent(params) {
-    const { llm, tools, messageModifier, stateModifier, checkpointSaver, interruptBefore, interruptAfter, store, } = params;
+    const { llm, tools, messageModifier, stateModifier, stateSchema, checkpointSaver, interruptBefore, interruptAfter, store, } = params;
     let toolClasses;
     if (!Array.isArray(tools)) {
         toolClasses = tools.tools;
@@ -135,7 +135,7 @@ export function createReactAgent(params) {
         // TODO: Auto-promote streaming.
         return { messages: [await modelRunnable.invoke(state, config)] };
     };
-    const workflow = new StateGraph(MessagesAnnotation)
+    const workflow = new StateGraph(stateSchema ?? MessagesAnnotation)
         .addNode("agent", callModel)
         .addNode("tools", new ToolNode(toolClasses))
         .addEdge(START, "agent")

package/dist/prebuilt/tool_node.cjs

@@ -5,6 +5,7 @@ const messages_1 = require("@langchain/core/messages");
 const utils_js_1 = require("../utils.cjs");
 const graph_js_1 = require("../graph/graph.cjs");
 const errors_js_1 = require("../errors.cjs");
+const constants_js_1 = require("../constants.cjs");
 /**
  * A node that runs the tools requested in the last AIMessage. It can be used
  * either in StateGraph with a "messages" key or in MessageGraph. If multiple
@@ -163,7 +164,8 @@ class ToolNode extends utils_js_1.RunnableCallable {
                     throw new Error(`Tool "${call.name}" not found.`);
                 }
                 const output = await tool.invoke({ ...call, type: "tool_call" }, config);
-                if ((0, messages_1.isBaseMessage)(output) && output._getType() === "tool") {
+                if (((0, messages_1.isBaseMessage)(output) && output._getType() === "tool") ||
+                    (0, constants_js_1.isCommand)(output)) {
                     return output;
                 }
                 else {
@@ -192,7 +194,18 @@ class ToolNode extends utils_js_1.RunnableCallable {
                 });
             }
         }) ?? []);
-        return (Array.isArray(input) ? outputs : { messages: outputs });
+        // Preserve existing behavior for non-command tool outputs for backwards compatibility
+        if (!outputs.some(constants_js_1.isCommand)) {
+            return (Array.isArray(input) ? outputs : { messages: outputs });
+        }
+        // Handle mixed Command and non-Command outputs
+        const combinedOutputs = outputs.map((output) => {
+            if ((0, constants_js_1.isCommand)(output)) {
+                return output;
+            }
+            return Array.isArray(input) ? [output] : { messages: [output] };
+        });
+        return combinedOutputs;
     }
 }
 exports.ToolNode = ToolNode;

package/dist/prebuilt/tool_node.js

@@ -2,6 +2,7 @@ import { ToolMessage, isBaseMessage, } from "@langchain/core/messages";
 import { RunnableCallable } from "../utils.js";
 import { END } from "../graph/graph.js";
 import { isGraphInterrupt } from "../errors.js";
+import { isCommand } from "../constants.js";
 /**
  * A node that runs the tools requested in the last AIMessage. It can be used
  * either in StateGraph with a "messages" key or in MessageGraph. If multiple
@@ -160,7 +161,8 @@ export class ToolNode extends RunnableCallable {
                     throw new Error(`Tool "${call.name}" not found.`);
                 }
                 const output = await tool.invoke({ ...call, type: "tool_call" }, config);
-                if (isBaseMessage(output) && output._getType() === "tool") {
+                if ((isBaseMessage(output) && output._getType() === "tool") ||
+                    isCommand(output)) {
                     return output;
                 }
                 else {
@@ -189,7 +191,18 @@ export class ToolNode extends RunnableCallable {
                 });
             }
         }) ?? []);
-        return (Array.isArray(input) ? outputs : { messages: outputs });
+        // Preserve existing behavior for non-command tool outputs for backwards compatibility
+        if (!outputs.some(isCommand)) {
+            return (Array.isArray(input) ? outputs : { messages: outputs });
+        }
+        // Handle mixed Command and non-Command outputs
+        const combinedOutputs = outputs.map((output) => {
+            if (isCommand(output)) {
+                return output;
+            }
+            return Array.isArray(input) ? [output] : { messages: [output] };
+        });
+        return combinedOutputs;
     }
 }
 export function toolsCondition(state) {

package/dist/pregel/loop.cjs

@@ -587,8 +587,8 @@ class PregelLoop {
         const isResuming = Object.keys(this.checkpoint.channel_versions).length !== 0 &&
             (this.config.configurable?.[constants_js_1.CONFIG_KEY_RESUMING] !== undefined ||
                 this.input === null ||
-                (0, constants_js_1._isCommand)(this.input));
-        if ((0, constants_js_1._isCommand)(this.input)) {
+                (0, constants_js_1.isCommand)(this.input));
+        if ((0, constants_js_1.isCommand)(this.input)) {
             const writes = {};
             // group writes by task id
             for (const [tid, key, value] of (0, io_js_1.mapCommand)(this.input, this.checkpointPendingWrites)) {

package/dist/pregel/loop.js

@@ -1,7 +1,7 @@
 import { IterableReadableStream } from "@langchain/core/utils/stream";
 import { copyCheckpoint, emptyCheckpoint, AsyncBatchedStore, WRITES_IDX_MAP, } from "@langchain/langgraph-checkpoint";
 import { createCheckpoint, emptyChannels, } from "../channels/base.js";
-import { _isCommand, CHECKPOINT_NAMESPACE_SEPARATOR, CONFIG_KEY_CHECKPOINT_MAP, CONFIG_KEY_READ, CONFIG_KEY_RESUMING, CONFIG_KEY_STREAM, ERROR, INPUT, INTERRUPT, NULL_TASK_ID, RESUME, TAG_HIDDEN, } from "../constants.js";
+import { isCommand, CHECKPOINT_NAMESPACE_SEPARATOR, CONFIG_KEY_CHECKPOINT_MAP, CONFIG_KEY_READ, CONFIG_KEY_RESUMING, CONFIG_KEY_STREAM, ERROR, INPUT, INTERRUPT, NULL_TASK_ID, RESUME, TAG_HIDDEN, } from "../constants.js";
 import { _applyWrites, _prepareNextTasks, increment, shouldInterrupt, } from "./algo.js";
 import { gatherIterator, gatherIteratorSync, prefixGenerator, } from "../utils.js";
 import { mapCommand, mapInput, mapOutputUpdates, mapOutputValues, readChannels, } from "./io.js";
@@ -583,8 +583,8 @@ export class PregelLoop {
         const isResuming = Object.keys(this.checkpoint.channel_versions).length !== 0 &&
             (this.config.configurable?.[CONFIG_KEY_RESUMING] !== undefined ||
                 this.input === null ||
-                _isCommand(this.input));
-        if (_isCommand(this.input)) {
+                isCommand(this.input));
+        if (isCommand(this.input)) {
             const writes = {};
             // group writes by task id
             for (const [tid, key, value] of mapCommand(this.input, this.checkpointPendingWrites)) {

package/dist/pregel/write.cjs

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChannelWrite = exports.PASSTHROUGH = exports.SKIP_WRITE = void 0;
+const runnables_1 = require("@langchain/core/runnables");
 const constants_js_1 = require("../constants.cjs");
 const utils_js_1 = require("../utils.cjs");
 const errors_js_1 = require("../errors.cjs");
@@ -29,7 +30,13 @@ class ChannelWrite extends utils_js_1.RunnableCallable {
     constructor(writes, tags) {
         const name = `ChannelWrite<${writes
             .map((packet) => {
-            return (0, constants_js_1._isSend)(packet) ? packet.node : packet.channel;
+            if ((0, constants_js_1._isSend)(packet)) {
+                return packet.node;
+            }
+            else if ("channel" in packet) {
+                return packet.channel;
+            }
+            return "...";
         })
             .join(",")}>`;
         super({
@@ -48,7 +55,13 @@ class ChannelWrite extends utils_js_1.RunnableCallable {
     }
     async _write(input, config) {
         const writes = this.writes.map((write) => {
-            if (_isChannelWriteEntry(write) && _isPassthrough(write.value)) {
+            if (_isChannelWriteTupleEntry(write) && _isPassthrough(write.value)) {
+                return {
+                    mapper: write.mapper,
+                    value: input,
+                };
+            }
+            else if (_isChannelWriteEntry(write) && _isPassthrough(write.value)) {
                 return {
                     channel: write.channel,
                     value: input,
@@ -65,36 +78,52 @@ class ChannelWrite extends utils_js_1.RunnableCallable {
     }
     // TODO: Support requireAtLeastOneOf
     static async doWrite(config, writes) {
-        const sends = writes.filter(constants_js_1._isSend).map((packet) => {
-            return [constants_js_1.TASKS, packet];
-        });
-        const entries = writes.filter((write) => {
-            return !(0, constants_js_1._isSend)(write);
-        });
-        const invalidEntry = entries.find((write) => {
-            return write.channel === constants_js_1.TASKS;
-        });
-        if (invalidEntry) {
-            throw new errors_js_1.InvalidUpdateError(`Cannot write to the reserved channel ${constants_js_1.TASKS}`);
+        // validate
+        for (const w of writes) {
+            if (_isChannelWriteEntry(w)) {
+                if (w.channel === constants_js_1.TASKS) {
+                    throw new errors_js_1.InvalidUpdateError("Cannot write to the reserved channel TASKS");
+                }
+                if (_isPassthrough(w.value)) {
+                    throw new errors_js_1.InvalidUpdateError("PASSTHROUGH value must be replaced");
+                }
+            }
+            if (_isChannelWriteTupleEntry(w)) {
+                if (_isPassthrough(w.value)) {
+                    throw new errors_js_1.InvalidUpdateError("PASSTHROUGH value must be replaced");
+                }
+            }
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const writeEntries = [];
+        for (const w of writes) {
+            if ((0, constants_js_1._isSend)(w)) {
+                writeEntries.push([constants_js_1.TASKS, w]);
+            }
+            else if (_isChannelWriteTupleEntry(w)) {
+                const mappedResult = await w.mapper.invoke(w.value, config);
+                if (mappedResult != null && mappedResult.length > 0) {
+                    writeEntries.push(...mappedResult);
+                }
+            }
+            else if (_isChannelWriteEntry(w)) {
+                const mappedValue = w.mapper !== undefined
+                    ? await w.mapper.invoke(w.value, config)
+                    : w.value;
+                if (_isSkipWrite(mappedValue)) {
+                    continue;
+                }
+                if (w.skipNone && mappedValue === undefined) {
+                    continue;
+                }
+                writeEntries.push([w.channel, mappedValue]);
+            }
+            else {
+                throw new Error(`Invalid write entry: ${JSON.stringify(w)}`);
+            }
         }
-        const values = await Promise.all(entries.map(async (write) => {
-            const mappedValue = write.mapper
-                ? await write.mapper.invoke(write.value, config)
-                : write.value;
-            return {
-                ...write,
-                value: mappedValue,
-            };
-        })).then((writes) => {
-            return writes
-                .filter((write) => !write.skipNone || write.value !== null)
-                .map((write) => {
-                return [write.channel, write.value];
-            });
-        });
         const write = config.configurable?.[constants_js_1.CONFIG_KEY_SEND];
-        const filtered = values.filter(([_, value]) => !_isSkipWrite(value));
-        write([...sends, ...filtered]);
+        write(writeEntries);
     }
     static isWriter(runnable) {
         return (
@@ -110,3 +139,8 @@ exports.ChannelWrite = ChannelWrite;
 function _isChannelWriteEntry(x) {
     return (x !== undefined && typeof x.channel === "string");
 }
+function _isChannelWriteTupleEntry(x) {
+    return (x !== undefined &&
+        !_isChannelWriteEntry(x) &&
+        runnables_1.Runnable.isRunnable(x.mapper));
+}

package/dist/pregel/write.d.ts

@@ -12,10 +12,10 @@ export declare const PASSTHROUGH: {
  * or None to skip writing.
  */
 export declare class ChannelWrite<RunInput = any> extends RunnableCallable {
-    writes: Array<ChannelWriteEntry | Send>;
-    constructor(writes: Array<ChannelWriteEntry | Send>, tags?: string[]);
+    writes: Array<ChannelWriteEntry | ChannelWriteTupleEntry | Send>;
+    constructor(writes: Array<ChannelWriteEntry | ChannelWriteTupleEntry | Send>, tags?: string[]);
     _write(input: unknown, config: RunnableConfig): Promise<unknown>;
-    static doWrite(config: RunnableConfig, writes: (ChannelWriteEntry | Send)[]): Promise<void>;
+    static doWrite(config: RunnableConfig, writes: (ChannelWriteEntry | ChannelWriteTupleEntry | Send)[]): Promise<void>;
     static isWriter(runnable: RunnableLike): runnable is ChannelWrite;
     static registerWriter<T extends Runnable>(runnable: T): T;
 }
@@ -25,3 +25,7 @@ export interface ChannelWriteEntry {
     skipNone?: boolean;
     mapper?: Runnable;
 }
+export interface ChannelWriteTupleEntry {
+    value: unknown;
+    mapper: Runnable<any, [string, any][]>;
+}

package/dist/pregel/write.js

@@ -1,3 +1,4 @@
+import { Runnable, } from "@langchain/core/runnables";
 import { _isSend, CONFIG_KEY_SEND, TASKS } from "../constants.js";
 import { RunnableCallable } from "../utils.js";
 import { InvalidUpdateError } from "../errors.js";
@@ -26,7 +27,13 @@ export class ChannelWrite extends RunnableCallable {
     constructor(writes, tags) {
         const name = `ChannelWrite<${writes
             .map((packet) => {
-            return _isSend(packet) ? packet.node : packet.channel;
+            if (_isSend(packet)) {
+                return packet.node;
+            }
+            else if ("channel" in packet) {
+                return packet.channel;
+            }
+            return "...";
         })
             .join(",")}>`;
         super({
@@ -45,7 +52,13 @@ export class ChannelWrite extends RunnableCallable {
     }
     async _write(input, config) {
         const writes = this.writes.map((write) => {
-            if (_isChannelWriteEntry(write) && _isPassthrough(write.value)) {
+            if (_isChannelWriteTupleEntry(write) && _isPassthrough(write.value)) {
+                return {
+                    mapper: write.mapper,
+                    value: input,
+                };
+            }
+            else if (_isChannelWriteEntry(write) && _isPassthrough(write.value)) {
                 return {
                     channel: write.channel,
                     value: input,
@@ -62,36 +75,52 @@ export class ChannelWrite extends RunnableCallable {
     }
     // TODO: Support requireAtLeastOneOf
     static async doWrite(config, writes) {
-        const sends = writes.filter(_isSend).map((packet) => {
-            return [TASKS, packet];
-        });
-        const entries = writes.filter((write) => {
-            return !_isSend(write);
-        });
-        const invalidEntry = entries.find((write) => {
-            return write.channel === TASKS;
-        });
-        if (invalidEntry) {
-            throw new InvalidUpdateError(`Cannot write to the reserved channel ${TASKS}`);
+        // validate
+        for (const w of writes) {
+            if (_isChannelWriteEntry(w)) {
+                if (w.channel === TASKS) {
+                    throw new InvalidUpdateError("Cannot write to the reserved channel TASKS");
+                }
+                if (_isPassthrough(w.value)) {
+                    throw new InvalidUpdateError("PASSTHROUGH value must be replaced");
+                }
+            }
+            if (_isChannelWriteTupleEntry(w)) {
+                if (_isPassthrough(w.value)) {
+                    throw new InvalidUpdateError("PASSTHROUGH value must be replaced");
+                }
+            }
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const writeEntries = [];
+        for (const w of writes) {
+            if (_isSend(w)) {
+                writeEntries.push([TASKS, w]);
+            }
+            else if (_isChannelWriteTupleEntry(w)) {
+                const mappedResult = await w.mapper.invoke(w.value, config);
+                if (mappedResult != null && mappedResult.length > 0) {
+                    writeEntries.push(...mappedResult);
+                }
+            }
+            else if (_isChannelWriteEntry(w)) {
+                const mappedValue = w.mapper !== undefined
+                    ? await w.mapper.invoke(w.value, config)
+                    : w.value;
+                if (_isSkipWrite(mappedValue)) {
+                    continue;
+                }
+                if (w.skipNone && mappedValue === undefined) {
+                    continue;
+                }
+                writeEntries.push([w.channel, mappedValue]);
+            }
+            else {
+                throw new Error(`Invalid write entry: ${JSON.stringify(w)}`);
+            }
         }
-        const values = await Promise.all(entries.map(async (write) => {
-            const mappedValue = write.mapper
-                ? await write.mapper.invoke(write.value, config)
-                : write.value;
-            return {
-                ...write,
-                value: mappedValue,
-            };
-        })).then((writes) => {
-            return writes
-                .filter((write) => !write.skipNone || write.value !== null)
-                .map((write) => {
-                return [write.channel, write.value];
-            });
-        });
         const write = config.configurable?.[CONFIG_KEY_SEND];
-        const filtered = values.filter(([_, value]) => !_isSkipWrite(value));
-        write([...sends, ...filtered]);
+        write(writeEntries);
     }
     static isWriter(runnable) {
         return (
@@ -106,3 +135,8 @@ export class ChannelWrite extends RunnableCallable {
 function _isChannelWriteEntry(x) {
     return (x !== undefined && typeof x.channel === "string");
 }
+function _isChannelWriteTupleEntry(x) {
+    return (x !== undefined &&
+        !_isChannelWriteEntry(x) &&
+        Runnable.isRunnable(x.mapper));
+}

package/dist/web.cjs

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MessagesAnnotation = exports.InMemoryStore = exports.AsyncBatchedStore = exports.BaseStore = exports.BaseCheckpointSaver = exports.emptyCheckpoint = exports.copyCheckpoint = exports.MemorySaver = exports.interrupt = exports.Command = exports.Send = exports.BinaryOperatorAggregate = exports.BaseChannel = exports.Annotation = exports.messagesStateReducer = exports.MessageGraph = exports.CompiledStateGraph = exports.StateGraph = exports.START = exports.Graph = exports.END = void 0;
+exports.MessagesAnnotation = exports.InMemoryStore = exports.AsyncBatchedStore = exports.BaseStore = exports.BaseCheckpointSaver = exports.emptyCheckpoint = exports.copyCheckpoint = exports.MemorySaver = exports.interrupt = exports.isCommand = exports.Command = exports.Send = exports.BinaryOperatorAggregate = exports.BaseChannel = exports.Annotation = exports.messagesStateReducer = exports.MessageGraph = exports.CompiledStateGraph = exports.StateGraph = exports.START = exports.Graph = exports.END = void 0;
 var index_js_1 = require("./graph/index.cjs");
 Object.defineProperty(exports, "END", { enumerable: true, get: function () { return index_js_1.END; } });
 Object.defineProperty(exports, "Graph", { enumerable: true, get: function () { return index_js_1.Graph; } });
@@ -31,6 +31,7 @@ Object.defineProperty(exports, "BinaryOperatorAggregate", { enumerable: true, ge
 var constants_js_1 = require("./constants.cjs");
 Object.defineProperty(exports, "Send", { enumerable: true, get: function () { return constants_js_1.Send; } });
 Object.defineProperty(exports, "Command", { enumerable: true, get: function () { return constants_js_1.Command; } });
+Object.defineProperty(exports, "isCommand", { enumerable: true, get: function () { return constants_js_1.isCommand; } });
 var interrupt_js_1 = require("./interrupt.cjs");
 Object.defineProperty(exports, "interrupt", { enumerable: true, get: function () { return interrupt_js_1.interrupt; } });
 var langgraph_checkpoint_1 = require("@langchain/langgraph-checkpoint");

package/dist/web.d.ts

@@ -4,7 +4,7 @@ export * from "./errors.js";
 export { BaseChannel, type BinaryOperator, BinaryOperatorAggregate, type AnyValue, type WaitForNames, type DynamicBarrierValue, type LastValue, type NamedBarrierValue, type Topic, } from "./channels/index.js";
 export { type AnnotationRoot as _INTERNAL_ANNOTATION_ROOT } from "./graph/index.js";
 export { type RetryPolicy } from "./pregel/utils/index.js";
-export { Send, Command, type CommandParams, type Interrupt, } from "./constants.js";
+export { Send, Command, type CommandParams, isCommand, type Interrupt, } from "./constants.js";
 export { interrupt } from "./interrupt.js";
 export { MemorySaver, type Checkpoint, type CheckpointMetadata, type CheckpointTuple, copyCheckpoint, emptyCheckpoint, BaseCheckpointSaver, type Item, type GetOperation, type SearchOperation, type PutOperation, type Operation, type OperationResults, BaseStore, AsyncBatchedStore, InMemoryStore, type NameSpacePath, type NamespaceMatchType, type MatchCondition, type ListNamespacesOperation, } from "@langchain/langgraph-checkpoint";
 export * from "./managed/index.js";

package/dist/web.js

@@ -1,7 +1,7 @@
 export { END, Graph, START, StateGraph, CompiledStateGraph, MessageGraph, messagesStateReducer, Annotation, } from "./graph/index.js";
 export * from "./errors.js";
 export { BaseChannel, BinaryOperatorAggregate, } from "./channels/index.js";
-export { Send, Command, } from "./constants.js";
+export { Send, Command, isCommand, } from "./constants.js";
 export { interrupt } from "./interrupt.js";
 export { MemorySaver, copyCheckpoint, emptyCheckpoint, BaseCheckpointSaver, BaseStore, AsyncBatchedStore, InMemoryStore, } from "@langchain/langgraph-checkpoint";
 export * from "./managed/index.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/langgraph",
-  "version": "0.2.32",
+  "version": "0.2.33",
   "description": "LangGraph",
   "type": "module",
   "engines": {
@@ -43,7 +43,7 @@
     "@jest/globals": "^29.5.0",
     "@langchain/anthropic": "^0.3.5",
     "@langchain/community": "^0.3.9",
-    "@langchain/core": "^0.3.22",
+    "@langchain/core": "^0.3.23",
     "@langchain/langgraph-checkpoint-postgres": "workspace:*",
     "@langchain/langgraph-checkpoint-sqlite": "workspace:*",
     "@langchain/openai": "^0.3.11",