web

Reducer function for combining two sets of messages in LangGraph's state system.

This reducer handles several tasks:

1. Normalizes both left and right message inputs to arrays.
2. Coerces any message-like objects into real BaseMessage instances, and message chunks (e.g. AIMessageChunk) into their non-chunk class.
3. Ensures all messages have unique, stable IDs by generating missing ones.
4. If a RemoveMessage instance is encountered in right with the ID REMOVE_ALL_MESSAGES, all previous messages are discarded and only the subsequent messages in right are returned.
5. Otherwise, merges left and right messages together following these rules:
   • If a message in right shares an ID with a message in left:
     • If it is a RemoveMessage, that message (by ID) is marked for removal.
     • If it is a normal message, it replaces the message with the same ID from left.
   • If a message in right does not exist in left:
     • If it is a RemoveMessage, this is considered an error (cannot remove non-existent ID).
     • Otherwise, the message is appended.
   • Messages flagged for removal are omitted from the final output.

Creates a GraphRunStream with built-in transformers and kicks off the background pump that feeds raw stream chunks through the transformer pipeline.

Built-in transformers are registered in this order:

1. subgraph discovery — materializes SubgraphRunStream handles for each newly observed top-level namespace and announces them on the mux _discoveries log.
2. lifecycle — synthesizes lifecycle channel events.
3. values — powers run.values / run.output.
4. messages — powers run.messages / .messagesFrom.

Subgraph discovery is registered first so that downstream transformers (notably lifecycle) observe child namespaces with their stream handles already in place. User-supplied transformer factories are registered afterwards.

Create the built-in lifecycle transformer.

Marked as a NativeStreamTransformer so the run stream factory can expose _lifecycleLog via a dedicated getter (run.lifecycle) rather than through run.extensions.

Creates a StreamTransformer that groups messages channel events into per-message ChatModelStream instances.

A new ChatModelStream is created on message-start and closed on message-finish. Content-block events in between are forwarded to the active stream. Only events whose namespace exactly matches path are processed; child namespaces are ignored.

Create the subgraph discovery transformer.

Registering this transformer against a mux replaces the legacy inline behavior that previously lived in StreamMux.push. The mux no longer knows about the subgraph factory: instead, this transformer is the single component that materializes stream handles and announces them on _discoveries.

Marked as a NativeStreamTransformer so the projection is treated as internal wiring (not merged into run.extensions and not auto-forwarded via StreamMux.wireChannels).

Creates a StreamTransformer that captures values channel events into a local StreamChannel. Only events whose namespace exactly matches path are recorded; events from child or sibling namespaces are ignored.

The final snapshot is resolved by StreamMux.close directly; this transformer only accumulates intermediate values.

Define a LangGraph workflow using the entrypoint function.

Function signature

The wrapped function must accept at most two parameters. The first parameter is the input to the function. The second (optional) parameter is a LangGraphRunnableConfig object. If you wish to pass multiple parameters to the function, you can pass them as an object.

Helper functions

Streaming

To write data to the "custom" stream, use the getWriter function, or the LangGraphRunnableConfig.writer property.

State management

The getPreviousState function can be used to access the previous state that was returned from the last invocation of the entrypoint on the same thread id.

If you wish to save state other than the return value, you can use the entrypoint.final function.

Filter a lifecycle StreamChannel to only the entries whose namespace lies within the subtree rooted at path.

Returns an AsyncIterable whose iterator yields every entry whose namespace either equals path or is a descendant of it. Iteration begins at startAt, so callers can capture the log's current size at construction time to skip entries emitted before the caller existed (e.g. a subgraph stream discovered mid-run shouldn't replay the root's started).

Filter a SubgraphDiscovery channel to only the direct children of a given namespace.

Returns an AsyncIterable whose iterator yields stream handles for discoveries whose namespace is exactly one segment deeper than path and shares it as a prefix. Iteration begins at startAt (so each caller picks up only discoveries added after its construction) and terminates when the underlying log closes or fails.

A helper utility function that returns the LangGraphRunnableConfig that was set when the graph was initialized.

