@langchain/langgraph 1.0.7 → 1.0.12

package/dist/constants.d.cts

@@ -1,285 +0,0 @@
-import { PendingWrite } from "@langchain/langgraph-checkpoint";
-
-//#region src/constants.d.ts
-/** Special reserved node name denoting the start of a graph. */
-declare const START = "__start__";
-/** Special reserved node name denoting the end of a graph. */
-declare const END = "__end__";
-/** Special channel reserved for graph interrupts */
-declare const INTERRUPT = "__interrupt__";
-/** Special channel reserved for graph resume */
-
-/** Special channel reserved for graph previous state */
-declare const PREVIOUS = "__previous__";
-/** @internal */
-declare const COMMAND_SYMBOL: unique symbol;
-/**
- * Instance of a {@link Command} class.
- *
- * This is used to avoid IntelliSense suggesting public fields
- * of {@link Command} class when a plain object is expected.
- *
- * @see {@link Command}
- * @internal
- */
-declare class CommandInstance<Resume = unknown, Update extends Record<string, unknown> = Record<string, unknown>, Nodes extends string = string> {
-  [COMMAND_SYMBOL]: CommandParams<Resume, Update, Nodes>;
-  constructor(args: CommandParams<Resume, Update, Nodes>);
-}
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-interface SendInterface<Node extends string = string, Args = any> {
-  node: Node;
-  args: Args;
-}
-/**
- *
- * 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`] }
- * ```
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-declare class Send<Node extends string = string, Args = any> implements SendInterface<Node, Args> {
-  lg_name: string;
-  node: Node;
-  args: Args;
-  constructor(node: Node, args: Args);
-  toJSON(): {
-    lg_name: string;
-    node: Node;
-    args: Args;
-  };
-}
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type Interrupt<Value = any> = {
-  id?: string;
-  value?: Value;
-};
-/**
- * Checks if the given graph invoke / stream chunk contains interrupt.
- *
- * @example
- * ```ts
- * import { INTERRUPT, isInterrupted } from "@langchain/langgraph";
- *
- * const values = await graph.invoke({ foo: "bar" });
- * if (isInterrupted<string>(values)) {
- *   const interrupt = values[INTERRUPT][0].value;
- * }
- * ```
- *
- * @param values - The values to check.
- * @returns `true` if the values contain an interrupt, `false` otherwise.
- */
-declare function isInterrupted<Value = unknown>(values: unknown): values is {
-  [INTERRUPT]: Interrupt<Value>[];
-};
-type CommandParams<Resume = unknown, Update extends Record<string, unknown> = Record<string, unknown>, Nodes extends string = string> = {
-  /**
-   * A discriminator field used to identify the type of object. Must be populated when serializing.
-   *
-   * Optional because it's not required to specify this when directly constructing a {@link Command}
-   * object.
-   */
-  lg_name?: "Command";
-  /**
-   * Value to resume execution with. To be used together with {@link interrupt}.
-   */
-  resume?: Resume;
-  /**
-   * Graph to send the command to. Supported values are:
-   *   - None: the current graph (default)
-   *   - The specific name of the graph to send the command to
-   *   - {@link Command.PARENT}: closest parent graph (only supported when returned from a node in a subgraph)
-   */
-  graph?: string;
-  /**
-   * Update to apply to the graph's state.
-   */
-  update?: Update | [string, unknown][];
-  /**
-   * Can be one of the following:
-   *   - name of the node to navigate to next (any node that belongs to the specified `graph`)
-   *   - sequence of node names to navigate to next
-   *   - `Send` object (to execute a node with the input provided)
-   *   - sequence of `Send` objects
-   */
-  goto?: Nodes | SendInterface<Nodes> // eslint-disable-line @typescript-eslint/no-explicit-any
-  | (Nodes | SendInterface<Nodes>)[]; // eslint-disable-line @typescript-eslint/no-explicit-any
-};
-/**
- * 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' }
- * ```
- */
-declare class Command<Resume = unknown, Update extends Record<string, unknown> = Record<string, unknown>, Nodes extends string = string> extends CommandInstance<Resume, Update, Nodes> {
-  readonly lg_name: string;
-  lc_direct_tool_output: boolean;
-  /**
-   * Graph to send the command to. Supported values are:
-   *   - None: the current graph (default)
-   *   - The specific name of the graph to send the command to
-   *   - {@link Command.PARENT}: closest parent graph (only supported when returned from a node in a subgraph)
-   */
-  graph?: string;
-  /**
-   * Update to apply to the graph's state as a result of executing the node that is returning the command.
-   * Written to the state as if the node had simply returned this value instead of the Command object.
-   */
-  update?: Update | [string, unknown][];
-  /**
-   * Value to resume execution with. To be used together with {@link interrupt}.
-   */
-  resume?: Resume;
-  /**
-   * Can be one of the following:
-   *   - name of the node to navigate to next (any node that belongs to the specified `graph`)
-   *   - sequence of node names to navigate to next
-   *   - {@link Send} object (to execute a node with the exact input provided in the {@link Send} object)
-   *   - sequence of {@link Send} objects
-   */
-  goto?: Nodes | Send<Nodes> | (Nodes | Send<Nodes>)[];
-  static PARENT: string;
-  constructor(args: Omit<CommandParams<Resume, Update, Nodes>, "lg_name">);
-  /**
-   * Convert the update field to a list of {@link PendingWrite} tuples
-   * @returns List of {@link PendingWrite} tuples of the form `[channelKey, value]`.
-   * @internal
-   */
-  _updateAsTuples(): PendingWrite[];
-  toJSON(): {
-    lg_name: string;
-    update: Update | [string, unknown][] | undefined;
-    resume: Resume | undefined;
-    goto: Nodes | (Nodes | {
-      lg_name: string;
-      node: Nodes;
-      args: any;
-    })[] | {
-      lg_name: string;
-      node: Nodes;
-      args: any;
-    } | undefined;
-  };
-}
-/**
- * A type guard to check if the given value is a {@link Command}.
- *
- * Useful for type narrowing when working with the {@link Command} object.
- *
- * @param x - The value to check.
- * @returns `true` if the value is a {@link Command}, `false` otherwise.
- */
-declare function isCommand(x: unknown): x is Command;
-/**
- * Reconstructs Command and Send objects from a deeply nested tree of anonymous objects
- * matching their interfaces.
- *
- * This is only exported for testing purposes. It is NOT intended to be used outside of
- * the Command and Send classes.
- *
- * @internal
- *
- * @param x - The command send tree to convert.
- * @param seen - A map of seen objects to avoid infinite loops.
- * @returns The converted command send tree.
- */
-//#endregion
-export { Command, CommandInstance, CommandParams, END, INTERRUPT, Interrupt, PREVIOUS, START, Send, isCommand, isInterrupted };
-//# sourceMappingURL=constants.d.cts.map

