@langchain/langgraph 0.4.9 → 1.0.0-alpha.1

package/dist/pregel/types.d.cts

@@ -0,0 +1,440 @@
+import { BaseChannel } from "../channels/base.cjs";
+import { LangGraphRunnableConfig } from "./runnable_types.cjs";
+import { CachePolicy, RetryPolicy } from "./utils/index.cjs";
+import { PregelNode } from "./read.cjs";
+import { Interrupt } from "../constants.cjs";
+import { All, BaseCache, BaseCheckpointSaver, BaseStore, CheckpointListOptions, CheckpointMetadata, PendingWrite } from "@langchain/langgraph-checkpoint";
+import { Runnable, RunnableConfig } from "@langchain/core/runnables";
+import { Graph } from "@langchain/core/runnables/graph";
+import { IterableReadableStream } from "@langchain/core/utils/stream";
+import { BaseMessage } from "@langchain/core/messages";
+
+//#region src/pregel/types.d.ts
+
+/**
+ * Selects the type of output you'll receive when streaming from the graph. See [Streaming](/langgraphjs/how-tos/#streaming) for more details.
+ */
+type StreamMode = "values" | "updates" | "debug" | "messages" | "checkpoints" | "tasks" | "custom";
+type Durability = "exit" | "async" | "sync";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type PregelInputType = any;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type PregelOutputType = any;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type StreamMessageOutput = [BaseMessage, Record<string, any>];
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type StreamDebugOutput = Record<string, any>;
+type StreamCheckpointsOutput<StreamValues> = {
+  values: StreamValues;
+  next: string[];
+  config: RunnableConfig;
+  metadata?: CheckpointMetadata;
+  parentConfig?: RunnableConfig | undefined;
+  tasks: PregelTaskDescription[];
+};
+interface StreamTasksOutputBase {
+  id: string;
+  name: string;
+  interrupts: Interrupt[];
+}
+interface StreamTasksCreateOutput<StreamValues> extends StreamTasksOutputBase {
+  input: StreamValues;
+  triggers: string[];
+}
+interface StreamTasksResultOutput<Keys, StreamUpdates> extends StreamTasksOutputBase {
+  result: [Keys, StreamUpdates][];
+}
+type StreamTasksOutput<StreamUpdates, StreamValues, Nodes = string> = StreamTasksCreateOutput<StreamValues> | StreamTasksResultOutput<Nodes, StreamUpdates>;
+type DefaultStreamMode = "updates";
+type StreamOutputMap<TStreamMode extends StreamMode | StreamMode[] | undefined, TStreamSubgraphs extends boolean, StreamUpdates, StreamValues, Nodes, NodeReturnType, StreamCustom> = (undefined extends TStreamMode ? [] : StreamMode | StreamMode[] extends TStreamMode ? TStreamMode extends StreamMode[] ? TStreamMode[number] : TStreamMode : TStreamMode extends StreamMode[] ? TStreamMode[number] : []) extends infer Multiple extends StreamMode ? [TStreamSubgraphs] extends [true] ? {
+  values: [string[], "values", StreamValues];
+  updates: [string[], "updates", NodeReturnType extends Record<string, unknown> ? { [K in keyof NodeReturnType]?: NodeReturnType[K] } : Record<Nodes extends string ? Nodes : string, StreamUpdates>];
+  messages: [string[], "messages", StreamMessageOutput];
+  custom: [string[], "custom", StreamCustom];
+  checkpoints: [string[], "checkpoints", StreamCheckpointsOutput<StreamValues>];
+  tasks: [string[], "tasks", StreamTasksOutput<StreamUpdates, StreamValues>];
+  debug: [string[], "debug", StreamDebugOutput];
+}[Multiple] : {
+  values: ["values", StreamValues];
+  updates: ["updates", NodeReturnType extends Record<string, unknown> ? { [K in keyof NodeReturnType]?: NodeReturnType[K] } : Record<Nodes extends string ? Nodes : string, StreamUpdates>];
+  messages: ["messages", StreamMessageOutput];
+  custom: ["custom", StreamCustom];
+  checkpoints: ["checkpoints", StreamCheckpointsOutput<StreamValues>];
+  tasks: ["tasks", StreamTasksOutput<StreamUpdates, StreamValues, Nodes>];
+  debug: ["debug", StreamDebugOutput];
+}[Multiple] : (undefined extends TStreamMode ? DefaultStreamMode : TStreamMode) extends infer Single extends StreamMode ? [TStreamSubgraphs] extends [true] ? {
+  values: [string[], StreamValues];
+  updates: [string[], NodeReturnType extends Record<string, unknown> ? { [K in keyof NodeReturnType]?: NodeReturnType[K] } : Record<Nodes extends string ? Nodes : string, StreamUpdates>];
+  messages: [string[], StreamMessageOutput];
+  custom: [string[], StreamCustom];
+  checkpoints: [string[], StreamCheckpointsOutput<StreamValues>];
+  tasks: [string[], StreamTasksOutput<StreamUpdates, StreamValues, Nodes>];
+  debug: [string[], StreamDebugOutput];
+}[Single] : {
+  values: StreamValues;
+  updates: NodeReturnType extends Record<string, unknown> ? { [K in keyof NodeReturnType]?: NodeReturnType[K] } : Record<Nodes extends string ? Nodes : string, StreamUpdates>;
+  messages: StreamMessageOutput;
+  custom: StreamCustom;
+  checkpoints: StreamCheckpointsOutput<StreamValues>;
+  tasks: StreamTasksOutput<StreamUpdates, StreamValues, Nodes>;
+  debug: StreamDebugOutput;
+}[Single] : never;
+/**
+ * Configuration options for executing a Pregel graph.
+ * These options control how the graph executes, what data is streamed, and how interrupts are handled.
+ *
+ * @typeParam Nodes - Mapping of node names to their {@link PregelNode} implementations
+ * @typeParam Channels - Mapping of channel names to their {@link BaseChannel} implementations
+ * @typeParam ContextType - Type of context that can be passed to the graph
+ */
+interface PregelOptions<Nodes extends StrRecord<string, PregelNode>, Channels extends StrRecord<string, BaseChannel>,
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+ContextType extends Record<string, any> = Record<string, any>, TStreamMode extends StreamMode | StreamMode[] | undefined = StreamMode | StreamMode[] | undefined, TSubgraphs extends boolean = boolean> extends RunnableConfig<ContextType> {
+  /**
+   * Controls what information is streamed during graph execution.
+   * Multiple modes can be enabled simultaneously.
+   *
+   * Supported modes:
+   * - "values": Streams complete state after each step
+   * - "updates": Streams only state changes after each step
+   * - "messages": Streams messages from within nodes
+   * - "custom": Streams custom events from within nodes
+   * - "debug": Streams detailed execution events for tracing & debugging
+   *
+   * @example
+   * ```typescript
+   * // Stream only values
+   * streamMode: "values"
+   *
+   * // Stream both values and debug info
+   * streamMode: ["values", "debug"]
+   * ```
+   *
+   * @default ["values"]
+   */
+  streamMode?: TStreamMode;
+  /**
+   * Specifies which channel keys to retrieve from the checkpoint when resuming execution.
+   * This is an advanced option that you generally don't need to set manually.
+   * The graph will automatically determine the appropriate input keys based on its configuration.
+   */
+  inputKeys?: keyof Channels | Array<keyof Channels>;
+  /**
+   * Specifies which channel keys to include in the output stream and final result.
+   * Use this to filter which parts of the graph state you want to observe.
+   *
+   * @example
+   * ```typescript
+   * // Stream only the 'result' channel
+   * outputKeys: "result"
+   *
+   * // Stream multiple channels
+   * outputKeys: ["result", "intermediateState"]
+   * ```
+   */
+  outputKeys?: keyof Channels | Array<keyof Channels>;
+  /**
+   * List of nodes where execution should be interrupted BEFORE the node runs.
+   * Can be used for debugging and advanced state manipulation use cases. For
+   * human-in-the-loop workflows, developers should prefer the
+   * @link {interrupt} function instead.
+   *
+   * When interrupted, a resume @link {Command} must be provided to continue
+   * execution.
+   *
+   * @example
+   * ```typescript
+   * // Interrupt before specific nodes
+   * interruptBefore: ["humanReview", "qualityCheck"]
+   *
+   * // Interrupt before all nodes
+   * interruptBefore: "all"
+   * ```
+   */
+  interruptBefore?: All | Array<keyof Nodes>;
+  /**
+   * List of nodes where execution should be interrupted AFTER the node runs.
+   * Similar to interruptBefore, but interrupts after node completion.
+   * Useful when the node's output needs to be reviewed before proceeding.
+   *
+   * @example
+   * ```typescript
+   * // Interrupt after specific nodes
+   * interruptAfter: ["generateContent", "analyze"]
+   *
+   * // Interrupt after all nodes
+   * interruptAfter: "all"
+   * ```
+   */
+  interruptAfter?: All | Array<keyof Nodes>;
+  /**
+   * Enables detailed debug logging during graph execution.
+   * When enabled, prints information about:
+   * - Task execution
+   * - Channel updates
+   * - Checkpoint writes
+   *
+   * @default false
+   */
+  debug?: boolean;
+  /**
+   * Whether to include subgraph execution details in the stream.
+   * When true, state updates from nested graphs will also be streamed.
+   *
+   * @default false
+   */
+  subgraphs?: TSubgraphs;
+  /**
+   * Whether to checkpoint intermediate steps, defaults to `true`.
+   * If `false`, only the final checkpoint is saved.
+   * @deprecated Use `durability` instead.
+   */
+  checkpointDuring?: boolean;
+  /**
+   * Whether to checkpoint during the run (or only at the end/interruption).
+   * - `"async"`: Save checkpoint asynchronously while the next step executes (default).
+   * - `"sync"`: Save checkpoint synchronously before the next step starts.
+   * - `"exit"`: Save checkpoint only when the graph exits.
+   * @default "async"
+   */
+  durability?: Durability;
+  /**
+   * A shared value store that allows you to store and retrieve state across
+   * threads. Useful for implementing long-term memory patterns.
+   */
+  store?: BaseStore;
+  /**
+   * Optional cache for the graph, useful for caching tasks.
+   */
+  cache?: BaseCache;
+  /**
+   * Static context for the graph run, like `userId`, `dbConnection` etc.
+   */
+  context?: ContextType;
+}
+/**
+ * Construct a type with a set of properties K of type T
+ */
+type StrRecord<K extends string, T> = { [P in K]: T };
+interface PregelInterface<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>> {
+  lg_is_pregel: boolean;
+  withConfig(config: RunnableConfig): PregelInterface<Nodes, Channels>;
+  getGraphAsync(config: RunnableConfig & {
+    xray?: boolean | number;
+  }): Promise<Graph>;
+  /** @deprecated Use getSubgraphsAsync instead. The async method will become the default in the next minor release. */
+  getSubgraphs(namespace?: string, recurse?: boolean
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ): Generator<[string, PregelInterface<any, any>]>;
+  getSubgraphsAsync(namespace?: string, recurse?: boolean
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ): AsyncGenerator<[string, PregelInterface<any, any>]>;
+  getState(config: RunnableConfig, options?: {
+    subgraphs?: boolean;
+  }): Promise<StateSnapshot>;
+  getStateHistory(config: RunnableConfig, options?: CheckpointListOptions): AsyncIterableIterator<StateSnapshot>;
+  updateState(inputConfig: LangGraphRunnableConfig, values: Record<string, unknown> | unknown, asNode?: keyof Nodes | string): Promise<RunnableConfig>;
+  stream(input: PregelInputType, options?: Partial<PregelOptions<Nodes, Channels, ContextType>>): Promise<IterableReadableStream<PregelOutputType>>;
+  invoke(input: PregelInputType, options?: Partial<PregelOptions<Nodes, Channels, ContextType>>): Promise<PregelOutputType>;
+}
+/**
+ * Parameters for creating a Pregel graph.
+ * @internal
+ */
+type PregelParams<Nodes extends StrRecord<string, PregelNode>, Channels extends StrRecord<string, BaseChannel>> = {
+  /**
+   * The name of the graph. @see {@link Runnable.name}
+   */
+  name?: string;
+  /**
+   * The nodes in the graph.
+   */
+  nodes: Nodes;
+  /**
+   * The channels in the graph.
+   */
+  channels: Channels;
+  /**
+   * Whether to validate the graph.
+   *
+   * @default true
+   */
+  autoValidate?: boolean;
+  /**
+   * The stream mode for the graph run. See [Streaming](/langgraphjs/how-tos/#streaming) for more details.
+   *
+   * @default ["values"]
+   */
+  streamMode?: StreamMode | StreamMode[];
+  /**
+   * The input channels for the graph run.
+   */
+  inputChannels: keyof Channels | Array<keyof Channels>;
+  /**
+   * The output channels for the graph run.
+   */
+  outputChannels: keyof Channels | Array<keyof Channels>;
+  /**
+   * After processing one of the nodes named in this list, the graph will be interrupted and a resume {@link Command} must be provided to proceed with the execution of this thread.
+   * @default []
+   */
+  interruptAfter?: Array<keyof Nodes> | All;
+  /**
+   * Before processing one of the nodes named in this list, the graph will be interrupted and a resume {@link Command} must be provided to proceed with the execution of this thread.
+   * @default []
+   */
+  interruptBefore?: Array<keyof Nodes> | All;
+  /**
+   * The channels to stream from the graph run.
+   * @default []
+   */
+  streamChannels?: keyof Channels | Array<keyof Channels>;
+  /**
+   * @default undefined
+   */
+  stepTimeout?: number;
+  /**
+   * @default false
+   */
+  debug?: boolean;
+  /**
+   * The {@link BaseCheckpointSaver | checkpointer} to use for the graph run.
+   */
+  checkpointer?: BaseCheckpointSaver | boolean;
+  /**
+   * The default retry policy for this graph. For defaults, see {@link RetryPolicy}.
+   */
+  retryPolicy?: RetryPolicy;
+  /**
+   * The configuration for the graph run.
+   */
+  config?: LangGraphRunnableConfig;
+  /**
+   * External key-value store.
+   */
+  store?: BaseStore;
+  /**
+   * Storage used for node caching.
+   */
+  cache?: BaseCache;
+  /**
+   * The trigger to node mapping for the graph run.
+   * @internal
+   */
+  triggerToNodes?: Record<string, string[]>;
+};
+interface PregelTaskDescription {
+  readonly id: string;
+  readonly name: string;
+  readonly error?: unknown;
+  readonly interrupts: Interrupt[];
+  readonly state?: LangGraphRunnableConfig | StateSnapshot;
+  readonly path?: TaskPath;
+  readonly result?: unknown;
+}
+interface StateSnapshot {
+  /**
+   * Current values of channels
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  readonly values: Record<string, any> | any;
+  /**
+   * Nodes to execute in the next step, if any
+   */
+  readonly next: Array<string>;
+  /**
+   * Config used to fetch this snapshot
+   */
+  readonly config: RunnableConfig;
+  /**
+   * Metadata about the checkpoint
+   */
+  readonly metadata?: CheckpointMetadata;
+  /**
+   * Time when the snapshot was created
+   */
+  readonly createdAt?: string;
+  /**
+   * Config used to fetch the parent snapshot, if any
+   * @default undefined
+   */
+  readonly parentConfig?: RunnableConfig | undefined;
+  /**
+   * Tasks to execute in this step. If already attempted, may contain an error.
+   */
+  readonly tasks: PregelTaskDescription[];
+}
+/**
+ * Options for subscribing to multiple channels.
+ */
+type MultipleChannelSubscriptionOptions = {
+  /**
+   * Optional tags to associate with the subscription.
+   */
+  tags?: string[];
+};
+/**
+ * Options for subscribing to a single channel.
+ */
+type SingleChannelSubscriptionOptions = {
+  /**
+   * When specified, the channel mapping will be an object with this key pointing
+   * to the array of channels to subscribe to. Otherwise, the channel mapping
+   * will be an array of channels.
+   */
+  key?: string;
+  /**
+   * Optional tags to associate with the subscription.
+   */
+  tags?: string[];
+};
+/**
+ * Options for getting the state of the graph.
+ */
+type GetStateOptions = {
+  /**
+   * Whether to include subgraph states.
+   * @default false
+   */
+  subgraphs?: boolean;
+};
+/**
+ * Used for storing/retrieving internal execution state.
+ *
+ * @internal
+ */
+
+type CallOptions = {
+  func: (...args: unknown[]) => unknown | Promise<unknown>;
+  name: string;
+  input: unknown;
+  cache?: CachePolicy;
+  retry?: RetryPolicy;
+  callbacks?: unknown;
+};
+declare class Call {
+  func: (...args: unknown[]) => unknown | Promise<unknown>;
+  name: string;
+  input: unknown;
+  retry?: RetryPolicy;
+  cache?: CachePolicy;
+  callbacks?: unknown;
+  readonly __lg_type: string;
+  constructor({
+    func,
+    name,
+    input,
+    retry,
+    cache,
+    callbacks
+  }: CallOptions);
+}
+type SimpleTaskPath = [string, string | number];
+type VariadicTaskPath = [string, ...(string | number)[], boolean];
+type CallTaskPath = [string, ...(string | number)[], Call] | [string, TaskPath, ...(string | number)[], Call];
+type TaskPath = SimpleTaskPath | CallTaskPath | VariadicTaskPath;
+//#endregion
+export { Durability, GetStateOptions, MultipleChannelSubscriptionOptions, PregelInputType, PregelInterface, PregelOptions, PregelOutputType, PregelParams, SingleChannelSubscriptionOptions, StateSnapshot, StreamMode, StreamOutputMap };
+//# sourceMappingURL=types.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.cts","names":["Runnable","RunnableConfig","All","PendingWrite","CheckpointMetadata","BaseCheckpointSaver","BaseStore","CheckpointListOptions","BaseCache","Graph","DrawableGraph","IterableReadableStream","BaseMessage","BaseChannel","PregelNode","Interrupt","CachePolicy","RetryPolicy","LangGraphRunnableConfig","StreamMode","Durability","PregelInputType","PregelOutputType","StreamMessageOutput","Record","StreamDebugOutput","StreamCheckpointsOutput","StreamValues","PregelTaskDescription","StreamTasksOutputBase","StreamTasksCreateOutput","StreamTasksResultOutput","Keys","StreamUpdates","StreamTasksOutput","Nodes","DefaultStreamMode","StreamOutputMap","TStreamMode","TStreamSubgraphs","NodeReturnType","K","StreamCustom","Multiple","Single","PregelOptions","StrRecord","ContextType","Channels","Array","TSubgraphs","T","PregelInterface","Promise","Generator","AsyncGenerator","StateSnapshot","AsyncIterableIterator","Partial","PregelParams","TaskPath","CacheKey","PregelExecutableTask","PropertyKey","NodeKey","ChannelKey","MultipleChannelSubscriptionOptions","SingleChannelSubscriptionOptions","GetStateOptions","PregelScratchpad","Resume","PregelAbortSignals","AbortSignal","CallOptions","Call","func","name","input","retry","cache","callbacks","isCall","SimpleTaskPath","VariadicTaskPath","CallTaskPath"],"sources":["../../src/pregel/types.d.ts"],"sourcesContent":["import type { Runnable, RunnableConfig } from \"@langchain/core/runnables\";\nimport type { All, PendingWrite, CheckpointMetadata, BaseCheckpointSaver, BaseStore, CheckpointListOptions, BaseCache } from \"@langchain/langgraph-checkpoint\";\nimport { Graph as DrawableGraph } from \"@langchain/core/runnables/graph\";\nimport { IterableReadableStream } from \"@langchain/core/utils/stream\";\nimport type { BaseMessage } from \"@langchain/core/messages\";\nimport type { BaseChannel } from \"../channels/base.js\";\nimport type { PregelNode } from \"./read.js\";\nimport type { Interrupt } from \"../constants.js\";\nimport { CachePolicy, RetryPolicy } from \"./utils/index.js\";\nimport { LangGraphRunnableConfig } from \"./runnable_types.js\";\n/**\n * Selects the type of output you'll receive when streaming from the graph. See [Streaming](/langgraphjs/how-tos/#streaming) for more details.\n */\nexport type StreamMode = \"values\" | \"updates\" | \"debug\" | \"messages\" | \"checkpoints\" | \"tasks\" | \"custom\";\nexport type Durability = \"exit\" | \"async\" | \"sync\";\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type PregelInputType = any;\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type PregelOutputType = any;\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype StreamMessageOutput = [BaseMessage, Record<string, any>];\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype StreamDebugOutput = Record<string, any>;\ntype StreamCheckpointsOutput<StreamValues> = {\n    values: StreamValues;\n    next: string[];\n    config: RunnableConfig;\n    metadata?: CheckpointMetadata;\n    parentConfig?: RunnableConfig | undefined;\n    tasks: PregelTaskDescription[];\n};\ninterface StreamTasksOutputBase {\n    id: string;\n    name: string;\n    interrupts: Interrupt[];\n}\ninterface StreamTasksCreateOutput<StreamValues> extends StreamTasksOutputBase {\n    input: StreamValues;\n    triggers: string[];\n}\ninterface StreamTasksResultOutput<Keys, StreamUpdates> extends StreamTasksOutputBase {\n    result: [Keys, StreamUpdates][];\n}\ntype StreamTasksOutput<StreamUpdates, StreamValues, Nodes = string> = StreamTasksCreateOutput<StreamValues> | StreamTasksResultOutput<Nodes, StreamUpdates>;\ntype DefaultStreamMode = \"updates\";\nexport type StreamOutputMap<TStreamMode extends StreamMode | StreamMode[] | undefined, TStreamSubgraphs extends boolean, StreamUpdates, StreamValues, Nodes, NodeReturnType, StreamCustom> = (undefined extends TStreamMode ? [] : StreamMode | StreamMode[] extends TStreamMode ? TStreamMode extends StreamMode[] ? TStreamMode[number] : TStreamMode : TStreamMode extends StreamMode[] ? TStreamMode[number] : []) extends infer Multiple extends StreamMode ? [TStreamSubgraphs] extends [true] ? {\n    values: [string[], \"values\", StreamValues];\n    updates: [\n        string[],\n        \"updates\",\n        NodeReturnType extends Record<string, unknown> ? {\n            [K in keyof NodeReturnType]?: NodeReturnType[K];\n        } : Record<Nodes extends string ? Nodes : string, StreamUpdates>\n    ];\n    messages: [string[], \"messages\", StreamMessageOutput];\n    custom: [string[], \"custom\", StreamCustom];\n    checkpoints: [\n        string[],\n        \"checkpoints\",\n        StreamCheckpointsOutput<StreamValues>\n    ];\n    tasks: [\n        string[],\n        \"tasks\",\n        StreamTasksOutput<StreamUpdates, StreamValues>\n    ];\n    debug: [string[], \"debug\", StreamDebugOutput];\n}[Multiple] : {\n    values: [\"values\", StreamValues];\n    updates: [\n        \"updates\",\n        NodeReturnType extends Record<string, unknown> ? {\n            [K in keyof NodeReturnType]?: NodeReturnType[K];\n        } : Record<Nodes extends string ? Nodes : string, StreamUpdates>\n    ];\n    messages: [\"messages\", StreamMessageOutput];\n    custom: [\"custom\", StreamCustom];\n    checkpoints: [\"checkpoints\", StreamCheckpointsOutput<StreamValues>];\n    tasks: [\"tasks\", StreamTasksOutput<StreamUpdates, StreamValues, Nodes>];\n    debug: [\"debug\", StreamDebugOutput];\n}[Multiple] : (undefined extends TStreamMode ? DefaultStreamMode : TStreamMode) extends infer Single extends StreamMode ? [TStreamSubgraphs] extends [true] ? {\n    values: [string[], StreamValues];\n    updates: [\n        string[],\n        NodeReturnType extends Record<string, unknown> ? {\n            [K in keyof NodeReturnType]?: NodeReturnType[K];\n        } : Record<Nodes extends string ? Nodes : string, StreamUpdates>\n    ];\n    messages: [string[], StreamMessageOutput];\n    custom: [string[], StreamCustom];\n    checkpoints: [string[], StreamCheckpointsOutput<StreamValues>];\n    tasks: [\n        string[],\n        StreamTasksOutput<StreamUpdates, StreamValues, Nodes>\n    ];\n    debug: [string[], StreamDebugOutput];\n}[Single] : {\n    values: StreamValues;\n    updates: NodeReturnType extends Record<string, unknown> ? {\n        [K in keyof NodeReturnType]?: NodeReturnType[K];\n    } : Record<Nodes extends string ? Nodes : string, StreamUpdates>;\n    messages: StreamMessageOutput;\n    custom: StreamCustom;\n    checkpoints: StreamCheckpointsOutput<StreamValues>;\n    tasks: StreamTasksOutput<StreamUpdates, StreamValues, Nodes>;\n    debug: StreamDebugOutput;\n}[Single] : never;\n/**\n * Configuration options for executing a Pregel graph.\n * These options control how the graph executes, what data is streamed, and how interrupts are handled.\n *\n * @typeParam Nodes - Mapping of node names to their {@link PregelNode} implementations\n * @typeParam Channels - Mapping of channel names to their {@link BaseChannel} implementations\n * @typeParam ContextType - Type of context that can be passed to the graph\n */\nexport interface PregelOptions<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> = Record<string, any>, TStreamMode extends StreamMode | StreamMode[] | undefined = StreamMode | StreamMode[] | undefined, TSubgraphs extends boolean = boolean> extends RunnableConfig<ContextType> {\n    /**\n     * Controls what information is streamed during graph execution.\n     * Multiple modes can be enabled simultaneously.\n     *\n     * Supported modes:\n     * - \"values\": Streams complete state after each step\n     * - \"updates\": Streams only state changes after each step\n     * - \"messages\": Streams messages from within nodes\n     * - \"custom\": Streams custom events from within nodes\n     * - \"debug\": Streams detailed execution events for tracing & debugging\n     *\n     * @example\n     * ```typescript\n     * // Stream only values\n     * streamMode: \"values\"\n     *\n     * // Stream both values and debug info\n     * streamMode: [\"values\", \"debug\"]\n     * ```\n     *\n     * @default [\"values\"]\n     */\n    streamMode?: TStreamMode;\n    /**\n     * Specifies which channel keys to retrieve from the checkpoint when resuming execution.\n     * This is an advanced option that you generally don't need to set manually.\n     * The graph will automatically determine the appropriate input keys based on its configuration.\n     */\n    inputKeys?: keyof Channels | Array<keyof Channels>;\n    /**\n     * Specifies which channel keys to include in the output stream and final result.\n     * Use this to filter which parts of the graph state you want to observe.\n     *\n     * @example\n     * ```typescript\n     * // Stream only the 'result' channel\n     * outputKeys: \"result\"\n     *\n     * // Stream multiple channels\n     * outputKeys: [\"result\", \"intermediateState\"]\n     * ```\n     */\n    outputKeys?: keyof Channels | Array<keyof Channels>;\n    /**\n     * List of nodes where execution should be interrupted BEFORE the node runs.\n     * Can be used for debugging and advanced state manipulation use cases. For\n     * human-in-the-loop workflows, developers should prefer the\n     * @link {interrupt} function instead.\n     *\n     * When interrupted, a resume @link {Command} must be provided to continue\n     * execution.\n     *\n     * @example\n     * ```typescript\n     * // Interrupt before specific nodes\n     * interruptBefore: [\"humanReview\", \"qualityCheck\"]\n     *\n     * // Interrupt before all nodes\n     * interruptBefore: \"all\"\n     * ```\n     */\n    interruptBefore?: All | Array<keyof Nodes>;\n    /**\n     * List of nodes where execution should be interrupted AFTER the node runs.\n     * Similar to interruptBefore, but interrupts after node completion.\n     * Useful when the node's output needs to be reviewed before proceeding.\n     *\n     * @example\n     * ```typescript\n     * // Interrupt after specific nodes\n     * interruptAfter: [\"generateContent\", \"analyze\"]\n     *\n     * // Interrupt after all nodes\n     * interruptAfter: \"all\"\n     * ```\n     */\n    interruptAfter?: All | Array<keyof Nodes>;\n    /**\n     * Enables detailed debug logging during graph execution.\n     * When enabled, prints information about:\n     * - Task execution\n     * - Channel updates\n     * - Checkpoint writes\n     *\n     * @default false\n     */\n    debug?: boolean;\n    /**\n     * Whether to include subgraph execution details in the stream.\n     * When true, state updates from nested graphs will also be streamed.\n     *\n     * @default false\n     */\n    subgraphs?: TSubgraphs;\n    /**\n     * Whether to checkpoint intermediate steps, defaults to `true`.\n     * If `false`, only the final checkpoint is saved.\n     * @deprecated Use `durability` instead.\n     */\n    checkpointDuring?: boolean;\n    /**\n     * Whether to checkpoint during the run (or only at the end/interruption).\n     * - `\"async\"`: Save checkpoint asynchronously while the next step executes (default).\n     * - `\"sync\"`: Save checkpoint synchronously before the next step starts.\n     * - `\"exit\"`: Save checkpoint only when the graph exits.\n     * @default \"async\"\n     */\n    durability?: Durability;\n    /**\n     * A shared value store that allows you to store and retrieve state across\n     * threads. Useful for implementing long-term memory patterns.\n     */\n    store?: BaseStore;\n    /**\n     * Optional cache for the graph, useful for caching tasks.\n     */\n    cache?: BaseCache;\n    /**\n     * Static context for the graph run, like `userId`, `dbConnection` etc.\n     */\n    context?: ContextType;\n}\n/**\n * Construct a type with a set of properties K of type T\n */\ntype StrRecord<K extends string, T> = {\n    [P in K]: T;\n};\nexport interface PregelInterface<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>> {\n    lg_is_pregel: boolean;\n    withConfig(config: RunnableConfig): PregelInterface<Nodes, Channels>;\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(namespace?: string, recurse?: boolean\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    ): Generator<[string, PregelInterface<any, any>]>;\n    getSubgraphsAsync(namespace?: string, recurse?: boolean\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    ): AsyncGenerator<[string, PregelInterface<any, any>]>;\n    getState(config: RunnableConfig, options?: {\n        subgraphs?: boolean;\n    }): Promise<StateSnapshot>;\n    getStateHistory(config: RunnableConfig, options?: CheckpointListOptions): AsyncIterableIterator<StateSnapshot>;\n    updateState(inputConfig: LangGraphRunnableConfig, values: Record<string, unknown> | unknown, asNode?: keyof Nodes | string): Promise<RunnableConfig>;\n    stream(input: PregelInputType, options?: Partial<PregelOptions<Nodes, Channels, ContextType>>): Promise<IterableReadableStream<PregelOutputType>>;\n    invoke(input: PregelInputType, options?: Partial<PregelOptions<Nodes, Channels, ContextType>>): Promise<PregelOutputType>;\n}\n/**\n * Parameters for creating a Pregel graph.\n * @internal\n */\nexport type PregelParams<Nodes extends StrRecord<string, PregelNode>, Channels extends StrRecord<string, BaseChannel>> = {\n    /**\n     * The name of the graph. @see {@link Runnable.name}\n     */\n    name?: string;\n    /**\n     * The nodes in the graph.\n     */\n    nodes: Nodes;\n    /**\n     * The channels in the graph.\n     */\n    channels: Channels;\n    /**\n     * Whether to validate the graph.\n     *\n     * @default true\n     */\n    autoValidate?: boolean;\n    /**\n     * The stream mode for the graph run. See [Streaming](/langgraphjs/how-tos/#streaming) for more details.\n     *\n     * @default [\"values\"]\n     */\n    streamMode?: StreamMode | StreamMode[];\n    /**\n     * The input channels for the graph run.\n     */\n    inputChannels: keyof Channels | Array<keyof Channels>;\n    /**\n     * The output channels for the graph run.\n     */\n    outputChannels: keyof Channels | Array<keyof Channels>;\n    /**\n     * After processing one of the nodes named in this list, the graph will be interrupted and a resume {@link Command} must be provided to proceed with the execution of this thread.\n     * @default []\n     */\n    interruptAfter?: Array<keyof Nodes> | All;\n    /**\n     * Before processing one of the nodes named in this list, the graph will be interrupted and a resume {@link Command} must be provided to proceed with the execution of this thread.\n     * @default []\n     */\n    interruptBefore?: Array<keyof Nodes> | All;\n    /**\n     * The channels to stream from the graph run.\n     * @default []\n     */\n    streamChannels?: keyof Channels | Array<keyof Channels>;\n    /**\n     * @default undefined\n     */\n    stepTimeout?: number;\n    /**\n     * @default false\n     */\n    debug?: boolean;\n    /**\n     * The {@link BaseCheckpointSaver | checkpointer} to use for the graph run.\n     */\n    checkpointer?: BaseCheckpointSaver | boolean;\n    /**\n     * The default retry policy for this graph. For defaults, see {@link RetryPolicy}.\n     */\n    retryPolicy?: RetryPolicy;\n    /**\n     * The configuration for the graph run.\n     */\n    config?: LangGraphRunnableConfig;\n    /**\n     * External key-value store.\n     */\n    store?: BaseStore;\n    /**\n     * Storage used for node caching.\n     */\n    cache?: BaseCache;\n    /**\n     * The trigger to node mapping for the graph run.\n     * @internal\n     */\n    triggerToNodes?: Record<string, string[]>;\n};\nexport interface PregelTaskDescription {\n    readonly id: string;\n    readonly name: string;\n    readonly error?: unknown;\n    readonly interrupts: Interrupt[];\n    readonly state?: LangGraphRunnableConfig | StateSnapshot;\n    readonly path?: TaskPath;\n    readonly result?: unknown;\n}\ninterface CacheKey {\n    ns: string[];\n    key: string;\n    ttl?: number;\n}\nexport interface PregelExecutableTask<NodeKey extends PropertyKey, ChannelKey extends PropertyKey> {\n    readonly name: NodeKey;\n    readonly input: unknown;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    readonly proc: Runnable<any, any, LangGraphRunnableConfig>;\n    readonly writes: PendingWrite<ChannelKey>[];\n    readonly config?: LangGraphRunnableConfig;\n    readonly triggers: Array<string>;\n    readonly retry_policy?: RetryPolicy;\n    readonly cache_key?: CacheKey;\n    readonly id: string;\n    readonly path?: TaskPath;\n    readonly subgraphs?: Runnable[];\n    readonly writers: Runnable[];\n}\nexport interface StateSnapshot {\n    /**\n     * Current values of channels\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    readonly values: Record<string, any> | any;\n    /**\n     * Nodes to execute in the next step, if any\n     */\n    readonly next: Array<string>;\n    /**\n     * Config used to fetch this snapshot\n     */\n    readonly config: RunnableConfig;\n    /**\n     * Metadata about the checkpoint\n     */\n    readonly metadata?: CheckpointMetadata;\n    /**\n     * Time when the snapshot was created\n     */\n    readonly createdAt?: string;\n    /**\n     * Config used to fetch the parent snapshot, if any\n     * @default undefined\n     */\n    readonly parentConfig?: RunnableConfig | undefined;\n    /**\n     * Tasks to execute in this step. If already attempted, may contain an error.\n     */\n    readonly tasks: PregelTaskDescription[];\n}\n/**\n * Options for subscribing to multiple channels.\n */\nexport type MultipleChannelSubscriptionOptions = {\n    /**\n     * Optional tags to associate with the subscription.\n     */\n    tags?: string[];\n};\n/**\n * Options for subscribing to a single channel.\n */\nexport type SingleChannelSubscriptionOptions = {\n    /**\n     * When specified, the channel mapping will be an object with this key pointing\n     * to the array of channels to subscribe to. Otherwise, the channel mapping\n     * will be an array of channels.\n     */\n    key?: string;\n    /**\n     * Optional tags to associate with the subscription.\n     */\n    tags?: string[];\n};\n/**\n * Options for getting the state of the graph.\n */\nexport type GetStateOptions = {\n    /**\n     * Whether to include subgraph states.\n     * @default false\n     */\n    subgraphs?: boolean;\n};\n/**\n * Used for storing/retrieving internal execution state.\n *\n * @internal\n */\nexport type PregelScratchpad<Resume = unknown> = {\n    /** Counter for tracking call invocations */\n    callCounter: number;\n    /** Counter for tracking interrupts */\n    interruptCounter: number;\n    /** List of resume values */\n    resume: Resume[];\n    /** Single resume value for null task ID */\n    nullResume: Resume;\n    consumeNullResume: () => Resume | undefined;\n    /** Counter for tracking subgraph invocations */\n    subgraphCounter: number;\n    /** The input to the currently executing task */\n    currentTaskInput: unknown;\n};\n/**\n * @internal\n */\nexport type PregelAbortSignals = {\n    /** Aborts when the user calls `stream.cancel()` or aborts the {@link AbortSignal} that they passed in via the `signal` option */\n    externalAbortSignal?: AbortSignal;\n    /**\n     * Aborts when the currently executing task throws any error other than a {@link GraphBubbleUp}\n     */\n    timeoutAbortSignal?: AbortSignal;\n    /**\n     * A reference to the AbortSignal that is passed to the node. Aborts on step timeout, stream cancel, or when an error is thrown.\n     */\n    composedAbortSignal?: AbortSignal;\n};\nexport type CallOptions = {\n    func: (...args: unknown[]) => unknown | Promise<unknown>;\n    name: string;\n    input: unknown;\n    cache?: CachePolicy;\n    retry?: RetryPolicy;\n    callbacks?: unknown;\n};\nexport declare class Call {\n    func: (...args: unknown[]) => unknown | Promise<unknown>;\n    name: string;\n    input: unknown;\n    retry?: RetryPolicy;\n    cache?: CachePolicy;\n    callbacks?: unknown;\n    readonly __lg_type: string;\n    constructor({ func, name, input, retry, cache, callbacks }: CallOptions);\n}\nexport declare function isCall(value: unknown): value is Call;\nexport type SimpleTaskPath = [string, string | number];\nexport type VariadicTaskPath = [string, ...(string | number)[], boolean];\nexport type CallTaskPath = [string, ...(string | number)[], Call] | [string, TaskPath, ...(string | number)[], Call];\nexport type TaskPath = SimpleTaskPath | CallTaskPath | VariadicTaskPath;\nexport {};\n"],"mappings":"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"}