Note: This only works when running in an environment that supports node:async_hooks and AsyncLocalStorage. If you're running this in a web environment, access the LangGraphRunnableConfig from the node function directly.

A helper utility function that returns the input for the currently executing task.

Note: When called without arguments, this relies on node:async_hooks / AsyncLocalStorage, which is available in many JavaScript environments (Node.js, Deno, Cloudflare Workers) but not in web browsers. In environments without AsyncLocalStorage support, pass the config that your node/tool function receives directly, e.g. getCurrentTaskInput(config).

Tip: Inside a tool run by a ToolNode, prefer reading graph state from runtime.state on the second tool argument (typed as ToolRuntime from @langchain/core/tools). It works in every runtime, including web browsers.

Get the JSON schema from a SerializableSchema.

A helper utility function for use with the functional API that returns the previous state from the checkpoint from the last invocation of the current thread.

This function allows workflows to access state that was saved in previous runs using entrypoint.final.

Detect if a schema has a default value by validating undefined.

Uses the Standard Schema ~standard.validate API to detect defaults. If the schema accepts undefined and returns a value, that value is the default.

This approach is library-agnostic and works with any Standard Schema compliant library (Zod, Valibot, ArkType, etc.) without needing to introspect internals.

A helper utility function that returns the BaseStore that was set when the graph was initialized

Used for subgraph detection.

A helper utility function that returns the LangGraphRunnableConfig#writer if "custom" stream mode is enabled, otherwise undefined.

Interrupts the execution of a graph node. This function can be used to pause execution of a node, and return the value of the resume input when the graph is re-invoked using Command. Multiple interrupts can be called within a single node, and each will be handled sequentially.

When an interrupt is called:

1. If there's a resume value available (from a previous Command), it returns that value.
2. Otherwise, it throws a GraphInterrupt with the provided value
3. The graph can be resumed by passing a Command with a resume value

Because the interrupt function propagates by throwing a special GraphInterrupt error, you should avoid using try/catch blocks around the interrupt function, or if you do, ensure that the GraphInterrupt error is thrown again within your catch block.

True when payload is a lightweight checkpoint envelope (not a full-state Pregel checkpoints debug payload).

A type guard to check if the given value is a Command.

Useful for type narrowing when working with the Command object.

Checks if the given graph invoke / stream chunk contains interrupt.

Whether error was thrown because a resume value didn't match the interrupt's responseSchema, directly or as the cause of a wrapping error (such as one from agent middleware). The resume fails once the step's other tasks finish, and the interrupt can be answered again.

Type guard that tests whether a transformer is a NativeStreamTransformer.

Type guard that checks whether a value is a NodeError.

Type guard to check if a given value is a SerializableSchema, i.e. both a Standard Schema and a Standard JSON Schema object.

Type guard to check if a given value is a Standard Schema V1 object.

Experimental. Batch reducer for use with DeltaChannel.

Processes all writes in one pass — dedup by ID and RemoveMessage tombstoning — without calling messagesStateReducer.

This reducer is batching-invariant, as required by DeltaChannel: reducer(reducer(state, xs), ys) === reducer(state, xs.concat(ys)).

A RemoveMessage carrying the REMOVE_ALL_MESSAGES sentinel id clears all messages accumulated so far (prior state plus earlier writes in the same batch) and keeps only the messages that follow it, mirroring messagesStateReducer. Clearing happens in the same single linear pass, so the batching-invariant still holds.

Raw object / string inputs are coerced to typed BaseMessage objects so that HTTP-driven graphs work without a separate coercion step, and message chunks are converted to their non-chunk class. This is not full messagesStateReducer parity — unknown-id RemoveMessage errors and missing-id UUID assignment are not handled here.

Reducer function for combining two sets of messages in LangGraph's state system.

This reducer handles several tasks:

