@langchain/langgraph 0.2.73 → 0.3.0

package/dist/graph/messages_annotation.js

@@ -1,6 +1,8 @@
 /* __LC_ALLOW_ENTRYPOINT_SIDE_EFFECTS__ */
+import { z } from "zod";
 import { Annotation } from "./annotation.js";
 import { messagesStateReducer } from "./message.js";
+import { withLangGraph } from "./zod/state.js";
 /**
  * Prebuilt state annotation that combines returned messages.
  * Can handle standard messages and special modifiers like {@link RemoveMessage}
@@ -42,4 +44,55 @@ export const MessagesAnnotation = Annotation.Root({
         default: () => [],
     }),
 });
+/**
+ * Prebuilt state object that uses Zod to combine returned messages.
+ * This utility is synonymous with the `MessagesAnnotation` annotation,
+ * but uses Zod as the way to express messages state.
+ *
+ * You can use import and use this prebuilt schema like this:
+ *
+ * @example
+ * ```ts
+ * import { MessagesZodState, StateGraph } from "@langchain/langgraph";
+ *
+ * const graph = new StateGraph(MessagesZodState)
+ *   .addNode(...)
+ *   ...
+ * ```
+ *
+ * Which is equivalent to initializing the schema object manually like this:
+ *
+ * @example
+ * ```ts
+ * import { z } from "zod";
+ * import type { BaseMessage, BaseMessageLike } from "@langchain/core/messages";
+ * import { StateGraph, messagesStateReducer } from "@langchain/langgraph";
+ * import "@langchain/langgraph/zod";
+ *
+ * const AgentState = z.object({
+ *   messages: z
+ *     .custom<BaseMessage[]>()
+ *     .default(() => [])
+ *     .langgraph.reducer(
+ *        messagesStateReducer,
+ *        z.custom<BaseMessageLike | BaseMessageLike[]>()
+ *     ),
+ * });
+ * const graph = new StateGraph(AgentState)
+ *   .addNode(...)
+ *   ...
+ * ```
+ */
+export const MessagesZodState = z.object({
+    messages: withLangGraph(z.custom(), {
+        reducer: {
+            schema: z.custom(),
+            fn: messagesStateReducer,
+        },
+        jsonSchemaExtra: {
+            langgraph_type: "messages",
+        },
+        default: () => [],
+    }),
+});
 //# sourceMappingURL=messages_annotation.js.map

package/dist/graph/messages_annotation.js.map

@@ -1 +1 @@
-{"version":3,"file":"messages_annotation.js","sourceRoot":"","sources":["../../src/graph/messages_annotation.ts"],"names":[],"mappings":"AAAA,0CAA0C;AAG1C,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAY,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAE9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,UAAU,CAAC,IAAI,CAAC;IAChD,QAAQ,EAAE,UAAU,CAA0B;QAC5C,OAAO,EAAE,oBAAoB;QAC7B,OAAO,EAAE,GAAG,EAAE,CAAC,EAAE;KAClB,CAAC;CACH,CAAC,CAAC"}
+{"version":3,"file":"messages_annotation.js","sourceRoot":"","sources":["../../src/graph/messages_annotation.ts"],"names":[],"mappings":"AAAA,0CAA0C;AAG1C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAY,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAC9D,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,UAAU,CAAC,IAAI,CAAC;IAChD,QAAQ,EAAE,UAAU,CAA0B;QAC5C,OAAO,EAAE,oBAAoB;QAC7B,OAAO,EAAE,GAAG,EAAE,CAAC,EAAE;KAClB,CAAC;CACH,CAAC,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC;IACvC,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,MAAM,EAAiB,EAAE;QACjD,OAAO,EAAE;YACP,MAAM,EAAE,CAAC,CAAC,MAAM,EAAY;YAC5B,EAAE,EAAE,oBAAoB;SACzB;QACD,eAAe,EAAE;YACf,cAAc,EAAE,UAAU;SAC3B;QACD,OAAO,EAAE,GAAG,EAAE,CAAC,EAAE;KAClB,CAAC;CACH,CAAC,CAAC"}

