@langchain/langgraph 1.1.3 → 1.1.5

package/dist/pregel/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":["Runnable","RunnableConfig","RunnableFunc","StreamEvent","IterableReadableStream","All","BaseCache","BaseCheckpointSaver","BaseStore","CheckpointListOptions","CheckpointTuple","BaseChannel","Command","CommandInstance","StrRecord","PregelNode","LangGraphRunnableConfig","Durability","GetStateOptions","MultipleChannelSubscriptionOptions","PregelInputType","PregelInterface","PregelOptions","PregelOutputType","PregelParams","SingleChannelSubscriptionOptions","StateSnapshot","StreamMode","StreamOutputMap","RetryPolicy","ChannelWrite","WriteValue","StreamEventsOptions","Parameters","Channel","Record","PartialRunnable","RunInput","RunOutput","CallOptions","Partial","Promise","Pregel","InputType","OutputType","CommandType","Nodes","Channels","ContextType","Array","Omit","_langchain_core_runnables_graph0","Graph","Generator","AsyncGenerator","config","saved","subgraphCheckpointer","applyPendingWrites","AsyncIterableIterator","TStreamMode","TSubgraphs","TEncoding","StreamUpdatesType","StreamValuesType","NodeReturnType","StreamCustom","Uint8Array"],"sources":["../../src/pregel/index.d.ts"],"sourcesContent":["import { Runnable, RunnableConfig, RunnableFunc } from \"@langchain/core/runnables\";\nimport type { StreamEvent } from \"@langchain/core/tracers/log_stream\";\nimport { IterableReadableStream } from \"@langchain/core/utils/stream\";\nimport { All, BaseCache, BaseCheckpointSaver, BaseStore, CheckpointListOptions, CheckpointTuple } from \"@langchain/langgraph-checkpoint\";\nimport { BaseChannel } from \"../channels/base.js\";\nimport { Command, type CommandInstance } from \"../constants.js\";\nimport { StrRecord } from \"./algo.js\";\nimport { PregelNode } from \"./read.js\";\nimport { LangGraphRunnableConfig } from \"./runnable_types.js\";\nimport type { Durability, GetStateOptions, MultipleChannelSubscriptionOptions, PregelInputType, PregelInterface, PregelOptions, PregelOutputType, PregelParams, SingleChannelSubscriptionOptions, StateSnapshot, StreamMode, StreamOutputMap } from \"./types.js\";\nimport { RetryPolicy } from \"./utils/index.js\";\nimport { ChannelWrite } from \"./write.js\";\ntype WriteValue = Runnable | RunnableFunc<unknown, unknown> | unknown;\ntype StreamEventsOptions = Parameters<Runnable[\"streamEvents\"]>[2];\n/**\n * Utility class for working with channels in the Pregel system.\n * Provides static methods for subscribing to channels and writing to them.\n *\n * Channels are the communication pathways between nodes in a Pregel graph.\n * They enable message passing and state updates between different parts of the graph.\n */\nexport declare class Channel {\n    /**\n     * Creates a PregelNode that subscribes to a single channel.\n     * This is used to define how nodes receive input from channels.\n     *\n     * @example\n     * ```typescript\n     * // Subscribe to a single channel\n     * const node = Channel.subscribeTo(\"messages\");\n     *\n     * // Subscribe to multiple channels\n     * const node = Channel.subscribeTo([\"messages\", \"state\"]);\n     *\n     * // Subscribe with a custom key\n     * const node = Channel.subscribeTo(\"messages\", { key: \"chat\" });\n     * ```\n     *\n     * @param channel Single channel name to subscribe to\n     * @param options Subscription options\n     * @returns A PregelNode configured to receive from the specified channels\n     * @throws {Error} If a key is specified when subscribing to multiple channels\n     */\n    static subscribeTo(channel: string, options?: SingleChannelSubscriptionOptions): PregelNode;\n    /**\n     * Creates a PregelNode that subscribes to multiple channels.\n     * This is used to define how nodes receive input from channels.\n     *\n     * @example\n     * ```typescript\n     * // Subscribe to a single channel\n     * const node = Channel.subscribeTo(\"messages\");\n     *\n     * // Subscribe to multiple channels\n     * const node = Channel.subscribeTo([\"messages\", \"state\"]);\n     *\n     * // Subscribe with a custom key\n     * const node = Channel.subscribeTo(\"messages\", { key: \"chat\" });\n     * ```\n     *\n     * @param channels Single channel name to subscribe to\n     * @param options Subscription options\n     * @returns A PregelNode configured to receive from the specified channels\n     * @throws {Error} If a key is specified when subscribing to multiple channels\n     */\n    static subscribeTo(channels: string[], options?: MultipleChannelSubscriptionOptions): PregelNode;\n    /**\n     * Creates a ChannelWrite that specifies how to write values to channels.\n     * This is used to define how nodes send output to channels.\n     *\n     * @example\n     * ```typescript\n     * // Write to multiple channels\n     * const write = Channel.writeTo([\"output\", \"state\"]);\n     *\n     * // Write with specific values\n     * const write = Channel.writeTo([\"output\"], {\n     *   state: \"completed\",\n     *   result: calculateResult()\n     * });\n     *\n     * // Write with a transformation function\n     * const write = Channel.writeTo([\"output\"], {\n     *   result: (x) => processResult(x)\n     * });\n     * ```\n     *\n     * @param channels - Array of channel names to write to\n     * @param writes - Optional map of channel names to values or transformations\n     * @returns A ChannelWrite object that can be used to write to the specified channels\n     */\n    static writeTo(channels: string[], writes?: Record<string, WriteValue>): ChannelWrite;\n}\nexport type { PregelInputType, PregelOptions, PregelOutputType };\ndeclare class PartialRunnable<RunInput, RunOutput, CallOptions extends RunnableConfig> extends Runnable<RunInput, RunOutput, CallOptions> {\n    lc_namespace: string[];\n    invoke(_input: RunInput, _options?: Partial<CallOptions>): Promise<any>;\n    withConfig(_config: CallOptions): typeof this;\n    stream(input: RunInput, options?: Partial<CallOptions>): Promise<IterableReadableStream<any>>;\n}\n/**\n * The Pregel class is the core runtime engine of LangGraph, implementing a message-passing graph computation model\n * inspired by [Google's Pregel system](https://research.google/pubs/pregel-a-system-for-large-scale-graph-processing/).\n * It provides the foundation for building reliable, controllable agent workflows that can evolve state over time.\n *\n * Key features:\n * - Message passing between nodes in discrete \"supersteps\"\n * - Built-in persistence layer through checkpointers\n * - First-class streaming support for values, updates, and events\n * - Human-in-the-loop capabilities via interrupts\n * - Support for parallel node execution within supersteps\n *\n * The Pregel class is not intended to be instantiated directly by consumers. Instead, use the following higher-level APIs:\n * - {@link StateGraph}: The main graph class for building agent workflows\n *   - Compiling a {@link StateGraph} will return a {@link CompiledGraph} instance, which extends `Pregel`\n * - Functional API: A declarative approach using tasks and entrypoints\n *   - A `Pregel` instance is returned by the {@link entrypoint} function\n *\n * @example\n * ```typescript\n * // Using StateGraph API\n * const graph = new StateGraph(annotation)\n *   .addNode(\"nodeA\", myNodeFunction)\n *   .addEdge(\"nodeA\", \"nodeB\")\n *   .compile();\n *\n * // The compiled graph is a Pregel instance\n * const result = await graph.invoke(input);\n * ```\n *\n * @example\n * ```typescript\n * // Using Functional API\n * import { task, entrypoint } from \"@langchain/langgraph\";\n * import { MemorySaver } from \"@langchain/langgraph-checkpoint\";\n *\n * // Define tasks that can be composed\n * const addOne = task(\"add\", async (x: number) => x + 1);\n *\n * // Create a workflow using the entrypoint function\n * const workflow = entrypoint({\n *   name: \"workflow\",\n *   checkpointer: new MemorySaver()\n * }, async (numbers: number[]) => {\n *   // Tasks can be run in parallel\n *   const results = await Promise.all(numbers.map(n => addOne(n)));\n *   return results;\n * });\n *\n * // The workflow is a Pregel instance\n * const result = await workflow.invoke([1, 2, 3]); // Returns [2, 3, 4]\n * ```\n *\n * @typeParam Nodes - Mapping of node names to their {@link PregelNode} implementations\n * @typeParam Channels - Mapping of channel names to their {@link BaseChannel} or {@link ManagedValueSpec} implementations\n * @typeParam ContextType - Type of context that can be passed to the graph\n * @typeParam InputType - Type of input values accepted by the graph\n * @typeParam OutputType - Type of output values produced by the graph\n */\nexport declare class Pregel<Nodes extends StrRecord<string, PregelNode>, Channels extends StrRecord<string, BaseChannel>, ContextType extends Record<string, any> = StrRecord<string, any>, InputType = PregelInputType, OutputType = PregelOutputType, StreamUpdatesType = InputType, StreamValuesType = OutputType, NodeReturnType = unknown, CommandType = CommandInstance, StreamCustom = any> extends PartialRunnable<InputType | CommandType | null, OutputType, PregelOptions<Nodes, Channels, ContextType>> implements PregelInterface<Nodes, Channels, ContextType> {\n    /**\n     * Name of the class when serialized\n     * @internal\n     */\n    static lc_name(): string;\n    /** @internal Used for type inference */\n    \"~InputType\": InputType;\n    /** @internal Used for type inference */\n    \"~OutputType\": OutputType;\n    /** @internal LangChain namespace for serialization necessary because Pregel extends Runnable */\n    lc_namespace: string[];\n    /** @internal Flag indicating this is a Pregel instance - necessary for serialization */\n    lg_is_pregel: boolean;\n    /** The nodes in the graph, mapping node names to their PregelNode instances */\n    nodes: Nodes;\n    /** The channels in the graph, mapping channel names to their BaseChannel or ManagedValueSpec instances */\n    channels: Channels;\n    /**\n     * The input channels for the graph. These channels receive the initial input when the graph is invoked.\n     * Can be a single channel key or an array of channel keys.\n     */\n    inputChannels: keyof Channels | Array<keyof Channels>;\n    /**\n     * The output channels for the graph. These channels contain the final output when the graph completes.\n     * Can be a single channel key or an array of channel keys.\n     */\n    outputChannels: keyof Channels | Array<keyof Channels>;\n    /** Whether to automatically validate the graph structure when it is compiled. Defaults to true. */\n    autoValidate: boolean;\n    /**\n     * The streaming modes enabled for this graph. Defaults to [\"values\"].\n     * Supported modes:\n     * - \"values\": Streams the full state after each step\n     * - \"updates\": Streams state updates after each step\n     * - \"messages\": Streams messages from within nodes\n     * - \"custom\": Streams custom events from within nodes\n     * - \"debug\": Streams events related to the execution of the graph - useful for tracing & debugging graph execution\n     */\n    streamMode: StreamMode[];\n    /**\n     * Optional channels to stream. If not specified, all channels will be streamed.\n     * Can be a single channel key or an array of channel keys.\n     */\n    streamChannels?: keyof Channels | Array<keyof Channels>;\n    /**\n     * Optional array of node names or \"all\" to interrupt after executing these nodes.\n     * Used for implementing human-in-the-loop workflows.\n     */\n    interruptAfter?: Array<keyof Nodes> | All;\n    /**\n     * Optional array of node names or \"all\" to interrupt before executing these nodes.\n     * Used for implementing human-in-the-loop workflows.\n     */\n    interruptBefore?: Array<keyof Nodes> | All;\n    /** Optional timeout in milliseconds for the execution of each superstep */\n    stepTimeout?: number;\n    /** Whether to enable debug logging. Defaults to false. */\n    debug: boolean;\n    /**\n     * Optional checkpointer for persisting graph state.\n     * When provided, saves a checkpoint of the graph state at every superstep.\n     * When false or undefined, checkpointing is disabled, and the graph will not be able to save or restore state.\n     */\n    checkpointer?: BaseCheckpointSaver | boolean;\n    /** Optional retry policy for handling failures in node execution */\n    retryPolicy?: RetryPolicy;\n    /** The default configuration for graph execution, can be overridden on a per-invocation basis */\n    config?: LangGraphRunnableConfig;\n    /**\n     * Optional long-term memory store for the graph, allows for persistence & retrieval of data across threads\n     */\n    store?: BaseStore;\n    /**\n     * Optional cache for the graph, useful for caching tasks.\n     */\n    cache?: BaseCache;\n    /**\n     * Optional interrupt helper function.\n     * @internal\n     */\n    private userInterrupt?;\n    /**\n     * The trigger to node mapping for the graph run.\n     * @internal\n     */\n    private triggerToNodes;\n    /**\n     * Constructor for Pregel - meant for internal use only.\n     *\n     * @internal\n     */\n    constructor(fields: PregelParams<Nodes, Channels>);\n    /**\n     * Creates a new instance of the Pregel graph with updated configuration.\n     * This method follows the immutable pattern - instead of modifying the current instance,\n     * it returns a new instance with the merged configuration.\n     *\n     * @example\n     * ```typescript\n     * // Create a new instance with debug enabled\n     * const debugGraph = graph.withConfig({ debug: true });\n     *\n     * // Create a new instance with a specific thread ID\n     * const threadGraph = graph.withConfig({\n     *   configurable: { thread_id: \"123\" }\n     * });\n     * ```\n     *\n     * @param config - The configuration to merge with the current configuration\n     * @returns A new Pregel instance with the merged configuration\n     */\n    withConfig(config: Omit<LangGraphRunnableConfig, \"store\" | \"writer\" | \"interrupt\">): typeof this;\n    /**\n     * Validates the graph structure to ensure it is well-formed.\n     * Checks for:\n     * - No orphaned nodes\n     * - Valid input/output channel configurations\n     * - Valid interrupt configurations\n     *\n     * @returns this - The Pregel instance for method chaining\n     * @throws {GraphValidationError} If the graph structure is invalid\n     */\n    validate(): this;\n    /**\n     * Gets a list of all channels that should be streamed.\n     * If streamChannels is specified, returns those channels.\n     * Otherwise, returns all channels in the graph.\n     *\n     * @returns Array of channel keys to stream\n     */\n    get streamChannelsList(): Array<keyof Channels>;\n    /**\n     * Gets the channels to stream in their original format.\n     * If streamChannels is specified, returns it as-is (either single key or array).\n     * Otherwise, returns all channels in the graph as an array.\n     *\n     * @returns Channel keys to stream, either as a single key or array\n     */\n    get streamChannelsAsIs(): keyof Channels | Array<keyof Channels>;\n    /**\n     * Gets a drawable representation of the graph structure.\n     * This is an async version of getGraph() and is the preferred method to use.\n     *\n     * @param config - Configuration for generating the graph visualization\n     * @returns A representation of the graph that can be visualized\n     */\n    getGraphAsync(config: RunnableConfig): Promise<import(\"@langchain/core/runnables/graph\").Graph>;\n    /**\n     * Gets all subgraphs within this graph.\n     * A subgraph is a Pregel instance that is nested within a node of this graph.\n     *\n     * @deprecated Use getSubgraphsAsync instead. The async method will become the default in the next minor release.\n     * @param namespace - Optional namespace to filter subgraphs\n     * @param recurse - Whether to recursively get subgraphs of subgraphs\n     * @returns Generator yielding tuples of [name, subgraph]\n     */\n    getSubgraphs(namespace?: string, recurse?: boolean): Generator<[string, Pregel<any, any>]>;\n    /**\n     * Gets all subgraphs within this graph asynchronously.\n     * A subgraph is a Pregel instance that is nested within a node of this graph.\n     *\n     * @param namespace - Optional namespace to filter subgraphs\n     * @param recurse - Whether to recursively get subgraphs of subgraphs\n     * @returns AsyncGenerator yielding tuples of [name, subgraph]\n     */\n    getSubgraphsAsync(namespace?: string, recurse?: boolean): AsyncGenerator<[string, Pregel<any, any>]>;\n    /**\n     * Prepares a state snapshot from saved checkpoint data.\n     * This is an internal method used by getState and getStateHistory.\n     *\n     * @param config - Configuration for preparing the snapshot\n     * @param saved - Optional saved checkpoint data\n     * @param subgraphCheckpointer - Optional checkpointer for subgraphs\n     * @param applyPendingWrites - Whether to apply pending writes to tasks and then to channels\n     * @returns A snapshot of the graph state\n     * @internal\n     */\n    protected _prepareStateSnapshot({ config, saved, subgraphCheckpointer, applyPendingWrites }: {\n        config: RunnableConfig;\n        saved?: CheckpointTuple;\n        subgraphCheckpointer?: BaseCheckpointSaver;\n        applyPendingWrites?: boolean;\n    }): Promise<StateSnapshot>;\n    /**\n     * Gets the current state of the graph.\n     * Requires a checkpointer to be configured.\n     *\n     * @param config - Configuration for retrieving the state\n     * @param options - Additional options\n     * @returns A snapshot of the current graph state\n     * @throws {GraphValueError} If no checkpointer is configured\n     */\n    getState(config: RunnableConfig, options?: GetStateOptions): Promise<StateSnapshot>;\n    /**\n     * Gets the history of graph states.\n     * Requires a checkpointer to be configured.\n     * Useful for:\n     * - Debugging execution history\n     * - Implementing time travel\n     * - Analyzing graph behavior\n     *\n     * @param config - Configuration for retrieving the history\n     * @param options - Options for filtering the history\n     * @returns An async iterator of state snapshots\n     * @throws {Error} If no checkpointer is configured\n     */\n    getStateHistory(config: RunnableConfig, options?: CheckpointListOptions): AsyncIterableIterator<StateSnapshot>;\n    /**\n     * Apply updates to the graph state in bulk.\n     * Requires a checkpointer to be configured.\n     *\n     * This method is useful for recreating a thread\n     * from a list of updates, especially if a checkpoint\n     * is created as a result of multiple tasks.\n     *\n     * @internal The API might change in the future.\n     *\n     * @param startConfig - Configuration for the update\n     * @param updates - The list of updates to apply to graph state\n     * @returns Updated configuration\n     * @throws {GraphValueError} If no checkpointer is configured\n     * @throws {InvalidUpdateError} If the update cannot be attributed to a node or an update can be only applied in sequence.\n     */\n    bulkUpdateState(startConfig: LangGraphRunnableConfig, supersteps: Array<{\n        updates: Array<{\n            values?: Record<string, unknown> | unknown;\n            asNode?: keyof Nodes | string;\n        }>;\n    }>): Promise<RunnableConfig>;\n    /**\n     * Updates the state of the graph with new values.\n     * Requires a checkpointer to be configured.\n     *\n     * This method can be used for:\n     * - Implementing human-in-the-loop workflows\n     * - Modifying graph state during breakpoints\n     * - Integrating external inputs into the graph\n     *\n     * @param inputConfig - Configuration for the update\n     * @param values - The values to update the state with\n     * @param asNode - Optional node name to attribute the update to\n     * @returns Updated configuration\n     * @throws {GraphValueError} If no checkpointer is configured\n     * @throws {InvalidUpdateError} If the update cannot be attributed to a node\n     */\n    updateState(inputConfig: LangGraphRunnableConfig, values: Record<string, unknown> | unknown, asNode?: keyof Nodes | string): Promise<RunnableConfig>;\n    /**\n     * Gets the default values for various graph configuration options.\n     * This is an internal method used to process and normalize configuration options.\n     *\n     * @param config - The input configuration options\n     * @returns A tuple containing normalized values for:\n     * - debug mode\n     * - stream modes\n     * - input keys\n     * - output keys\n     * - remaining config\n     * - interrupt before nodes\n     * - interrupt after nodes\n     * - checkpointer\n     * - store\n     * - whether stream mode is single\n     * - node cache\n     * - whether checkpoint during is enabled\n     * @internal\n     */\n    _defaults(config: PregelOptions<Nodes, Channels>): [\n        boolean,\n        StreamMode[],\n        string | string[],\n        string | string[],\n        LangGraphRunnableConfig,\n        All | string[],\n        All | string[],\n        BaseCheckpointSaver | undefined,\n        BaseStore | undefined,\n        boolean,\n        BaseCache | undefined,\n        Durability\n    ];\n    /**\n     * Streams the execution of the graph, emitting state updates as they occur.\n     * This is the primary method for observing graph execution in real-time.\n     *\n     * Stream modes:\n     * - \"values\": Emits complete state after each step\n     * - \"updates\": Emits only state changes after each step\n     * - \"debug\": Emits detailed debug information\n     * - \"messages\": Emits messages from within nodes\n     * - \"custom\": Emits custom events from within nodes\n     * - \"checkpoints\": Emits checkpoints from within nodes\n     * - \"tasks\": Emits tasks from within nodes\n     *\n     * @param input - The input to start graph execution with\n     * @param options - Configuration options for streaming\n     * @returns An async iterable stream of graph state updates\n     */\n    stream<TStreamMode extends StreamMode | StreamMode[] | undefined, TSubgraphs extends boolean, TEncoding extends \"text/event-stream\" | undefined>(input: InputType | CommandType | null, options?: Partial<PregelOptions<Nodes, Channels, ContextType, TStreamMode, TSubgraphs, TEncoding>>): Promise<IterableReadableStream<StreamOutputMap<TStreamMode, TSubgraphs, StreamUpdatesType, StreamValuesType, keyof Nodes, NodeReturnType, StreamCustom, TEncoding>>>;\n    /**\n     * @inheritdoc\n     */\n    streamEvents(input: InputType | CommandType | null, options: Partial<PregelOptions<Nodes, Channels, ContextType>> & {\n        version: \"v1\" | \"v2\";\n    }, streamOptions?: StreamEventsOptions): IterableReadableStream<StreamEvent>;\n    streamEvents(input: InputType | CommandType | null, options: Partial<PregelOptions<Nodes, Channels, ContextType>> & {\n        version: \"v1\" | \"v2\";\n        encoding: \"text/event-stream\";\n    }, streamOptions?: StreamEventsOptions): IterableReadableStream<Uint8Array>;\n    /**\n     * Validates the input for the graph.\n     * @param input - The input to validate\n     * @returns The validated input\n     * @internal\n     */\n    protected _validateInput(input: PregelInputType): Promise<any>;\n    /**\n     * Validates the context options for the graph.\n     * @param context - The context options to validate\n     * @returns The validated context options\n     * @internal\n     */\n    protected _validateContext(context: Partial<LangGraphRunnableConfig[\"context\"]>): Promise<LangGraphRunnableConfig[\"context\"]>;\n    /**\n     * Internal iterator used by stream() to generate state updates.\n     * This method handles the core logic of graph execution and streaming.\n     *\n     * @param input - The input to start graph execution with\n     * @param options - Configuration options for streaming\n     * @returns AsyncGenerator yielding state updates\n     * @internal\n     */\n    _streamIterator(input: PregelInputType | Command, options?: Partial<PregelOptions<Nodes, Channels>>): AsyncGenerator<PregelOutputType>;\n    /**\n     * Run the graph with a single input and config.\n     * @param input The input to the graph.\n     * @param options The configuration to use for the run.\n     */\n    invoke(input: InputType | CommandType | null, options?: Partial<Omit<PregelOptions<Nodes, Channels, ContextType>, \"encoding\">>): Promise<OutputType>;\n    private _runLoop;\n    clearCache(): Promise<void>;\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../src/pregel/index.ts"],"mappings":"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"}