1. Normalizes both left and right message inputs to arrays.
2. Coerces any message-like objects into real BaseMessage instances, and message chunks (e.g. AIMessageChunk) into their non-chunk class.
3. Ensures all messages have unique, stable IDs by generating missing ones.
4. If a RemoveMessage instance is encountered in right with the ID REMOVE_ALL_MESSAGES, all previous messages are discarded and only the subsequent messages in right are returned.
5. Otherwise, merges left and right messages together following these rules:
   • If a message in right shares an ID with a message in left:
     • If it is a RemoveMessage, that message (by ID) is marked for removal.
     • If it is a normal message, it replaces the message with the same ID from left.
   • If a message in right does not exist in left:
     • If it is a RemoveMessage, this is considered an error (cannot remove non-existent ID).
     • Otherwise, the message is appended.
   • Messages flagged for removal are omitted from the final output.

Manually push a message to a message stream.

This is useful when you need to push a manually created message before the node has finished executing.

When a message is pushed, it will be automatically persisted to the state after the node has finished executing. To disable persisting, set options.stateKey to null.

Define a LangGraph task using the task function.

Tasks can only be called from within an entrypoint or from within a StateGraph. A task can be called like a regular function with the following differences:

• When a checkpointer is enabled, the function inputs and outputs must be serializable.
• The wrapped function can only be called from within an entrypoint or StateGraph.
• Calling the function produces a promise. This makes it easy to parallelize tasks.

Abstract base class for persistent key-value stores.

Stores enable persistence and memory that can be shared across threads, scoped to user IDs, assistant IDs, or other arbitrary namespaces.

Features:

• Hierarchical namespaces for organization
• Key-value storage with metadata
• Vector similarity search (if configured)
• Filtering and pagination

Abstract base class for persistent key-value stores.

Stores enable persistence and memory that can be shared across threads, scoped to user IDs, assistant IDs, or other arbitrary namespaces.

Features:

• Hierarchical namespaces for organization
• Key-value storage with metadata
• Vector similarity search (if configured)
• Filtering and pagination

Stores the result of applying a binary operator to the current value and each new value.

The main stream object returned by chat model streaming.

Implements AsyncIterable<ChatModelStreamEvent> for raw event access and PromiseLike<AIMessage> for simple await usage.

One or more commands to update the graph's state and send messages to nodes. Can be used to combine routing logic with state updates in lieu of conditional edges

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

Reducer channel that stores only a sentinel in checkpoint blobs and reconstructs state by replaying ancestor writes through the reducer.

DeltaChannel avoids re-serializing the full accumulated value at every step. Instead of writing the value into channel_values, the channel is omitted entirely and its state is reconstructed on read by walking the ancestor chain and replaying the per-step writes through the reducer (see BaseCheckpointSaver.getDeltaChannelHistory).

Snapshot cadence is driven by two counters: a per-channel update count and the total supersteps since the last snapshot. A full DeltaSnapshot blob is written when EITHER the update count reaches snapshotFrequency OR the supersteps count reaches the system-wide DELTA_MAX_SUPERSTEPS_SINCE_SNAPSHOT bound (default 5000), bounding replay depth even for channels that stop receiving writes.

Represents a state field backed by a DeltaChannel.

Unlike ReducedValue (which stores the full accumulated value in every checkpoint blob via BinaryOperatorAggregate), a DeltaValue field persists only per-step deltas (plus periodic snapshots) and reconstructs its state on read by replaying ancestor writes through a batch reducer. This avoids re-serializing large accumulators (e.g. long message histories) at every step.

A projection channel for StreamTransformers.

Implements AsyncIterable<T> so it can be iterated directly by in-process consumers via run.extensions.<key>. Channels created with StreamChannel.remote or new StreamChannel(name) are also auto-forwarded to remote clients.

Extend this class and pass an instance through callbacks to observe graph interrupts and resumes. Lifecycle methods are always awaited, including when other callbacks run in the background. Set raiseError to propagate errors.

Raised when a graph run exits early due to a drain request.

This indicates the graph stopped cooperatively at a superstep boundary because RunControl#requestDrain was called (e.g., in response to SIGTERM). The checkpoint is saved and the run can be resumed later.

Primary run stream for a LangGraph execution.

