langchain.js
    Preparing search index...

    Class CompiledStateGraph<S, U, N, I, O, C, NodeReturnType, InterruptType, WriterType>

    Final result from building and compiling a StateGraph. Should not be instantiated directly, only using the StateGraph .compile() instance method.

    Type Parameters

    • S

      The full state type representing the complete shape of your graph's state after all reducers have been applied. This is the type you receive when reading state in nodes or after invoking the graph.

    • U

      The update type representing what nodes can return to modify state. Typically a partial of the state type, allowing nodes to update only specific fields. Can also include Command objects for advanced control flow.

    • N extends string = typeof START

      Union of all node names in the graph (e.g., "agent" | "tool"). Used for type-safe routing with Command.goto and edge definitions.

    • I extends StateDefinitionInit = StateDefinition

      The input schema definition. Determines what shape of data the graph accepts when invoked. Defaults to the main state schema if not explicitly set.

    • O extends StateDefinitionInit = StateDefinition

      The output schema definition. Determines what shape of data the graph returns after execution. Defaults to the main state schema if not explicitly set.

    • C extends StateDefinitionInit = StateDefinition

      The config/context schema definition. Defines additional configuration that can be passed to the graph at runtime via LangGraphRunnableConfig.

    • NodeReturnType = unknown

      Constrains what types nodes in this graph can return. Useful for enforcing consistent return patterns across all nodes.

    • InterruptType = unknown

      The type of values that can be passed when resuming from an interrupt. Used with human-in-the-loop patterns.

    • WriterType = unknown

      The type for custom stream writers. Used with the writer option to enable typed custom streaming from within nodes.

    Hierarchy (View Summary)

    Index

    Constructors

    constructor

    Properties

    ~NodeReturnType ~NodeType ~RunInput ~RunOutput autoValidate builder cache? channels checkpointer? config? debug description? inputChannels interruptAfter? interruptBefore? nodes outputChannels retryPolicy? stepTimeout? store? streamChannels? streamMode

    Accessors

    streamChannelsAsIs streamChannelsList

    Methods

    attachBranch attachEdge attachNode clearCache getGraph getGraphAsync getState getStateHistory getSubgraphs getSubgraphsAsync invoke isInterrupted stream streamEvents updateState validate withConfig

    Constructors

    • Type Parameters

      • S
      • U
      • N extends string = "__start__"
      • I extends StateDefinitionInit = StateDefinition
      • O extends StateDefinitionInit = StateDefinition
      • C extends StateDefinitionInit = StateDefinition
      • NodeReturnType = unknown
      • InterruptType = unknown
      • WriterType = unknown

      Parameters

      • __namedParameters: { description?: string } & { builder: Graph<N, S, U> } & PregelParams<
            Record<"__start__" | N, PregelNode<S, U>>,
            Record<string | N, BaseChannel<unknown, unknown, unknown>>,
        >

      Returns CompiledStateGraph<S, U, N, I, O, C, NodeReturnType, InterruptType, WriterType>

    Properties

    "~NodeReturnType": NodeReturnType
    "~NodeType": N
    "~RunInput": U
    "~RunOutput": S
    autoValidate: boolean = true

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

    builder: StateGraph<unknown, S, U, N, I, O, C, NodeReturnType>
    cache?: any

    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?: any

    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 = false

    Whether to enable debug logging. Defaults to false.

    description?: string

    The description of the compiled graph. This is used by the supervisor agent to describe the handoff to the agent.

    inputChannels: string | N | (string | N)[]

    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?: any

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

    interruptBefore?: any

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

    nodes: Nodes

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

    outputChannels: string | N | (string | N)[]

    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?: any

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

    streamChannels?: string | N | (string | N)[]

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

    • Parameters

      • start: "__start__" | N
      • _: string
      • branch: Branch<S, N>
      • options: { withReader?: boolean } = ...

      Returns void

    • Parameters

      • starts: "__start__" | N | N[]
      • end: "__end__" | N

      Returns void

    • Parameters

      • key: "__start__"
      • Optionalnode: undefined

      Returns void

    • Parameters

      • key: N
      • node: StateGraphNodeSpec<S, U>

      Returns void

    • Returns Promise<void>

    • Returns a drawable representation of the computation graph.

      Parameters

      • Optionalconfig: RunnableConfig<Record<string, any>> & { xray?: number | boolean }

      Returns Graph

      Use getGraphAsync instead. The async method will be the default in the next minor core release.

    • Returns a drawable representation of the computation graph.

      Parameters

      • Optionalconfig: RunnableConfig<Record<string, any>> & { xray?: number | boolean }

      Returns Promise<Graph>

    • 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: any

        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. 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.

    • 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
            | ExtractUpdateType<I, ExtractStateType<I, I>>
            | CommandInstance<
                InferInterruptResumeType<InterruptType, false>,
                { [K in string | number | symbol]: U[K] },
                N,
            >

        The input to the graph.

      • Optionaloptions: Partial<
            Omit<
                PregelOptions<
                    Record<"__start__" | N, PregelNode<S, U>>,
                    Record<string | N, BaseChannel<unknown, unknown, unknown>>,
                    ExtractStateType<C, C> & Record<string, any>,
                    undefined | StreamMode | StreamMode[],
                    boolean,
                    undefined | "text/event-stream",
                >,
                "encoding",
            >,
        >

        The configuration to use for the run.

      Returns Promise<ExtractStateType<O, O>>

    • Parameters

      • input: unknown

      Returns input is { __interrupt__: Interrupt<InferInterruptInputType<InterruptType>>[] }

    • 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

      • input:
            | null
            | ExtractUpdateType<I, ExtractStateType<I, I>>
            | CommandInstance<
                InferInterruptResumeType<InterruptType, false>,
                { [K in string | number | symbol]: U[K] },
                N,
            >

        The input to start graph execution with

      • Optionaloptions: Partial<
            PregelOptions<
                Record<"__start__" | N, PregelNode<S, U>>,
                Record<string | N, BaseChannel<unknown, unknown, unknown>>,
                ExtractStateType<C, C> & Record<string, any>,
                TStreamMode,
                TSubgraphs,
                TEncoding,
            >,
        >

        Configuration options for streaming

      Returns Promise<
          IterableReadableStream<
              StreamOutputMap<
                  TStreamMode,
                  TSubgraphs,
                  ExtractUpdateType<I, ExtractStateType<I, I>>,
                  ExtractStateType<O, O>,
                  "__start__" | N,
                  NodeReturnType,
                  InferWriterType<WriterType>,
                  TEncoding,
              >,
          >,
      >

      An async iterable stream of graph state updates

    • Parameters

      • input:
            | null
            | ExtractUpdateType<I, ExtractStateType<I, I>>
            | CommandInstance<
                InferInterruptResumeType<InterruptType, false>,
                { [K in string | number | symbol]: U[K] },
                N,
            >
      • options: Partial<
            PregelOptions<
                Record<"__start__" | N, PregelNode<S, U>>,
                Record<string | N, BaseChannel<unknown, unknown, unknown>>,
                ExtractStateType<C, C> & Record<string, any>,
                undefined | StreamMode | StreamMode[],
                boolean,
                undefined | "text/event-stream",
            >,
        > & { version: "v1" | "v2" }
      • OptionalstreamOptions: Omit<EventStreamCallbackHandlerInput, "autoClose">

      Returns IterableReadableStream<StreamEvent>

    • Parameters

      • input:
            | null
            | ExtractUpdateType<I, ExtractStateType<I, I>>
            | CommandInstance<
                InferInterruptResumeType<InterruptType, false>,
                { [K in string | number | symbol]: U[K] },
                N,
            >
      • options: Partial<
            PregelOptions<
                Record<"__start__" | N, PregelNode<S, U>>,
                Record<string | N, BaseChannel<unknown, unknown, unknown>>,
                ExtractStateType<C, C> & Record<string, any>,
                undefined | StreamMode | StreamMode[],
                boolean,
                undefined | "text/event-stream",
            >,
        > & { encoding: "text/event-stream"; version: "v1" | "v2" }
      • OptionalstreamOptions: Omit<EventStreamCallbackHandlerInput, "autoClose">

      Returns IterableReadableStream<Uint8Array<ArrayBufferLike>>

    • 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 | N

        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

    • 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.

      Parameters

      • config: Omit<LangGraphRunnableConfig, "store" | "writer" | "interrupt">

        The configuration to merge with the current configuration

      Returns CompiledStateGraph<S, U, N, I, O, C, NodeReturnType, InterruptType, WriterType>

      A new Pregel instance with the merged configuration

      // 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" }
      });

    Settings

    Member Visibility

    On This Page

    Constructors
    Properties
    Accessors
    Methods