package/dist/pregel/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":["Runnable","RunnableConfig","RunnableFunc","StreamEvent","IterableReadableStream","All","BaseCache","BaseCheckpointSaver","BaseStore","CheckpointListOptions","CheckpointTuple","BaseChannel","Command","CommandInstance","StrRecord","PregelNode","LangGraphRunnableConfig","Durability","GetStateOptions","MultipleChannelSubscriptionOptions","PregelInputType","PregelInterface","PregelOptions","PregelOutputType","PregelParams","SingleChannelSubscriptionOptions","StateSnapshot","StreamMode","StreamOutputMap","RetryPolicy","ChannelWrite","WriteValue","StreamEventsOptions","Parameters","Channel","Record","PartialRunnable","RunInput","RunOutput","CallOptions","Partial","Promise","Pregel","InputType","OutputType","CommandType","Nodes","Channels","ContextType","Array","Omit","_langchain_core_runnables_graph0","Graph","Generator","AsyncGenerator","config","saved","subgraphCheckpointer","applyPendingWrites","AsyncIterableIterator","TStreamMode","TSubgraphs","TEncoding","StreamUpdatesType","StreamValuesType","NodeReturnType","StreamCustom","Uint8Array"],"sources":["../../src/pregel/index.d.ts"],"sourcesContent":["import { Runnable, RunnableConfig, RunnableFunc } from \"@langchain/core/runnables\";\nimport type { StreamEvent } from \"@langchain/core/tracers/log_stream\";\nimport { IterableReadableStream } from \"@langchain/core/utils/stream\";\nimport { All, BaseCache, BaseCheckpointSaver, BaseStore, CheckpointListOptions, CheckpointTuple } from \"@langchain/langgraph-checkpoint\";\nimport { BaseChannel } from \"../channels/base.js\";\nimport { Command, type CommandInstance } from \"../constants.js\";\nimport { StrRecord } from \"./algo.js\";\nimport { PregelNode } from \"./read.js\";\nimport { LangGraphRunnableConfig } from \"./runnable_types.js\";\nimport type { Durability, GetStateOptions, MultipleChannelSubscriptionOptions, PregelInputType, PregelInterface, PregelOptions, PregelOutputType, PregelParams, SingleChannelSubscriptionOptions, StateSnapshot, StreamMode, StreamOutputMap } from \"./types.js\";\nimport { RetryPolicy } from \"./utils/index.js\";\nimport { ChannelWrite } from \"./write.js\";\ntype WriteValue = Runnable | RunnableFunc<unknown, unknown> | unknown;\ntype StreamEventsOptions = Parameters<Runnable[\"streamEvents\"]>[2];\n/**\n * Utility class for working with channels in the Pregel system.\n * Provides static methods for subscribing to channels and writing to them.\n *\n * Channels are the communication pathways between nodes in a Pregel graph.\n * They enable message passing and state updates between different parts of the graph.\n */\nexport declare class Channel {\n    /**\n     * Creates a PregelNode that subscribes to a single channel.\n     * This is used to define how nodes receive input from channels.\n     *\n     * @example\n     * ```typescript\n     * // Subscribe to a single channel\n     * const node = Channel.subscribeTo(\"messages\");\n     *\n     * // Subscribe to multiple channels\n     * const node = Channel.subscribeTo([\"messages\", \"state\"]);\n     *\n     * // Subscribe with a custom key\n     * const node = Channel.subscribeTo(\"messages\", { key: \"chat\" });\n     * ```\n     *\n     * @param channel Single channel name to subscribe to\n     * @param options Subscription options\n     * @returns A PregelNode configured to receive from the specified channels\n     * @throws {Error} If a key is specified when subscribing to multiple channels\n     */\n    static subscribeTo(channel: string, options?: SingleChannelSubscriptionOptions): PregelNode;\n    /**\n     * Creates a PregelNode that subscribes to multiple channels.\n     * This is used to define how nodes receive input from channels.\n     *\n     * @example\n     * ```typescript\n     * // Subscribe to a single channel\n     * const node = Channel.subscribeTo(\"messages\");\n     *\n     * // Subscribe to multiple channels\n     * const node = Channel.subscribeTo([\"messages\", \"state\"]);\n     *\n     * // Subscribe with a custom key\n     * const node = Channel.subscribeTo(\"messages\", { key: \"chat\" });\n     * ```\n     *\n     * @param channels Single channel name to subscribe to\n     * @param options Subscription options\n     * @returns A PregelNode configured to receive from the specified channels\n     * @throws {Error} If a key is specified when subscribing to multiple channels\n     */\n    static subscribeTo(channels: string[], options?: MultipleChannelSubscriptionOptions): PregelNode;\n    /**\n     * Creates a ChannelWrite that specifies how to write values to channels.\n     * This is used to define how nodes send output to channels.\n     *\n     * @example\n     * ```typescript\n     * // Write to multiple channels\n     * const write = Channel.writeTo([\"output\", \"state\"]);\n     *\n     * // Write with specific values\n     * const write = Channel.writeTo([\"output\"], {\n     *   state: \"completed\",\n     *   result: calculateResult()\n     * });\n     *\n     * // Write with a transformation function\n     * const write = Channel.writeTo([\"output\"], {\n     *   result: (x) => processResult(x)\n     * });\n     * ```\n     *\n     * @param channels - Array of channel names to write to\n     * @param writes - Optional map of channel names to values or transformations\n     * @returns A ChannelWrite object that can be used to write to the specified channels\n     */\n    static writeTo(channels: string[], writes?: Record<string, WriteValue>): ChannelWrite;\n}\nexport type { PregelInputType, PregelOptions, PregelOutputType };\ndeclare class PartialRunnable<RunInput, RunOutput, CallOptions extends RunnableConfig> extends Runnable<RunInput, RunOutput, CallOptions> {\n    lc_namespace: string[];\n    invoke(_input: RunInput, _options?: Partial<CallOptions>): Promise<any>;\n    withConfig(_config: CallOptions): typeof this;\n    stream(input: RunInput, options?: Partial<CallOptions>): Promise<IterableReadableStream<any>>;\n}\n/**\n * The Pregel class is the core runtime engine of LangGraph, implementing a message-passing graph computation model\n * inspired by [Google's Pregel system](https://research.google/pubs/pregel-a-system-for-large-scale-graph-processing/).\n * It provides the foundation for building reliable, controllable agent workflows that can evolve state over time.\n *\n * Key features:\n * - Message passing between nodes in discrete \"supersteps\"\n * - Built-in persistence layer through checkpointers\n * - First-class streaming support for values, updates, and events\n * - Human-in-the-loop capabilities via interrupts\n * - Support for parallel node execution within supersteps\n *\n * The Pregel class is not intended to be instantiated directly by consumers. Instead, use the following higher-level APIs:\n * - {@link StateGraph}: The main graph class for building agent workflows\n *   - Compiling a {@link StateGraph} will return a {@link CompiledGraph} instance, which extends `Pregel`\n * - Functional API: A declarative approach using tasks and entrypoints\n *   - A `Pregel` instance is returned by the {@link entrypoint} function\n *\n * @example\n * ```typescript\n * // Using StateGraph API\n * const graph = new StateGraph(annotation)\n *   .addNode(\"nodeA\", myNodeFunction)\n *   .addEdge(\"nodeA\", \"nodeB\")\n *   .compile();\n *\n * // The compiled graph is a Pregel instance\n * const result = await graph.invoke(input);\n * ```\n *\n * @example\n * ```typescript\n * // Using Functional API\n * import { task, entrypoint } from \"@langchain/langgraph\";\n * import { MemorySaver } from \"@langchain/langgraph-checkpoint\";\n *\n * // Define tasks that can be composed\n * const addOne = task(\"add\", async (x: number) => x + 1);\n *\n * // Create a workflow using the entrypoint function\n * const workflow = entrypoint({\n *   name: \"workflow\",\n *   checkpointer: new MemorySaver()\n * }, async (numbers: number[]) => {\n *   // Tasks can be run in parallel\n *   const results = await Promise.all(numbers.map(n => addOne(n)));\n *   return results;\n * });\n *\n * // The workflow is a Pregel instance\n * const result = await workflow.invoke([1, 2, 3]); // Returns [2, 3, 4]\n * ```\n *\n * @typeParam Nodes - Mapping of node names to their {@link PregelNode} implementations\n * @typeParam Channels - Mapping of channel names to their {@link BaseChannel} or {@link ManagedValueSpec} implementations\n * @typeParam ContextType - Type of context that can be passed to the graph\n * @typeParam InputType - Type of input values accepted by the graph\n * @typeParam OutputType - Type of output values produced by the graph\n */\nexport declare class Pregel<Nodes extends StrRecord<string, PregelNode>, Channels extends StrRecord<string, BaseChannel>, ContextType extends Record<string, any> = StrRecord<string, any>, InputType = PregelInputType, OutputType = PregelOutputType, StreamUpdatesType = InputType, StreamValuesType = OutputType, NodeReturnType = unknown, CommandType = CommandInstance, StreamCustom = any> extends PartialRunnable<InputType | CommandType | null, OutputType, PregelOptions<Nodes, Channels, ContextType>> implements PregelInterface<Nodes, Channels, ContextType> {\n    /**\n     * Name of the class when serialized\n     * @internal\n     */\n    static lc_name(): string;\n    /** @internal Used for type inference */\n    \"~InputType\": InputType;\n    /** @internal Used for type inference */\n    \"~OutputType\": OutputType;\n    /** @internal LangChain namespace for serialization necessary because Pregel extends Runnable */\n    lc_namespace: string[];\n    /** @internal Flag indicating this is a Pregel instance - necessary for serialization */\n    lg_is_pregel: boolean;\n    /** The nodes in the graph, mapping node names to their PregelNode instances */\n    nodes: Nodes;\n    /** The channels in the graph, mapping channel names to their BaseChannel or ManagedValueSpec instances */\n    channels: Channels;\n    /**\n     * The input channels for the graph. These channels receive the initial input when the graph is invoked.\n     * Can be a single channel key or an array of channel keys.\n     */\n    inputChannels: keyof Channels | Array<keyof Channels>;\n    /**\n     * The output channels for the graph. These channels contain the final output when the graph completes.\n     * Can be a single channel key or an array of channel keys.\n     */\n    outputChannels: keyof Channels | Array<keyof Channels>;\n    /** Whether to automatically validate the graph structure when it is compiled. Defaults to true. */\n    autoValidate: boolean;\n    /**\n     * The streaming modes enabled for this graph. Defaults to [\"values\"].\n     * Supported modes:\n     * - \"values\": Streams the full state after each step\n     * - \"updates\": Streams state updates after each step\n     * - \"messages\": Streams messages from within nodes\n     * - \"custom\": Streams custom events from within nodes\n     * - \"debug\": Streams events related to the execution of the graph - useful for tracing & debugging graph execution\n     */\n    streamMode: StreamMode[];\n    /**\n     * Optional channels to stream. If not specified, all channels will be streamed.\n     * Can be a single channel key or an array of channel keys.\n     */\n    streamChannels?: keyof Channels | Array<keyof Channels>;\n    /**\n     * Optional array of node names or \"all\" to interrupt after executing these nodes.\n     * Used for implementing human-in-the-loop workflows.\n     */\n    interruptAfter?: Array<keyof Nodes> | All;\n    /**\n     * Optional array of node names or \"all\" to interrupt before executing these nodes.\n     * Used for implementing human-in-the-loop workflows.\n     */\n    interruptBefore?: Array<keyof Nodes> | All;\n    /** Optional timeout in milliseconds for the execution of each superstep */\n    stepTimeout?: number;\n    /** Whether to enable debug logging. Defaults to false. */\n    debug: boolean;\n    /**\n     * Optional checkpointer for persisting graph state.\n     * When provided, saves a checkpoint of the graph state at every superstep.\n     * When false or undefined, checkpointing is disabled, and the graph will not be able to save or restore state.\n     */\n    checkpointer?: BaseCheckpointSaver | boolean;\n    /** Optional retry policy for handling failures in node execution */\n    retryPolicy?: RetryPolicy;\n    /** The default configuration for graph execution, can be overridden on a per-invocation basis */\n    config?: LangGraphRunnableConfig;\n    /**\n     * Optional long-term memory store for the graph, allows for persistence & retrieval of data across threads\n     */\n    store?: BaseStore;\n    /**\n     * Optional cache for the graph, useful for caching tasks.\n     */\n    cache?: BaseCache;\n    /**\n     * Optional interrupt helper function.\n     * @internal\n     */\n    private userInterrupt?;\n    /**\n     * The trigger to node mapping for the graph run.\n     * @internal\n     */\n    private triggerToNodes;\n    /**\n     * Constructor for Pregel - meant for internal use only.\n     *\n     * @internal\n     */\n    constructor(fields: PregelParams<Nodes, Channels>);\n    /**\n     * Creates a new instance of the Pregel graph with updated configuration.\n     * This method follows the immutable pattern - instead of modifying the current instance,\n     * it returns a new instance with the merged configuration.\n     *\n     * @example\n     * ```typescript\n     * // Create a new instance with debug enabled\n     * const debugGraph = graph.withConfig({ debug: true });\n     *\n     * // Create a new instance with a specific thread ID\n     * const threadGraph = graph.withConfig({\n     *   configurable: { thread_id: \"123\" }\n     * });\n     * ```\n     *\n     * @param config - The configuration to merge with the current configuration\n     * @returns A new Pregel instance with the merged configuration\n     */\n    withConfig(config: Omit<LangGraphRunnableConfig, \"store\" | \"writer\" | \"interrupt\">): typeof this;\n    /**\n     * Validates the graph structure to ensure it is well-formed.\n     * Checks for:\n     * - No orphaned nodes\n     * - Valid input/output channel configurations\n     * - Valid interrupt configurations\n     *\n     * @returns this - The Pregel instance for method chaining\n     * @throws {GraphValidationError} If the graph structure is invalid\n     */\n    validate(): this;\n    /**\n     * Gets a list of all channels that should be streamed.\n     * If streamChannels is specified, returns those channels.\n     * Otherwise, returns all channels in the graph.\n     *\n     * @returns Array of channel keys to stream\n     */\n    get streamChannelsList(): Array<keyof Channels>;\n    /**\n     * Gets the channels to stream in their original format.\n     * If streamChannels is specified, returns it as-is (either single key or array).\n     * Otherwise, returns all channels in the graph as an array.\n     *\n     * @returns Channel keys to stream, either as a single key or array\n     */\n    get streamChannelsAsIs(): keyof Channels | Array<keyof Channels>;\n    /**\n     * Gets a drawable representation of the graph structure.\n     * This is an async version of getGraph() and is the preferred method to use.\n     *\n     * @param config - Configuration for generating the graph visualization\n     * @returns A representation of the graph that can be visualized\n     */\n    getGraphAsync(config: RunnableConfig): Promise<import(\"@langchain/core/runnables/graph\").Graph>;\n    /**\n     * Gets all subgraphs within this graph.\n     * A subgraph is a Pregel instance that is nested within a node of this graph.\n     *\n     * @deprecated Use getSubgraphsAsync instead. The async method will become the default in the next minor release.\n     * @param namespace - Optional namespace to filter subgraphs\n     * @param recurse - Whether to recursively get subgraphs of subgraphs\n     * @returns Generator yielding tuples of [name, subgraph]\n     */\n    getSubgraphs(namespace?: string, recurse?: boolean): Generator<[string, Pregel<any, any>]>;\n    /**\n     * Gets all subgraphs within this graph asynchronously.\n     * A subgraph is a Pregel instance that is nested within a node of this graph.\n     *\n     * @param namespace - Optional namespace to filter subgraphs\n     * @param recurse - Whether to recursively get subgraphs of subgraphs\n     * @returns AsyncGenerator yielding tuples of [name, subgraph]\n     */\n    getSubgraphsAsync(namespace?: string, recurse?: boolean): AsyncGenerator<[string, Pregel<any, any>]>;\n    /**\n     * Prepares a state snapshot from saved checkpoint data.\n     * This is an internal method used by getState and getStateHistory.\n     *\n     * @param config - Configuration for preparing the snapshot\n     * @param saved - Optional saved checkpoint data\n     * @param subgraphCheckpointer - Optional checkpointer for subgraphs\n     * @param applyPendingWrites - Whether to apply pending writes to tasks and then to channels\n     * @returns A snapshot of the graph state\n     * @internal\n     */\n    protected _prepareStateSnapshot({ config, saved, subgraphCheckpointer, applyPendingWrites }: {\n        config: RunnableConfig;\n        saved?: CheckpointTuple;\n        subgraphCheckpointer?: BaseCheckpointSaver;\n        applyPendingWrites?: boolean;\n    }): Promise<StateSnapshot>;\n    /**\n     * Gets the current state of the graph.\n     * Requires a checkpointer to be configured.\n     *\n     * @param config - Configuration for retrieving the state\n     * @param options - Additional options\n     * @returns A snapshot of the current graph state\n     * @throws {GraphValueError} If no checkpointer is configured\n     */\n    getState(config: RunnableConfig, options?: GetStateOptions): Promise<StateSnapshot>;\n    /**\n     * Gets the history of graph states.\n     * Requires a checkpointer to be configured.\n     * Useful for:\n     * - Debugging execution history\n     * - Implementing time travel\n     * - Analyzing graph behavior\n     *\n     * @param config - Configuration for retrieving the history\n     * @param options - Options for filtering the history\n     * @returns An async iterator of state snapshots\n     * @throws {Error} If no checkpointer is configured\n     */\n    getStateHistory(config: RunnableConfig, options?: CheckpointListOptions): AsyncIterableIterator<StateSnapshot>;\n    /**\n     * Apply updates to the graph state in bulk.\n     * Requires a checkpointer to be configured.\n     *\n     * This method is useful for recreating a thread\n     * from a list of updates, especially if a checkpoint\n     * is created as a result of multiple tasks.\n     *\n     * @internal The API might change in the future.\n     *\n     * @param startConfig - Configuration for the update\n     * @param updates - The list of updates to apply to graph state\n     * @returns Updated configuration\n     * @throws {GraphValueError} If no checkpointer is configured\n     * @throws {InvalidUpdateError} If the update cannot be attributed to a node or an update can be only applied in sequence.\n     */\n    bulkUpdateState(startConfig: LangGraphRunnableConfig, supersteps: Array<{\n        updates: Array<{\n            values?: Record<string, unknown> | unknown;\n            asNode?: keyof Nodes | string;\n        }>;\n    }>): Promise<RunnableConfig>;\n    /**\n     * Updates the state of the graph with new values.\n     * Requires a checkpointer to be configured.\n     *\n     * This method can be used for:\n     * - Implementing human-in-the-loop workflows\n     * - Modifying graph state during breakpoints\n     * - Integrating external inputs into the graph\n     *\n     * @param inputConfig - Configuration for the update\n     * @param values - The values to update the state with\n     * @param asNode - Optional node name to attribute the update to\n     * @returns Updated configuration\n     * @throws {GraphValueError} If no checkpointer is configured\n     * @throws {InvalidUpdateError} If the update cannot be attributed to a node\n     */\n    updateState(inputConfig: LangGraphRunnableConfig, values: Record<string, unknown> | unknown, asNode?: keyof Nodes | string): Promise<RunnableConfig>;\n    /**\n     * Gets the default values for various graph configuration options.\n     * This is an internal method used to process and normalize configuration options.\n     *\n     * @param config - The input configuration options\n     * @returns A tuple containing normalized values for:\n     * - debug mode\n     * - stream modes\n     * - input keys\n     * - output keys\n     * - remaining config\n     * - interrupt before nodes\n     * - interrupt after nodes\n     * - checkpointer\n     * - store\n     * - whether stream mode is single\n     * - node cache\n     * - whether checkpoint during is enabled\n     * @internal\n     */\n    _defaults(config: PregelOptions<Nodes, Channels>): [\n        boolean,\n        StreamMode[],\n        string | string[],\n        string | string[],\n        LangGraphRunnableConfig,\n        All | string[],\n        All | string[],\n        BaseCheckpointSaver | undefined,\n        BaseStore | undefined,\n        boolean,\n        BaseCache | undefined,\n        Durability\n    ];\n    /**\n     * Streams the execution of the graph, emitting state updates as they occur.\n     * This is the primary method for observing graph execution in real-time.\n     *\n     * Stream modes:\n     * - \"values\": Emits complete state after each step\n     * - \"updates\": Emits only state changes after each step\n     * - \"debug\": Emits detailed debug information\n     * - \"messages\": Emits messages from within nodes\n     * - \"custom\": Emits custom events from within nodes\n     * - \"checkpoints\": Emits checkpoints from within nodes\n     * - \"tasks\": Emits tasks from within nodes\n     *\n     * @param input - The input to start graph execution with\n     * @param options - Configuration options for streaming\n     * @returns An async iterable stream of graph state updates\n     */\n    stream<TStreamMode extends StreamMode | StreamMode[] | undefined, TSubgraphs extends boolean, TEncoding extends \"text/event-stream\" | undefined>(input: InputType | CommandType | null, options?: Partial<PregelOptions<Nodes, Channels, ContextType, TStreamMode, TSubgraphs, TEncoding>>): Promise<IterableReadableStream<StreamOutputMap<TStreamMode, TSubgraphs, StreamUpdatesType, StreamValuesType, keyof Nodes, NodeReturnType, StreamCustom, TEncoding>>>;\n    /**\n     * @inheritdoc\n     */\n    streamEvents(input: InputType | CommandType | null, options: Partial<PregelOptions<Nodes, Channels, ContextType>> & {\n        version: \"v1\" | \"v2\";\n    }, streamOptions?: StreamEventsOptions): IterableReadableStream<StreamEvent>;\n    streamEvents(input: InputType | CommandType | null, options: Partial<PregelOptions<Nodes, Channels, ContextType>> & {\n        version: \"v1\" | \"v2\";\n        encoding: \"text/event-stream\";\n    }, streamOptions?: StreamEventsOptions): IterableReadableStream<Uint8Array>;\n    /**\n     * Validates the input for the graph.\n     * @param input - The input to validate\n     * @returns The validated input\n     * @internal\n     */\n    protected _validateInput(input: PregelInputType): Promise<any>;\n    /**\n     * Validates the context options for the graph.\n     * @param context - The context options to validate\n     * @returns The validated context options\n     * @internal\n     */\n    protected _validateContext(context: Partial<LangGraphRunnableConfig[\"context\"]>): Promise<LangGraphRunnableConfig[\"context\"]>;\n    /**\n     * Internal iterator used by stream() to generate state updates.\n     * This method handles the core logic of graph execution and streaming.\n     *\n     * @param input - The input to start graph execution with\n     * @param options - Configuration options for streaming\n     * @returns AsyncGenerator yielding state updates\n     * @internal\n     */\n    _streamIterator(input: PregelInputType | Command, options?: Partial<PregelOptions<Nodes, Channels>>): AsyncGenerator<PregelOutputType>;\n    /**\n     * Run the graph with a single input and config.\n     * @param input The input to the graph.\n     * @param options The configuration to use for the run.\n     */\n    invoke(input: InputType | CommandType | null, options?: Partial<Omit<PregelOptions<Nodes, Channels, ContextType>, \"encoding\">>): Promise<OutputType>;\n    private _runLoop;\n    clearCache(): Promise<void>;\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/pregel/index.ts"],"mappings":"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"}