package/dist/graph/state.cjs

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CompiledStateGraph = exports.StateGraph = void 0;
+exports.typedNode = typedNode;
 /* eslint-disable @typescript-eslint/no-use-before-define */
 const runnables_1 = require("@langchain/core/runnables");
 const base_js_1 = require("../channels/base.cjs");
@@ -16,7 +17,9 @@ const annotation_js_1 = require("./annotation.cjs");
 const base_js_2 = require("../managed/base.cjs");
 const subgraph_js_1 = require("../pregel/utils/subgraph.cjs");
 const state_js_1 = require("./zod/state.cjs");
+const last_value_js_1 = require("../channels/last_value.cjs");
 const ROOT = "__root__";
+const PartialStateSchema = Symbol.for("langgraph.state.partial");
 /**
  * A graph whose nodes communicate by reading and writing to a shared state.
  * Each node takes a defined `State` as input and returns a `Partial<State>`.
@@ -168,7 +171,7 @@ class StateGraph extends graph_js_1.Graph {
             this._schemaDefinition = stateDef;
             this._schemaRuntimeDefinition = fields.state;
             this._inputDefinition = inputDef;
-            this._inputRuntimeDefinition = fields.input ?? fields.state.partial();
+            this._inputRuntimeDefinition = fields.input ?? PartialStateSchema;
             this._outputDefinition = outputDef;
             this._outputRuntimeDefinition = fields.output ?? fields.state;
         }
@@ -177,7 +180,7 @@ class StateGraph extends graph_js_1.Graph {
             this._schemaDefinition = stateDef;
             this._schemaRuntimeDefinition = fields;
             this._inputDefinition = stateDef;
-            this._inputRuntimeDefinition = fields.partial();
+            this._inputRuntimeDefinition = PartialStateSchema;
             this._outputDefinition = stateDef;
             this._outputRuntimeDefinition = fields;
         }
@@ -202,7 +205,7 @@ class StateGraph extends graph_js_1.Graph {
             this._schemaDefinition = spec;
         }
         else {
-            throw new Error("Invalid StateGraph input.");
+            throw new Error("Invalid StateGraph input. Make sure to pass a valid Annotation.Root or Zod schema.");
         }
         this._inputDefinition ??= this._schemaDefinition;
         this._outputDefinition ??= this._schemaDefinition;
@@ -246,54 +249,87 @@ class StateGraph extends graph_js_1.Graph {
             }
         }
     }
-    addNode(key, action, options) {
-        if (key in this.channels) {
-            throw new Error(`${key} is already being used as a state attribute (a.k.a. a channel), cannot also be used as a node name.`);
-        }
-        for (const reservedChar of [
-            constants_js_1.CHECKPOINT_NAMESPACE_SEPARATOR,
-            constants_js_1.CHECKPOINT_NAMESPACE_END,
-        ]) {
-            if (key.includes(reservedChar)) {
-                throw new Error(`"${reservedChar}" is a reserved character and is not allowed in node names.`);
+    addNode(...args) {
+        function isMultipleNodes(args) {
+            return args.length >= 1 && typeof args[0] !== "string";
+        }
+        const nodes = (isMultipleNodes(args) // eslint-disable-line no-nested-ternary
+            ? Array.isArray(args[0])
+                ? args[0]
+                : Object.entries(args[0]).map(([key, action]) => [
+                    key,
+                    action,
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    action[Symbol.for("langgraph.state.node")] ?? undefined,
+                ])
+            : [[args[0], args[1], args[2]]]);
+        if (nodes.length === 0) {
+            throw new Error("No nodes provided in `addNode`");
+        }
+        for (const [key, action, options] of nodes) {
+            if (key in this.channels) {
+                throw new Error(`${key} is already being used as a state attribute (a.k.a. a channel), cannot also be used as a node name.`);
             }
+            for (const reservedChar of [
+                constants_js_1.CHECKPOINT_NAMESPACE_SEPARATOR,
+                constants_js_1.CHECKPOINT_NAMESPACE_END,
+            ]) {
+                if (key.includes(reservedChar)) {
+                    throw new Error(`"${reservedChar}" is a reserved character and is not allowed in node names.`);
+                }
+            }
+            this.warnIfCompiled(`Adding a node to a graph that has already been compiled. This will not be reflected in the compiled graph.`);
+            if (key in this.nodes) {
+                throw new Error(`Node \`${key}\` already present.`);
+            }
+            if (key === constants_js_1.END || key === constants_js_1.START) {
+                throw new Error(`Node \`${key}\` is reserved.`);
+            }
+            let inputSpec = this._schemaDefinition;
+            if (options?.input !== undefined) {
+                if ((0, state_js_1.isAnyZodObject)(options.input)) {
+                    inputSpec = (0, state_js_1.getChannelsFromZod)(options.input);
+                }
+                else if (options.input.spec !== undefined) {
+                    inputSpec = options.input.spec;
+                }
+            }
+            if (inputSpec !== undefined) {
+                this._addSchema(inputSpec);
+            }
+            let runnable;
+            if (runnables_1.Runnable.isRunnable(action)) {
+                runnable = action;
+            }
+            else if (typeof action === "function") {
+                runnable = new utils_js_1.RunnableCallable({
+                    func: action,
+                    name: key,
+                    trace: false,
+                });
+            }
+            else {
+                runnable = (0, runnables_1._coerceToRunnable)(action);
+            }
+            let cachePolicy = options?.cachePolicy;
+            if (typeof cachePolicy === "boolean") {
+                cachePolicy = cachePolicy ? {} : undefined;
+            }
+            const nodeSpec = {
+                runnable: runnable,
+                retryPolicy: options?.retryPolicy,
+                cachePolicy,
+                metadata: options?.metadata,
+                input: inputSpec ?? this._schemaDefinition,
+                subgraphs: (0, subgraph_js_1.isPregelLike)(runnable)
+                    ? // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        [runnable]
+                    : options?.subgraphs,
+                ends: options?.ends,
+                defer: options?.defer,
+            };
+            this.nodes[key] = nodeSpec;
         }
-        this.warnIfCompiled(`Adding a node to a graph that has already been compiled. This will not be reflected in the compiled graph.`);
-        if (key in this.nodes) {
-            throw new Error(`Node \`${key}\` already present.`);
-        }
-        if (key === constants_js_1.END || key === constants_js_1.START) {
-            throw new Error(`Node \`${key}\` is reserved.`);
-        }
-        if (options?.input !== undefined) {
-            this._addSchema(options.input.spec);
-        }
-        let runnable;
-        if (runnables_1.Runnable.isRunnable(action)) {
-            runnable = action;
-        }
-        else if (typeof action === "function") {
-            runnable = new utils_js_1.RunnableCallable({
-                func: action,
-                name: key,
-                trace: false,
-            });
-        }
-        else {
-            runnable = (0, runnables_1._coerceToRunnable)(action);
-        }
-        const nodeSpec = {
-            runnable: runnable,
-            retryPolicy: options?.retryPolicy,
-            metadata: options?.metadata,
-            input: options?.input?.spec ?? this._schemaDefinition,
-            subgraphs: (0, subgraph_js_1.isPregelLike)(runnable)
-                ? // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    [runnable]
-                : options?.subgraphs,
-            ends: options?.ends,
-        };
-        this.nodes[key] = nodeSpec;
         return this;
     }
     addEdge(startKey, endKey) {
@@ -321,7 +357,33 @@ class StateGraph extends graph_js_1.Graph {
         this.waitingEdges.add([startKey, endKey]);
         return this;
     }
-    compile({ checkpointer, store, interruptBefore, interruptAfter, name, } = {}) {
+    addSequence(nodes) {
+        const parsedNodes = Array.isArray(nodes)
+            ? nodes
+            : Object.entries(nodes).map(([key, action]) => [
+                key,
+                action,
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                action[Symbol.for("langgraph.state.node")] ?? undefined,
+            ]);
+        if (parsedNodes.length === 0) {
+            throw new Error("Sequence requires at least one node.");
+        }
+        let previousNode;
+        for (const [key, action, options] of parsedNodes) {
+            if (key in this.nodes) {
+                throw new Error(`Node names must be unique: node with the name "${key}" already exists.`);
+            }
+            const validKey = key;
+            this.addNode(validKey, action, options);
+            if (previousNode != null) {
+                this.addEdge(previousNode, validKey);
+            }
+            previousNode = validKey;
+        }
+        return this;
+    }
+    compile({ checkpointer, store, cache, interruptBefore, interruptAfter, name, } = {}) {
         // validate the graph
         this.validate([
             ...(Array.isArray(interruptBefore) ? interruptBefore : []),
@@ -349,6 +411,7 @@ class StateGraph extends graph_js_1.Graph {
             streamChannels,
             streamMode: "updates",
             store,
+            cache,
             name,
         });
         // attach nodes, edges and branches
@@ -507,15 +570,16 @@ class CompiledStateGraph extends graph_js_1.CompiledGraph {
             const inputDefinition = node?.input ?? this.builder._schemaDefinition;
             const inputValues = Object.fromEntries(Object.keys(this.builder._schemaDefinitions.get(inputDefinition)).map((k) => [k, k]));
             const isSingleInput = Object.keys(inputValues).length === 1 && ROOT in inputValues;
-            this.channels[key] = new ephemeral_value_js_1.EphemeralValue(false);
+            const branchChannel = `branch:to:${key}`;
+            this.channels[branchChannel] = node?.defer
+                ? new last_value_js_1.LastValueAfterFinish()
+                : new ephemeral_value_js_1.EphemeralValue(false);
             this.nodes[key] = new read_js_1.PregelNode({
-                triggers: [],
+                triggers: [branchChannel],
                 // read state keys
                 channels: isSingleInput ? Object.keys(inputValues) : inputValues,
-                // publish to this channel and state keys
-                writers: [
-                    new write_js_1.ChannelWrite(stateWriteEntries.concat({ channel: key, value: key }), [constants_js_1.TAG_HIDDEN]),
-                ],
+                // publish to state keys
+                writers: [new write_js_1.ChannelWrite(stateWriteEntries, [constants_js_1.TAG_HIDDEN])],
                 mapper: isSingleInput
                     ? undefined
                     : // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -525,55 +589,41 @@ class CompiledStateGraph extends graph_js_1.CompiledGraph {
                 bound: node?.runnable,
                 metadata: node?.metadata,
                 retryPolicy: node?.retryPolicy,
+                cachePolicy: node?.cachePolicy,
                 subgraphs: node?.subgraphs,
                 ends: node?.ends,
             });
         }
     }
-    attachEdge(start, end) {
-        if (end === constants_js_1.END) {
+    attachEdge(starts, end) {
+        if (end === constants_js_1.END)
             return;
+        if (typeof starts === "string") {
+            this.nodes[starts].writers.push(new write_js_1.ChannelWrite([{ channel: `branch:to:${end}`, value: null }], [constants_js_1.TAG_HIDDEN]));
         }
-        if (Array.isArray(start)) {
-            const channelName = `join:${start.join("+")}:${end}`;
+        else if (Array.isArray(starts)) {
+            const channelName = `join:${starts.join("+")}:${end}`;
             // register channel
-            this.channels[channelName] =
-                new named_barrier_value_js_1.NamedBarrierValue(new Set(start));
+            this.channels[channelName] = this.builder.nodes[end].defer
+                ? new named_barrier_value_js_1.NamedBarrierValueAfterFinish(new Set(starts))
+                : new named_barrier_value_js_1.NamedBarrierValue(new Set(starts));
             // subscribe to channel
             this.nodes[end].triggers.push(channelName);
             // publish to channel
-            for (const s of start) {
-                this.nodes[s].writers.push(new write_js_1.ChannelWrite([{ channel: channelName, value: s }], [constants_js_1.TAG_HIDDEN]));
+            for (const start of starts) {
+                this.nodes[start].writers.push(new write_js_1.ChannelWrite([{ channel: channelName, value: start }], [constants_js_1.TAG_HIDDEN]));
             }
         }
-        else if (start === constants_js_1.START) {
-            const channelName = `${constants_js_1.START}:${end}`;
-            // register channel
-            this.channels[channelName] =
-                new ephemeral_value_js_1.EphemeralValue();
-            // subscribe to channel
-            this.nodes[end].triggers.push(channelName);
-            // publish to channel
-            this.nodes[constants_js_1.START].writers.push(new write_js_1.ChannelWrite([{ channel: channelName, value: constants_js_1.START }], [constants_js_1.TAG_HIDDEN]));
-        }
-        else {
-            this.nodes[end].triggers.push(start);
-        }
     }
-    attachBranch(start, name, branch, options = { withReader: true }) {
+    attachBranch(start, _, branch, options = { withReader: true }) {
         const branchWriter = async (packets, config) => {
             const filteredPackets = packets.filter((p) => p !== constants_js_1.END);
-            if (!filteredPackets.length) {
+            if (!filteredPackets.length)
                 return;
-            }
             const writes = filteredPackets.map((p) => {
-                if ((0, constants_js_1._isSend)(p)) {
+                if ((0, constants_js_1._isSend)(p))
                     return p;
-                }
-                return {
-                    channel: `branch:${start}:${name}:${p}`,
-                    value: start,
-                };
+                return { channel: p === constants_js_1.END ? p : `branch:to:${p}`, value: start };
             });
             await write_js_1.ChannelWrite.doWrite({ ...config, tags: (config.tags ?? []).concat([constants_js_1.TAG_HIDDEN]) }, writes);
         };
@@ -583,30 +633,32 @@ class CompiledStateGraph extends graph_js_1.CompiledGraph {
         options.withReader
             ? (config) => read_js_1.ChannelRead.doRead(config, this.streamChannels ?? this.outputChannels, true)
             : undefined));
-        // attach branch subscribers
-        const ends = branch.ends
-            ? Object.values(branch.ends)
-            : Object.keys(this.builder.nodes);
-        for (const end of ends) {
-            if (end === constants_js_1.END) {
-                continue;
-            }
-            const channelName = `branch:${start}:${name}:${end}`;
-            this.channels[channelName] =
-                new ephemeral_value_js_1.EphemeralValue(false);
-            this.nodes[end].triggers.push(channelName);
-        }
     }
     async _validateInput(input) {
-        const inputSchema = this.builder._inputRuntimeDefinition;
+        if (input == null)
+            return input;
+        const schema = (() => {
+            const input = this.builder._inputRuntimeDefinition;
+            const schema = this.builder._schemaRuntimeDefinition;
+            const apply = (schema) => {
+                if (schema == null)
+                    return undefined;
+                return (0, state_js_1.applyZodPlugin)(schema, { reducer: true });
+            };
+            if ((0, state_js_1.isAnyZodObject)(input))
+                return apply(input);
+            if (input === PartialStateSchema)
+                return apply(schema)?.partial();
+            return undefined;
+        })();
         if ((0, constants_js_1.isCommand)(input)) {
             const parsedInput = input;
-            if (input.update && (0, state_js_1.isAnyZodObject)(inputSchema))
-                parsedInput.update = inputSchema.parse(input.update);
+            if (input.update && schema != null)
+                parsedInput.update = schema.parse(input.update);
             return parsedInput;
         }
-        if ((0, state_js_1.isAnyZodObject)(inputSchema))
-            return inputSchema.parse(input);
+        if (schema != null)
+            return schema.parse(input);
         return input;
     }
     async _validateConfigurable(config) {
@@ -707,4 +759,10 @@ function _getControlBranch() {
         path: CONTROL_BRANCH_PATH,
     });
 }
+function typedNode(_state, _options) {
+    return (func, options) => {
+        Object.assign(func, { [Symbol.for("langgraph.state.node")]: options });
+        return func;
+    };
+}
 //# sourceMappingURL=state.js.map

package/dist/graph/state.d.ts

@@ -1,10 +1,10 @@
 import { RunnableLike } from "@langchain/core/runnables";
-import { All, BaseCheckpointSaver, BaseStore } from "@langchain/langgraph-checkpoint";
+import { All, type BaseCache, BaseCheckpointSaver, BaseStore } from "@langchain/langgraph-checkpoint";
 import { BaseChannel } from "../channels/base.js";
 import { CompiledGraph, Graph, Branch, AddNodeOptions, NodeSpec } from "./graph.js";
-import { END, START } from "../constants.js";
+import { Command, END, START } from "../constants.js";
 import { AnnotationRoot, SingleReducer, StateDefinition, StateType, UpdateType } from "./annotation.js";
-import type { RetryPolicy } from "../pregel/utils/index.js";
+import type { CachePolicy, RetryPolicy } from "../pregel/utils/index.js";
 import { ManagedValueSpec } from "../managed/base.js";
 import type { LangGraphRunnableConfig } from "../pregel/runnable_types.js";
 import { AnyZodObject, ZodToStateDefinition } from "./zod/state.js";
@@ -21,11 +21,13 @@ export interface StateGraphArgs<Channels extends object | unknown> {
 export type StateGraphNodeSpec<RunInput, RunOutput> = NodeSpec<RunInput, RunOutput> & {
     input?: StateDefinition;
     retryPolicy?: RetryPolicy;
+    cachePolicy?: CachePolicy;
 };
-export type StateGraphAddNodeOptions = {
+export type StateGraphAddNodeOptions<Nodes extends string = string> = {
     retryPolicy?: RetryPolicy;
-    input?: AnnotationRoot<any>;
-} & AddNodeOptions;
+    cachePolicy?: CachePolicy | boolean;
+    input?: AnnotationRoot<any> | AnyZodObject;
+} & AddNodeOptions<Nodes>;
 export type StateGraphArgsWithStateSchema<SD extends StateDefinition, I extends StateDefinition, O extends StateDefinition> = {
     stateSchema: AnnotationRoot<SD>;
     input?: AnnotationRoot<I>;
@@ -42,6 +44,10 @@ type ZodStateGraphArgsWithStateSchema<SD extends AnyZodObject, I extends SDZod,
 };
 type SDZod = StateDefinition | AnyZodObject;
 type ToStateDefinition<T> = T extends AnyZodObject ? ZodToStateDefinition<T> : T extends StateDefinition ? T : never;
+type NodeAction<S, U, C extends SDZod> = RunnableLike<S, U extends object ? U & Record<string, any> : U, // eslint-disable-line @typescript-eslint/no-explicit-any
+LangGraphRunnableConfig<StateType<ToStateDefinition<C>>>>;
+declare const PartialStateSchema: unique symbol;
+type PartialStateSchema = typeof PartialStateSchema;
 /**
  * A graph whose nodes communicate by reading and writing to a shared state.
  * Each node takes a defined `State` as input and returns a `Partial<State>`.
@@ -114,7 +120,7 @@ export declare class StateGraph<SD extends SDZod | unknown, S = SD extends SDZod
     /** @internal */
     _inputDefinition: I;
     /** @internal */