Implements AsyncIterable over ProtocolEvent and exposes ergonomic projections for values, messages, subgraphs, output, and interrupts. Created by createGraphRunStream.

In-memory key-value store with optional vector search.

A lightweight store implementation using JavaScript Maps. Supports basic key-value operations and vector search when configured with embeddings.

Failure context passed to a node-level error handler.

A node-level error handler is registered via StateGraph.addNode(name, fn, { errorHandler }). The handler runs ONLY after the failing node's RetryPolicy is exhausted, so retry and handling stay decoupled. The handler receives the failed node's name and the thrown error via a NodeError instance, can return a state update, and can route to a recovery branch via new Command({ goto }) (saga / compensation flows).

Raised by a node to interrupt execution.

Raised when a node invocation exceeds one of its configured timeouts.

Does not extend GraphBubbleUp (so it flows through the normal node error path) and is intentionally treated as retryable by the default retry policy — its message/name do not match the default retryOn blocklist, so a configured RetryPolicy will retry it (see langchain-ai/langgraph#7659).

Both NodeTimeoutError.runTimeout and NodeTimeoutError.idleTimeout reflect the configured policy at the time of the failure (each undefined if not configured). NodeTimeoutError.kind and NodeTimeoutError.timeout identify which one fired.

Bypass a reducer and write the wrapped value directly to a BinaryOperatorAggregate channel.

Receiving multiple Overwrite values for the same channel in a single super-step will raise an InvalidUpdateError.

Represents a state field whose value is computed and updated using a reducer function.

ReducedValue allows you to define accumulators, counters, aggregators, or other fields whose value is determined incrementally by applying a reducer to incoming updates.

Each time a new input is provided, the reducer function is called with the current output and the new input, producing an updated value. Input validation can be controlled separately from output validation by providing an explicit input schema.

Exception raised when an error occurs in the remote graph.

Run-scoped control surface for cooperative draining.

Intended for a single graph run. Create a fresh RunControl per run; reusing a control after RunControl#requestDrain leaves it drained.

Safe to use from any concurrent context: the drain request is represented by a single field write, so no synchronization is needed for this signal. If more mutable state is added here, add synchronization.

The intended use is hooking SIGTERM (or any external supervisor signal) to RunControl#requestDrain so an in-flight graph run can stop cleanly at the next superstep boundary and be resumed later from the saved checkpoint.

A message or packet to send to a specific node in the graph.

The Send class is used within a StateGraph's conditional edges to dynamically invoke a node with a custom state at the next step.

Importantly, the sent state can differ from the core graph's state, allowing for flexible and dynamic workflow management.

One such example is a "map-reduce" workflow where your graph invokes the same node multiple times in parallel with different states, before aggregating the results back into the main graph's state.

A graph whose nodes communicate by reading and writing to a shared state. Each node takes a defined State as input and returns a Partial<State>.

Each state key can optionally be annotated with a reducer function that will be used to aggregate the values of that key received from multiple nodes. The signature of a reducer function is (left: Value, right: UpdateValue) => Value.

See Annotation for more on defining state.

After adding nodes and edges to your graph, you must call .compile() on it before you can use it.

Error thrown when invalid input is provided to a StateGraph.

This typically means that the input to the StateGraph constructor or builder did not match the required types. A valid input should be a StateDefinition, an Annotation.Root, or a Zod schema.

StateSchema provides a unified API for defining LangGraph state schemas.

A projection channel for StreamTransformers.

Implements AsyncIterable<T> so it can be iterated directly by in-process consumers via run.extensions.<key>. Channels created with StreamChannel.remote or new StreamChannel(name) are also auto-forwarded to remote clients.

A run stream for a child subgraph within a parent graph execution.

Extends GraphRunStream with a parsed name and index extracted from the last segment of the namespace path. The segment is expected to follow the "name:index" convention; when no numeric suffix is present, index defaults to 0.

Raised in strict resume mode when a resume doesn't match the pending interrupts. reason says how:

• "not_pending": the resume names interrupts that aren't pending, listed in interruptIds.
• "empty_map": the resume is an empty map.
• "ambiguous": the resume is one value while several interrupts are pending.

pendingIds lists the interrupts still waiting for an answer. The error is raised before anything is written, so they can still be answered.

Each interrupt() call in a task has its own id, so an answer retried after the task asked its next question is refused instead of answering that question.

Represents a state field whose value is transient and never checkpointed.

Use UntrackedValue for state fields that should be tracked for the lifetime of the process, but should not participate in durable checkpoints or recovery.

Should not be instantiated directly. See Annotation.

Stores the last value received, assumes that if multiple values are received, they are all equal.

Note: Unlike 'LastValue' if multiple nodes write to this channel in a single step, the values will be continuously overwritten.

Type bag for ConditionalEdgeRouter that accepts schema types. Unlike GraphNodeTypes, conditional edges don't have separate input/output - they just read state and return routing decisions.

Options accepted by createGraphRunStream.

A channel that switches between two states

• in the "priming" state it can't be read from.
  • if it receives a WaitForNames update, it switches to the "waiting" state.
• in the "waiting" state it collects named values until all are received.
  • once all named values are received, it can be read once, and it switches back to the "priming" state.

Stores the value received in the step immediately preceding, clears after.

Read-only execution info/metadata for the execution of current thread/run/node.

Operation to retrieve an item by namespace and ID.

The root graph paused. Static interrupts can have an empty payload list.

Type bag for GraphNode that accepts schema types. All fields are optional - unspecified fields use defaults.

This enables separate input/output schemas for nodes, which is useful when a node receives a subset of state fields and returns different fields.

A graph execution resumed from a checkpoint.

Human-in-the-loop interrupt: stable id plus opaque payload for resume UIs.

Represents a stored item with metadata.

Single lifecycle entry surfaced by the in-process GraphRunStream.lifecycle projection. Combines the CDDL LifecycleData payload with the namespace it applies to so consumers can filter or correlate without dipping into raw ProtocolEvents.

Projection returned from the lifecycle transformer's init().

The local StreamChannel is closed automatically when the transformer finalizes or fails. _lifecycleLog is intentionally underscore-prefixed to signal that it is consumed by the run stream wiring (see run-stream.ts) and not meant for direct user access - consumers should read run.lifecycle instead.

The lifecycle iterable is the root-scoped projection (prefix [], starting at offset 0) mirroring the pattern used by the subgraph discovery transformer. Root stream wiring consumes it via SET_LIFECYCLE_ITERABLE; child streams are wired with their own path-scoped iterable produced by filterLifecycleEntries.

Configuration knobs for createLifecycleTransformer.

Operation to list and filter namespaces in the store.

A channel that waits until all named values are received before making the value available.

This ensures that if node N and node M both write to channel C, the value of C will not be updated until N and M have completed updating.

Marker interface for transformers provided by internal LangChain products (e.g. ReactAgent's ToolCallTransformer, DeepAgent's SubagentTransformer).

Native transformers differ from user-defined extension transformers in where their projection lands on the run stream:

• Native — projections become direct getters on a GraphRunStream subclass (e.g. run.toolCalls, run.subagents). They emit events on protocol-defined channels (tools, lifecycle, tasks, etc.).

• Extension (user-defined) — projections are merged into run.extensions. Events emitted via emit() use an application-chosen method name (e.g. emit("a2a", data)) and are accessible to remote clients via session.subscribe("custom:<name>").

The __native brand is used by downstream stream factory functions to distinguish native transformers from extension transformers at registration time. See docs/native-stream-transformers.md for the full pattern.

An object representing a direct overwrite of a value for a channel. Used to signal that the channel value should be replaced with the given value, bypassing any reducer or binary operator logic.

Configuration options for executing a Pregel graph. These options control how the graph executes, what data is streamed, and how interrupts are handled.

Single envelope for a streaming protocol emission: sequence, channel (method), and payload (params).

Operation to store, update, or delete an item.

Operation to search for items within a namespace prefix.

Metadata injected by LangGraph Server. Undefined when running open-source LangGraph without LangSmith deployments.

Narrow capability handle passed to StreamTransformer.onRegister. Exposes only the minimal mux surface required for synthetic event emission — intentionally does not expose close/fail/register/etc. to keep the transformer contract small and tamper-resistant.

Observes ProtocolEvents during a graph run and builds typed derived projections (secondary event logs, promises, etc.).

Data is surfaced to consumers through projections returned from init(). Projections are merged into GraphRunStream.extensions for in-process consumers. Use StreamChannel.local for local streaming values, StreamChannel.remote for values that should also be visible to remote clients, or Promise<T> for final values.

To make projection data available to remote clients (SDK consumers over WebSocket / SSE), create a named channel with StreamChannel.remote(name). The StreamMux detects named StreamChannel instances in the init() return and auto-forwards every push() as a ProtocolEvent on custom:<name>. Remote clients subscribe via session.subscribe("custom:<name>").

finalize and fail are optional. When a transformer uses StreamChannel, the mux auto-closes/fails the channels on run completion — no manual lifecycle management needed. Implement finalize/fail only for non-channel teardown (e.g. resolving a Promise).

Projection returned by createSubgraphDiscoveryTransformer.

Configuration for createSubgraphDiscoveryTransformer.

Options for the task function

Stable handle for one tool call: name, arguments, and async results.

Emitted when content-block-finish delivers a finalized tool_call block.

A configurable PubSub Topic.

Initialization options for UntrackedValue.

Configuration for caching nodes.

Additional details about the checkpoint, including the source, step, writes, and parents.

Convenience type for referencing a compiled graph by named type slots.

Type for conditional edge routing functions.

Use this to type functions passed to addConditionalEdges for full type safety on state, runtime context, and return values.

Supports two patterns:

1. Single schema pattern - Single schema: ConditionalEdgeRouter<Schema, Context, Nodes>

2. Type bag pattern - Separate schemas for state, context: ConditionalEdgeRouter<{ Schema; ContextSchema; Nodes }>

A batch reducer for use with DeltaChannel.

Receives the current accumulated value and a batch of writes in one call, returning the new accumulated value: reducer(state, [write1, write2, ...]) -> newState.

Reducers must be deterministic and batching-invariant (associative across folds): applying two consecutive write batches separately must produce the same state as applying their concatenation once:

reducer(reducer(state, xs), ys) === reducer(state, xs.concat(ys))

This lets LangGraph replay checkpointed writes in larger batches than they were originally produced without changing reconstructed state. If your reducer is not associative, use BinaryOperatorAggregate instead — DeltaChannel is not a drop-in replacement for every reducer.

Initialization options for DeltaValue.

Two forms are supported:

1. Provide only a reducer (and optionally snapshotFrequency / jsonSchemaExtra) — the reducer's inputs are validated using the value schema.
2. Provide an explicit inputSchema to distinguish the reducer's input type from the stored/output type.

Options for the entrypoint function

Extract the State type from any supported schema type.

Supports:

• StateSchema
• AnnotationRoot
• StateDefinition (internal channel definitions)
• InteropZodObject (Zod v3/v4 object schemas)

Extract the Update type from any supported schema type.

The Update type represents what a node can return to update the state. All fields are optional since nodes only need to return the fields they modify.

Supports:

• StateSchema
• AnnotationRoot
• StateDefinition (internal channel definitions)
• InteropZodObject (Zod v3/v4 object schemas)

Options for getting the state of the graph.

Loop status at a graph lifecycle transition.

Strongly-typed utility for authoring graph nodes outside of the StateGraph builder, supporting inference for both state (from Schema) and config context (from Context type).

This type enables you to define graph node functions with full type safety—both for the evolving state and for additional context that may be passed in at runtime. Typing the context parameter allows for better code organization and precise editor support.

Works with StateSchema, AnnotationRoot, and Zod object schemas for state, and with a user-defined object shape for context.

Supports two patterns:

1. Single schema usage - Single schema for both input and output: GraphNode<Schema, Context, Nodes>

2. Type bag pattern - Separate schemas for input, output, context: GraphNode<{ InputSchema; OutputSchema; ContextSchema; Nodes }>

Return value type for GraphNode functions. Nodes can return an update object, a Command, or a Promise of either.

Infers the merged extensions type from a tuple of transformer factory functions.

Given [() => StreamTransformer<{ a: number }>, () => StreamTransformer<{ b: string }>], produces { a: number } & { b: string }.

Infer the Update type from a StateSchemaFields. This is the type for partial updates to state.

• ReducedValue<Value, Input> → Input (the reducer input type)
• UntrackedValue → Value
• SerializableSchema<Input, Output> → Input (what you provide)

Infer the State type from a StateSchemaFields. This is the type of the full state object.

• ReducedValue<Value, Input> → Value (the stored type)
• UntrackedValue → Value
• SerializableSchema<Input, Output> → Output (the validated type)

Type that represents an acceptable input for the messages state reducer.

• Can be a single BaseMessage or BaseMessageLike.
• Can be an array of BaseMessage or BaseMessageLike.

Options for subscribing to multiple channels.

Hierarchical path identifying a position in the agent tree.

Each element is one segment; longer arrays mean deeper nesting (e.g. subgraph or multi-agent scopes).

Retry and cache policies configurable on graph nodes.

Use with StateGraph.addNode for per-node overrides, or with StateGraph.setNodeDefaults for graph-wide defaults applied at compile() time. Per-node values always take precedence over defaults. setNodeDefaults may be called before or after addNode, including as the last step before compile().

Initialization options for ReducedValue.

Two forms are supported:

1. Provide only a reducer (and optionally jsonSchemaExtra)—in this case, the reducer's inputs are validated using the output value schema.
2. Provide an explicit inputSchema field to distinguish the reducer's input type from the stored/output type.

Keyword options for Send.

Options for subscribing to a single channel.

Options for StateGraph.addNode() method.

Initialization options for StateGraph. Accepts any combination of schema types for state/input/output.

Supports both state and stateSchema as aliases for backward compatibility. If only input is provided (no state/stateSchema), input is used as the state schema.

Valid field types for StateSchema. Either a LangGraph state value type or a raw schema (e.g., Zod schema).

Init object for StateSchema constructor. Uses any to allow variance in generic types (e.g., ReducedValue<string, string[]>).

Converts StateSchema fields into a strongly-typed State Definition object, where each field is mapped to its channel type.

This utility type is used internally to create the shape of the state channels for a given schema, substituting each field with the result of StateSchemaFieldToChannel.

If you define a state schema as:

const fields = {
  a: ReducedValue<number, string>(),
  b: UntrackedValue<boolean>(),
  c: SomeSerializableSchemaType, // SerializableSchema<in, out>
}

then StateSchemaFieldsToStateDefinition<typeof fields> yields:

{
  a: BaseChannel<number, string>;
  b: BaseChannel<boolean, boolean>;
  c: BaseChannel<typeof schema's output type, typeof schema's input type>;
}

Maps a single StateSchema field definition to its corresponding Channel type.

This utility type inspects the type of the field and returns an appropriate BaseChannel type, parameterized with the state "value" and "input" types according to the field's shape.

Rules:

• If the field (F) is a DeltaValue<V, I>, the channel will store values of type V and accept input of type I (or an Overwrite).
• If the field (F) is a ReducedValue<V, I>, the channel will store values of type V and accept input of type I.
• If the field is a UntrackedValue<V>, the channel will store and accept values of type V.
• If the field is a SerializableSchema<I, O>, the channel will store values of type O (the schema's output/validated value) and accept input of type I.
• For all other types, a generic BaseChannel<unknown, unknown> is used as fallback.

Configuration for timing out node attempts.

A timeout applies to a single attempt of a node/task. When a node has a RetryPolicy, the timer resets for each retry attempt.

Timeouts are expressed in milliseconds, matching other LangGraph.js durations (e.g. RetryPolicy intervals and stepTimeout).

High-level outcome of a single tool call for UI or aggregators.