package/dist/pregel/read.d.cts

@@ -2,7 +2,6 @@ import { CachePolicy, RetryPolicy } from "./utils/index.cjs";
 import { Runnable, RunnableBinding, RunnableBindingArgs, RunnableConfig, RunnableLike } from "@langchain/core/runnables";
 
 //#region src/pregel/read.d.ts
-
 interface PregelNodeArgs<RunInput, RunOutput> extends Partial<RunnableBindingArgs<RunInput, RunOutput>> {
   channels: Record<string, string> | string[];
   triggers: Array<string>;

package/dist/pregel/read.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"read.d.cts","names":["Runnable","RunnableBinding","RunnableBindingArgs","RunnableConfig","RunnableLike","RunnableCallable","CachePolicy","RetryPolicy","ChannelRead","Array","T","PregelNodeArgs","RunInput","RunOutput","Record","Partial","PregelNodeInputType","PregelNodeOutputType","PregelNode","NewRunOutput","Error","Exclude"],"sources":["../../src/pregel/read.d.ts"],"sourcesContent":["import { Runnable, RunnableBinding, RunnableBindingArgs, RunnableConfig, type RunnableLike } from \"@langchain/core/runnables\";\nimport { RunnableCallable } from \"../utils.js\";\nimport type { CachePolicy, RetryPolicy } from \"./utils/index.js\";\nexport declare class ChannelRead<RunInput = any> extends RunnableCallable {\n    lc_graph_name: string;\n    channel: string | Array<string>;\n    fresh: boolean;\n    mapper?: (args: any) => any;\n    constructor(channel: string | Array<string>, mapper?: (args: any) => any, fresh?: boolean);\n    static doRead<T = unknown>(config: RunnableConfig, channel: string | Array<string>, fresh: boolean, mapper?: (args: unknown) => unknown): T;\n}\ninterface PregelNodeArgs<RunInput, RunOutput> extends Partial<RunnableBindingArgs<RunInput, RunOutput>> {\n    channels: Record<string, string> | string[];\n    triggers: Array<string>;\n    mapper?: (args: any) => any;\n    writers?: Runnable<RunOutput, unknown>[];\n    tags?: string[];\n    bound?: Runnable<RunInput, RunOutput>;\n    kwargs?: Record<string, any>;\n    config?: RunnableConfig;\n    metadata?: Record<string, unknown>;\n    retryPolicy?: RetryPolicy;\n    cachePolicy?: CachePolicy;\n    subgraphs?: Runnable[];\n    ends?: string[];\n}\nexport type PregelNodeInputType = any;\nexport type PregelNodeOutputType = any;\nexport declare class PregelNode<RunInput = PregelNodeInputType, RunOutput = PregelNodeOutputType> extends RunnableBinding<RunInput, RunOutput, RunnableConfig> {\n    lc_graph_name: string;\n    channels: Record<string, string> | string[];\n    triggers: string[];\n    mapper?: (args: any) => any;\n    writers: Runnable[];\n    bound: Runnable<RunInput, RunOutput>;\n    kwargs: Record<string, any>;\n    metadata: Record<string, unknown>;\n    tags: string[];\n    retryPolicy?: RetryPolicy;\n    cachePolicy?: CachePolicy;\n    subgraphs?: Runnable[];\n    ends?: string[];\n    constructor(fields: PregelNodeArgs<RunInput, RunOutput>);\n    getWriters(): Array<Runnable>;\n    getNode(): Runnable<RunInput, RunOutput> | undefined;\n    join(channels: Array<string>): PregelNode<RunInput, RunOutput>;\n    pipe<NewRunOutput>(coerceable: RunnableLike): PregelNode<RunInput, Exclude<NewRunOutput, Error>>;\n}\nexport {};\n"],"mappings":";;;;;UAWUW,cAIaE,CAAAA,QAAAA,EAAAA,SAAAA,CAAAA,SAJ+BE,OAI/BF,CAJuCX,mBAIvCW,CAJ2DD,QAI3DC,EAJqEA,SAIrEA,CAAAA,CAAAA,CAAAA;UAATb,EAHAc,MAGAd,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA,GAAAA,MAAAA,EAAAA;UAEOY,EAJPH,KAIOG,CAAAA,MAAAA,CAAAA;QAAUC,CAAAA,EAAAA,CAAAA,IAAAA,EAAAA,GAAAA,EAAAA,GAAAA,GAAAA;SAAnBb,CAAAA,EAFEA,QAEFA,CAFWa,SAEXb,EAAAA,OAAAA,CAAAA,EAAAA;MACCc,CAAAA,EAAAA,MAAAA,EAAAA;OACAX,CAAAA,EAFDH,QAECG,CAFQS,QAERT,EAFkBU,SAElBV,CAAAA;QACEW,CAAAA,EAFFA,MAEEA,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA;QACGP,CAAAA,EAFLJ,cAEKI;UACAD,CAAAA,EAFHQ,MAEGR,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA;aACFN,CAAAA,EAFEO,WAEFP;aAZsCe,CAAAA,EAWpCT,WAXoCS;EAAO,SAAA,CAAA,EAY7Cf,QAZ6C,EAAA;EAejDgB,IAAAA,CAAAA,EAAAA,MAAAA,EAAAA;AACZ;AACqBE,KAFTF,mBAAAA,GAEmB,GAAA;AAAA,KADnBC,oBAAAA,GACmB,GAAA;AAAYD,cAAtBE,UAAsBF,CAAAA,WAAAA,mBAAAA,EAAAA,YAAiCC,oBAAjCD,CAAAA,SAA+Df,eAA/De,CAA+EJ,QAA/EI,EAAyFH,SAAzFG,EAAoGb,cAApGa,CAAAA,CAAAA;eAAiCC,EAAAA,MAAAA;UAA8CL,EAE5GE,MAF4GF,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA,GAAAA,MAAAA,EAAAA;UAAUC,EAAAA,MAAAA,EAAAA;QAAWV,CAAAA,EAAAA,CAAAA,IAAAA,EAAAA,GAAAA,EAAAA,GAAAA,GAAAA;SAEjIW,EAGDd,QAHCc,EAAAA;OAGDd,EACFA,QADEA,CACOY,QADPZ,EACiBa,SADjBb,CAAAA;QACOY,EACRE,MADQF,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA;UAAUC,EAEhBC,MAFgBD,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA;MAAnBb,EAAAA,MAAAA,EAAAA;aACCc,CAAAA,EAGMP,WAHNO;aACEA,CAAAA,EAGIR,WAHJQ;WAEIP,CAAAA,EAEFP,QAFEO,EAAAA;MACAD,CAAAA,EAAAA,MAAAA,EAAAA;aACFN,CAAAA,MAAAA,EAEQW,cAFRX,CAEuBY,QAFvBZ,EAEiCa,SAFjCb,CAAAA;YAEuBY,CAAAA,CAAAA,EACrBH,KADqBG,CACfZ,QADeY,CAAAA;SAAUC,CAAAA,CAAAA,EAElCb,QAFkCa,CAEzBD,QAFyBC,EAEfA,SAFeA,CAAAA,GAAAA,SAAAA;MAAzBF,CAAAA,QAAAA,EAGLF,KAHKE,CAAAA,MAAAA,CAAAA,CAAAA,EAGWO,UAHXP,CAGsBC,QAHtBD,EAGgCE,SAHhCF,CAAAA;MACAX,CAAAA,YAAAA,CAAAA,CAAAA,UAAAA,EAGWI,YAHXJ,CAAAA,EAG0BkB,UAH1BlB,CAGqCY,QAHrCZ,EAG+CqB,OAH/CrB,CAGuDmB,YAHvDnB,EAGqEoB,KAHrEpB,CAAAA,CAAAA"}
+{"version":3,"file":"read.d.cts","names":[],"sources":["../../src/pregel/read.ts"],"mappings":";;;;UAuEU,cAAA,8BACA,OAAA,CAAQ,mBAAA,CAAoB,QAAA,EAAU,SAAA;EAC9C,QAAA,EAAU,MAAA;EACV,QAAA,EAAU,KAAA;EAEV,MAAA,IAAU,IAAA;EACV,OAAA,GAAU,QAAA,CAAS,SAAA;EACnB,IAAA;EACA,KAAA,GAAQ,QAAA,CAAS,QAAA,EAAU,SAAA;EAE3B,MAAA,GAAS,MAAA;EACT,MAAA,GAAS,cAAA;EACT,QAAA,GAAW,MAAA;EACX,WAAA,GAAc,WAAA;EACd,WAAA,GAAc,WAAA;EACd,SAAA,GAAY,QAAA;EACZ,IAAA;AAAA;AAAA,KAIU,mBAAA;AAAA,KAGA,oBAAA;AAAA,cAEC,UAAA,YACA,mBAAA,cACC,oBAAA,UACJ,eAAA,CAAgB,QAAA,EAAU,SAAA,EAAW,cAAA;EAC7C,aAAA;EAEA,QAAA,EAAU,MAAA;EAEV,QAAA;EAGA,MAAA,IAAU,IAAA;EAEV,OAAA,EAAS,QAAA;EAET,KAAA,EAAO,QAAA,CAAS,QAAA,EAAU,SAAA;EAG1B,MAAA,EAAQ,MAAA;EAER,QAAA,EAAU,MAAA;EAEV,IAAA;EAEA,WAAA,GAAc,WAAA;EAEd,WAAA,GAAc,WAAA;EAEd,SAAA,GAAY,QAAA;EAEZ,IAAA;EAEA,WAAA,CAAY,MAAA,EAAQ,cAAA,CAAe,QAAA,EAAU,SAAA;EA6C7C,UAAA,CAAA,GAAc,KAAA,CAAM,QAAA;EAsBpB,OAAA,CAAA,GAAW,QAAA,CAAS,QAAA,EAAU,SAAA;EAyB9B,IAAA,CAAK,QAAA,EAAU,KAAA,WAAgB,UAAA,CAAW,QAAA,EAAU,SAAA;EAwBpD,IAAA,cAAA,CACE,UAAA,EAAY,YAAA,GACX,UAAA,CAAW,QAAA,EAAU,OAAA,CAAQ,YAAA,EAAc,KAAA;AAAA"}

