stream

Handle returned by ChannelRegistry.acquire. Framework bindings use store as the reactivity source and must call release() when the consumer tears down.

Agent-server branch: caller points useStream at an assistant on a LangGraph-Platform-compatible server. Discriminated against CustomAdapterOptions by transport being absent or a string.

Reactive tool handle for framework bindings (stream.toolCalls, useToolCalls, injectToolCalls).

status, error, and output are plain values that the assembler updates in place as tool events arrive. That lets React, Vue, Svelte, and Angular re-render from a snapshot on each store tick without await, effects, or Suspense boundaries around a promise. ClientAssembledToolCall keeps a promise-based output instead for script consumers that read tool results sequentially.

output is null while the call is running or after it fails; successful completion sets it to the parsed tool return value (objects and strings are unwrapped from ToolMessage wire envelopes when needed).

Options for acquireChannelEffect. Extends ChannelProjectionOptions (bufferSize, replay) with the per-event callback and an optional error sink.

Custom-adapter branch: caller brings their own AgentServerAdapter. Discriminated against AgentServerOptions by transport being an adapter instance.

Metadata tracked per message id. Surfaced to applications via useMessageMetadata(stream, messageId).

A projection spec describes a single logical subscription managed by the ChannelRegistry. Framework bindings don't construct these directly — the per-kind factory functions in stream/projections/ emit them.

Read-only fan-out of the StreamController's always-on root subscription. Projections that only need a subset of the root pump's channels at the root namespace can attach here instead of opening a second server subscription.

Always-on root snapshot surfaced by StreamController.rootStore.

Populated by a single multi-channel subscription at the thread root (values, lifecycle, input, messages, tools). Every app pays for this — selector hooks for scoped projections layer on top.

Payload for run-end callbacks.

Payload for run-start callbacks.

Options for StreamController.respondAll / framework respondAll().

Carries run-level config / metadata onto the single run that services the batched resume — the same fields as StreamRespondOptions, minus the per-interrupt target (each response in the map carries its own interruptId as the key).

Options for StreamController.respond / framework respond().

Targets a single pending interrupt (interruptId / namespace) and carries run-level config and metadata onto the resume so the resumed run applies the same configurable values (model, user context, timezone, …) and metadata (trigger source, test flags, …) a fresh StreamSubmitOptions would. The server folds these into the run it starts to service the input.respond command.

To resume several interrupts pending at the same checkpoint, use StreamController.respondAll instead.

Options for StreamController.stop / framework stop().

Lightweight discovery record for a subagent running inside the thread.

Populated eagerly from the root subscription (tools + lifecycle channels). Content projections (messages, toolCalls, custom extensions) are opened lazily via selector hooks, keyed on namespace.

Lightweight discovery record for a subgraph running inside the thread.

Queued submission entry mirrored from the server-side run queue.

Surfaces the deferred submission to UI consumers via StreamController.queueStore.

Options common to both transport branches of framework useStream APIs.

Public v1 name for TransportAdapter plus optional high-level capabilities. Renamed to reflect that this interface now denotes the full agent-server protocol contract (not merely wire transport): any object that satisfies it can back a useStream call. See plan-custom-transport.md §4 for the rollout.

The extra optional methods let adapters surface thread state and history without the framework needing to issue a parallel HTTP request — useStream.hydrate() calls getState?() when present and falls back to client.threads.getState otherwise. Adapters that don't know how to produce these values can simply omit them.

The legacy TransportAdapter export is retained for back-compat and resolves to the same structural type; new code should prefer AgentServerAdapter.

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

Shared surface across every media handle returned by MediaAssembler.

The handle is live while its parent message is active:

• partialBytes is a snapshot of all bytes received so far.
• stream is a lazy, single-consumer byte stream (see accessor docstring).
• blob / objectURL settle on message-finish.
• error becomes set if the handle terminates in any of the MediaAssemblyErrorKind failure modes.

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.

Shared surface across every media handle returned by MediaAssembler.

The handle is live while its parent message is active:

• partialBytes is a snapshot of all bytes received so far.
• stream is a lazy, single-consumer byte stream (see accessor docstring).
• blob / objectURL settle on message-finish.
• error becomes set if the handle terminates in any of the MediaAssemblyErrorKind failure modes.

Shared surface across every media handle returned by MediaAssembler.

The handle is live while its parent message is active:

• partialBytes is a snapshot of all bytes received so far.
• stream is a lazy, single-consumer byte stream (see accessor docstring).
• blob / objectURL settle on message-finish.
• error becomes set if the handle terminates in any of the MediaAssemblyErrorKind failure modes.