package/dist/constants.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.d.cts","names":["PendingWrite","START","END","INPUT","COPY","ERROR","CACHE_NS_WRITES","CONFIG_KEY_SEND","CONFIG_KEY_CALL","CONFIG_KEY_READ","CONFIG_KEY_CHECKPOINTER","CONFIG_KEY_RESUMING","CONFIG_KEY_TASK_ID","CONFIG_KEY_STREAM","CONFIG_KEY_RESUME_VALUE","CONFIG_KEY_RESUME_MAP","CONFIG_KEY_SCRATCHPAD","CONFIG_KEY_PREVIOUS_STATE","CONFIG_KEY_DURABILITY","CONFIG_KEY_CHECKPOINT_ID","CONFIG_KEY_CHECKPOINT_NS","CONFIG_KEY_NODE_FINISHED","CONFIG_KEY_CHECKPOINT_MAP","CONFIG_KEY_ABORT_SIGNALS","INTERRUPT","RESUME","NO_WRITES","RETURN","PREVIOUS","RUNTIME_PLACEHOLDER","RECURSION_LIMIT_DEFAULT","TAG_HIDDEN","TAG_NOSTREAM","SELF","TASKS","PUSH","PULL","TASK_NAMESPACE","NULL_TASK_ID","RESERVED","CHECKPOINT_NAMESPACE_SEPARATOR","CHECKPOINT_NAMESPACE_END","COMMAND_SYMBOL","CommandInstance","Record","Resume","Update","Nodes","CommandParams","SendInterface","Node","Args","_isSendInterface","Send","_isSend","Interrupt","Value","isInterrupted","Command","Omit","isCommand","_deserializeCommandSendObjectGraph","Map"],"sources":["../src/constants.d.ts"],"sourcesContent":["import { PendingWrite } from \"@langchain/langgraph-checkpoint\";\n/** Special reserved node name denoting the start of a graph. */\nexport declare const START = \"__start__\";\n/** Special reserved node name denoting the end of a graph. */\nexport declare const END = \"__end__\";\nexport declare const INPUT = \"__input__\";\nexport declare const COPY = \"__copy__\";\nexport declare const ERROR = \"__error__\";\n/** Special reserved cache namespaces */\nexport declare const CACHE_NS_WRITES = \"__pregel_ns_writes\";\nexport declare const CONFIG_KEY_SEND = \"__pregel_send\";\n/** config key containing function used to call a node (push task) */\nexport declare const CONFIG_KEY_CALL = \"__pregel_call\";\nexport declare const CONFIG_KEY_READ = \"__pregel_read\";\nexport declare const CONFIG_KEY_CHECKPOINTER = \"__pregel_checkpointer\";\nexport declare const CONFIG_KEY_RESUMING = \"__pregel_resuming\";\nexport declare const CONFIG_KEY_TASK_ID = \"__pregel_task_id\";\nexport declare const CONFIG_KEY_STREAM = \"__pregel_stream\";\nexport declare const CONFIG_KEY_RESUME_VALUE = \"__pregel_resume_value\";\nexport declare const CONFIG_KEY_RESUME_MAP = \"__pregel_resume_map\";\nexport declare const CONFIG_KEY_SCRATCHPAD = \"__pregel_scratchpad\";\n/** config key containing state from previous invocation of graph for the given thread */\nexport declare const CONFIG_KEY_PREVIOUS_STATE = \"__pregel_previous\";\nexport declare const CONFIG_KEY_DURABILITY = \"__pregel_durability\";\nexport declare const CONFIG_KEY_CHECKPOINT_ID = \"checkpoint_id\";\nexport declare const CONFIG_KEY_CHECKPOINT_NS = \"checkpoint_ns\";\nexport declare const CONFIG_KEY_NODE_FINISHED = \"__pregel_node_finished\";\n// this one is part of public API\nexport declare const CONFIG_KEY_CHECKPOINT_MAP = \"checkpoint_map\";\nexport declare const CONFIG_KEY_ABORT_SIGNALS = \"__pregel_abort_signals\";\n/** Special channel reserved for graph interrupts */\nexport declare const INTERRUPT = \"__interrupt__\";\n/** Special channel reserved for graph resume */\nexport declare const RESUME = \"__resume__\";\n/** Special channel reserved for cases when a task exits without any writes */\nexport declare const NO_WRITES = \"__no_writes__\";\n/** Special channel reserved for graph return */\nexport declare const RETURN = \"__return__\";\n/** Special channel reserved for graph previous state */\nexport declare const PREVIOUS = \"__previous__\";\nexport declare const RUNTIME_PLACEHOLDER = \"__pregel_runtime_placeholder__\";\nexport declare const RECURSION_LIMIT_DEFAULT = 25;\nexport declare const TAG_HIDDEN = \"langsmith:hidden\";\nexport declare const TAG_NOSTREAM = \"langsmith:nostream\";\nexport declare const SELF = \"__self__\";\nexport declare const TASKS = \"__pregel_tasks\";\nexport declare const PUSH = \"__pregel_push\";\nexport declare const PULL = \"__pregel_pull\";\nexport declare const TASK_NAMESPACE = \"6ba7b831-9dad-11d1-80b4-00c04fd430c8\";\nexport declare const NULL_TASK_ID = \"00000000-0000-0000-0000-000000000000\";\nexport declare const RESERVED: string[];\nexport declare const CHECKPOINT_NAMESPACE_SEPARATOR = \"|\";\nexport declare const CHECKPOINT_NAMESPACE_END = \":\";\n/** @internal */\ndeclare const COMMAND_SYMBOL: unique symbol;\n/**\n * Instance of a {@link Command} class.\n *\n * This is used to avoid IntelliSense suggesting public fields\n * of {@link Command} class when a plain object is expected.\n *\n * @see {@link Command}\n * @internal\n */\nexport declare class CommandInstance<Resume = unknown, Update extends Record<string, unknown> = Record<string, unknown>, Nodes extends string = string> {\n    [COMMAND_SYMBOL]: CommandParams<Resume, Update, Nodes>;\n    constructor(args: CommandParams<Resume, Update, Nodes>);\n}\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport interface SendInterface<Node extends string = string, Args = any> {\n    node: Node;\n    args: Args;\n}\nexport declare function _isSendInterface(x: unknown): x is SendInterface;\n/**\n *\n * A message or packet to send to a specific node in the graph.\n *\n * The `Send` class is used within a `StateGraph`'s conditional edges to\n * dynamically invoke a node with a custom state at the next step.\n *\n * Importantly, the sent state can differ from the core graph's state,\n * allowing for flexible and dynamic workflow management.\n *\n * One such example is a \"map-reduce\" workflow where your graph invokes\n * the same node multiple times in parallel with different states,\n * before aggregating the results back into the main graph's state.\n *\n * @example\n * ```typescript\n * import { Annotation, Send, StateGraph } from \"@langchain/langgraph\";\n *\n * const ChainState = Annotation.Root({\n *   subjects: Annotation<string[]>,\n *   jokes: Annotation<string[]>({\n *     reducer: (a, b) => a.concat(b),\n *   }),\n * });\n *\n * const continueToJokes = async (state: typeof ChainState.State) => {\n *   return state.subjects.map((subject) => {\n *     return new Send(\"generate_joke\", { subjects: [subject] });\n *   });\n * };\n *\n * const graph = new StateGraph(ChainState)\n *   .addNode(\"generate_joke\", (state) => ({\n *     jokes: [`Joke about ${state.subjects}`],\n *   }))\n *   .addConditionalEdges(\"__start__\", continueToJokes)\n *   .addEdge(\"generate_joke\", \"__end__\")\n *   .compile();\n *\n * const res = await graph.invoke({ subjects: [\"cats\", \"dogs\"] });\n * console.log(res);\n *\n * // Invoking with two subjects results in a generated joke for each\n * // { subjects: [\"cats\", \"dogs\"], jokes: [`Joke about cats`, `Joke about dogs`] }\n * ```\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport declare class Send<Node extends string = string, Args = any> implements SendInterface<Node, Args> {\n    lg_name: string;\n    node: Node;\n    args: Args;\n    constructor(node: Node, args: Args);\n    toJSON(): {\n        lg_name: string;\n        node: Node;\n        args: Args;\n    };\n}\nexport declare function _isSend(x: unknown): x is Send;\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type Interrupt<Value = any> = {\n    id?: string;\n    value?: Value;\n};\n/**\n * Checks if the given graph invoke / stream chunk contains interrupt.\n *\n * @example\n * ```ts\n * import { INTERRUPT, isInterrupted } from \"@langchain/langgraph\";\n *\n * const values = await graph.invoke({ foo: \"bar\" });\n * if (isInterrupted<string>(values)) {\n *   const interrupt = values[INTERRUPT][0].value;\n * }\n * ```\n *\n * @param values - The values to check.\n * @returns `true` if the values contain an interrupt, `false` otherwise.\n */\nexport declare function isInterrupted<Value = unknown>(values: unknown): values is {\n    [INTERRUPT]: Interrupt<Value>[];\n};\nexport type CommandParams<Resume = unknown, Update extends Record<string, unknown> = Record<string, unknown>, Nodes extends string = string> = {\n    /**\n     * A discriminator field used to identify the type of object. Must be populated when serializing.\n     *\n     * Optional because it's not required to specify this when directly constructing a {@link Command}\n     * object.\n     */\n    lg_name?: \"Command\";\n    /**\n     * Value to resume execution with. To be used together with {@link interrupt}.\n     */\n    resume?: Resume;\n    /**\n     * Graph to send the command to. Supported values are:\n     *   - None: the current graph (default)\n     *   - The specific name of the graph to send the command to\n     *   - {@link Command.PARENT}: closest parent graph (only supported when returned from a node in a subgraph)\n     */\n    graph?: string;\n    /**\n     * Update to apply to the graph's state.\n     */\n    update?: Update | [string, unknown][];\n    /**\n     * Can be one of the following:\n     *   - name of the node to navigate to next (any node that belongs to the specified `graph`)\n     *   - sequence of node names to navigate to next\n     *   - `Send` object (to execute a node with the input provided)\n     *   - sequence of `Send` objects\n     */\n    goto?: Nodes | SendInterface<Nodes> // eslint-disable-line @typescript-eslint/no-explicit-any\n     | (Nodes | SendInterface<Nodes>)[]; // eslint-disable-line @typescript-eslint/no-explicit-any\n};\n/**\n * One or more commands to update the graph's state and send messages to nodes.\n * Can be used to combine routing logic with state updates in lieu of conditional edges\n *\n * @example\n * ```ts\n * import { Annotation, Command } from \"@langchain/langgraph\";\n *\n * // Define graph state\n * const StateAnnotation = Annotation.Root({\n *   foo: Annotation<string>,\n * });\n *\n * // Define the nodes\n * const nodeA = async (_state: typeof StateAnnotation.State) => {\n *   console.log(\"Called A\");\n *   // this is a replacement for a real conditional edge function\n *   const goto = Math.random() > .5 ? \"nodeB\" : \"nodeC\";\n *   // note how Command allows you to BOTH update the graph state AND route to the next node\n *   return new Command({\n *     // this is the state update\n *     update: {\n *       foo: \"a\",\n *     },\n *     // this is a replacement for an edge\n *     goto,\n *   });\n * };\n *\n * // Nodes B and C are unchanged\n * const nodeB = async (state: typeof StateAnnotation.State) => {\n *   console.log(\"Called B\");\n *   return {\n *     foo: state.foo + \"|b\",\n *   };\n * }\n *\n * const nodeC = async (state: typeof StateAnnotation.State) => {\n *   console.log(\"Called C\");\n *   return {\n *     foo: state.foo + \"|c\",\n *   };\n * }\n *\n * import { StateGraph } from \"@langchain/langgraph\";\n\n * // NOTE: there are no edges between nodes A, B and C!\n * const graph = new StateGraph(StateAnnotation)\n *   .addNode(\"nodeA\", nodeA, {\n *     ends: [\"nodeB\", \"nodeC\"],\n *   })\n *   .addNode(\"nodeB\", nodeB)\n *   .addNode(\"nodeC\", nodeC)\n *   .addEdge(\"__start__\", \"nodeA\")\n *   .compile();\n *\n * await graph.invoke({ foo: \"\" });\n *\n * // Randomly oscillates between\n * // { foo: 'a|c' } and { foo: 'a|b' }\n * ```\n */\nexport declare class Command<Resume = unknown, Update extends Record<string, unknown> = Record<string, unknown>, Nodes extends string = string> extends CommandInstance<Resume, Update, Nodes> {\n    readonly lg_name: string;\n    lc_direct_tool_output: boolean;\n    /**\n     * Graph to send the command to. Supported values are:\n     *   - None: the current graph (default)\n     *   - The specific name of the graph to send the command to\n     *   - {@link Command.PARENT}: closest parent graph (only supported when returned from a node in a subgraph)\n     */\n    graph?: string;\n    /**\n     * Update to apply to the graph's state as a result of executing the node that is returning the command.\n     * Written to the state as if the node had simply returned this value instead of the Command object.\n     */\n    update?: Update | [string, unknown][];\n    /**\n     * Value to resume execution with. To be used together with {@link interrupt}.\n     */\n    resume?: Resume;\n    /**\n     * Can be one of the following:\n     *   - name of the node to navigate to next (any node that belongs to the specified `graph`)\n     *   - sequence of node names to navigate to next\n     *   - {@link Send} object (to execute a node with the exact input provided in the {@link Send} object)\n     *   - sequence of {@link Send} objects\n     */\n    goto?: Nodes | Send<Nodes> | (Nodes | Send<Nodes>)[];\n    static PARENT: string;\n    constructor(args: Omit<CommandParams<Resume, Update, Nodes>, \"lg_name\">);\n    /**\n     * Convert the update field to a list of {@link PendingWrite} tuples\n     * @returns List of {@link PendingWrite} tuples of the form `[channelKey, value]`.\n     * @internal\n     */\n    _updateAsTuples(): PendingWrite[];\n    toJSON(): {\n        lg_name: string;\n        update: Update | [string, unknown][] | undefined;\n        resume: Resume | undefined;\n        goto: Nodes | (Nodes | {\n            lg_name: string;\n            node: Nodes;\n            args: any;\n        })[] | {\n            lg_name: string;\n            node: Nodes;\n            args: any;\n        } | undefined;\n    };\n}\n/**\n * A type guard to check if the given value is a {@link Command}.\n *\n * Useful for type narrowing when working with the {@link Command} object.\n *\n * @param x - The value to check.\n * @returns `true` if the value is a {@link Command}, `false` otherwise.\n */\nexport declare function isCommand(x: unknown): x is Command;\n/**\n * Reconstructs Command and Send objects from a deeply nested tree of anonymous objects\n * matching their interfaces.\n *\n * This is only exported for testing purposes. It is NOT intended to be used outside of\n * the Command and Send classes.\n *\n * @internal\n *\n * @param x - The command send tree to convert.\n * @param seen - A map of seen objects to avoid infinite loops.\n * @returns The converted command send tree.\n */\nexport declare function _deserializeCommandSendObjectGraph(x: unknown, seen?: Map<object, unknown>): unknown;\nexport {};\n"],"mappings":";;;;cAEqBC,KAAAA;AAArB;AAEqBC,cAAAA,GAAAA,GAAG,SAAA;;AAuHdgD,cA5FW1B,SAAAA,GA4FX0B,eAAAA;;;;AAWEK,cA/FS3B,QAAAA,GAiGT4B,cAAAA;;cAlFEd,cAqIKO,EAAAA,OAAAA,MAAAA;;;;;AAiEnB;;;;;AAAgLH,cA5L3JH,eA4L2JG,CAAAA,SAAAA,OAAAA,EAAAA,eA5L1GF,MA4L0GE,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,GA5LhFF,MA4LgFE,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,EAAAA,cAAAA,MAAAA,GAAAA,MAAAA,CAAAA,CAAAA;GA3L3KJ,cAAAA,CA2LmLK,EA3LlKC,aA2LkKD,CA3LpJF,MA2LoJE,EA3L5ID,MA2L4IC,EA3LpIA,KA2LoIA,CAAAA;aAc3KD,CAAAA,IAAAA,EAxMSE,aAwMTF,CAxMuBD,MAwMvBC,EAxM+BA,MAwM/BA,EAxMuCC,KAwMvCD,CAAAA;;;AAYWC,UAjNPE,aAiNOF,CAAAA,aAAAA,MAAAA,GAAAA,MAAAA,EAAAA,OAAAA,GAAAA,CAAAA,CAAAA;MAALM,EAhNTH,IAgNSG;MAAeN,EA/MxBI,IA+MwBJ;;;;;;;;;;;;;;;;AAgClC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA7LqBM,0DAA0DJ,cAAcC,MAAMC;;QAEzFD;QACAC;oBACYD,YAAYC;;;UAGpBD;UACAC;;;;KAKFI;;UAEAC;;;;;;;;;;;;;;;;;;iBAkBYC;GACnBjC,SAAAA,GAAY+B,UAAUC;;KAEfR,+CAA+CJ,0BAA0BA;;;;;;;;;;;WAWxEC;;;;;;;;;;;WAWAC;;;;;;;;SAQFC,QAAQE,cAAcF;KACzBA,QAAQE,cAAcF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAgETW,yCAAyCd,0BAA0BA,gEAAgED,gBAAgBE,QAAQC,QAAQC;;;;;;;;;;;;;;WAc3KD;;;;WAIAD;;;;;;;;SAQFE,QAAQM,KAAKN,UAAUA,QAAQM,KAAKN;;oBAEzBY,KAAKX,cAAcH,QAAQC,QAAQC;;;;;;qBAMlC/C;;;YAGP8C;YACAD;UACFE,SAASA;;YAELA;;;;YAIAA;;;;;;;;;;;;;iBAaMa,SAAAA,mBAA4BF"}