package/dist/pregel/read.d.ts

@@ -1,8 +1,8 @@
+import "../utils.js";
 import { CachePolicy, RetryPolicy } from "./utils/index.js";
 import { Runnable, RunnableBinding, RunnableBindingArgs, RunnableConfig, RunnableLike } from "@langchain/core/runnables";
 
 //#region src/pregel/read.d.ts
-
 interface PregelNodeArgs<RunInput, RunOutput> extends Partial<RunnableBindingArgs<RunInput, RunOutput>> {
   channels: Record<string, string> | string[];
   triggers: Array<string>;

package/dist/pregel/read.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"read.d.ts","names":["Runnable","RunnableBinding","RunnableBindingArgs","RunnableConfig","RunnableLike","RunnableCallable","CachePolicy","RetryPolicy","ChannelRead","Array","T","PregelNodeArgs","RunInput","RunOutput","Record","Partial","PregelNodeInputType","PregelNodeOutputType","PregelNode","NewRunOutput","Error","Exclude"],"sources":["../../src/pregel/read.d.ts"],"sourcesContent":["import { Runnable, RunnableBinding, RunnableBindingArgs, RunnableConfig, type RunnableLike } from \"@langchain/core/runnables\";\nimport { RunnableCallable } from \"../utils.js\";\nimport type { CachePolicy, RetryPolicy } from \"./utils/index.js\";\nexport declare class ChannelRead<RunInput = any> extends RunnableCallable {\n    lc_graph_name: string;\n    channel: string | Array<string>;\n    fresh: boolean;\n    mapper?: (args: any) => any;\n    constructor(channel: string | Array<string>, mapper?: (args: any) => any, fresh?: boolean);\n    static doRead<T = unknown>(config: RunnableConfig, channel: string | Array<string>, fresh: boolean, mapper?: (args: unknown) => unknown): T;\n}\ninterface PregelNodeArgs<RunInput, RunOutput> extends Partial<RunnableBindingArgs<RunInput, RunOutput>> {\n    channels: Record<string, string> | string[];\n    triggers: Array<string>;\n    mapper?: (args: any) => any;\n    writers?: Runnable<RunOutput, unknown>[];\n    tags?: string[];\n    bound?: Runnable<RunInput, RunOutput>;\n    kwargs?: Record<string, any>;\n    config?: RunnableConfig;\n    metadata?: Record<string, unknown>;\n    retryPolicy?: RetryPolicy;\n    cachePolicy?: CachePolicy;\n    subgraphs?: Runnable[];\n    ends?: string[];\n}\nexport type PregelNodeInputType = any;\nexport type PregelNodeOutputType = any;\nexport declare class PregelNode<RunInput = PregelNodeInputType, RunOutput = PregelNodeOutputType> extends RunnableBinding<RunInput, RunOutput, RunnableConfig> {\n    lc_graph_name: string;\n    channels: Record<string, string> | string[];\n    triggers: string[];\n    mapper?: (args: any) => any;\n    writers: Runnable[];\n    bound: Runnable<RunInput, RunOutput>;\n    kwargs: Record<string, any>;\n    metadata: Record<string, unknown>;\n    tags: string[];\n    retryPolicy?: RetryPolicy;\n    cachePolicy?: CachePolicy;\n    subgraphs?: Runnable[];\n    ends?: string[];\n    constructor(fields: PregelNodeArgs<RunInput, RunOutput>);\n    getWriters(): Array<Runnable>;\n    getNode(): Runnable<RunInput, RunOutput> | undefined;\n    join(channels: Array<string>): PregelNode<RunInput, RunOutput>;\n    pipe<NewRunOutput>(coerceable: RunnableLike): PregelNode<RunInput, Exclude<NewRunOutput, Error>>;\n}\nexport {};\n"],"mappings":";;;;;UAWUW,cAIaE,CAAAA,QAAAA,EAAAA,SAAAA,CAAAA,SAJ+BE,OAI/BF,CAJuCX,mBAIvCW,CAJ2DD,QAI3DC,EAJqEA,SAIrEA,CAAAA,CAAAA,CAAAA;UAATb,EAHAc,MAGAd,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA,GAAAA,MAAAA,EAAAA;UAEOY,EAJPH,KAIOG,CAAAA,MAAAA,CAAAA;QAAUC,CAAAA,EAAAA,CAAAA,IAAAA,EAAAA,GAAAA,EAAAA,GAAAA,GAAAA;SAAnBb,CAAAA,EAFEA,QAEFA,CAFWa,SAEXb,EAAAA,OAAAA,CAAAA,EAAAA;MACCc,CAAAA,EAAAA,MAAAA,EAAAA;OACAX,CAAAA,EAFDH,QAECG,CAFQS,QAERT,EAFkBU,SAElBV,CAAAA;QACEW,CAAAA,EAFFA,MAEEA,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA;QACGP,CAAAA,EAFLJ,cAEKI;UACAD,CAAAA,EAFHQ,MAEGR,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA;aACFN,CAAAA,EAFEO,WAEFP;aAZsCe,CAAAA,EAWpCT,WAXoCS;EAAO,SAAA,CAAA,EAY7Cf,QAZ6C,EAAA;EAejDgB,IAAAA,CAAAA,EAAAA,MAAAA,EAAAA;AACZ;AACqBE,KAFTF,mBAAAA,GAEmB,GAAA;AAAA,KADnBC,oBAAAA,GACmB,GAAA;AAAYD,cAAtBE,UAAsBF,CAAAA,WAAAA,mBAAAA,EAAAA,YAAiCC,oBAAjCD,CAAAA,SAA+Df,eAA/De,CAA+EJ,QAA/EI,EAAyFH,SAAzFG,EAAoGb,cAApGa,CAAAA,CAAAA;eAAiCC,EAAAA,MAAAA;UAA8CL,EAE5GE,MAF4GF,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA,GAAAA,MAAAA,EAAAA;UAAUC,EAAAA,MAAAA,EAAAA;QAAWV,CAAAA,EAAAA,CAAAA,IAAAA,EAAAA,GAAAA,EAAAA,GAAAA,GAAAA;SAEjIW,EAGDd,QAHCc,EAAAA;OAGDd,EACFA,QADEA,CACOY,QADPZ,EACiBa,SADjBb,CAAAA;QACOY,EACRE,MADQF,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA;UAAUC,EAEhBC,MAFgBD,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA;MAAnBb,EAAAA,MAAAA,EAAAA;aACCc,CAAAA,EAGMP,WAHNO;aACEA,CAAAA,EAGIR,WAHJQ;WAEIP,CAAAA,EAEFP,QAFEO,EAAAA;MACAD,CAAAA,EAAAA,MAAAA,EAAAA;aACFN,CAAAA,MAAAA,EAEQW,cAFRX,CAEuBY,QAFvBZ,EAEiCa,SAFjCb,CAAAA;YAEuBY,CAAAA,CAAAA,EACrBH,KADqBG,CACfZ,QADeY,CAAAA;SAAUC,CAAAA,CAAAA,EAElCb,QAFkCa,CAEzBD,QAFyBC,EAEfA,SAFeA,CAAAA,GAAAA,SAAAA;MAAzBF,CAAAA,QAAAA,EAGLF,KAHKE,CAAAA,MAAAA,CAAAA,CAAAA,EAGWO,UAHXP,CAGsBC,QAHtBD,EAGgCE,SAHhCF,CAAAA;MACAX,CAAAA,YAAAA,CAAAA,CAAAA,UAAAA,EAGWI,YAHXJ,CAAAA,EAG0BkB,UAH1BlB,CAGqCY,QAHrCZ,EAG+CqB,OAH/CrB,CAGuDmB,YAHvDnB,EAGqEoB,KAHrEpB,CAAAA,CAAAA"}
+{"version":3,"file":"read.d.ts","names":[],"sources":["../../src/pregel/read.ts"],"mappings":";;;;;UAuEU,cAAA,8BACA,OAAA,CAAQ,mBAAA,CAAoB,QAAA,EAAU,SAAA;EAC9C,QAAA,EAAU,MAAA;EACV,QAAA,EAAU,KAAA;EAEV,MAAA,IAAU,IAAA;EACV,OAAA,GAAU,QAAA,CAAS,SAAA;EACnB,IAAA;EACA,KAAA,GAAQ,QAAA,CAAS,QAAA,EAAU,SAAA;EAE3B,MAAA,GAAS,MAAA;EACT,MAAA,GAAS,cAAA;EACT,QAAA,GAAW,MAAA;EACX,WAAA,GAAc,WAAA;EACd,WAAA,GAAc,WAAA;EACd,SAAA,GAAY,QAAA;EACZ,IAAA;AAAA;AAAA,KAIU,mBAAA;AAAA,KAGA,oBAAA;AAAA,cAEC,UAAA,YACA,mBAAA,cACC,oBAAA,UACJ,eAAA,CAAgB,QAAA,EAAU,SAAA,EAAW,cAAA;EAC7C,aAAA;EAEA,QAAA,EAAU,MAAA;EAEV,QAAA;EAGA,MAAA,IAAU,IAAA;EAEV,OAAA,EAAS,QAAA;EAET,KAAA,EAAO,QAAA,CAAS,QAAA,EAAU,SAAA;EAG1B,MAAA,EAAQ,MAAA;EAER,QAAA,EAAU,MAAA;EAEV,IAAA;EAEA,WAAA,GAAc,WAAA;EAEd,WAAA,GAAc,WAAA;EAEd,SAAA,GAAY,QAAA;EAEZ,IAAA;EAEA,WAAA,CAAY,MAAA,EAAQ,cAAA,CAAe,QAAA,EAAU,SAAA;EA6C7C,UAAA,CAAA,GAAc,KAAA,CAAM,QAAA;EAsBpB,OAAA,CAAA,GAAW,QAAA,CAAS,QAAA,EAAU,SAAA;EAyB9B,IAAA,CAAK,QAAA,EAAU,KAAA,WAAgB,UAAA,CAAW,QAAA,EAAU,SAAA;EAwBpD,IAAA,cAAA,CACE,UAAA,EAAY,YAAA,GACX,UAAA,CAAW,QAAA,EAAU,OAAA,CAAQ,YAAA,EAAc,KAAA;AAAA"}

