@langchain/langgraph 1.0.6 → 1.0.12

package/dist/pregel/index.d.cts

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

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

@@ -1 +0,0 @@
-{"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":["/* eslint-disable no-param-reassign */\nimport { 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 };\n// This is a workaround to allow Pregel to override `invoke` / `stream` and `withConfig`\n// without having to adhere to the types in the `Runnable` class (thanks to `any`).\n// Alternatively we could mark those methods with @ts-ignore / @ts-expect-error,\n// but these do not get carried over when building via `tsc`.\ndeclare class PartialRunnable<RunInput, RunOutput, CallOptions extends RunnableConfig> extends Runnable<RunInput, RunOutput, CallOptions> {\n    lc_namespace: string[];\n    invoke(_input: RunInput, _options?: Partial<CallOptions>\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    ): Promise<any>;\n    // Overriden by `Pregel`\n    withConfig(_config: CallOptions): typeof this;\n    // Overriden by `Pregel`\n    stream(input: RunInput, options?: Partial<CallOptions>\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    ): 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>, \n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nContextType extends Record<string, any> = StrRecord<string, any>, InputType = PregelInputType, OutputType = PregelOutputType, StreamUpdatesType = InputType, StreamValuesType = OutputType, NodeReturnType = unknown, CommandType = CommandInstance, \n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nStreamCustom = 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\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    ): 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\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    ): 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, // debug\n        StreamMode[], // stream mode\n        // stream mode\n        string | string[], // input keys\n        // input keys\n        string | string[], // output keys\n        LangGraphRunnableConfig, // config without pregel keys\n        // config without pregel keys\n        All | string[], // interrupt before\n        // interrupt before\n        All | string[], // interrupt after\n        // interrupt after\n        BaseCheckpointSaver | undefined, // checkpointer\n        // checkpointer\n        BaseStore | undefined, // store\n        boolean, // stream mode single\n        // stream mode single\n        BaseCache | undefined, // node cache\n        Durability // 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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"}