react

Base interface for stream-like objects. Contains common properties shared between UseStream and SubagentStream.

Minimal interface matching the structure of AgentTypeConfig from @langchain/langgraph. This allows type inference from ReactAgent without requiring the langchain dependency.

Base stream interface shared by all stream types.

Contains core properties for state management, messaging, and stream control that are common to CompiledStateGraph, ReactAgent, and DeepAgent streams.

This interface provides the foundation that all stream types build upon:

• State management (values, isLoading, error)
• Message handling (messages)
• Interrupt handling (interrupt)
• Stream lifecycle (submit, stop)
• Branching and history (branch, history)

Minimal interface matching the structure of a CompiledSubAgent from deepagents. Used for structural type matching without importing deepagents.

Minimal interface matching the structure of DeepAgentTypeConfig from deepagents. Extends AgentTypeConfigLike to include subagent type information.

Client-side implementation returned by headlessTool.implement(...).

Represents a headless tool interrupt payload emitted by LangChain's schema-only tool({ ... }) overload.

Servers may serialize the nested tool call as toolCall (JS) or tool_call (Python). Use parseHeadlessToolInterruptPayload to normalize either shape before reading fields.

Minimal interface matching the structure of a SubAgent from deepagents. Used for structural type matching without importing deepagents.

Base interface for a single subagent stream. Tracks the lifecycle of a subagent from invocation to completion.

Extends StreamBase to share common properties with UseStream, allowing subagents to be treated similarly to the main stream.

Prefer using SubagentStream which supports passing an agent type directly for automatic type inference.

Represents a tool call that initiated a subagent.

Stream interface for ReactAgent instances created with createAgent.

Extends UseGraphStream with tool calling capabilities. Tool calls are automatically typed based on the agent's tools configuration.

Use this interface when streaming from an agent created with createAgent. For subagent streaming capabilities, use UseDeepAgentStream with createDeepAgent.

This interface is subject to change.

Options for configuring an agent stream.

Use this options interface when calling useStream with a ReactAgent created via createAgent.

This interface is subject to change.

Stream interface for DeepAgent instances created with createDeepAgent.

Extends UseAgentStream with subagent streaming capabilities. Subagent streams are automatically typed based on the agent's subagent configuration, enabling type-safe access to subagent state and messages.

Use this interface when streaming from an agent created with createDeepAgent that orchestrates multiple specialized subagents.

This interface is subject to change.

Options for configuring a deep agent stream.

Use this options interface when calling useStream with a DeepAgent created via createDeepAgent. Includes all agent options plus subagent-specific configuration.

Transport used to stream the thread. Only applicable for custom endpoints using toLangGraphEventStream or toLangGraphEventStreamResponse.

Base state type for subagents. All subagents have at least a messages array, similar to the main agent.

Default subagent state map used when no specific subagent types are provided. Maps any string key to Record<string, unknown>.

Default tool call type when no specific tool definitions are provided.

Extract the AgentTypeConfig from an agent-like type.

Extract the DeepAgentTypeConfig from a DeepAgent-like type.

Helper type to extract middleware from a SubAgent definition. Handles both mutable and readonly middleware arrays.

Extract the tool call type from a StateType's messages property. This is the canonical way to get typed tool calls in useStream.

Tool call types are now extracted from the messages property of StateType, rather than being specified separately in the Bag.

Extract tool calls type from an agent's tools. Converts the tools array to a discriminated union of tool calls.

This handles both tuple types (e.g., readonly [Tool1, Tool2]) and array-of-union types (e.g., readonly (Tool1 | Tool2)[]) which is how createAgent captures tool types.

Infer the Bag type from an agent, defaulting to the provided Bag.

Currently returns the provided Bag for all types. Can be extended in the future to extract Bag from agent types.

Extract the Subagents array type from a DeepAgent.

Infer the node names from a compiled graph.

Extracts the ~NodeType phantom property from CompiledGraph instances, providing a union of all node names defined in the graph.

Infer the state type from an agent, graph, or direct state type.

Detection order:

1. Agent-like (~agentTypes) → InferAgentState
2. CompiledGraph (~RunOutput) → Extract RunOutput
3. Pregel (~OutputType) → Extract OutputType
4. Direct state type → Return as-is

Helper type to extract a subagent by name from a DeepAgent.

Extract all subagent names as a string union from a DeepAgent.

Infer the state type for a specific subagent by extracting and merging its middleware state schemas, plus the base agent state (messages).

Infer subagent state map from a DeepAgent.

For DeepAgent, creates a map of subagent names to their state types. For non-DeepAgent, returns DefaultSubagentStates.

Infer tool call types from an agent.

For agents, extracts typed tool calls from the agent's tools. For non-agents, returns DefaultToolCall.

Check if a type is agent-like (has ~agentTypes phantom property). This property is present on ReactAgent instances created with createAgent.

Check if a type is a DeepAgent (has ~deepAgentTypes phantom property). This property is present on DeepAgent instances created with createDeepAgent.

Resolves the appropriate stream interface based on the agent/graph type.

This type automatically selects the correct stream interface based on the type of agent or graph passed to useStream:

1. DeepAgent (~deepAgentTypes) → UseDeepAgentStream

   • Includes: values, messages, toolCalls, subagents, getSubagentsByType, getSubagentsByMessage

2. ReactAgent (~agentTypes) → UseAgentStream

   • Includes: values, messages, toolCalls, getToolCalls
   • Excludes: subagents, getSubagentsByType

3. CompiledGraph / Default → BaseStream

   • Includes: values, messages, submit, stop
   • Does NOT include: toolCalls, subagents (not applicable to raw graphs)

Resolves the appropriate options interface based on the agent/graph type.

This type automatically selects the correct options interface based on the type of agent or graph:

1. DeepAgent → UseDeepAgentStreamOptions

   • Includes: filterSubagentMessages option

2. ReactAgent → UseAgentStreamOptions

3. CompiledGraph / Default → UseGraphStreamOptions

Create a map of subagent names to their state types. This is useful for type-safe getSubagentsByType calls.

The execution status of a subagent.

• "pending" - The subagent has been invoked but hasn't started processing yet. This is the initial state when a tool call is detected but before any streaming events are received from the subgraph.

• "running" - The subagent is actively executing and streaming updates. The subagent transitions to this state when the first update event is received from its namespace.

• "complete" - The subagent has finished execution successfully. A tool message with the result has been received, and the result property contains the final output.

• "error" - The subagent encountered an error during execution. The error property on the SubagentStream contains error details.

Represents a single subagent stream.

Supports two usage patterns:

1. Agent type inference (recommended): Pass a DeepAgent type directly and let TypeScript infer the correct state and tool call types.

import type { agent } from "./agent";

// Automatically infers state and tool call types from the agent
const subagent: SubagentStream<typeof agent> = ...;

2. Explicit generics: Pass state and tool call types manually.

type ResearcherState = { research_notes: string };
const researcher: SubagentStream<ResearcherState, MyToolCall> = ...;

Infer a union of tool call types from an array of tools. Works with tools created via tool() from @langchain/core/tools.

The lifecycle state of a tool call.

• pending: Tool call received, awaiting result
• completed: Tool execution finished successfully
• error: Tool execution failed (result.status === "error")

Represents a tool call paired with its result. Useful for rendering tool invocations and their outputs together.