package/dist/constants.d.ts

@@ -1,285 +0,0 @@
-import { PendingWrite } from "@langchain/langgraph-checkpoint";
-
-//#region src/constants.d.ts
-/** Special reserved node name denoting the start of a graph. */
-declare const START = "__start__";
-/** Special reserved node name denoting the end of a graph. */
-declare const END = "__end__";
-/** Special channel reserved for graph interrupts */
-declare const INTERRUPT = "__interrupt__";
-/** Special channel reserved for graph resume */
-
-/** Special channel reserved for graph previous state */
-declare const PREVIOUS = "__previous__";
-/** @internal */
-declare const COMMAND_SYMBOL: unique symbol;
-/**
- * Instance of a {@link Command} class.
- *
- * This is used to avoid IntelliSense suggesting public fields
- * of {@link Command} class when a plain object is expected.
- *
- * @see {@link Command}
- * @internal
- */
-declare class CommandInstance<Resume = unknown, Update extends Record<string, unknown> = Record<string, unknown>, Nodes extends string = string> {
-  [COMMAND_SYMBOL]: CommandParams<Resume, Update, Nodes>;
-  constructor(args: CommandParams<Resume, Update, Nodes>);
-}
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-interface SendInterface<Node extends string = string, Args = any> {
-  node: Node;
-  args: Args;
-}
-/**
- *
- * 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`] }
- * ```
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-declare class Send<Node extends string = string, Args = any> implements SendInterface<Node, Args> {
-  lg_name: string;
-  node: Node;
-  args: Args;
-  constructor(node: Node, args: Args);
-  toJSON(): {
-    lg_name: string;
-    node: Node;
-    args: Args;
-  };
-}
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type Interrupt<Value = any> = {
-  id?: string;
-  value?: Value;
-};
-/**
- * Checks if the given graph invoke / stream chunk contains interrupt.
- *
- * @example
- * ```ts
- * import { INTERRUPT, isInterrupted } from "@langchain/langgraph";
- *
- * const values = await graph.invoke({ foo: "bar" });
- * if (isInterrupted<string>(values)) {
- *   const interrupt = values[INTERRUPT][0].value;
- * }
- * ```
- *
- * @param values - The values to check.
- * @returns `true` if the values contain an interrupt, `false` otherwise.
- */
-declare function isInterrupted<Value = unknown>(values: unknown): values is {
-  [INTERRUPT]: Interrupt<Value>[];
-};
-type CommandParams<Resume = unknown, Update extends Record<string, unknown> = Record<string, unknown>, Nodes extends string = string> = {
-  /**
-   * A discriminator field used to identify the type of object. Must be populated when serializing.
-   *
-   * Optional because it's not required to specify this when directly constructing a {@link Command}
-   * object.
-   */
-  lg_name?: "Command";
-  /**
-   * Value to resume execution with. To be used together with {@link interrupt}.
-   */
-  resume?: Resume;
-  /**
-   * Graph to send the command to. Supported values are:
-   *   - None: the current graph (default)
-   *   - The specific name of the graph to send the command to
-   *   - {@link Command.PARENT}: closest parent graph (only supported when returned from a node in a subgraph)
-   */
-  graph?: string;
-  /**
-   * Update to apply to the graph's state.
-   */
-  update?: Update | [string, unknown][];
-  /**
-   * Can be one of the following:
-   *   - name of the node to navigate to next (any node that belongs to the specified `graph`)
-   *   - sequence of node names to navigate to next
-   *   - `Send` object (to execute a node with the input provided)
-   *   - sequence of `Send` objects
-   */
-  goto?: Nodes | SendInterface<Nodes> // eslint-disable-line @typescript-eslint/no-explicit-any
-  | (Nodes | SendInterface<Nodes>)[]; // eslint-disable-line @typescript-eslint/no-explicit-any
-};
-/**
- * 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' }
- * ```
- */
-declare class Command<Resume = unknown, Update extends Record<string, unknown> = Record<string, unknown>, Nodes extends string = string> extends CommandInstance<Resume, Update, Nodes> {
-  readonly lg_name: string;
-  lc_direct_tool_output: boolean;
-  /**
-   * Graph to send the command to. Supported values are:
-   *   - None: the current graph (default)
-   *   - The specific name of the graph to send the command to
-   *   - {@link Command.PARENT}: closest parent graph (only supported when returned from a node in a subgraph)
-   */
-  graph?: string;
-  /**
-   * Update to apply to the graph's state as a result of executing the node that is returning the command.
-   * Written to the state as if the node had simply returned this value instead of the Command object.
-   */
-  update?: Update | [string, unknown][];
-  /**
-   * Value to resume execution with. To be used together with {@link interrupt}.
-   */
-  resume?: Resume;
-  /**
-   * Can be one of the following:
-   *   - name of the node to navigate to next (any node that belongs to the specified `graph`)
-   *   - sequence of node names to navigate to next
-   *   - {@link Send} object (to execute a node with the exact input provided in the {@link Send} object)
-   *   - sequence of {@link Send} objects
-   */
-  goto?: Nodes | Send<Nodes> | (Nodes | Send<Nodes>)[];
-  static PARENT: string;
-  constructor(args: Omit<CommandParams<Resume, Update, Nodes>, "lg_name">);
-  /**
-   * Convert the update field to a list of {@link PendingWrite} tuples
-   * @returns List of {@link PendingWrite} tuples of the form `[channelKey, value]`.
-   * @internal
-   */
-  _updateAsTuples(): PendingWrite[];
-  toJSON(): {
-    lg_name: string;
-    update: Update | [string, unknown][] | undefined;
-    resume: Resume | undefined;
-    goto: Nodes | (Nodes | {
-      lg_name: string;
-      node: Nodes;
-      args: any;
-    })[] | {
-      lg_name: string;
-      node: Nodes;
-      args: any;
-    } | undefined;
-  };
-}
-/**
- * A type guard to check if the given value is a {@link Command}.
- *
- * Useful for type narrowing when working with the {@link Command} object.
- *
- * @param x - The value to check.
- * @returns `true` if the value is a {@link Command}, `false` otherwise.
- */
-declare function isCommand(x: unknown): x is Command;
-/**
- * Reconstructs Command and Send objects from a deeply nested tree of anonymous objects
- * matching their interfaces.
- *
- * This is only exported for testing purposes. It is NOT intended to be used outside of
- * the Command and Send classes.
- *
- * @internal
- *
- * @param x - The command send tree to convert.
- * @param seen - A map of seen objects to avoid infinite loops.
- * @returns The converted command send tree.
- */
-//#endregion
-export { Command, CommandInstance, CommandParams, END, INTERRUPT, Interrupt, PREVIOUS, START, Send, isCommand, isInterrupted };
-//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.d.ts","names":["PendingWrite","START","END","INPUT","COPY","ERROR","CACHE_NS_WRITES","CONFIG_KEY_SEND","CONFIG_KEY_CALL","CONFIG_KEY_READ","CONFIG_KEY_CHECKPOINTER","CONFIG_KEY_RESUMING","CONFIG_KEY_TASK_ID","CONFIG_KEY_STREAM","CONFIG_KEY_RESUME_VALUE","CONFIG_KEY_RESUME_MAP","CONFIG_KEY_SCRATCHPAD","CONFIG_KEY_PREVIOUS_STATE","CONFIG_KEY_DURABILITY","CONFIG_KEY_CHECKPOINT_ID","CONFIG_KEY_CHECKPOINT_NS","CONFIG_KEY_NODE_FINISHED","CONFIG_KEY_CHECKPOINT_MAP","CONFIG_KEY_ABORT_SIGNALS","INTERRUPT","RESUME","NO_WRITES","RETURN","PREVIOUS","RUNTIME_PLACEHOLDER","RECURSION_LIMIT_DEFAULT","TAG_HIDDEN","TAG_NOSTREAM","SELF","TASKS","PUSH","PULL","TASK_NAMESPACE","NULL_TASK_ID","RESERVED","CHECKPOINT_NAMESPACE_SEPARATOR","CHECKPOINT_NAMESPACE_END","COMMAND_SYMBOL","CommandInstance","Record","Resume","Update","Nodes","CommandParams","SendInterface","Node","Args","_isSendInterface","Send","_isSend","Interrupt","Value","isInterrupted","Command","Omit","isCommand","_deserializeCommandSendObjectGraph","Map"],"sources":["../src/constants.d.ts"],"sourcesContent":["import { PendingWrite } from \"@langchain/langgraph-checkpoint\";\n/** Special reserved node name denoting the start of a graph. */\nexport declare const START = \"__start__\";\n/** Special reserved node name denoting the end of a graph. */\nexport declare const END = \"__end__\";\nexport declare const INPUT = \"__input__\";\nexport declare const COPY = \"__copy__\";\nexport declare const ERROR = \"__error__\";\n/** Special reserved cache namespaces */\nexport declare const CACHE_NS_WRITES = \"__pregel_ns_writes\";\nexport declare const CONFIG_KEY_SEND = \"__pregel_send\";\n/** config key containing function used to call a node (push task) */\nexport declare const CONFIG_KEY_CALL = \"__pregel_call\";\nexport declare const CONFIG_KEY_READ = \"__pregel_read\";\nexport declare const CONFIG_KEY_CHECKPOINTER = \"__pregel_checkpointer\";\nexport declare const CONFIG_KEY_RESUMING = \"__pregel_resuming\";\nexport declare const CONFIG_KEY_TASK_ID = \"__pregel_task_id\";\nexport declare const CONFIG_KEY_STREAM = \"__pregel_stream\";\nexport declare const CONFIG_KEY_RESUME_VALUE = \"__pregel_resume_value\";\nexport declare const CONFIG_KEY_RESUME_MAP = \"__pregel_resume_map\";\nexport declare const CONFIG_KEY_SCRATCHPAD = \"__pregel_scratchpad\";\n/** config key containing state from previous invocation of graph for the given thread */\nexport declare const CONFIG_KEY_PREVIOUS_STATE = \"__pregel_previous\";\nexport declare const CONFIG_KEY_DURABILITY = \"__pregel_durability\";\nexport declare const CONFIG_KEY_CHECKPOINT_ID = \"checkpoint_id\";\nexport declare const CONFIG_KEY_CHECKPOINT_NS = \"checkpoint_ns\";\nexport declare const CONFIG_KEY_NODE_FINISHED = \"__pregel_node_finished\";\n// this one is part of public API\nexport declare const CONFIG_KEY_CHECKPOINT_MAP = \"checkpoint_map\";\nexport declare const CONFIG_KEY_ABORT_SIGNALS = \"__pregel_abort_signals\";\n/** Special channel reserved for graph interrupts */\nexport declare const INTERRUPT = \"__interrupt__\";\n/** Special channel reserved for graph resume */\nexport declare const RESUME = \"__resume__\";\n/** Special channel reserved for cases when a task exits without any writes */\nexport declare const NO_WRITES = \"__no_writes__\";\n/** Special channel reserved for graph return */\nexport declare const RETURN = \"__return__\";\n/** Special channel reserved for graph previous state */\nexport declare const PREVIOUS = \"__previous__\";\nexport declare const RUNTIME_PLACEHOLDER = \"__pregel_runtime_placeholder__\";\nexport declare const RECURSION_LIMIT_DEFAULT = 25;\nexport declare const TAG_HIDDEN = \"langsmith:hidden\";\nexport declare const TAG_NOSTREAM = \"langsmith:nostream\";\nexport declare const SELF = \"__self__\";\nexport declare const TASKS = \"__pregel_tasks\";\nexport declare const PUSH = \"__pregel_push\";\nexport declare const PULL = \"__pregel_pull\";\nexport declare const TASK_NAMESPACE = \"6ba7b831-9dad-11d1-80b4-00c04fd430c8\";\nexport declare const NULL_TASK_ID = \"00000000-0000-0000-0000-000000000000\";\nexport declare const RESERVED: string[];\nexport declare const CHECKPOINT_NAMESPACE_SEPARATOR = \"|\";\nexport declare const CHECKPOINT_NAMESPACE_END = \":\";\n/** @internal */\ndeclare const COMMAND_SYMBOL: unique symbol;\n/**\n * Instance of a {@link Command} class.\n *\n * This is used to avoid IntelliSense suggesting public fields\n * of {@link Command} class when a plain object is expected.\n *\n * @see {@link Command}\n * @internal\n */\nexport declare class CommandInstance<Resume = unknown, Update extends Record<string, unknown> = Record<string, unknown>, Nodes extends string = string> {\n    [COMMAND_SYMBOL]: CommandParams<Resume, Update, Nodes>;\n    constructor(args: CommandParams<Resume, Update, Nodes>);\n}\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport interface SendInterface<Node extends string = string, Args = any> {\n    node: Node;\n    args: Args;\n}\nexport declare function _isSendInterface(x: unknown): x is SendInterface;\n/**\n *\n * A message or packet to send to a specific node in the graph.\n *\n * The `Send` class is used within a `StateGraph`'s conditional edges to\n * dynamically invoke a node with a custom state at the next step.\n *\n * Importantly, the sent state can differ from the core graph's state,\n * allowing for flexible and dynamic workflow management.\n *\n * One such example is a \"map-reduce\" workflow where your graph invokes\n * the same node multiple times in parallel with different states,\n * before aggregating the results back into the main graph's state.\n *\n * @example\n * ```typescript\n * import { Annotation, Send, StateGraph } from \"@langchain/langgraph\";\n *\n * const ChainState = Annotation.Root({\n *   subjects: Annotation<string[]>,\n *   jokes: Annotation<string[]>({\n *     reducer: (a, b) => a.concat(b),\n *   }),\n * });\n *\n * const continueToJokes = async (state: typeof ChainState.State) => {\n *   return state.subjects.map((subject) => {\n *     return new Send(\"generate_joke\", { subjects: [subject] });\n *   });\n * };\n *\n * const graph = new StateGraph(ChainState)\n *   .addNode(\"generate_joke\", (state) => ({\n *     jokes: [`Joke about ${state.subjects}`],\n *   }))\n *   .addConditionalEdges(\"__start__\", continueToJokes)\n *   .addEdge(\"generate_joke\", \"__end__\")\n *   .compile();\n *\n * const res = await graph.invoke({ subjects: [\"cats\", \"dogs\"] });\n * console.log(res);\n *\n * // Invoking with two subjects results in a generated joke for each\n * // { subjects: [\"cats\", \"dogs\"], jokes: [`Joke about cats`, `Joke about dogs`] }\n * ```\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport declare class Send<Node extends string = string, Args = any> implements SendInterface<Node, Args> {\n    lg_name: string;\n    node: Node;\n    args: Args;\n    constructor(node: Node, args: Args);\n    toJSON(): {\n        lg_name: string;\n        node: Node;\n        args: Args;\n    };\n}\nexport declare function _isSend(x: unknown): x is Send;\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type Interrupt<Value = any> = {\n    id?: string;\n    value?: Value;\n};\n/**\n * Checks if the given graph invoke / stream chunk contains interrupt.\n *\n * @example\n * ```ts\n * import { INTERRUPT, isInterrupted } from \"@langchain/langgraph\";\n *\n * const values = await graph.invoke({ foo: \"bar\" });\n * if (isInterrupted<string>(values)) {\n *   const interrupt = values[INTERRUPT][0].value;\n * }\n * ```\n *\n * @param values - The values to check.\n * @returns `true` if the values contain an interrupt, `false` otherwise.\n */\nexport declare function isInterrupted<Value = unknown>(values: unknown): values is {\n    [INTERRUPT]: Interrupt<Value>[];\n};\nexport type CommandParams<Resume = unknown, Update extends Record<string, unknown> = Record<string, unknown>, Nodes extends string = string> = {\n    /**\n     * A discriminator field used to identify the type of object. Must be populated when serializing.\n     *\n     * Optional because it's not required to specify this when directly constructing a {@link Command}\n     * object.\n     */\n    lg_name?: \"Command\";\n    /**\n     * Value to resume execution with. To be used together with {@link interrupt}.\n     */\n    resume?: Resume;\n    /**\n     * Graph to send the command to. Supported values are:\n     *   - None: the current graph (default)\n     *   - The specific name of the graph to send the command to\n     *   - {@link Command.PARENT}: closest parent graph (only supported when returned from a node in a subgraph)\n     */\n    graph?: string;\n    /**\n     * Update to apply to the graph's state.\n     */\n    update?: Update | [string, unknown][];\n    /**\n     * Can be one of the following:\n     *   - name of the node to navigate to next (any node that belongs to the specified `graph`)\n     *   - sequence of node names to navigate to next\n     *   - `Send` object (to execute a node with the input provided)\n     *   - sequence of `Send` objects\n     */\n    goto?: Nodes | SendInterface<Nodes> // eslint-disable-line @typescript-eslint/no-explicit-any\n     | (Nodes | SendInterface<Nodes>)[]; // eslint-disable-line @typescript-eslint/no-explicit-any\n};\n/**\n * One or more commands to update the graph's state and send messages to nodes.\n * Can be used to combine routing logic with state updates in lieu of conditional edges\n *\n * @example\n * ```ts\n * import { Annotation, Command } from \"@langchain/langgraph\";\n *\n * // Define graph state\n * const StateAnnotation = Annotation.Root({\n *   foo: Annotation<string>,\n * });\n *\n * // Define the nodes\n * const nodeA = async (_state: typeof StateAnnotation.State) => {\n *   console.log(\"Called A\");\n *   // this is a replacement for a real conditional edge function\n *   const goto = Math.random() > .5 ? \"nodeB\" : \"nodeC\";\n *   // note how Command allows you to BOTH update the graph state AND route to the next node\n *   return new Command({\n *     // this is the state update\n *     update: {\n *       foo: \"a\",\n *     },\n *     // this is a replacement for an edge\n *     goto,\n *   });\n * };\n *\n * // Nodes B and C are unchanged\n * const nodeB = async (state: typeof StateAnnotation.State) => {\n *   console.log(\"Called B\");\n *   return {\n *     foo: state.foo + \"|b\",\n *   };\n * }\n *\n * const nodeC = async (state: typeof StateAnnotation.State) => {\n *   console.log(\"Called C\");\n *   return {\n *     foo: state.foo + \"|c\",\n *   };\n * }\n *\n * import { StateGraph } from \"@langchain/langgraph\";\n\n * // NOTE: there are no edges between nodes A, B and C!\n * const graph = new StateGraph(StateAnnotation)\n *   .addNode(\"nodeA\", nodeA, {\n *     ends: [\"nodeB\", \"nodeC\"],\n *   })\n *   .addNode(\"nodeB\", nodeB)\n *   .addNode(\"nodeC\", nodeC)\n *   .addEdge(\"__start__\", \"nodeA\")\n *   .compile();\n *\n * await graph.invoke({ foo: \"\" });\n *\n * // Randomly oscillates between\n * // { foo: 'a|c' } and { foo: 'a|b' }\n * ```\n */\nexport declare class Command<Resume = unknown, Update extends Record<string, unknown> = Record<string, unknown>, Nodes extends string = string> extends CommandInstance<Resume, Update, Nodes> {\n    readonly lg_name: string;\n    lc_direct_tool_output: boolean;\n    /**\n     * Graph to send the command to. Supported values are:\n     *   - None: the current graph (default)\n     *   - The specific name of the graph to send the command to\n     *   - {@link Command.PARENT}: closest parent graph (only supported when returned from a node in a subgraph)\n     */\n    graph?: string;\n    /**\n     * Update to apply to the graph's state as a result of executing the node that is returning the command.\n     * Written to the state as if the node had simply returned this value instead of the Command object.\n     */\n    update?: Update | [string, unknown][];\n    /**\n     * Value to resume execution with. To be used together with {@link interrupt}.\n     */\n    resume?: Resume;\n    /**\n     * Can be one of the following:\n     *   - name of the node to navigate to next (any node that belongs to the specified `graph`)\n     *   - sequence of node names to navigate to next\n     *   - {@link Send} object (to execute a node with the exact input provided in the {@link Send} object)\n     *   - sequence of {@link Send} objects\n     */\n    goto?: Nodes | Send<Nodes> | (Nodes | Send<Nodes>)[];\n    static PARENT: string;\n    constructor(args: Omit<CommandParams<Resume, Update, Nodes>, \"lg_name\">);\n    /**\n     * Convert the update field to a list of {@link PendingWrite} tuples\n     * @returns List of {@link PendingWrite} tuples of the form `[channelKey, value]`.\n     * @internal\n     */\n    _updateAsTuples(): PendingWrite[];\n    toJSON(): {\n        lg_name: string;\n        update: Update | [string, unknown][] | undefined;\n        resume: Resume | undefined;\n        goto: Nodes | (Nodes | {\n            lg_name: string;\n            node: Nodes;\n            args: any;\n        })[] | {\n            lg_name: string;\n            node: Nodes;\n            args: any;\n        } | undefined;\n    };\n}\n/**\n * A type guard to check if the given value is a {@link Command}.\n *\n * Useful for type narrowing when working with the {@link Command} object.\n *\n * @param x - The value to check.\n * @returns `true` if the value is a {@link Command}, `false` otherwise.\n */\nexport declare function isCommand(x: unknown): x is Command;\n/**\n * Reconstructs Command and Send objects from a deeply nested tree of anonymous objects\n * matching their interfaces.\n *\n * This is only exported for testing purposes. It is NOT intended to be used outside of\n * the Command and Send classes.\n *\n * @internal\n *\n * @param x - The command send tree to convert.\n * @param seen - A map of seen objects to avoid infinite loops.\n * @returns The converted command send tree.\n */\nexport declare function _deserializeCommandSendObjectGraph(x: unknown, seen?: Map<object, unknown>): unknown;\nexport {};\n"],"mappings":";;;;cAEqBC,KAAAA;AAArB;AAEqBC,cAAAA,GAAAA,GAAG,SAAA;;AAuHdgD,cA5FW1B,SAAAA,GA4FX0B,eAAAA;;;;AAWEK,cA/FS3B,QAAAA,GAiGT4B,cAAAA;;cAlFEd,cAqIKO,EAAAA,OAAAA,MAAAA;;;;;AAiEnB;;;;;AAAgLH,cA5L3JH,eA4L2JG,CAAAA,SAAAA,OAAAA,EAAAA,eA5L1GF,MA4L0GE,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,GA5LhFF,MA4LgFE,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,EAAAA,cAAAA,MAAAA,GAAAA,MAAAA,CAAAA,CAAAA;GA3L3KJ,cAAAA,CA2LmLK,EA3LlKC,aA2LkKD,CA3LpJF,MA2LoJE,EA3L5ID,MA2L4IC,EA3LpIA,KA2LoIA,CAAAA;aAc3KD,CAAAA,IAAAA,EAxMSE,aAwMTF,CAxMuBD,MAwMvBC,EAxM+BA,MAwM/BA,EAxMuCC,KAwMvCD,CAAAA;;;AAYWC,UAjNPE,aAiNOF,CAAAA,aAAAA,MAAAA,GAAAA,MAAAA,EAAAA,OAAAA,GAAAA,CAAAA,CAAAA;MAALM,EAhNTH,IAgNSG;MAAeN,EA/MxBI,IA+MwBJ;;;;;;;;;;;;;;;;AAgClC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA7LqBM,0DAA0DJ,cAAcC,MAAMC;;QAEzFD;QACAC;oBACYD,YAAYC;;;UAGpBD;UACAC;;;;KAKFI;;UAEAC;;;;;;;;;;;;;;;;;;iBAkBYC;GACnBjC,SAAAA,GAAY+B,UAAUC;;KAEfR,+CAA+CJ,0BAA0BA;;;;;;;;;;;WAWxEC;;;;;;;;;;;WAWAC;;;;;;;;SAQFC,QAAQE,cAAcF;KACzBA,QAAQE,cAAcF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAgETW,yCAAyCd,0BAA0BA,gEAAgED,gBAAgBE,QAAQC,QAAQC;;;;;;;;;;;;;;WAc3KD;;;;WAIAD;;;;;;;;SAQFE,QAAQM,KAAKN,UAAUA,QAAQM,KAAKN;;oBAEzBY,KAAKX,cAAcH,QAAQC,QAAQC;;;;;;qBAMlC/C;;;YAGP8C;YACAD;UACFE,SAASA;;YAELA;;;;YAIAA;;;;;;;;;;;;;iBAaMa,SAAAA,mBAA4BF"}