-    _inputRuntimeDefinition: AnyZodObject | undefined;
+    _inputRuntimeDefinition: AnyZodObject | PartialStateSchema | undefined;
     /** @internal */
     _outputDefinition: O;
     /** @internal */
@@ -133,11 +139,23 @@ export declare class StateGraph<SD extends SDZod | unknown, S = SD extends SDZod
     constructor(fields: SD extends AnyZodObject ? SD | ZodStateGraphArgsWithStateSchema<SD, I, O> : never, configSchema?: C | AnnotationRoot<ToStateDefinition<C>>);
     get allEdges(): Set<[string, string]>;
     _addSchema(stateDefinition: SDZod): void;
-    addNode<K extends string, NodeInput = S>(key: K, action: RunnableLike<NodeInput, U extends object ? U & Record<string, any> : U, LangGraphRunnableConfig<StateType<ToStateDefinition<C>>>>, options?: StateGraphAddNodeOptions): StateGraph<SD, S, U, N | K, I, O, C>;
+    addNode<K extends string>(nodes: Record<K, NodeAction<S, U, C>> | [
+        key: K,
+        action: NodeAction<S, U, C>,
+        options?: StateGraphAddNodeOptions
+    ][]): StateGraph<SD, S, U, N | K, I, O, C>;
+    addNode<K extends string, NodeInput = S>(key: K, action: NodeAction<NodeInput, U, C>, options?: StateGraphAddNodeOptions): StateGraph<SD, S, U, N | K, I, O, C>;
     addEdge(startKey: typeof START | N | N[], endKey: N | typeof END): this;