Dispatch callbacks receive a freshly-started handle on its first matching content-block-start. Exactly one callback fires per (messageId, blockType) pair.

Dispatch callbacks receive a freshly-started handle on its first matching content-block-start. Exactly one callback fires per (messageId, blockType) pair.

Shared surface across every media handle returned by MediaAssembler.

The handle is live while its parent message is active:

• partialBytes is a snapshot of all bytes received so far.
• stream is a lazy, single-consumer byte stream (see accessor docstring).
• blob / objectURL settle on message-finish.
• error becomes set if the handle terminates in any of the MediaAssemblyErrorKind failure modes.

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

Represents a tool call that initiated a subagent.

Transport abstraction implemented by concrete client transports such as WebSocket or SSE adapters.

In the thread-centric protocol the thread ID is part of the request URLs. Transports may be bound at construction time, or left unbound and bound later via setThreadId (see that method) — which lets a single instance follow a lazily-created thread.

Shared surface across every media handle returned by MediaAssembler.

The handle is live while its parent message is active:

• partialBytes is a snapshot of all bytes received so far.
• stream is a lazy, single-consumer byte stream (see accessor docstring).
• blob / objectURL settle on message-finish.
• error becomes set if the handle terminates in any of the MediaAssemblyErrorKind failure modes.

Infer the streaming AssembledToolCall handle for a single LangChain tool.

Parallel to ToolCallFromTool for message-level tool calls — use this when a component receives one entry from stream.toolCalls and you know which tool definition it came from.

Unwrap the state shape from a compiled graph, a create-agent brand, or a plain type. Used by useStream<T>() to resolve T = typeof agent into the state the values/messages projections observe.

Structurally identical to the legacy @langchain/langgraph-sdk/ui helper of the same name; kept here as a framework-facing re-export so bindings can import from the stream subpath without needing the UI module.

Infer the subagent → state map from a DeepAgent brand. Non-brands collapse to DefaultSubagentStates.

Infer the discriminated union of AssembledToolCall handles from an agent brand, an array of LangChain tools, or fall back to the untyped default handle.

Pass typeof agent or typeof tools and narrow on name / args (aliases for input) in tool-call UI components.

Read-only map exposed via MessageMetadataTracker.store.

Why a run's active streaming phase ended.

Minimal observable store backing every framework binding.

The shape is intentionally tiny:

• subscribe(listener) → unsubscribe lines up with React's useSyncExternalStore.
• getSnapshot() returns a referentially-stable value for unchanged state so React can bail out of renders.
• Vue/Svelte/Angular bindings wrap subscribe + getSnapshot in their own reactivity primitive (shallowRef / writable / signal) in ~10 lines.

Snapshot identity matters: a listener is only useful if getSnapshot() returns a different reference when state changes. Callers MUST pass a freshly-constructed value to setState; mutating the previous snapshot in place will break React's bail-out and cause infinite re-renders.

Read-only snapshot of the queue. The queue store hands this out directly; consumers must not mutate the array.

Anything with a namespace can be passed to selector hooks as a scope target. Both SubagentDiscoverySnapshot and SubgraphDiscoverySnapshot satisfy this; callers can also hand-build { namespace: [...] } objects.

High-level outcome of a single tool call.

Options accepted by framework useStream APIs. Discriminated on the shape of transport:

• omitted or a string ("sse" / "websocket") -> agent-server branch (AgentServerOptions); supply assistantId + apiUrl.
• an AgentServerAdapter instance -> custom-adapter branch (CustomAdapterOptions); bring your own transport.

Widen an update type so its messages field also accepts @langchain/core BaseMessage class instances (single or array). Framework bindings apply this to submit() so callers can write stream.submit({ messages: [new HumanMessage("hi")] }).

Port of the legacy AcceptBaseMessages<T> helper; the public name matches the v1 spec in plan-types.md §8.

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

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 the successful return type of a LangChain tool.

Resolution order mirrors InferToolInput: func, then invoke, then _call, so inference survives cross-package boundaries where _call is protected.

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.

Kinds of failure that can terminate a media handle prematurely.

• "message-error" — the upstream message emitted an error event before completion.
• "stream-closed" — the transport stream closed before message-finish arrived (thread closed, transport dropped, etc.).
• "fetch-failed" — the block was url-sourced and the lazy fetch() rejected (CORS, 404, 5xx, network).

Block types this assembler knows how to reassemble into media handles.

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