package/dist/pregel/remote.cjs

@@ -10,7 +10,7 @@ let _langchain_langgraph_sdk = require("@langchain/langgraph-sdk");
 const _serializeInputs = (obj) => {
 	if (obj === null || typeof obj !== "object") return obj;
 	if (Array.isArray(obj)) return obj.map(_serializeInputs);
-	if ((0, _langchain_core_messages.isBaseMessage)(obj)) return {
+	if (_langchain_core_messages.BaseMessage.isInstance(obj)) return {
 		...obj.toDict().data,
 		role: obj.getType()
 	};

package/dist/pregel/remote.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"remote.cjs","names":["Runnable","Client","CONFIG_KEY_STREAM","isCommand","CHECKPOINT_NAMESPACE_SEPARATOR","INTERRUPT","GraphInterrupt","RemoteException","DrawableGraph"],"sources":["../../src/pregel/remote.ts"],"sourcesContent":["import {\n  Client,\n  type Checkpoint,\n  type ThreadState,\n} from \"@langchain/langgraph-sdk\";\nimport {\n  Graph as DrawableGraph,\n  Node as DrawableNode,\n} from \"@langchain/core/runnables/graph\";\nimport {\n  mergeConfigs,\n  Runnable,\n  RunnableConfig,\n} from \"@langchain/core/runnables\";\nimport {\n  All,\n  CheckpointListOptions,\n  CheckpointMetadata,\n} from \"@langchain/langgraph-checkpoint\";\nimport { StreamEvent } from \"@langchain/core/tracers/log_stream\";\nimport { IterableReadableStream } from \"@langchain/core/utils/stream\";\nimport { isBaseMessage } from \"@langchain/core/messages\";\n\nimport {\n  BaseChannel,\n  GraphInterrupt,\n  LangGraphRunnableConfig,\n  RemoteException,\n} from \"../web.js\";\nimport { StrRecord } from \"./algo.js\";\nimport { PregelInputType, PregelOptions, PregelOutputType } from \"./index.js\";\nimport { PregelNode } from \"./read.js\";\nimport {\n  PregelParams,\n  PregelInterface,\n  PregelTaskDescription,\n  StateSnapshot,\n  StreamMode,\n} from \"./types.js\";\nimport {\n  CHECKPOINT_NAMESPACE_SEPARATOR,\n  CONFIG_KEY_STREAM,\n  INTERRUPT,\n  isCommand,\n} from \"../constants.js\";\n\nexport type RemoteGraphParams = Omit<\n  PregelParams<StrRecord<string, PregelNode>, StrRecord<string, BaseChannel>>,\n  \"channels\" | \"nodes\" | \"inputChannels\" | \"outputChannels\"\n> & {\n  graphId: string;\n  client?: Client;\n  url?: string;\n  apiKey?: string;\n  headers?: Record<string, string>;\n  streamResumable?: boolean;\n};\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nconst _serializeInputs = (obj: any): any => {\n  if (obj === null || typeof obj !== \"object\") {\n    return obj;\n  }\n\n  if (Array.isArray(obj)) {\n    return obj.map(_serializeInputs);\n  }\n\n  // Handle BaseMessage instances by converting them to a serializable format\n  if (isBaseMessage(obj)) {\n    const dict = obj.toDict();\n    return {\n      ...dict.data,\n      role: obj.getType(),\n    };\n  }\n\n  return Object.fromEntries(\n    Object.entries(obj).map(([key, value]) => [key, _serializeInputs(value)])\n  );\n};\n\n/**\n * Return a tuple of the final list of stream modes sent to the\n * remote graph and a boolean flag indicating if only one stream mode was\n * originally requested and whether stream mode 'updates'\n * was present in the original list of stream modes.\n *\n * 'updates' mode is always added to the list of stream modes so that interrupts\n * can be detected in the remote graph.\n */\nconst getStreamModes = (\n  streamMode?: StreamMode | StreamMode[],\n  defaultStreamMode: StreamMode = \"updates\"\n) => {\n  const updatedStreamModes: StreamMode[] = [];\n  let reqUpdates = false;\n  let reqSingle = true;\n\n  if (\n    streamMode !== undefined &&\n    (typeof streamMode === \"string\" ||\n      (Array.isArray(streamMode) && streamMode.length > 0))\n  ) {\n    reqSingle = typeof streamMode === \"string\";\n    const mapped = Array.isArray(streamMode) ? streamMode : [streamMode];\n    updatedStreamModes.push(...mapped);\n  } else {\n    updatedStreamModes.push(defaultStreamMode);\n  }\n  if (updatedStreamModes.includes(\"updates\")) {\n    reqUpdates = true;\n  } else {\n    updatedStreamModes.push(\"updates\");\n  }\n  return {\n    updatedStreamModes,\n    reqUpdates,\n    reqSingle,\n  };\n};\n\n/**\n * The `RemoteGraph` class is a client implementation for calling remote\n * APIs that implement the LangGraph Server API specification.\n *\n * For example, the `RemoteGraph` class can be used to call APIs from deployments\n * on LangSmith Deployment.\n *\n * `RemoteGraph` behaves the same way as a `StateGraph` and can be used directly as\n * a node in another `StateGraph`.\n *\n * @example\n * ```ts\n * import { RemoteGraph } from \"@langchain/langgraph/remote\";\n *\n * // Can also pass a LangGraph SDK client instance directly\n * const remoteGraph = new RemoteGraph({\n *   graphId: process.env.LANGGRAPH_REMOTE_GRAPH_ID!,\n *   apiKey: process.env.LANGGRAPH_REMOTE_GRAPH_API_KEY,\n *   url: process.env.LANGGRAPH_REMOTE_GRAPH_API_URL,\n * });\n *\n * const input = {\n *   messages: [\n *     {\n *       role: \"human\",\n *       content: \"Hello world!\",\n *     },\n *   ],\n * };\n *\n * const config = {\n *   configurable: { thread_id: \"threadId1\" },\n * };\n *\n * await remoteGraph.invoke(input, config);\n * ```\n */\nexport class RemoteGraph<\n    Nn extends StrRecord<string, PregelNode> = StrRecord<string, PregelNode>,\n    Cc extends StrRecord<string, BaseChannel> = StrRecord<string, BaseChannel>,\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    ContextType extends Record<string, any> = StrRecord<string, any>\n  >\n  extends Runnable<\n    PregelInputType,\n    PregelOutputType,\n    PregelOptions<Nn, Cc, ContextType>\n  >\n  implements PregelInterface<Nn, Cc, ContextType>\n{\n  static lc_name() {\n    return \"RemoteGraph\";\n  }\n\n  lc_namespace = [\"langgraph\", \"pregel\"];\n\n  lg_is_pregel = true;\n\n  config?: RunnableConfig;\n\n  graphId: string;\n\n  protected client: Client;\n\n  protected interruptBefore?: Array<keyof Nn> | All;\n\n  protected interruptAfter?: Array<keyof Nn> | All;\n\n  protected streamResumable?: boolean;\n\n  constructor(params: RemoteGraphParams) {\n    super(params);\n\n    this.graphId = params.graphId;\n    this.client =\n      params.client ??\n      new Client({\n        apiUrl: params.url,\n        apiKey: params.apiKey,\n        defaultHeaders: params.headers,\n      });\n    this.config = params.config;\n    this.interruptBefore = params.interruptBefore;\n    this.interruptAfter = params.interruptAfter;\n    this.streamResumable = params.streamResumable;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n  // @ts-ignore Remove ignore when we remove support for 0.2 versions of core\n  override withConfig(config: RunnableConfig): typeof this {\n    const mergedConfig = mergeConfigs(this.config, config);\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    return new (this.constructor as any)({ ...this, config: mergedConfig });\n  }\n\n  protected _sanitizeConfig(config: RunnableConfig) {\n    const reservedConfigurableKeys = new Set([\n      \"callbacks\",\n      \"checkpoint_map\",\n      \"checkpoint_id\",\n      \"checkpoint_ns\",\n    ]);\n\n    const sanitizeObj = <T>(obj: T): T => {\n      try {\n        // This will only throw if we're trying to serialize a circular reference\n        // or trying to serialize a BigInt...\n        JSON.stringify(obj);\n        return obj;\n      } catch {\n        const seen = new WeakSet();\n        return JSON.parse(\n          JSON.stringify(obj, (_, value) => {\n            if (typeof value === \"object\" && value != null) {\n              if (seen.has(value)) return \"[Circular]\";\n              seen.add(value);\n            }\n\n            if (typeof value === \"bigint\") return value.toString();\n            return value;\n          })\n        );\n      }\n    };\n\n    // Remove non-JSON serializable fields from the config\n    const sanitizedConfig = sanitizeObj(config);\n\n    // Only include configurable keys that are not reserved and\n    // not starting with \"__pregel_\" prefix\n    const newConfigurable = Object.fromEntries(\n      Object.entries(sanitizedConfig.configurable ?? {}).filter(\n        ([k]) => !reservedConfigurableKeys.has(k) && !k.startsWith(\"__pregel_\")\n      )\n    );\n\n    return {\n      tags: sanitizedConfig.tags ?? [],\n      metadata: sanitizedConfig.metadata ?? {},\n      configurable: newConfigurable,\n      recursion_limit: sanitizedConfig.recursionLimit,\n    };\n  }\n\n  protected _getConfig(checkpoint: Record<string, unknown>): RunnableConfig {\n    return {\n      configurable: {\n        thread_id: checkpoint.thread_id,\n        checkpoint_ns: checkpoint.checkpoint_ns,\n        checkpoint_id: checkpoint.checkpoint_id,\n        checkpoint_map: checkpoint.checkpoint_map ?? {},\n      },\n    };\n  }\n\n  protected _getCheckpoint(config?: RunnableConfig): Checkpoint | undefined {\n    if (config?.configurable === undefined) {\n      return undefined;\n    }\n\n    const checkpointKeys = [\n      \"thread_id\",\n      \"checkpoint_ns\",\n      \"checkpoint_id\",\n      \"checkpoint_map\",\n    ] as const;\n\n    const checkpoint = Object.fromEntries(\n      checkpointKeys\n        .map((key) => [key, config.configurable![key]])\n        .filter(([_, value]) => value !== undefined)\n    );\n\n    return Object.keys(checkpoint).length > 0 ? checkpoint : undefined;\n  }\n\n  protected _createStateSnapshot(state: ThreadState): StateSnapshot {\n    const tasks: PregelTaskDescription[] = state.tasks.map((task) => {\n      return {\n        id: task.id,\n        name: task.name,\n        error: task.error ? { message: task.error } : undefined,\n        // TODO: remove in LangGraph.js 0.4\n        interrupts: task.interrupts.map(({ id, ...rest }) => ({\n          interrupt_id: id,\n          ...rest,\n        })),\n        // eslint-disable-next-line no-nested-ternary\n        state: task.state\n          ? this._createStateSnapshot(task.state)\n          : task.checkpoint\n          ? { configurable: task.checkpoint }\n          : undefined,\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        result: (task as any).result,\n      };\n    });\n\n    return {\n      values: state.values,\n      next: state.next ? [...state.next] : [],\n      config: {\n        configurable: {\n          thread_id: state.checkpoint.thread_id,\n          checkpoint_ns: state.checkpoint.checkpoint_ns,\n          checkpoint_id: state.checkpoint.checkpoint_id,\n          checkpoint_map: state.checkpoint.checkpoint_map ?? {},\n        },\n      },\n      metadata: state.metadata\n        ? (state.metadata as CheckpointMetadata)\n        : undefined,\n      createdAt: state.created_at ?? undefined,\n      parentConfig: state.parent_checkpoint\n        ? {\n            configurable: {\n              thread_id: state.parent_checkpoint.thread_id,\n              checkpoint_ns: state.parent_checkpoint.checkpoint_ns,\n              checkpoint_id: state.parent_checkpoint.checkpoint_id,\n              checkpoint_map: state.parent_checkpoint.checkpoint_map ?? {},\n            },\n          }\n        : undefined,\n      tasks,\n    };\n  }\n\n  override async invoke(\n    input: PregelInputType,\n    options?: Partial<PregelOptions<Nn, Cc, ContextType>>\n  ): Promise<PregelOutputType> {\n    let lastValue;\n    const stream = await this.stream(input, {\n      ...options,\n      streamMode: \"values\",\n    });\n    for await (const chunk of stream) {\n      lastValue = chunk;\n    }\n    return lastValue;\n  }\n\n  override streamEvents(\n    input: PregelInputType,\n    options: Partial<PregelOptions<Nn, Cc, ContextType>> & {\n      version: \"v1\" | \"v2\";\n    }\n  ): IterableReadableStream<StreamEvent>;\n\n  override streamEvents(\n    input: PregelInputType,\n    options: Partial<PregelOptions<Nn, Cc, ContextType>> & {\n      version: \"v1\" | \"v2\";\n      encoding: never;\n    }\n  ): IterableReadableStream<never>;\n\n  override streamEvents(\n    _input: PregelInputType,\n    _options: Partial<PregelOptions<Nn, Cc, ContextType>> & {\n      version: \"v1\" | \"v2\";\n      encoding?: never;\n    }\n  ): IterableReadableStream<StreamEvent> {\n    throw new Error(\"Not implemented.\");\n  }\n\n  override async *_streamIterator(\n    input: PregelInputType,\n    options?: Partial<PregelOptions<Nn, Cc, ContextType>>\n  ): AsyncGenerator<PregelOutputType> {\n    const mergedConfig = mergeConfigs(this.config, options);\n    const sanitizedConfig = this._sanitizeConfig(mergedConfig);\n\n    const streamProtocolInstance = options?.configurable?.[CONFIG_KEY_STREAM];\n\n    const streamSubgraphs =\n      options?.subgraphs ?? streamProtocolInstance !== undefined;\n\n    const interruptBefore = options?.interruptBefore ?? this.interruptBefore;\n    const interruptAfter = options?.interruptAfter ?? this.interruptAfter;\n\n    const { updatedStreamModes, reqSingle, reqUpdates } = getStreamModes(\n      options?.streamMode\n    );\n\n    const extendedStreamModes = [\n      ...new Set([\n        ...updatedStreamModes,\n        ...(streamProtocolInstance?.modes ?? new Set()),\n      ]),\n    ].map((mode) => {\n      if (mode === \"messages\") return \"messages-tuple\";\n      return mode;\n    });\n\n    let command;\n    let serializedInput;\n    if (isCommand(input)) {\n      // TODO: Remove cast when SDK type fix gets merged\n      command = input.toJSON() as Record<string, unknown>;\n      serializedInput = undefined;\n    } else {\n      serializedInput = _serializeInputs(input);\n    }\n\n    for await (const chunk of this.client.runs.stream(\n      sanitizedConfig.configurable.thread_id as string,\n      this.graphId,\n      {\n        command,\n        input: serializedInput,\n        config: sanitizedConfig,\n        streamMode: extendedStreamModes,\n        interruptBefore: interruptBefore as string[],\n        interruptAfter: interruptAfter as string[],\n        streamSubgraphs,\n        ifNotExists: \"create\",\n        signal: mergedConfig.signal,\n        streamResumable: this.streamResumable,\n      }\n    )) {\n      let mode;\n      let namespace: string[];\n      if (chunk.event.includes(CHECKPOINT_NAMESPACE_SEPARATOR)) {\n        const eventComponents = chunk.event.split(\n          CHECKPOINT_NAMESPACE_SEPARATOR\n        );\n        // eslint-disable-next-line prefer-destructuring\n        mode = eventComponents[0];\n        namespace = eventComponents.slice(1);\n      } else {\n        mode = chunk.event;\n        namespace = [];\n      }\n      const callerNamespace = options?.configurable?.checkpoint_ns;\n      if (typeof callerNamespace === \"string\") {\n        namespace = callerNamespace\n          .split(CHECKPOINT_NAMESPACE_SEPARATOR)\n          .concat(namespace);\n      }\n      if (\n        streamProtocolInstance !== undefined &&\n        streamProtocolInstance.modes?.has(chunk.event)\n      ) {\n        streamProtocolInstance.push([namespace, mode, chunk.data]);\n      }\n      if (chunk.event.startsWith(\"updates\")) {\n        if (\n          typeof chunk.data === \"object\" &&\n          chunk.data?.[INTERRUPT] !== undefined\n        ) {\n          throw new GraphInterrupt(chunk.data[INTERRUPT]);\n        }\n        if (!reqUpdates) {\n          continue;\n        }\n      } else if (chunk.event?.startsWith(\"error\")) {\n        throw new RemoteException(\n          typeof chunk.data === \"string\"\n            ? chunk.data\n            : JSON.stringify(chunk.data)\n        );\n      }\n      if (\n        !updatedStreamModes.includes(\n          chunk.event.split(CHECKPOINT_NAMESPACE_SEPARATOR)[0] as StreamMode\n        )\n      ) {\n        continue;\n      }\n      if (options?.subgraphs) {\n        if (reqSingle) {\n          yield [namespace, chunk.data];\n        } else {\n          yield [namespace, mode, chunk.data];\n        }\n      } else if (reqSingle) {\n        yield chunk.data;\n      } else {\n        yield [mode, chunk.data];\n      }\n    }\n  }\n\n  async updateState(\n    inputConfig: LangGraphRunnableConfig,\n    values: Record<string, unknown>,\n    asNode?: string\n  ): Promise<RunnableConfig> {\n    const mergedConfig = mergeConfigs(this.config, inputConfig);\n    const response = await this.client.threads.updateState(\n      mergedConfig.configurable?.thread_id,\n      { values, asNode, checkpoint: this._getCheckpoint(mergedConfig) }\n    );\n    // TODO: Fix SDK typing\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    return this._getConfig((response as any).checkpoint);\n  }\n\n  async *getStateHistory(\n    config: RunnableConfig,\n    options?: CheckpointListOptions\n  ): AsyncIterableIterator<StateSnapshot> {\n    const mergedConfig = mergeConfigs(this.config, config);\n    const states = await this.client.threads.getHistory(\n      mergedConfig.configurable?.thread_id,\n      {\n        limit: options?.limit ?? 10,\n        // TODO: Fix type\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        before: this._getCheckpoint(options?.before) as any,\n        metadata: options?.filter,\n        checkpoint: this._getCheckpoint(mergedConfig),\n      }\n    );\n    for (const state of states) {\n      yield this._createStateSnapshot(state);\n    }\n  }\n\n  protected _getDrawableNodes(\n    nodes: Array<{\n      id: string | number;\n      name?: string;\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      data?: Record<string, any> | string;\n      metadata?: unknown;\n    }>\n  ): Record<string, DrawableNode> {\n    const nodesMap: Record<string, DrawableNode> = {};\n    for (const node of nodes) {\n      const nodeId = node.id;\n      nodesMap[nodeId] = {\n        id: nodeId.toString(),\n        name: typeof node.data === \"string\" ? node.data : node.data?.name ?? \"\",\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        data: (node.data as any) ?? {},\n        metadata:\n          typeof node.data !== \"string\" ? node.data?.metadata ?? {} : {},\n      };\n    }\n    return nodesMap;\n  }\n\n  async getState(\n    config: RunnableConfig,\n    options?: { subgraphs?: boolean }\n  ): Promise<StateSnapshot> {\n    const mergedConfig = mergeConfigs(this.config, config);\n\n    const state = await this.client.threads.getState(\n      mergedConfig.configurable?.thread_id,\n      this._getCheckpoint(mergedConfig),\n      options\n    );\n    return this._createStateSnapshot(state);\n  }\n\n  /** @deprecated Use getGraphAsync instead. The async method will become the default in the next minor release. */\n  override getGraph(\n    _?: RunnableConfig & { xray?: boolean | number }\n  ): DrawableGraph {\n    throw new Error(\n      `The synchronous \"getGraph\" is not supported for this graph. Call \"getGraphAsync\" instead.`\n    );\n  }\n\n  /**\n   * Returns a drawable representation of the computation graph.\n   */\n  async getGraphAsync(config?: RunnableConfig & { xray?: boolean | number }) {\n    const graph = await this.client.assistants.getGraph(this.graphId, {\n      xray: config?.xray,\n    });\n    return new DrawableGraph({\n      nodes: this._getDrawableNodes(graph.nodes),\n      edges: graph.edges,\n    });\n  }\n\n  /** @deprecated Use getSubgraphsAsync instead. The async method will become the default in the next minor release. */\n  getSubgraphs(): Generator<[string, PregelInterface<Nn, Cc, ContextType>]> {\n    throw new Error(\n      `The synchronous \"getSubgraphs\" method is not supported for this graph. Call \"getSubgraphsAsync\" instead.`\n    );\n  }\n\n  async *getSubgraphsAsync(\n    namespace?: string,\n    recurse = false\n  ): AsyncGenerator<[string, PregelInterface<Nn, Cc, ContextType>]> {\n    const subgraphs = await this.client.assistants.getSubgraphs(this.graphId, {\n      namespace,\n      recurse,\n    });\n\n    for (const [ns, graphSchema] of Object.entries(subgraphs)) {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      const remoteSubgraph = new (this.constructor as any)({\n        ...this,\n        graphId: graphSchema.graph_id,\n      });\n      yield [ns, remoteSubgraph];\n    }\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"remote.cjs","names":["BaseMessage","Runnable","Client","CONFIG_KEY_STREAM","isCommand","CHECKPOINT_NAMESPACE_SEPARATOR","INTERRUPT","GraphInterrupt","RemoteException","DrawableGraph"],"sources":["../../src/pregel/remote.ts"],"sourcesContent":["import {\n  Client,\n  type Checkpoint,\n  type ThreadState,\n} from \"@langchain/langgraph-sdk\";\nimport {\n  Graph as DrawableGraph,\n  Node as DrawableNode,\n} from \"@langchain/core/runnables/graph\";\nimport {\n  mergeConfigs,\n  Runnable,\n  RunnableConfig,\n} from \"@langchain/core/runnables\";\nimport {\n  All,\n  CheckpointListOptions,\n  CheckpointMetadata,\n} from \"@langchain/langgraph-checkpoint\";\nimport { StreamEvent } from \"@langchain/core/tracers/log_stream\";\nimport { IterableReadableStream } from \"@langchain/core/utils/stream\";\nimport { BaseMessage } from \"@langchain/core/messages\";\n\nimport {\n  BaseChannel,\n  GraphInterrupt,\n  LangGraphRunnableConfig,\n  RemoteException,\n} from \"../web.js\";\nimport { StrRecord } from \"./algo.js\";\nimport { PregelInputType, PregelOptions, PregelOutputType } from \"./index.js\";\nimport { PregelNode } from \"./read.js\";\nimport {\n  PregelParams,\n  PregelInterface,\n  PregelTaskDescription,\n  StateSnapshot,\n  StreamMode,\n} from \"./types.js\";\nimport {\n  CHECKPOINT_NAMESPACE_SEPARATOR,\n  CONFIG_KEY_STREAM,\n  INTERRUPT,\n  isCommand,\n} from \"../constants.js\";\n\nexport type RemoteGraphParams = Omit<\n  PregelParams<StrRecord<string, PregelNode>, StrRecord<string, BaseChannel>>,\n  \"channels\" | \"nodes\" | \"inputChannels\" | \"outputChannels\"\n> & {\n  graphId: string;\n  client?: Client;\n  url?: string;\n  apiKey?: string;\n  headers?: Record<string, string>;\n  streamResumable?: boolean;\n};\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nconst _serializeInputs = (obj: any): any => {\n  if (obj === null || typeof obj !== \"object\") {\n    return obj;\n  }\n\n  if (Array.isArray(obj)) {\n    return obj.map(_serializeInputs);\n  }\n\n  // Handle BaseMessage instances by converting them to a serializable format\n  if (BaseMessage.isInstance(obj)) {\n    const dict = obj.toDict();\n    return {\n      ...dict.data,\n      role: obj.getType(),\n    };\n  }\n\n  return Object.fromEntries(\n    Object.entries(obj).map(([key, value]) => [key, _serializeInputs(value)])\n  );\n};\n\n/**\n * Return a tuple of the final list of stream modes sent to the\n * remote graph and a boolean flag indicating if only one stream mode was\n * originally requested and whether stream mode 'updates'\n * was present in the original list of stream modes.\n *\n * 'updates' mode is always added to the list of stream modes so that interrupts\n * can be detected in the remote graph.\n */\nconst getStreamModes = (\n  streamMode?: StreamMode | StreamMode[],\n  defaultStreamMode: StreamMode = \"updates\"\n) => {\n  const updatedStreamModes: StreamMode[] = [];\n  let reqUpdates = false;\n  let reqSingle = true;\n\n  if (\n    streamMode !== undefined &&\n    (typeof streamMode === \"string\" ||\n      (Array.isArray(streamMode) && streamMode.length > 0))\n  ) {\n    reqSingle = typeof streamMode === \"string\";\n    const mapped = Array.isArray(streamMode) ? streamMode : [streamMode];\n    updatedStreamModes.push(...mapped);\n  } else {\n    updatedStreamModes.push(defaultStreamMode);\n  }\n  if (updatedStreamModes.includes(\"updates\")) {\n    reqUpdates = true;\n  } else {\n    updatedStreamModes.push(\"updates\");\n  }\n  return {\n    updatedStreamModes,\n    reqUpdates,\n    reqSingle,\n  };\n};\n\n/**\n * The `RemoteGraph` class is a client implementation for calling remote\n * APIs that implement the LangGraph Server API specification.\n *\n * For example, the `RemoteGraph` class can be used to call APIs from deployments\n * on LangSmith Deployment.\n *\n * `RemoteGraph` behaves the same way as a `StateGraph` and can be used directly as\n * a node in another `StateGraph`.\n *\n * @example\n * ```ts\n * import { RemoteGraph } from \"@langchain/langgraph/remote\";\n *\n * // Can also pass a LangGraph SDK client instance directly\n * const remoteGraph = new RemoteGraph({\n *   graphId: process.env.LANGGRAPH_REMOTE_GRAPH_ID!,\n *   apiKey: process.env.LANGGRAPH_REMOTE_GRAPH_API_KEY,\n *   url: process.env.LANGGRAPH_REMOTE_GRAPH_API_URL,\n * });\n *\n * const input = {\n *   messages: [\n *     {\n *       role: \"human\",\n *       content: \"Hello world!\",\n *     },\n *   ],\n * };\n *\n * const config = {\n *   configurable: { thread_id: \"threadId1\" },\n * };\n *\n * await remoteGraph.invoke(input, config);\n * ```\n */\nexport class RemoteGraph<\n    Nn extends StrRecord<string, PregelNode> = StrRecord<string, PregelNode>,\n    Cc extends StrRecord<string, BaseChannel> = StrRecord<string, BaseChannel>,\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    ContextType extends Record<string, any> = StrRecord<string, any>\n  >\n  extends Runnable<\n    PregelInputType,\n    PregelOutputType,\n    PregelOptions<Nn, Cc, ContextType>\n  >\n  implements PregelInterface<Nn, Cc, ContextType>\n{\n  static lc_name() {\n    return \"RemoteGraph\";\n  }\n\n  lc_namespace = [\"langgraph\", \"pregel\"];\n\n  lg_is_pregel = true;\n\n  config?: RunnableConfig;\n\n  graphId: string;\n\n  protected client: Client;\n\n  protected interruptBefore?: Array<keyof Nn> | All;\n\n  protected interruptAfter?: Array<keyof Nn> | All;\n\n  protected streamResumable?: boolean;\n\n  constructor(params: RemoteGraphParams) {\n    super(params);\n\n    this.graphId = params.graphId;\n    this.client =\n      params.client ??\n      new Client({\n        apiUrl: params.url,\n        apiKey: params.apiKey,\n        defaultHeaders: params.headers,\n      });\n    this.config = params.config;\n    this.interruptBefore = params.interruptBefore;\n    this.interruptAfter = params.interruptAfter;\n    this.streamResumable = params.streamResumable;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n  // @ts-ignore Remove ignore when we remove support for 0.2 versions of core\n  override withConfig(config: RunnableConfig): typeof this {\n    const mergedConfig = mergeConfigs(this.config, config);\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    return new (this.constructor as any)({ ...this, config: mergedConfig });\n  }\n\n  protected _sanitizeConfig(config: RunnableConfig) {\n    const reservedConfigurableKeys = new Set([\n      \"callbacks\",\n      \"checkpoint_map\",\n      \"checkpoint_id\",\n      \"checkpoint_ns\",\n    ]);\n\n    const sanitizeObj = <T>(obj: T): T => {\n      try {\n        // This will only throw if we're trying to serialize a circular reference\n        // or trying to serialize a BigInt...\n        JSON.stringify(obj);\n        return obj;\n      } catch {\n        const seen = new WeakSet();\n        return JSON.parse(\n          JSON.stringify(obj, (_, value) => {\n            if (typeof value === \"object\" && value != null) {\n              if (seen.has(value)) return \"[Circular]\";\n              seen.add(value);\n            }\n\n            if (typeof value === \"bigint\") return value.toString();\n            return value;\n          })\n        );\n      }\n    };\n\n    // Remove non-JSON serializable fields from the config\n    const sanitizedConfig = sanitizeObj(config);\n\n    // Only include configurable keys that are not reserved and\n    // not starting with \"__pregel_\" prefix\n    const newConfigurable = Object.fromEntries(\n      Object.entries(sanitizedConfig.configurable ?? {}).filter(\n        ([k]) => !reservedConfigurableKeys.has(k) && !k.startsWith(\"__pregel_\")\n      )\n    );\n\n    return {\n      tags: sanitizedConfig.tags ?? [],\n      metadata: sanitizedConfig.metadata ?? {},\n      configurable: newConfigurable,\n      recursion_limit: sanitizedConfig.recursionLimit,\n    };\n  }\n\n  protected _getConfig(checkpoint: Record<string, unknown>): RunnableConfig {\n    return {\n      configurable: {\n        thread_id: checkpoint.thread_id,\n        checkpoint_ns: checkpoint.checkpoint_ns,\n        checkpoint_id: checkpoint.checkpoint_id,\n        checkpoint_map: checkpoint.checkpoint_map ?? {},\n      },\n    };\n  }\n\n  protected _getCheckpoint(config?: RunnableConfig): Checkpoint | undefined {\n    if (config?.configurable === undefined) {\n      return undefined;\n    }\n\n    const checkpointKeys = [\n      \"thread_id\",\n      \"checkpoint_ns\",\n      \"checkpoint_id\",\n      \"checkpoint_map\",\n    ] as const;\n\n    const checkpoint = Object.fromEntries(\n      checkpointKeys\n        .map((key) => [key, config.configurable![key]])\n        .filter(([_, value]) => value !== undefined)\n    );\n\n    return Object.keys(checkpoint).length > 0 ? checkpoint : undefined;\n  }\n\n  protected _createStateSnapshot(state: ThreadState): StateSnapshot {\n    const tasks: PregelTaskDescription[] = state.tasks.map((task) => {\n      return {\n        id: task.id,\n        name: task.name,\n        error: task.error ? { message: task.error } : undefined,\n        // TODO: remove in LangGraph.js 0.4\n        interrupts: task.interrupts.map(({ id, ...rest }) => ({\n          interrupt_id: id,\n          ...rest,\n        })),\n        // eslint-disable-next-line no-nested-ternary\n        state: task.state\n          ? this._createStateSnapshot(task.state)\n          : task.checkpoint\n          ? { configurable: task.checkpoint }\n          : undefined,\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        result: (task as any).result,\n      };\n    });\n\n    return {\n      values: state.values,\n      next: state.next ? [...state.next] : [],\n      config: {\n        configurable: {\n          thread_id: state.checkpoint.thread_id,\n          checkpoint_ns: state.checkpoint.checkpoint_ns,\n          checkpoint_id: state.checkpoint.checkpoint_id,\n          checkpoint_map: state.checkpoint.checkpoint_map ?? {},\n        },\n      },\n      metadata: state.metadata\n        ? (state.metadata as CheckpointMetadata)\n        : undefined,\n      createdAt: state.created_at ?? undefined,\n      parentConfig: state.parent_checkpoint\n        ? {\n            configurable: {\n              thread_id: state.parent_checkpoint.thread_id,\n              checkpoint_ns: state.parent_checkpoint.checkpoint_ns,\n              checkpoint_id: state.parent_checkpoint.checkpoint_id,\n              checkpoint_map: state.parent_checkpoint.checkpoint_map ?? {},\n            },\n          }\n        : undefined,\n      tasks,\n    };\n  }\n\n  override async invoke(\n    input: PregelInputType,\n    options?: Partial<PregelOptions<Nn, Cc, ContextType>>\n  ): Promise<PregelOutputType> {\n    let lastValue;\n    const stream = await this.stream(input, {\n      ...options,\n      streamMode: \"values\",\n    });\n    for await (const chunk of stream) {\n      lastValue = chunk;\n    }\n    return lastValue;\n  }\n\n  override streamEvents(\n    input: PregelInputType,\n    options: Partial<PregelOptions<Nn, Cc, ContextType>> & {\n      version: \"v1\" | \"v2\";\n    }\n  ): IterableReadableStream<StreamEvent>;\n\n  override streamEvents(\n    input: PregelInputType,\n    options: Partial<PregelOptions<Nn, Cc, ContextType>> & {\n      version: \"v1\" | \"v2\";\n      encoding: never;\n    }\n  ): IterableReadableStream<never>;\n\n  override streamEvents(\n    _input: PregelInputType,\n    _options: Partial<PregelOptions<Nn, Cc, ContextType>> & {\n      version: \"v1\" | \"v2\";\n      encoding?: never;\n    }\n  ): IterableReadableStream<StreamEvent> {\n    throw new Error(\"Not implemented.\");\n  }\n\n  override async *_streamIterator(\n    input: PregelInputType,\n    options?: Partial<PregelOptions<Nn, Cc, ContextType>>\n  ): AsyncGenerator<PregelOutputType> {\n    const mergedConfig = mergeConfigs(this.config, options);\n    const sanitizedConfig = this._sanitizeConfig(mergedConfig);\n\n    const streamProtocolInstance = options?.configurable?.[CONFIG_KEY_STREAM];\n\n    const streamSubgraphs =\n      options?.subgraphs ?? streamProtocolInstance !== undefined;\n\n    const interruptBefore = options?.interruptBefore ?? this.interruptBefore;\n    const interruptAfter = options?.interruptAfter ?? this.interruptAfter;\n\n    const { updatedStreamModes, reqSingle, reqUpdates } = getStreamModes(\n      options?.streamMode\n    );\n\n    const extendedStreamModes = [\n      ...new Set([\n        ...updatedStreamModes,\n        ...(streamProtocolInstance?.modes ?? new Set()),\n      ]),\n    ].map((mode) => {\n      if (mode === \"messages\") return \"messages-tuple\";\n      return mode;\n    });\n\n    let command;\n    let serializedInput;\n    if (isCommand(input)) {\n      // TODO: Remove cast when SDK type fix gets merged\n      command = input.toJSON() as Record<string, unknown>;\n      serializedInput = undefined;\n    } else {\n      serializedInput = _serializeInputs(input);\n    }\n\n    for await (const chunk of this.client.runs.stream(\n      sanitizedConfig.configurable.thread_id as string,\n      this.graphId,\n      {\n        command,\n        input: serializedInput,\n        config: sanitizedConfig,\n        streamMode: extendedStreamModes,\n        interruptBefore: interruptBefore as string[],\n        interruptAfter: interruptAfter as string[],\n        streamSubgraphs,\n        ifNotExists: \"create\",\n        signal: mergedConfig.signal,\n        streamResumable: this.streamResumable,\n      }\n    )) {\n      let mode;\n      let namespace: string[];\n      if (chunk.event.includes(CHECKPOINT_NAMESPACE_SEPARATOR)) {\n        const eventComponents = chunk.event.split(\n          CHECKPOINT_NAMESPACE_SEPARATOR\n        );\n        // eslint-disable-next-line prefer-destructuring\n        mode = eventComponents[0];\n        namespace = eventComponents.slice(1);\n      } else {\n        mode = chunk.event;\n        namespace = [];\n      }\n      const callerNamespace = options?.configurable?.checkpoint_ns;\n      if (typeof callerNamespace === \"string\") {\n        namespace = callerNamespace\n          .split(CHECKPOINT_NAMESPACE_SEPARATOR)\n          .concat(namespace);\n      }\n      if (\n        streamProtocolInstance !== undefined &&\n        streamProtocolInstance.modes?.has(chunk.event)\n      ) {\n        streamProtocolInstance.push([namespace, mode, chunk.data]);\n      }\n      if (chunk.event.startsWith(\"updates\")) {\n        if (\n          typeof chunk.data === \"object\" &&\n          chunk.data?.[INTERRUPT] !== undefined\n        ) {\n          throw new GraphInterrupt(chunk.data[INTERRUPT]);\n        }\n        if (!reqUpdates) {\n          continue;\n        }\n      } else if (chunk.event?.startsWith(\"error\")) {\n        throw new RemoteException(\n          typeof chunk.data === \"string\"\n            ? chunk.data\n            : JSON.stringify(chunk.data)\n        );\n      }\n      if (\n        !updatedStreamModes.includes(\n          chunk.event.split(CHECKPOINT_NAMESPACE_SEPARATOR)[0] as StreamMode\n        )\n      ) {\n        continue;\n      }\n      if (options?.subgraphs) {\n        if (reqSingle) {\n          yield [namespace, chunk.data];\n        } else {\n          yield [namespace, mode, chunk.data];\n        }\n      } else if (reqSingle) {\n        yield chunk.data;\n      } else {\n        yield [mode, chunk.data];\n      }\n    }\n  }\n\n  async updateState(\n    inputConfig: LangGraphRunnableConfig,\n    values: Record<string, unknown>,\n    asNode?: string\n  ): Promise<RunnableConfig> {\n    const mergedConfig = mergeConfigs(this.config, inputConfig);\n    const response = await this.client.threads.updateState(\n      mergedConfig.configurable?.thread_id,\n      { values, asNode, checkpoint: this._getCheckpoint(mergedConfig) }\n    );\n    // TODO: Fix SDK typing\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    return this._getConfig((response as any).checkpoint);\n  }\n\n  async *getStateHistory(\n    config: RunnableConfig,\n    options?: CheckpointListOptions\n  ): AsyncIterableIterator<StateSnapshot> {\n    const mergedConfig = mergeConfigs(this.config, config);\n    const states = await this.client.threads.getHistory(\n      mergedConfig.configurable?.thread_id,\n      {\n        limit: options?.limit ?? 10,\n        // TODO: Fix type\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        before: this._getCheckpoint(options?.before) as any,\n        metadata: options?.filter,\n        checkpoint: this._getCheckpoint(mergedConfig),\n      }\n    );\n    for (const state of states) {\n      yield this._createStateSnapshot(state);\n    }\n  }\n\n  protected _getDrawableNodes(\n    nodes: Array<{\n      id: string | number;\n      name?: string;\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      data?: Record<string, any> | string;\n      metadata?: unknown;\n    }>\n  ): Record<string, DrawableNode> {\n    const nodesMap: Record<string, DrawableNode> = {};\n    for (const node of nodes) {\n      const nodeId = node.id;\n      nodesMap[nodeId] = {\n        id: nodeId.toString(),\n        name: typeof node.data === \"string\" ? node.data : node.data?.name ?? \"\",\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        data: (node.data as any) ?? {},\n        metadata:\n          typeof node.data !== \"string\" ? node.data?.metadata ?? {} : {},\n      };\n    }\n    return nodesMap;\n  }\n\n  async getState(\n    config: RunnableConfig,\n    options?: { subgraphs?: boolean }\n  ): Promise<StateSnapshot> {\n    const mergedConfig = mergeConfigs(this.config, config);\n\n    const state = await this.client.threads.getState(\n      mergedConfig.configurable?.thread_id,\n      this._getCheckpoint(mergedConfig),\n      options\n    );\n    return this._createStateSnapshot(state);\n  }\n\n  /** @deprecated Use getGraphAsync instead. The async method will become the default in the next minor release. */\n  override getGraph(\n    _?: RunnableConfig & { xray?: boolean | number }\n  ): DrawableGraph {\n    throw new Error(\n      `The synchronous \"getGraph\" is not supported for this graph. Call \"getGraphAsync\" instead.`\n    );\n  }\n\n  /**\n   * Returns a drawable representation of the computation graph.\n   */\n  async getGraphAsync(config?: RunnableConfig & { xray?: boolean | number }) {\n    const graph = await this.client.assistants.getGraph(this.graphId, {\n      xray: config?.xray,\n    });\n    return new DrawableGraph({\n      nodes: this._getDrawableNodes(graph.nodes),\n      edges: graph.edges,\n    });\n  }\n\n  /** @deprecated Use getSubgraphsAsync instead. The async method will become the default in the next minor release. */\n  getSubgraphs(): Generator<[string, PregelInterface<Nn, Cc, ContextType>]> {\n    throw new Error(\n      `The synchronous \"getSubgraphs\" method is not supported for this graph. Call \"getSubgraphsAsync\" instead.`\n    );\n  }\n\n  async *getSubgraphsAsync(\n    namespace?: string,\n    recurse = false\n  ): AsyncGenerator<[string, PregelInterface<Nn, Cc, ContextType>]> {\n    const subgraphs = await this.client.assistants.getSubgraphs(this.graphId, {\n      namespace,\n      recurse,\n    });\n\n    for (const [ns, graphSchema] of Object.entries(subgraphs)) {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      const remoteSubgraph = new (this.constructor as any)({\n        ...this,\n        graphId: graphSchema.graph_id,\n      });\n      yield [ns, remoteSubgraph];\n    }\n  }\n}\n"],"mappings":"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"}

package/dist/pregel/remote.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"remote.d.cts","names":["Client","Checkpoint","ThreadState","Graph","DrawableGraph","Node","DrawableNode","Runnable","RunnableConfig","All","CheckpointListOptions","StreamEvent","IterableReadableStream","BaseChannel","LangGraphRunnableConfig","StrRecord","PregelInputType","PregelOptions","PregelOutputType","PregelNode","PregelParams","PregelInterface","StateSnapshot","RemoteGraphParams","Omit","Record","RemoteGraph","Nn","Cc","ContextType","Array","Partial","Promise","AsyncGenerator","AsyncIterableIterator","Generator"],"sources":["../../src/pregel/remote.d.ts"],"sourcesContent":["import { Client, type Checkpoint, type ThreadState } from \"@langchain/langgraph-sdk\";\nimport { Graph as DrawableGraph, Node as DrawableNode } from \"@langchain/core/runnables/graph\";\nimport { Runnable, RunnableConfig } from \"@langchain/core/runnables\";\nimport { All, CheckpointListOptions } from \"@langchain/langgraph-checkpoint\";\nimport { StreamEvent } from \"@langchain/core/tracers/log_stream\";\nimport { IterableReadableStream } from \"@langchain/core/utils/stream\";\nimport { BaseChannel, LangGraphRunnableConfig } from \"../web.js\";\nimport { StrRecord } from \"./algo.js\";\nimport { PregelInputType, PregelOptions, PregelOutputType } from \"./index.js\";\nimport { PregelNode } from \"./read.js\";\nimport { PregelParams, PregelInterface, StateSnapshot } from \"./types.js\";\nexport type RemoteGraphParams = Omit<PregelParams<StrRecord<string, PregelNode>, StrRecord<string, BaseChannel>>, \"channels\" | \"nodes\" | \"inputChannels\" | \"outputChannels\"> & {\n    graphId: string;\n    client?: Client;\n    url?: string;\n    apiKey?: string;\n    headers?: Record<string, string>;\n    streamResumable?: boolean;\n};\n/**\n * The `RemoteGraph` class is a client implementation for calling remote\n * APIs that implement the LangGraph Server API specification.\n *\n * For example, the `RemoteGraph` class can be used to call APIs from deployments\n * on LangSmith Deployment.\n *\n * `RemoteGraph` behaves the same way as a `StateGraph` and can be used directly as\n * a node in another `StateGraph`.\n *\n * @example\n * ```ts\n * import { RemoteGraph } from \"@langchain/langgraph/remote\";\n *\n * // Can also pass a LangGraph SDK client instance directly\n * const remoteGraph = new RemoteGraph({\n *   graphId: process.env.LANGGRAPH_REMOTE_GRAPH_ID!,\n *   apiKey: process.env.LANGGRAPH_REMOTE_GRAPH_API_KEY,\n *   url: process.env.LANGGRAPH_REMOTE_GRAPH_API_URL,\n * });\n *\n * const input = {\n *   messages: [\n *     {\n *       role: \"human\",\n *       content: \"Hello world!\",\n *     },\n *   ],\n * };\n *\n * const config = {\n *   configurable: { thread_id: \"threadId1\" },\n * };\n *\n * await remoteGraph.invoke(input, config);\n * ```\n */\nexport declare class RemoteGraph<Nn extends StrRecord<string, PregelNode> = StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel> = StrRecord<string, BaseChannel>, ContextType extends Record<string, any> = StrRecord<string, any>> extends Runnable<PregelInputType, PregelOutputType, PregelOptions<Nn, Cc, ContextType>> implements PregelInterface<Nn, Cc, ContextType> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lg_is_pregel: boolean;\n    config?: RunnableConfig;\n    graphId: string;\n    protected client: Client;\n    protected interruptBefore?: Array<keyof Nn> | All;\n    protected interruptAfter?: Array<keyof Nn> | All;\n    protected streamResumable?: boolean;\n    constructor(params: RemoteGraphParams);\n    withConfig(config: RunnableConfig): typeof this;\n    protected _sanitizeConfig(config: RunnableConfig): {\n        tags: string[];\n        metadata: Record<string, unknown>;\n        configurable: {\n            [k: string]: any;\n        };\n        recursion_limit: number | undefined;\n    };\n    protected _getConfig(checkpoint: Record<string, unknown>): RunnableConfig;\n    protected _getCheckpoint(config?: RunnableConfig): Checkpoint | undefined;\n    protected _createStateSnapshot(state: ThreadState): StateSnapshot;\n    invoke(input: PregelInputType, options?: Partial<PregelOptions<Nn, Cc, ContextType>>): Promise<PregelOutputType>;\n    streamEvents(input: PregelInputType, options: Partial<PregelOptions<Nn, Cc, ContextType>> & {\n        version: \"v1\" | \"v2\";\n    }): IterableReadableStream<StreamEvent>;\n    streamEvents(input: PregelInputType, options: Partial<PregelOptions<Nn, Cc, ContextType>> & {\n        version: \"v1\" | \"v2\";\n        encoding: never;\n    }): IterableReadableStream<never>;\n    _streamIterator(input: PregelInputType, options?: Partial<PregelOptions<Nn, Cc, ContextType>>): AsyncGenerator<PregelOutputType>;\n    updateState(inputConfig: LangGraphRunnableConfig, values: Record<string, unknown>, asNode?: string): Promise<RunnableConfig>;\n    getStateHistory(config: RunnableConfig, options?: CheckpointListOptions): AsyncIterableIterator<StateSnapshot>;\n    protected _getDrawableNodes(nodes: Array<{\n        id: string | number;\n        name?: string;\n        data?: Record<string, any> | string;\n        metadata?: unknown;\n    }>): Record<string, DrawableNode>;\n    getState(config: RunnableConfig, options?: {\n        subgraphs?: boolean;\n    }): Promise<StateSnapshot>;\n    /** @deprecated Use getGraphAsync instead. The async method will become the default in the next minor release. */\n    getGraph(_?: RunnableConfig & {\n        xray?: boolean | number;\n    }): DrawableGraph;\n    /**\n     * Returns a drawable representation of the computation graph.\n     */\n    getGraphAsync(config?: RunnableConfig & {\n        xray?: boolean | number;\n    }): Promise<DrawableGraph>;\n    /** @deprecated Use getSubgraphsAsync instead. The async method will become the default in the next minor release. */\n    getSubgraphs(): Generator<[string, PregelInterface<Nn, Cc, ContextType>]>;\n    getSubgraphsAsync(namespace?: string, recurse?: boolean): AsyncGenerator<[string, PregelInterface<Nn, Cc, ContextType>]>;\n}\n"],"mappings":"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"}
+{"version":3,"file":"remote.d.cts","names":[],"sources":["../../src/pregel/remote.ts"],"mappings":"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"}