-    compile({ checkpointer, store, interruptBefore, interruptAfter, name, }?: {
+    addSequence<K extends string>(nodes: [
+        key: K,
+        action: NodeAction<S, U, C>,
+        options?: StateGraphAddNodeOptions
+    ][]): StateGraph<SD, S, U, N | K, I, O, C>;
+    addSequence<K extends string>(nodes: Record<K, NodeAction<S, U, C>>): StateGraph<SD, S, U, N | K, I, O, C>;
+    compile({ checkpointer, store, cache, interruptBefore, interruptAfter, name, }?: {
         checkpointer?: BaseCheckpointSaver | false;
         store?: BaseStore;
+        cache?: BaseCache;
         interruptBefore?: N[] | All;
         interruptAfter?: N[] | All;
         name?: string;
@@ -152,11 +170,18 @@ export declare class CompiledStateGraph<S, U, N extends string = typeof START, I
     builder: StateGraph<unknown, S, U, N, I, O, C>;
     attachNode(key: typeof START, node?: never): void;
     attachNode(key: N, node: StateGraphNodeSpec<S, U>): void;
-    attachEdge(start: N | N[] | "__start__", end: N | "__end__"): void;
-    attachBranch(start: N | typeof START, name: string, branch: Branch<S, N>, options?: {
+    attachEdge(starts: N | N[] | "__start__", end: N | "__end__"): void;
+    attachBranch(start: N | typeof START, _: string, branch: Branch<S, N>, options?: {
         withReader?: boolean;
     }): void;
     protected _validateInput(input: UpdateType<ToStateDefinition<I>>): Promise<UpdateType<ToStateDefinition<I>>>;
     protected _validateConfigurable(config: Partial<LangGraphRunnableConfig["configurable"]>): Promise<LangGraphRunnableConfig["configurable"]>;
 }
+type TypedNodeAction<SD extends StateDefinition, Nodes extends string> = (state: StateType<SD>, config: LangGraphRunnableConfig) => UpdateType<SD> | Command<unknown, UpdateType<SD>, Nodes>;
+export declare function typedNode<SD extends SDZod, Nodes extends string>(_state: SD extends StateDefinition ? AnnotationRoot<SD> : never, _options?: {
+    nodes?: Nodes[];
+}): (func: TypedNodeAction<ToStateDefinition<SD>, Nodes>, options?: StateGraphAddNodeOptions<Nodes>) => TypedNodeAction<ToStateDefinition<SD>, Nodes>;
+export declare function typedNode<SD extends SDZod, Nodes extends string>(_state: SD extends AnyZodObject ? SD : never, _options?: {
+    nodes?: Nodes[];
+}): (func: TypedNodeAction<ToStateDefinition<SD>, Nodes>, options?: StateGraphAddNodeOptions<Nodes>) => TypedNodeAction<ToStateDefinition<SD>, Nodes>;
 export {};