@langchain/langgraph 0.4.9 → 1.0.0-alpha.1

package/dist/constants.js

@@ -1,470 +1,362 @@
-var _a;
+//#region src/constants.ts
 /** Special reserved node name denoting the start of a graph. */
-export const START = "__start__";
+const START = "__start__";
 /** Special reserved node name denoting the end of a graph. */
-export const END = "__end__";
-export const INPUT = "__input__";
-export const COPY = "__copy__";
-export const ERROR = "__error__";
+const END = "__end__";
+const INPUT = "__input__";
+const COPY = "__copy__";
+const ERROR = "__error__";
 /** Special reserved cache namespaces */
-export const CACHE_NS_WRITES = "__pregel_ns_writes";
-export const CONFIG_KEY_SEND = "__pregel_send";
+const CACHE_NS_WRITES = "__pregel_ns_writes";
+const CONFIG_KEY_SEND = "__pregel_send";
 /** config key containing function used to call a node (push task) */
-export const CONFIG_KEY_CALL = "__pregel_call";
-export const CONFIG_KEY_READ = "__pregel_read";
-export const CONFIG_KEY_CHECKPOINTER = "__pregel_checkpointer";
-export const CONFIG_KEY_RESUMING = "__pregel_resuming";
-export const CONFIG_KEY_TASK_ID = "__pregel_task_id";
-export const CONFIG_KEY_STREAM = "__pregel_stream";
-export const CONFIG_KEY_RESUME_VALUE = "__pregel_resume_value";
-export const CONFIG_KEY_RESUME_MAP = "__pregel_resume_map";
-export const CONFIG_KEY_SCRATCHPAD = "__pregel_scratchpad";
+const CONFIG_KEY_CALL = "__pregel_call";
+const CONFIG_KEY_READ = "__pregel_read";
+const CONFIG_KEY_CHECKPOINTER = "__pregel_checkpointer";
+const CONFIG_KEY_RESUMING = "__pregel_resuming";
+const CONFIG_KEY_TASK_ID = "__pregel_task_id";
+const CONFIG_KEY_STREAM = "__pregel_stream";
+const CONFIG_KEY_RESUME_VALUE = "__pregel_resume_value";
+const CONFIG_KEY_RESUME_MAP = "__pregel_resume_map";
+const CONFIG_KEY_SCRATCHPAD = "__pregel_scratchpad";
 /** config key containing state from previous invocation of graph for the given thread */
-export const CONFIG_KEY_PREVIOUS_STATE = "__pregel_previous";
-export const CONFIG_KEY_DURABILITY = "__pregel_durability";
-export const CONFIG_KEY_CHECKPOINT_ID = "checkpoint_id";
-export const CONFIG_KEY_CHECKPOINT_NS = "checkpoint_ns";
-export const CONFIG_KEY_NODE_FINISHED = "__pregel_node_finished";
-// this one is part of public API
-export const CONFIG_KEY_CHECKPOINT_MAP = "checkpoint_map";
-export const CONFIG_KEY_ABORT_SIGNALS = "__pregel_abort_signals";
+const CONFIG_KEY_PREVIOUS_STATE = "__pregel_previous";
+const CONFIG_KEY_DURABILITY = "__pregel_durability";
+const CONFIG_KEY_CHECKPOINT_ID = "checkpoint_id";
+const CONFIG_KEY_CHECKPOINT_NS = "checkpoint_ns";
+const CONFIG_KEY_NODE_FINISHED = "__pregel_node_finished";
+const CONFIG_KEY_CHECKPOINT_MAP = "checkpoint_map";
+const CONFIG_KEY_ABORT_SIGNALS = "__pregel_abort_signals";
 /** Special channel reserved for graph interrupts */
-export const INTERRUPT = "__interrupt__";
+const INTERRUPT = "__interrupt__";
 /** Special channel reserved for graph resume */
-export const RESUME = "__resume__";
+const RESUME = "__resume__";
 /** Special channel reserved for cases when a task exits without any writes */
-export const NO_WRITES = "__no_writes__";
+const NO_WRITES = "__no_writes__";
 /** Special channel reserved for graph return */
-export const RETURN = "__return__";
+const RETURN = "__return__";
 /** Special channel reserved for graph previous state */