package/dist/pregel/remote.d.ts

@@ -3,6 +3,8 @@ import { LangGraphRunnableConfig } from "./runnable_types.js";
 import { PregelNode } from "./read.js";
 import { PregelInputType, PregelInterface, PregelOptions, PregelOutputType, PregelParams, StateSnapshot } from "./types.js";
 import { StrRecord } from "./algo.js";
+import "./index.js";
+import "../web.js";
 import { All, CheckpointListOptions } from "@langchain/langgraph-checkpoint";
 import { Runnable, RunnableConfig } from "@langchain/core/runnables";
 import { Graph, Node } from "@langchain/core/runnables/graph";

package/dist/pregel/remote.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"remote.d.ts","names":["Client","Checkpoint","ThreadState","Graph","DrawableGraph","Node","DrawableNode","Runnable","RunnableConfig","All","CheckpointListOptions","StreamEvent","IterableReadableStream","BaseChannel","LangGraphRunnableConfig","StrRecord","PregelInputType","PregelOptions","PregelOutputType","PregelNode","PregelParams","PregelInterface","StateSnapshot","RemoteGraphParams","Omit","Record","RemoteGraph","Nn","Cc","ContextType","Array","Partial","Promise","AsyncGenerator","AsyncIterableIterator","Generator"],"sources":["../../src/pregel/remote.d.ts"],"sourcesContent":["import { Client, type Checkpoint, type ThreadState } from \"@langchain/langgraph-sdk\";\nimport { Graph as DrawableGraph, Node as DrawableNode } from \"@langchain/core/runnables/graph\";\nimport { Runnable, RunnableConfig } from \"@langchain/core/runnables\";\nimport { All, CheckpointListOptions } from \"@langchain/langgraph-checkpoint\";\nimport { StreamEvent } from \"@langchain/core/tracers/log_stream\";\nimport { IterableReadableStream } from \"@langchain/core/utils/stream\";\nimport { BaseChannel, LangGraphRunnableConfig } from \"../web.js\";\nimport { StrRecord } from \"./algo.js\";\nimport { PregelInputType, PregelOptions, PregelOutputType } from \"./index.js\";\nimport { PregelNode } from \"./read.js\";\nimport { PregelParams, PregelInterface, StateSnapshot } from \"./types.js\";\nexport type RemoteGraphParams = Omit<PregelParams<StrRecord<string, PregelNode>, StrRecord<string, BaseChannel>>, \"channels\" | \"nodes\" | \"inputChannels\" | \"outputChannels\"> & {\n    graphId: string;\n    client?: Client;\n    url?: string;\n    apiKey?: string;\n    headers?: Record<string, string>;\n    streamResumable?: boolean;\n};\n/**\n * The `RemoteGraph` class is a client implementation for calling remote\n * APIs that implement the LangGraph Server API specification.\n *\n * For example, the `RemoteGraph` class can be used to call APIs from deployments\n * on LangSmith Deployment.\n *\n * `RemoteGraph` behaves the same way as a `StateGraph` and can be used directly as\n * a node in another `StateGraph`.\n *\n * @example\n * ```ts\n * import { RemoteGraph } from \"@langchain/langgraph/remote\";\n *\n * // Can also pass a LangGraph SDK client instance directly\n * const remoteGraph = new RemoteGraph({\n *   graphId: process.env.LANGGRAPH_REMOTE_GRAPH_ID!,\n *   apiKey: process.env.LANGGRAPH_REMOTE_GRAPH_API_KEY,\n *   url: process.env.LANGGRAPH_REMOTE_GRAPH_API_URL,\n * });\n *\n * const input = {\n *   messages: [\n *     {\n *       role: \"human\",\n *       content: \"Hello world!\",\n *     },\n *   ],\n * };\n *\n * const config = {\n *   configurable: { thread_id: \"threadId1\" },\n * };\n *\n * await remoteGraph.invoke(input, config);\n * ```\n */\nexport declare class RemoteGraph<Nn extends StrRecord<string, PregelNode> = StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel> = StrRecord<string, BaseChannel>, ContextType extends Record<string, any> = StrRecord<string, any>> extends Runnable<PregelInputType, PregelOutputType, PregelOptions<Nn, Cc, ContextType>> implements PregelInterface<Nn, Cc, ContextType> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lg_is_pregel: boolean;\n    config?: RunnableConfig;\n    graphId: string;\n    protected client: Client;\n    protected interruptBefore?: Array<keyof Nn> | All;\n    protected interruptAfter?: Array<keyof Nn> | All;\n    protected streamResumable?: boolean;\n    constructor(params: RemoteGraphParams);\n    withConfig(config: RunnableConfig): typeof this;\n    protected _sanitizeConfig(config: RunnableConfig): {\n        tags: string[];\n        metadata: Record<string, unknown>;\n        configurable: {\n            [k: string]: any;\n        };\n        recursion_limit: number | undefined;\n    };\n    protected _getConfig(checkpoint: Record<string, unknown>): RunnableConfig;\n    protected _getCheckpoint(config?: RunnableConfig): Checkpoint | undefined;\n    protected _createStateSnapshot(state: ThreadState): StateSnapshot;\n    invoke(input: PregelInputType, options?: Partial<PregelOptions<Nn, Cc, ContextType>>): Promise<PregelOutputType>;\n    streamEvents(input: PregelInputType, options: Partial<PregelOptions<Nn, Cc, ContextType>> & {\n        version: \"v1\" | \"v2\";\n    }): IterableReadableStream<StreamEvent>;\n    streamEvents(input: PregelInputType, options: Partial<PregelOptions<Nn, Cc, ContextType>> & {\n        version: \"v1\" | \"v2\";\n        encoding: never;\n    }): IterableReadableStream<never>;\n    _streamIterator(input: PregelInputType, options?: Partial<PregelOptions<Nn, Cc, ContextType>>): AsyncGenerator<PregelOutputType>;\n    updateState(inputConfig: LangGraphRunnableConfig, values: Record<string, unknown>, asNode?: string): Promise<RunnableConfig>;\n    getStateHistory(config: RunnableConfig, options?: CheckpointListOptions): AsyncIterableIterator<StateSnapshot>;\n    protected _getDrawableNodes(nodes: Array<{\n        id: string | number;\n        name?: string;\n        data?: Record<string, any> | string;\n        metadata?: unknown;\n    }>): Record<string, DrawableNode>;\n    getState(config: RunnableConfig, options?: {\n        subgraphs?: boolean;\n    }): Promise<StateSnapshot>;\n    /** @deprecated Use getGraphAsync instead. The async method will become the default in the next minor release. */\n    getGraph(_?: RunnableConfig & {\n        xray?: boolean | number;\n    }): DrawableGraph;\n    /**\n     * Returns a drawable representation of the computation graph.\n     */\n    getGraphAsync(config?: RunnableConfig & {\n        xray?: boolean | number;\n    }): Promise<DrawableGraph>;\n    /** @deprecated Use getSubgraphsAsync instead. The async method will become the default in the next minor release. */\n    getSubgraphs(): Generator<[string, PregelInterface<Nn, Cc, ContextType>]>;\n    getSubgraphsAsync(namespace?: string, recurse?: boolean): AsyncGenerator<[string, PregelInterface<Nn, Cc, ContextType>]>;\n}\n"],"mappings":"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"}
+{"version":3,"file":"remote.d.ts","names":[],"sources":["../../src/pregel/remote.ts"],"mappings":";;;;;;;;;;;;;;;KA8CY,iBAAA,GAAoB,IAAA,CAC9B,YAAA,CAAa,SAAA,SAAkB,UAAA,GAAa,SAAA,SAAkB,WAAA;EAG9D,OAAA;EACA,MAAA,GAAS,MAAA;EACT,GAAA;EACA,MAAA;EACA,OAAA,GAAU,MAAA;EACV,eAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;AAwGF;;;;;;;;;;;;cAAa,WAAA,YACE,SAAA,SAAkB,UAAA,IAAc,SAAA,SAAkB,UAAA,cAClD,SAAA,SAAkB,WAAA,IAAe,SAAA,SAAkB,WAAA,uBAE1C,MAAA,gBAAsB,SAAA,uBAEpC,QAAA,CACN,eAAA,EACA,gBAAA,EACA,aAAA,CAAc,EAAA,EAAI,EAAA,EAAI,WAAA,cAEb,eAAA,CAAgB,EAAA,EAAI,EAAA,EAAI,WAAA;EAAA,OAE5B,OAAA,CAAA;EAIP,YAAA;EAEA,YAAA;EAEA,MAAA,GAAS,cAAA;EAET,OAAA;EAAA,UAEU,MAAA,EAAQ,MAAA;EAAA,UAER,eAAA,GAAkB,KAAA,OAAY,EAAA,IAAM,GAAA;EAAA,UAEpC,cAAA,GAAiB,KAAA,OAAY,EAAA,IAAM,GAAA;EAAA,UAEnC,eAAA;EAEV,WAAA,CAAY,MAAA,EAAQ,iBAAA;EAmBX,UAAA,CAAW,MAAA,EAAQ,cAAA;EAAA,UAMlB,eAAA,CAAgB,MAAA,EAAQ,cAAA;;;;;;;;YAiDxB,UAAA,CAAW,UAAA,EAAY,MAAA,oBAA0B,cAAA;EAAA,UAWjD,cAAA,CAAe,MAAA,GAAS,cAAA,GAAiB,YAAA;EAAA,UAqBzC,oBAAA,CAAqB,KAAA,EAAO,WAAA,GAAc,aAAA;EAmDrC,MAAA,CACb,KAAA,EAAO,eAAA,EACP,OAAA,GAAU,OAAA,CAAQ,aAAA,CAAc,EAAA,EAAI,EAAA,EAAI,WAAA,KACvC,OAAA,CAAQ,gBAAA;EAYF,YAAA,CACP,KAAA,EAAO,eAAA,EACP,OAAA,EAAS,OAAA,CAAQ,aAAA,CAAc,EAAA,EAAI,EAAA,EAAI,WAAA;IACrC,OAAA;EAAA,IAED,sBAAA,CAAuB,WAAA;EAEjB,YAAA,CACP,KAAA,EAAO,eAAA,EACP,OAAA,EAAS,OAAA,CAAQ,aAAA,CAAc,EAAA,EAAI,EAAA,EAAI,WAAA;IACrC,OAAA;IACA,QAAA;EAAA,IAED,sBAAA;EAYa,eAAA,CACd,KAAA,EAAO,eAAA,EACP,OAAA,GAAU,OAAA,CAAQ,aAAA,CAAc,EAAA,EAAI,EAAA,EAAI,WAAA,KACvC,cAAA,CAAe,gBAAA;EAmHZ,WAAA,CACJ,WAAA,EAAa,uBAAA,EACb,MAAA,EAAQ,MAAA,mBACR,MAAA,YACC,OAAA,CAAQ,cAAA;EAWJ,eAAA,CACL,MAAA,EAAQ,cAAA,EACR,OAAA,GAAU,qBAAA,GACT,qBAAA,CAAsB,aAAA;EAAA,UAkBf,iBAAA,CACR,KAAA,EAAO,KAAA;IACL,EAAA;IACA,IAAA;IAEA,IAAA,GAAO,MAAA;IACP,QAAA;EAAA,KAED,MAAA,SAAe,IAAA;EAgBZ,QAAA,CACJ,MAAA,EAAQ,cAAA,EACR,OAAA;IAAY,SAAA;EAAA,IACX,OAAA,CAAQ,aAAA;EAzMR;EAqNM,QAAA,CACP,CAAA,GAAI,cAAA;IAAmB,IAAA;EAAA,IACtB,KAAA;EAnNsC;;;EA4NnC,aAAA,CAAc,MAAA,GAAS,cAAA;IAAmB,IAAA;EAAA,IAAyB,OAAA,CAAA,KAAA;EA1MnC;EAqNtC,YAAA,CAAA,GAAgB,SAAA,UAAmB,eAAA,CAAgB,EAAA,EAAI,EAAA,EAAI,WAAA;EAMpD,iBAAA,CACL,SAAA,WACA,OAAA,aACC,cAAA,UAAwB,eAAA,CAAgB,EAAA,EAAI,EAAA,EAAI,WAAA;AAAA"}

package/dist/pregel/remote.js

@@ -3,14 +3,14 @@ import { CHECKPOINT_NAMESPACE_SEPARATOR, CONFIG_KEY_STREAM, INTERRUPT, isCommand
 import "../web.js";
 import { Runnable, mergeConfigs } from "@langchain/core/runnables";
 import { Graph } from "@langchain/core/runnables/graph";
-import { isBaseMessage } from "@langchain/core/messages";
+import { BaseMessage } from "@langchain/core/messages";
 import { Client } from "@langchain/langgraph-sdk";
 
 //#region src/pregel/remote.ts
 const _serializeInputs = (obj) => {
 	if (obj === null || typeof obj !== "object") return obj;
 	if (Array.isArray(obj)) return obj.map(_serializeInputs);
-	if (isBaseMessage(obj)) return {
+	if (BaseMessage.isInstance(obj)) return {
 		...obj.toDict().data,
 		role: obj.getType()
 	};