LangGraph.js API Reference
    Preparing search index...

    Class Pregel<Nodes, Channels, ContextType, InputType, OutputType, StreamUpdatesType, StreamValuesType, NodeReturnType, CommandType, StreamCustom>

    The Pregel class is the core runtime engine of LangGraph, implementing a message-passing graph computation model inspired by Google's Pregel system. 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:

    • StateGraph: The main graph class for building agent workflows
    • Functional API: A declarative approach using tasks and entrypoints
      • A Pregel instance is returned by the entrypoint function
    // 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);

    // 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]

    Type Parameters

    • Nodes extends StrRecord<string, PregelNode>

      Mapping of node names to their PregelNode implementations

    • Channels extends StrRecord<string, BaseChannel>

      Mapping of channel names to their BaseChannel or ManagedValueSpec implementations

    • ContextType extends Record<string, any> = StrRecord<string, any>

      Type of context that can be passed to the graph

    • InputType = PregelInputType

      Type of input values accepted by the graph

    • OutputType = PregelOutputType

      Type of output values produced by the graph

    • StreamUpdatesType = InputType
    • StreamValuesType = OutputType
    • NodeReturnType = unknown
    • CommandType = CommandInstance
    • StreamCustom = any

    Hierarchy (View Summary)

    Implements

    Index

    Properties

    autoValidate cache? channels checkpointer? config? debug inputChannels interruptAfter? interruptBefore? lc_kwargs lc_runnable lc_serializable name? nodes outputChannels retryPolicy? stepTimeout? store? streamChannels? streamMode

    Accessors

    lc_aliases lc_attributes lc_id lc_secrets lc_serializable_keys streamChannelsAsIs streamChannelsList

    Methods

    _batchWithConfig _callWithConfig _getOptionsList _separateRunnableConfigFromCallOptions _streamLog _transformStreamWithConfig assign asTool batch clearCache getGraph getGraphAsync getName getState getStateHistory getSubgraphsAsync invoke pick pipe stream streamEvents streamLog toJSON toJSONNotImplemented transform updateState validate withConfig withFallbacks withListeners withRetry isRunnable

    Deprecated

    getSubgraphs

    Properties

    autoValidate: boolean

    Whether to automatically validate the graph structure when it is compiled. Defaults to true.

    cache?: BaseCache<unknown>

    Optional cache for the graph, useful for caching tasks.

    channels: Channels

    The channels in the graph, mapping channel names to their BaseChannel or ManagedValueSpec instances

    checkpointer?: boolean | BaseCheckpointSaver<number>

    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.

    config?: LangGraphRunnableConfig<Record<string, any>>

    The default configuration for graph execution, can be overridden on a per-invocation basis

    debug: boolean

    Whether to enable debug logging. Defaults to false.

    inputChannels: keyof Channels | (keyof 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.

    interruptAfter?: (keyof Nodes)[] | "*"

    Optional array of node names or "all" to interrupt after executing these nodes. Used for implementing human-in-the-loop workflows.

    interruptBefore?: (keyof Nodes)[] | "*"

    Optional array of node names or "all" to interrupt before executing these nodes. Used for implementing human-in-the-loop workflows.

    lc_kwargs: SerializedFields
    lc_runnable: boolean
    lc_serializable: boolean
    name?: string
    nodes: Nodes

    The nodes in the graph, mapping node names to their PregelNode instances

    outputChannels: keyof Channels | (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.

    retryPolicy?: RetryPolicy

    Optional retry policy for handling failures in node execution

    stepTimeout?: number

    Optional timeout in milliseconds for the execution of each superstep

    store?: BaseStore

    Optional long-term memory store for the graph, allows for persistence & retrieval of data across threads

    streamChannels?: keyof Channels | (keyof Channels)[]

    Optional channels to stream. If not specified, all channels will be streamed. Can be a single channel key or an array of channel keys.

    streamMode: StreamMode[]

    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

    Accessors

    • get lc_aliases(): undefined | { [key: string]: string }

      A map of aliases for constructor args. Keys are the attribute names, e.g. "foo". Values are the alias that will replace the key in serialization. This is used to eg. make argument names match Python.

      Returns undefined | { [key: string]: string }

    • get lc_attributes(): undefined | SerializedFields

      A map of additional attributes to merge with constructor args. Keys are the attribute names, e.g. "foo". Values are the attribute values, which will be serialized. These attributes need to be accepted by the constructor as arguments.

      Returns undefined | SerializedFields

    • get lc_id(): string[]

      The final serialized identifier for the module.

      Returns string[]

    • get lc_secrets(): undefined | { [key: string]: string }

      A map of secrets, which will be omitted from serialization. Keys are paths to the secret in constructor args, e.g. "foo.bar.baz". Values are the secret ids, which will be used when deserializing.

      Returns undefined | { [key: string]: string }

    • get lc_serializable_keys(): undefined | string[]

      A manual list of keys that should be serialized. If not overridden, all fields passed into the constructor will be serialized.

      Returns undefined | string[]

    • get streamChannelsAsIs(): keyof Channels | (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 keyof Channels | (keyof Channels)[]

      Channel keys to stream, either as a single key or array

    • get streamChannelsList(): (keyof Channels)[]

      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 (keyof Channels)[]

      Array of channel keys to stream

    Methods

    _batchWithConfig

    • _batchWithConfig<T>(
          func: (
              inputs: T[],
              options?: Partial<
                  PregelOptions<
                      Nodes,
                      Channels,
                      ContextType,
                      undefined
                      | StreamMode
                      | StreamMode[],
                      boolean,
                      undefined | "text/event-stream",
                  >,
              >[],
              runManagers?: (undefined | CallbackManagerForChainRun)[],
              batchOptions?: RunnableBatchOptions,
          ) => Promise<(Error | OutputType)[]>,
          inputs: T[],
          options?:
              | Partial<
                  PregelOptions<
                      Nodes,
                      Channels,
                      ContextType,
                      undefined
                      | StreamMode
                      | StreamMode[],
                      boolean,
                      undefined | "text/event-stream",
                  > & { runType?: string },
              >
              | Partial<
                  PregelOptions<
                      Nodes,
                      Channels,
                      ContextType,
                      undefined
                      | StreamMode
                      | StreamMode[],
                      boolean,
                      undefined | "text/event-stream",
                  > & { runType?: string },
              >[],
          batchOptions?: RunnableBatchOptions,
      ): Promise<(Error | OutputType)[]>

      Internal method that handles batching and configuration for a runnable It takes a function, input values, and optional configuration, and returns a promise that resolves to the output values.

      Type Parameters

      • T

      Parameters

      • func: (
            inputs: T[],
            options?: Partial<
                PregelOptions<
                    Nodes,
                    Channels,
                    ContextType,
                    undefined
                    | StreamMode
                    | StreamMode[],
                    boolean,
                    undefined | "text/event-stream",
                >,
            >[],
            runManagers?: (undefined | CallbackManagerForChainRun)[],
            batchOptions?: RunnableBatchOptions,
        ) => Promise<(Error | OutputType)[]>

        The function to be executed for each input value.

      • inputs: T[]
      • Optionaloptions:
            | Partial<
                PregelOptions<
                    Nodes,
                    Channels,
                    ContextType,
                    undefined
                    | StreamMode
                    | StreamMode[],
                    boolean,
                    undefined | "text/event-stream",
                > & { runType?: string },
            >
            | Partial<
                PregelOptions<
                    Nodes,
                    Channels,
                    ContextType,
                    undefined
                    | StreamMode
                    | StreamMode[],
                    boolean,
                    undefined | "text/event-stream",
                > & { runType?: string },
            >[]
      • OptionalbatchOptions: RunnableBatchOptions

      Returns Promise<(Error | OutputType)[]>

      A promise that resolves to the output values.

    Protected_callWithConfig

    • _callWithConfig<T>(
          func:
              | ((input: T) => Promise<OutputType>)
              | (
                  (
                      input: T,
                      config?: Partial<
                          PregelOptions<
                              Nodes,
                              Channels,
                              ContextType,
                              undefined
                              | StreamMode
                              | StreamMode[],
                              boolean,
                              undefined | "text/event-stream",
                          >,
                      >,
                      runManager?: CallbackManagerForChainRun,
                  ) => Promise<OutputType>
              ),
          input: T,
          options?: Partial<
              PregelOptions<
                  Nodes,
                  Channels,
                  ContextType,
                  undefined
                  | StreamMode
                  | StreamMode[],
                  boolean,
                  undefined | "text/event-stream",
              >,
          > & { runType?: string },
      ): Promise<OutputType>

      Type Parameters

      • T

      Parameters

      • func:
            | ((input: T) => Promise<OutputType>)
            | (
                (
                    input: T,
                    config?: Partial<
                        PregelOptions<
                            Nodes,
                            Channels,
                            ContextType,
                            undefined
                            | StreamMode
                            | StreamMode[],
                            boolean,
                            undefined | "text/event-stream",
                        >,
                    >,
                    runManager?: CallbackManagerForChainRun,
                ) => Promise<OutputType>
            )
      • input: T
      • Optionaloptions: Partial<
            PregelOptions<
                Nodes,
                Channels,
                ContextType,
                undefined
                | StreamMode
                | StreamMode[],
                boolean,
                undefined | "text/event-stream",
            >,
        > & { runType?: string }

      Returns Promise<OutputType>

    Protected_getOptionsList

    • _getOptionsList<
          O extends
              PregelOptions<
                  Nodes,
                  Channels,
                  ContextType,
                  undefined
                  | StreamMode
                  | StreamMode[],
                  boolean,
                  undefined | "text/event-stream",
              > & { runType?: string },
      >(
          options: Partial<O> | Partial<O>[],
          length?: number,
      ): Partial<O>[]

      Type Parameters

      Parameters

      • options: Partial<O> | Partial<O>[]
      • Optionallength: number

      Returns Partial<O>[]

    Protected_separateRunnableConfigFromCallOptions

    • _separateRunnableConfigFromCallOptions(
          options?: Partial<
              PregelOptions<
                  Nodes,
                  Channels,
                  ContextType,
                  undefined
                  | StreamMode
                  | StreamMode[],
                  boolean,
                  undefined | "text/event-stream",
              >,
          >,
      ): [
          RunnableConfig<Record<string, any>>,
          Omit<
              Partial<
                  PregelOptions<
                      Nodes,
                      Channels,
                      ContextType,
                      undefined
                      | StreamMode
                      | StreamMode[],
                      boolean,
                      undefined | "text/event-stream",
                  >,
              >,
              keyof RunnableConfig<Record<string, any>>,
          >,
      ]

      Parameters

      • Optionaloptions: Partial<
            PregelOptions<
                Nodes,
                Channels,
                ContextType,
                undefined
                | StreamMode
                | StreamMode[],
                boolean,
                undefined | "text/event-stream",
            >,
        >

      Returns [
          RunnableConfig<Record<string, any>>,
          Omit<
              Partial<
                  PregelOptions<
                      Nodes,
                      Channels,
                      ContextType,
                      undefined
                      | StreamMode
                      | StreamMode[],
                      boolean,
                      undefined | "text/event-stream",
                  >,
              >,
              keyof RunnableConfig<Record<string, any>>,
          >,
      ]

    Protected_streamLog

    • _streamLog(
          input: null | InputType | CommandType,
          logStreamCallbackHandler: LogStreamCallbackHandler,
          config: Partial<CallOptions>,
      ): AsyncGenerator<RunLogPatch>

      Parameters

      • input: null | InputType | CommandType
      • logStreamCallbackHandler: LogStreamCallbackHandler
      • config: Partial<CallOptions>

      Returns AsyncGenerator<RunLogPatch>

    Protected_transformStreamWithConfig

    • _transformStreamWithConfig<I, O>(
          inputGenerator: AsyncGenerator<I>,
          transformer: (
              generator: AsyncGenerator<I>,
              runManager?: CallbackManagerForChainRun,
              options?: Partial<
                  PregelOptions<
                      Nodes,
                      Channels,
                      ContextType,
                      undefined
                      | StreamMode
                      | StreamMode[],
                      boolean,
                      undefined | "text/event-stream",
                  >,
              >,
          ) => AsyncGenerator<O>,
          options?: Partial<
              PregelOptions<
                  Nodes,
                  Channels,
                  ContextType,
                  undefined
                  | StreamMode
                  | StreamMode[],
                  boolean,
                  undefined | "text/event-stream",
              >,
          > & { runType?: string },
      ): AsyncGenerator<O>

      Helper method to transform an Iterator of Input values into an Iterator of Output values, with callbacks. Use this to implement stream() or transform() in Runnable subclasses.

      Type Parameters

      • I
      • O

      Parameters

      • inputGenerator: AsyncGenerator<I>
      • transformer: (
            generator: AsyncGenerator<I>,
            runManager?: CallbackManagerForChainRun,
            options?: Partial<
                PregelOptions<
                    Nodes,
                    Channels,
                    ContextType,
                    undefined
                    | StreamMode
                    | StreamMode[],
                    boolean,
                    undefined | "text/event-stream",
                >,
            >,
        ) => AsyncGenerator<O>
      • Optionaloptions: Partial<
            PregelOptions<
                Nodes,
                Channels,
                ContextType,
                undefined
                | StreamMode
                | StreamMode[],
                boolean,
                undefined | "text/event-stream",
            >,
        > & { runType?: string }

      Returns AsyncGenerator<O>

    • Assigns new fields to the dict output of this runnable. Returns a new runnable.

      Parameters

      • mapping: RunnableMapLike<Record<string, unknown>, Record<string, unknown>>

      Returns Runnable

    • Convert a runnable to a tool. Return a new instance of RunnableToolLike which contains the runnable, name, description and schema.

      Type Parameters

      Parameters

      • fields: { description?: string; name?: string; schema: InteropZodType<T> }
        • Optionaldescription?: string

          The description of the tool. Falls back to the description on the Zod schema if not provided, or undefined if neither are provided.

        • Optionalname?: string

          The name of the tool. If not provided, it will default to the name of the runnable.

        • schema: InteropZodType<T>

          The Zod schema for the input of the tool. Infers the Zod type from the input type of the runnable.

      Returns RunnableToolLike<
          InteropZodType<ToolCall<string, Record<string, any>> | T>,
          OutputType,
      >

      An instance of RunnableToolLike which is a runnable that can be used as a tool.

    • Default implementation of batch, which calls invoke N times. Subclasses should override this method if they can batch more efficiently.

      Parameters

      • inputs: (null | InputType | CommandType)[]

        Array of inputs to each batch call.

      • Optionaloptions:
            | Partial<
                PregelOptions<
                    Nodes,
                    Channels,
                    ContextType,
                    undefined
                    | StreamMode
                    | StreamMode[],
                    boolean,
                    undefined | "text/event-stream",
                >,
            >
            | Partial<
                PregelOptions<
                    Nodes,
                    Channels,
                    ContextType,
                    undefined
                    | StreamMode
                    | StreamMode[],
                    boolean,
                    undefined | "text/event-stream",
                >,
            >[]

        Either a single call options object to apply to each batch call or an array for each call.

      • OptionalbatchOptions: RunnableBatchOptions & { returnExceptions?: false }
        • returnExceptions

          Whether to return errors rather than throwing on the first one

        • OptionalreturnExceptions?: false

          Whether to return errors rather than throwing on the first one

      Returns Promise<OutputType[]>

      An array of RunOutputs, or mixed RunOutputs and errors if batchOptions.returnExceptions is set

    • Default implementation of batch, which calls invoke N times. Subclasses should override this method if they can batch more efficiently.

      Parameters

      • inputs: (null | InputType | CommandType)[]

        Array of inputs to each batch call.

      • Optionaloptions:
            | Partial<
                PregelOptions<
                    Nodes,
                    Channels,
                    ContextType,
                    undefined
                    | StreamMode
                    | StreamMode[],
                    boolean,
                    undefined | "text/event-stream",
                >,
            >
            | Partial<
                PregelOptions<
                    Nodes,
                    Channels,
                    ContextType,
                    undefined
                    | StreamMode
                    | StreamMode[],
                    boolean,
                    undefined | "text/event-stream",
                >,
            >[]

        Either a single call options object to apply to each batch call or an array for each call.

      • OptionalbatchOptions: RunnableBatchOptions & { returnExceptions: true }
        • returnExceptions

          Whether to return errors rather than throwing on the first one

        • returnExceptions: true

          Whether to return errors rather than throwing on the first one

      Returns Promise<(Error | OutputType)[]>

      An array of RunOutputs, or mixed RunOutputs and errors if batchOptions.returnExceptions is set

    • Default implementation of batch, which calls invoke N times. Subclasses should override this method if they can batch more efficiently.

      Parameters

      • inputs: (null | InputType | CommandType)[]

        Array of inputs to each batch call.

      • Optionaloptions:
            | Partial<
                PregelOptions<
                    Nodes,
                    Channels,
                    ContextType,
                    undefined
                    | StreamMode
                    | StreamMode[],
                    boolean,
                    undefined | "text/event-stream",
                >,
            >
            | Partial<
                PregelOptions<
                    Nodes,
                    Channels,
                    ContextType,
                    undefined
                    | StreamMode
                    | StreamMode[],
                    boolean,
                    undefined | "text/event-stream",
                >,
            >[]

        Either a single call options object to apply to each batch call or an array for each call.

      • OptionalbatchOptions: RunnableBatchOptions
        • returnExceptions

          Whether to return errors rather than throwing on the first one

      Returns Promise<(Error | OutputType)[]>

      An array of RunOutputs, or mixed RunOutputs and errors if batchOptions.returnExceptions is set

    • Returns Promise<void>

    • Parameters

      • Optional_: RunnableConfig<Record<string, any>>

      Returns Graph

    • Gets a drawable representation of the graph structure. This is an async version of getGraph() and is the preferred method to use.

      Parameters

      • config: RunnableConfig

        Configuration for generating the graph visualization

      Returns Promise<Graph>

      A representation of the graph that can be visualized

    • Parameters

      • Optionalsuffix: string

      Returns string

    • Gets the current state of the graph. Requires a checkpointer to be configured.

      Parameters

      • config: RunnableConfig

        Configuration for retrieving the state

      • Optionaloptions: GetStateOptions

        Additional options

      Returns Promise<StateSnapshot>

      A snapshot of the current graph state

      If no checkpointer is configured

    • Gets the history of graph states. Requires a checkpointer to be configured. Useful for:

      • Debugging execution history
      • Implementing time travel
      • Analyzing graph behavior

      Parameters

      • config: RunnableConfig

        Configuration for retrieving the history

      • Optionaloptions: CheckpointListOptions

        Options for filtering the history

      Returns AsyncIterableIterator<StateSnapshot>

      An async iterator of state snapshots

      If no checkpointer is configured

    • Gets all subgraphs within this graph asynchronously. A subgraph is a Pregel instance that is nested within a node of this graph.

      Parameters

      • Optionalnamespace: string

        Optional namespace to filter subgraphs

      • Optionalrecurse: boolean

        Whether to recursively get subgraphs of subgraphs

      Returns AsyncGenerator<
          [
              string,
              Pregel<
                  any,
                  any,
                  StrRecord<string, any>,
                  any,
                  any,
                  any,
                  any,
                  unknown,
                  CommandInstance<unknown, Record<string, unknown>, string>,
                  any,
              >,
          ],
      >

      AsyncGenerator yielding tuples of [name, subgraph]

    • Run the graph with a single input and config.

      Parameters

      • input: null | InputType | CommandType

        The input to the graph.

      • Optionaloptions: Partial<
            Omit<
                PregelOptions<
                    Nodes,
                    Channels,
                    ContextType,
                    undefined
                    | StreamMode
                    | StreamMode[],
                    boolean,
                    undefined | "text/event-stream",
                >,
                "encoding",
            >,
        >

        The configuration to use for the run.

      Returns Promise<OutputType>

    • Pick keys from the dict output of this runnable. Returns a new runnable.

      Parameters

      • keys: string | string[]

      Returns Runnable

    • Create a new runnable sequence that runs each individual runnable in series, piping the output of one runnable into another runnable or runnable-like.

      Type Parameters

      • NewRunOutput

      Parameters

      • coerceable: RunnableLike<OutputType, NewRunOutput>

        A runnable, function, or object whose values are functions or runnables.

      Returns Runnable<null | InputType | CommandType, Exclude<NewRunOutput, Error>>

      A new runnable sequence.

    • 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

      Type Parameters

      • TStreamMode extends undefined | StreamMode | StreamMode[]
      • TSubgraphs extends boolean
      • TEncoding extends undefined | "text/event-stream"

      Parameters

      Returns Promise<
          IterableReadableStream<
              StreamOutputMap<
                  TStreamMode,
                  TSubgraphs,
                  StreamUpdatesType,
                  StreamValuesType,
                  keyof Nodes,
                  NodeReturnType,
                  StreamCustom,
                  TEncoding,
              >,
          >,
      >

      An async iterable stream of graph state updates

    • Parameters

      • input: null | InputType | CommandType
      • options: Partial<
            PregelOptions<
                Nodes,
                Channels,
                ContextType,
                undefined
                | StreamMode
                | StreamMode[],
                boolean,
                undefined | "text/event-stream",
            >,
        > & { version: "v1" | "v2" }
      • OptionalstreamOptions: Omit<EventStreamCallbackHandlerInput, "autoClose">

      Returns IterableReadableStream<StreamEvent>

    • Parameters

      • input: null | InputType | CommandType
      • options: Partial<
            PregelOptions<
                Nodes,
                Channels,
                ContextType,
                undefined
                | StreamMode
                | StreamMode[],
                boolean,
                undefined | "text/event-stream",
            >,
        > & { encoding: "text/event-stream"; version: "v1" | "v2" }
      • OptionalstreamOptions: Omit<EventStreamCallbackHandlerInput, "autoClose">

      Returns IterableReadableStream<Uint8Array<ArrayBufferLike>>

    • Stream all output from a runnable, as reported to the callback system. This includes all inner runs of LLMs, Retrievers, Tools, etc. Output is streamed as Log objects, which include a list of jsonpatch ops that describe how the state of the run has changed in each step, and the final state of the run. The jsonpatch ops can be applied in order to construct state.

      Parameters

      • input: null | InputType | CommandType
      • Optionaloptions: Partial<
            PregelOptions<
                Nodes,
                Channels,
                ContextType,
                undefined
                | StreamMode
                | StreamMode[],
                boolean,
                undefined | "text/event-stream",
            >,
        >
      • OptionalstreamOptions: Omit<LogStreamCallbackHandlerInput, "autoClose">

      Returns AsyncGenerator<RunLogPatch>

    • Returns Serialized

    • Returns SerializedNotImplemented

    • Default implementation of transform, which buffers input and then calls stream. Subclasses should override this method if they can start producing output while input is still being generated.

      Parameters

      Returns AsyncGenerator<OutputType>

    • 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

      Parameters

      • inputConfig: LangGraphRunnableConfig

        Configuration for the update

      • values: unknown

        The values to update the state with

      • OptionalasNode: string | keyof Nodes

        Optional node name to attribute the update to

      Returns Promise<RunnableConfig<Record<string, any>>>

      Updated configuration

      If no checkpointer is configured

      If the update cannot be attributed to a node

    • 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

      this - The Pregel instance for method chaining

      If the graph structure is invalid

    • Create a new runnable from the current one that will try invoking other passed fallback runnables if the initial invocation fails.

      Parameters

      • fields:
            | {
                fallbacks: Runnable<
                    null
                    | InputType
                    | CommandType,
                    OutputType,
                    RunnableConfig<Record<string, any>>,
                >[];
            }
            | Runnable<
                null
                | InputType
                | CommandType,
                OutputType,
                RunnableConfig<Record<string, any>>,
            >[]
        • {
              fallbacks: Runnable<
                  null
                  | InputType
                  | CommandType,
                  OutputType,
                  RunnableConfig<Record<string, any>>,
              >[];
          }
          • fallbacks: Runnable<
                null
                | InputType
                | CommandType,
                OutputType,
                RunnableConfig<Record<string, any>>,
            >[]

            Other runnables to call if the runnable errors.

        • Runnable<
              null
              | InputType
              | CommandType,
              OutputType,
              RunnableConfig<Record<string, any>>,
          >[]

      Returns RunnableWithFallbacks<null | InputType | CommandType, OutputType>

      A new RunnableWithFallbacks.

    • Bind lifecycle listeners to a Runnable, returning a new Runnable. The Run object contains information about the run, including its id, type, input, output, error, startTime, endTime, and any tags or metadata added to the run.

      Parameters

      • params: {
            onEnd?: (
                run: Run,
                config?: RunnableConfig<Record<string, any>>,
            ) => void | Promise<void>;
            onError?: (
                run: Run,
                config?: RunnableConfig<Record<string, any>>,
            ) => void | Promise<void>;
            onStart?: (
                run: Run,
                config?: RunnableConfig<Record<string, any>>,
            ) => void | Promise<void>;
        }

        The object containing the callback functions.

        • OptionalonEnd?: (run: Run, config?: RunnableConfig<Record<string, any>>) => void | Promise<void>

          Called after the runnable finishes running, with the Run object.

        • OptionalonError?: (run: Run, config?: RunnableConfig<Record<string, any>>) => void | Promise<void>

          Called if the runnable throws an error, with the Run object.

        • OptionalonStart?: (run: Run, config?: RunnableConfig<Record<string, any>>) => void | Promise<void>

          Called before the runnable starts running, with the Run object.

      Returns Runnable<
          null
          | InputType
          | CommandType,
          OutputType,
          PregelOptions<
              Nodes,
              Channels,
              ContextType,
              undefined
              | StreamMode
              | StreamMode[],
              boolean,
              undefined | "text/event-stream",
          >,
      >

    • Add retry logic to an existing runnable.

      Parameters

      • Optionalfields: {
            onFailedAttempt?: RunnableRetryFailedAttemptHandler;
            stopAfterAttempt?: number;
        }
        • OptionalonFailedAttempt?: RunnableRetryFailedAttemptHandler

          A function that is called when a retry fails.

        • OptionalstopAfterAttempt?: number

          The number of attempts to retry.

      Returns RunnableRetry<
          null
          | InputType
          | CommandType,
          OutputType,
          PregelOptions<
              Nodes,
              Channels,
              ContextType,
              undefined
              | StreamMode
              | StreamMode[],
              boolean,
              undefined | "text/event-stream",
          >,
      >

      A new RunnableRetry that, when invoked, will retry according to the parameters.

    • Parameters

      • thing: any

      Returns thing is Runnable<any, any, RunnableConfig<Record<string, any>>>

    Deprecated

    • Gets all subgraphs within this graph. A subgraph is a Pregel instance that is nested within a node of this graph.

      Parameters

      • Optionalnamespace: string

        Optional namespace to filter subgraphs

      • Optionalrecurse: boolean

        Whether to recursively get subgraphs of subgraphs

      Returns Generator<
          [
              string,
              Pregel<
                  any,
                  any,
                  StrRecord<string, any>,
                  any,
                  any,
                  any,
                  any,
                  unknown,
                  CommandInstance<unknown, Record<string, unknown>, string>,
                  any,
              >,
          ],
      >

      Generator yielding tuples of [name, subgraph]

      Use getSubgraphsAsync instead. The async method will become the default in the next minor release.

    Settings

    Member Visibility

    On This Page

    Properties
    Accessors
    Methods
    Deprecated