-export const PREVIOUS = "__previous__";
-export const RUNTIME_PLACEHOLDER = "__pregel_runtime_placeholder__";
-export const RECURSION_LIMIT_DEFAULT = 25;
-export const TAG_HIDDEN = "langsmith:hidden";
-export const TAG_NOSTREAM = "langsmith:nostream";
-export const SELF = "__self__";
-export const TASKS = "__pregel_tasks";
-export const PUSH = "__pregel_push";
-export const PULL = "__pregel_pull";
-export const TASK_NAMESPACE = "6ba7b831-9dad-11d1-80b4-00c04fd430c8";
-export const NULL_TASK_ID = "00000000-0000-0000-0000-000000000000";
-export const RESERVED = [
-    TAG_HIDDEN,
-    INPUT,
-    INTERRUPT,
-    RESUME,
-    ERROR,
-    NO_WRITES,
-    // reserved config.configurable keys
-    CONFIG_KEY_SEND,
-    CONFIG_KEY_READ,
-    CONFIG_KEY_CHECKPOINTER,
-    CONFIG_KEY_DURABILITY,
-    CONFIG_KEY_STREAM,
-    CONFIG_KEY_RESUMING,
-    CONFIG_KEY_TASK_ID,
-    CONFIG_KEY_CALL,
-    CONFIG_KEY_RESUME_VALUE,
-    CONFIG_KEY_SCRATCHPAD,
-    CONFIG_KEY_PREVIOUS_STATE,
-    CONFIG_KEY_CHECKPOINT_MAP,
-    CONFIG_KEY_CHECKPOINT_NS,
-    CONFIG_KEY_CHECKPOINT_ID,
+const PREVIOUS = "__previous__";
+const TAG_HIDDEN = "langsmith:hidden";
+const TAG_NOSTREAM = "langsmith:nostream";
+const SELF = "__self__";
+const TASKS = "__pregel_tasks";
+const PUSH = "__pregel_push";
+const PULL = "__pregel_pull";
+const NULL_TASK_ID = "00000000-0000-0000-0000-000000000000";
+const RESERVED = [
+	TAG_HIDDEN,
+	INPUT,
+	INTERRUPT,
+	RESUME,
+	ERROR,
+	NO_WRITES,
+	CONFIG_KEY_SEND,
+	CONFIG_KEY_READ,
+	CONFIG_KEY_CHECKPOINTER,
+	CONFIG_KEY_DURABILITY,
+	CONFIG_KEY_STREAM,
+	CONFIG_KEY_RESUMING,
+	CONFIG_KEY_TASK_ID,
+	CONFIG_KEY_CALL,
+	CONFIG_KEY_RESUME_VALUE,
+	CONFIG_KEY_SCRATCHPAD,
+	CONFIG_KEY_PREVIOUS_STATE,
+	CONFIG_KEY_CHECKPOINT_MAP,
+	CONFIG_KEY_CHECKPOINT_NS,
+	CONFIG_KEY_CHECKPOINT_ID
 ];
-export const CHECKPOINT_NAMESPACE_SEPARATOR = "|";
-export const CHECKPOINT_NAMESPACE_END = ":";
+const CHECKPOINT_NAMESPACE_SEPARATOR = "|";
+const CHECKPOINT_NAMESPACE_END = ":";
 /** @internal */
 const COMMAND_SYMBOL = Symbol.for("langgraph.command");
 /**
- * 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
- */
-export class CommandInstance {
-    constructor() {
-        Object.defineProperty(this, _a, {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-    }
-}
-_a = COMMAND_SYMBOL;
-export function _isSendInterface(x) {
-    const operation = x;
-    return (operation !== null &&
-        operation !== undefined &&
-        typeof operation.node === "string" &&
-        operation.args !== undefined);
+* 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
+*/
+var CommandInstance = class {
+	[COMMAND_SYMBOL];
+	constructor(args) {
+		this[COMMAND_SYMBOL] = args;
+	}
+};
+function _isSendInterface(x) {
+	const operation = x;
+	return operation !== null && operation !== void 0 && typeof operation.node === "string" && operation.args !== void 0;
 }
 /**
- *
- * 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
-export class Send {
-    constructor(node, args) {
-        Object.defineProperty(this, "lg_name", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: "Send"
-        });
-        Object.defineProperty(this, "node", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "args", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.node = node;
-        this.args = _deserializeCommandSendObjectGraph(args);
-    }
-    toJSON() {
-        return { lg_name: this.lg_name, node: this.node, args: this.args };
-    }
-}
-export function _isSend(x) {
-    // eslint-disable-next-line no-instanceof/no-instanceof
-    return x instanceof Send;
+*
+* 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`] }
+* ```
+*/
+var Send = class {
+	lg_name = "Send";
+	node;
+	args;
+	constructor(node, args) {
+		this.node = node;
+		this.args = _deserializeCommandSendObjectGraph(args);
+	}
+	toJSON() {
+		return {
+			lg_name: this.lg_name,
+			node: this.node,
+			args: this.args
+		};
+	}
+};
+function _isSend(x) {
+	return x instanceof Send;
 }
 /**
- * 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.
- */
-export function isInterrupted(values) {
-    if (!values || typeof values !== "object")
-        return false;
-    if (!(INTERRUPT in values))
-        return false;
-    return Array.isArray(values[INTERRUPT]);
+* 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.
+*/
+function isInterrupted(values) {
+	if (!values || typeof values !== "object") return false;
+	if (!(INTERRUPT in values)) return false;
+	return Array.isArray(values[INTERRUPT]);
 }
 /**
- * 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";
+* 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 extends CommandInstance {
-    constructor(args) {
-        super();
-        Object.defineProperty(this, "lg_name", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: "Command"
-        });
-        Object.defineProperty(this, "lc_direct_tool_output", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: true
-        });
-        /**
-         * 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)
-         */
-        Object.defineProperty(this, "graph", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        /**
-         * 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.
-         */
-        Object.defineProperty(this, "update", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        /**
-         * Value to resume execution with. To be used together with {@link interrupt}.
-         */
-        Object.defineProperty(this, "resume", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        /**
-         * 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
-         */
-        Object.defineProperty(this, "goto", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: []
-        });
-        this.resume = args.resume;
-        this.graph = args.graph;
-        this.update = args.update;
-        if (args.goto) {
-            this.goto = Array.isArray(args.goto)
-                ? _deserializeCommandSendObjectGraph(args.goto)
-                : [_deserializeCommandSendObjectGraph(args.goto)];
-        }
-    }
-    /**
-     * Convert the update field to a list of {@link PendingWrite} tuples
-     * @returns List of {@link PendingWrite} tuples of the form `[channelKey, value]`.
-     * @internal
-     */
-    _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]];
-        }
-    }
-    toJSON() {
-        let serializedGoto;
-        if (typeof this.goto === "string") {
-            serializedGoto = this.goto;
-        }
-        else if (_isSend(this.goto)) {
-            serializedGoto = this.goto.toJSON();
-        }
-        else {
-            serializedGoto = this.goto?.map((innerGoto) => {
-                if (typeof innerGoto === "string") {
-                    return innerGoto;
-                }
-                else {
-                    return innerGoto.toJSON();
-                }
-            });
-        }
-        return {
-            lg_name: this.lg_name,
-            update: this.update,
-            resume: this.resume,
-            goto: serializedGoto,
-        };
-    }
-}
-Object.defineProperty(Command, "PARENT", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: "__parent__"
-});
+* // 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' }
+* ```
+*/
+var Command = class extends CommandInstance {
+	lg_name = "Command";
+	lc_direct_tool_output = true;
+	/**
+	* 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;
+	/**
+	* 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;
+	/**
+	* Value to resume execution with. To be used together with {@link interrupt}.
+	*/
+	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 = [];
+	static PARENT = "__parent__";
+	constructor(args) {
+		super(args);
+		this.resume = args.resume;
+		this.graph = args.graph;
+		this.update = args.update;
+		if (args.goto) this.goto = Array.isArray(args.goto) ? _deserializeCommandSendObjectGraph(args.goto) : [_deserializeCommandSendObjectGraph(args.goto)];
+	}
+	/**
+	* Convert the update field to a list of {@link PendingWrite} tuples
+	* @returns List of {@link PendingWrite} tuples of the form `[channelKey, value]`.
+	* @internal
+	*/
+	_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]];
+	}
+	toJSON() {
+		let serializedGoto;
+		if (typeof this.goto === "string") serializedGoto = this.goto;
+		else if (_isSend(this.goto)) serializedGoto = this.goto.toJSON();
+		else serializedGoto = this.goto?.map((innerGoto) => {
+			if (typeof innerGoto === "string") return innerGoto;
+			else return innerGoto.toJSON();
+		});
+		return {
+			lg_name: this.lg_name,
+			update: this.update,
+			resume: this.resume,
+			goto: serializedGoto
+		};
+	}
+};
 /**
- * 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.
- */
-export function isCommand(x) {
-    if (typeof x !== "object") {
-        return false;
-    }
-    if (x === null || x === undefined) {
-        return false;
-    }
-    if ("lg_name" in x && x.lg_name === "Command") {
-        return true;
-    }
-    return false;
+* 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.
+*/
+function isCommand(x) {
+	if (typeof x !== "object") return false;
+	if (x === null || x === void 0) return false;
+	if ("lg_name" in x && x.lg_name === "Command") return true;
+	return false;
 }
 /**
- * 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.
- */
-export function _deserializeCommandSendObjectGraph(x, seen = new Map()) {
-    if (x !== undefined && x !== null && typeof x === "object") {
-        // If we've already processed this object, return the transformed version
-        if (seen.has(x)) {
-            return seen.get(x);
-        }
-        let result;
-        if (Array.isArray(x)) {
-            // Create the array first, then populate it
-            result = [];
-            // Add to seen map before processing elements to handle self-references
-            seen.set(x, result);
-            // Now populate the array
-            x.forEach((item, index) => {
-                result[index] = _deserializeCommandSendObjectGraph(item, seen);
-            });
-            // eslint-disable-next-line no-instanceof/no-instanceof
-        }
-        else if (isCommand(x) && !(x instanceof Command)) {
-            result = new Command(x);
-            seen.set(x, result);
-            // eslint-disable-next-line no-instanceof/no-instanceof
-        }
-        else if (_isSendInterface(x) && !(x instanceof Send)) {
-            result = new Send(x.node, x.args);
-            seen.set(x, result);
-        }
-        else if (isCommand(x) || _isSend(x)) {
-            result = x;
-            seen.set(x, result);
-        }
-        else if ("lc_serializable" in x && x.lc_serializable) {
-            result = x;
-            seen.set(x, result);
-        }
-        else {
-            // Create empty object first
-            result = {};
-            // Add to seen map before processing properties to handle self-references
-            seen.set(x, result);
-            // Now populate the object
-            for (const [key, value] of Object.entries(x)) {
-                result[key] =
-                    _deserializeCommandSendObjectGraph(value, seen);
-            }
-        }
-        return result;
-    }
-    return x;
+* 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.
+*/
+function _deserializeCommandSendObjectGraph(x, seen = /* @__PURE__ */ new Map()) {
+	if (x !== void 0 && x !== null && typeof x === "object") {
+		if (seen.has(x)) return seen.get(x);
+		let result;
+		if (Array.isArray(x)) {
+			result = [];
+			seen.set(x, result);
+			x.forEach((item, index) => {
+				result[index] = _deserializeCommandSendObjectGraph(item, seen);
+			});
+		} else if (isCommand(x) && !(x instanceof Command)) {
+			result = new Command(x);
+			seen.set(x, result);
+		} else if (_isSendInterface(x) && !(x instanceof Send)) {
+			result = new Send(x.node, x.args);
+			seen.set(x, result);
+		} else if (isCommand(x) || _isSend(x)) {
+			result = x;
+			seen.set(x, result);
+		} else if ("lc_serializable" in x && x.lc_serializable) {
+			result = x;
+			seen.set(x, result);
+		} else {
+			result = {};
+			seen.set(x, result);
+			for (const [key, value] of Object.entries(x)) result[key] = _deserializeCommandSendObjectGraph(value, seen);
+		}
+		return result;
+	}
+	return x;
 }
+
+//#endregion
+export { CACHE_NS_WRITES, CHECKPOINT_NAMESPACE_END, CHECKPOINT_NAMESPACE_SEPARATOR, CONFIG_KEY_ABORT_SIGNALS, CONFIG_KEY_CALL, CONFIG_KEY_CHECKPOINTER, CONFIG_KEY_CHECKPOINT_ID, CONFIG_KEY_CHECKPOINT_MAP, CONFIG_KEY_CHECKPOINT_NS, CONFIG_KEY_DURABILITY, CONFIG_KEY_NODE_FINISHED, CONFIG_KEY_PREVIOUS_STATE, CONFIG_KEY_READ, CONFIG_KEY_RESUME_MAP, CONFIG_KEY_RESUMING, CONFIG_KEY_SCRATCHPAD, CONFIG_KEY_SEND, CONFIG_KEY_STREAM, CONFIG_KEY_TASK_ID, COPY, Command, END, ERROR, INPUT, INTERRUPT, NO_WRITES, NULL_TASK_ID, PREVIOUS, PULL, PUSH, RESERVED, RESUME, RETURN, SELF, START, Send, TAG_HIDDEN, TAG_NOSTREAM, TASKS, _isSend, _isSendInterface, isCommand, isInterrupted };
 //# sourceMappingURL=constants.js.map