@langchain/langgraph-sdk 1.8.10 → 1.9.0

package/dist/client/stream/transport.d.ts

@@ -0,0 +1,104 @@
+import { Command, CommandResponse, ErrorResponse, Message, SubscribeParams } from "@langchain/protocol";
+
+//#region src/client/stream/transport.d.ts
+/**
+ * Handle returned by {@link TransportAdapter.openEventStream} representing
+ * a single filtered SSE connection.
+ *
+ * The `ready` promise resolves once the underlying connection is
+ * established (response headers received), letting callers ensure the
+ * subscription is active server-side before proceeding.
+ */
+interface EventStreamHandle {
+  events: AsyncIterable<Message>;
+  ready: Promise<void>;
+  close(): void;
+}
+/**
+ * Transport abstraction implemented by concrete client transports such as
+ * WebSocket or SSE adapters.
+ *
+ * In the thread-centric protocol, transports are bound to a specific
+ * thread at construction time — the thread ID is part of the connection URL.
+ */
+interface TransportAdapter {
+  /**
+   * Thread ID this transport is bound to.
+   */
+  readonly threadId: string;
+  /**
+   * Opens the underlying connection (e.g. WebSocket handshake).
+   * For HTTP/SSE transports this is a no-op.
+   */
+  open(): Promise<void>;
+  /**
+   * Sends a command and optionally returns an immediate response.
+   *
+   * @param command - Protocol command to send over the transport.
+   */
+  send(command: Command): Promise<CommandResponse | ErrorResponse | void>;
+  /**
+   * Streams incoming protocol messages from the remote peer.
+   * Used by WebSocket transports where all events share one connection.
+   */
+  events(): AsyncIterable<Message>;
+  /**
+   * Opens an independent filtered SSE event stream.
+   * Each call creates a new server connection with the given filter.
+   * Returns `undefined` when the transport does not support per-subscription
+   * streams (e.g. WebSocket), in which case the caller should fall back to
+   * command-based subscriptions over {@link events}.
+   */
+  openEventStream?(params: SubscribeParams): EventStreamHandle;
+  /**
+   * Shuts down the transport and releases any underlying resources.
+   */
+  close(): Promise<void>;
+}
+/**
+ * Public v1 name for {@link 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`.
+ */
+interface AgentServerAdapter extends TransportAdapter {
+  /**
+   * Fetch the latest checkpointed state for the bound thread. When
+   * the adapter doesn't expose state (e.g. a purely event-replay
+   * backend), leave this undefined — the framework will skip
+   * hydration.
+   */
+  getState?<StateType = unknown>(): Promise<{
+    values: StateType;
+    checkpoint?: {
+      checkpoint_id?: string;
+    } | null;
+  } | null>;
+  /**
+   * Fetch a slice of checkpoint history for the bound thread. Used
+   * by branching and time-travel UIs. Optional — omitting it turns
+   * those UIs into no-ops rather than surfacing an error.
+   */
+  getHistory?<StateType = unknown>(options?: {
+    limit?: number;
+  }): Promise<Array<{
+    values: StateType;
+    checkpoint?: {
+      checkpoint_id?: string;
+    } | null;
+  }>>;
+}
+//#endregion
+export { AgentServerAdapter, EventStreamHandle, TransportAdapter };
+//# sourceMappingURL=transport.d.ts.map

package/dist/client/stream/transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.d.ts","names":[],"sources":["../../../src/client/stream/transport.ts"],"mappings":";;;;;AAgBA;;;;;;UAAiB,iBAAA;EACf,MAAA,EAAQ,aAAA,CAAc,OAAA;EACtB,KAAA,EAAO,OAAA;EACP,KAAA;AAAA;;;;;;AAUF;;UAAiB,gBAAA;EASP;;;EAAA,SALC,QAAA;EAWe;;;;EANxB,IAAA,IAAQ,OAAA;EAuBC;;;;;EAjBT,IAAA,CAAK,OAAA,EAAS,OAAA,GAAU,OAAA,CAAQ,eAAA,GAAkB,aAAA;EAAlD;;;;EAKA,MAAA,IAAU,aAAA,CAAc,OAAA;EAL0B;;;;;;;EAalD,eAAA,EAAiB,MAAA,EAAQ,eAAA,GAAkB,iBAAA;EAI3C;;;EAAA,KAAA,IAAS,OAAA;AAAA;;;;;;;;;;;;;;;;;;UAoBM,kBAAA,SAA2B,gBAAA;EAgB1C;;;;;;EATA,QAAA,0BAAkC,OAAA;IAChC,MAAA,EAAQ,SAAA;IACR,UAAA;MAAe,aAAA;IAAA;EAAA;;;;;;EAOjB,UAAA,uBAAiC,OAAA;IAC/B,KAAA;EAAA,IACE,OAAA,CACF,KAAA;IACE,MAAA,EAAQ,SAAA;IACR,UAAA;MAAe,aAAA;IAAA;EAAA;AAAA"}

package/dist/client/stream/types.d.cts

@@ -0,0 +1,208 @@
+import { AssembledMessage } from "./messages.cjs";
+import { AgentServerAdapter } from "./transport.cjs";
+import { AgentResult, Channel, Event, InputInjectParams, InputRespondParams, ListCheckpointsParams, ListCheckpointsResult, RunResult, RunStartParams, StateForkParams, StateForkResult, StateGetParams, StateGetResult, SubscribeParams } from "@langchain/protocol";
+
+//#region src/client/stream/types.d.ts
+interface ExtendedRunStartParams extends RunStartParams {
+  forkFrom?: {
+    checkpointId: string;
+  };
+  multitaskStrategy?: "reject" | "rollback" | "interrupt" | "enqueue";
+}
+type SubscribeOptions = Omit<SubscribeParams, "channels">;
+type EventMethodByChannel = {
+  values: "values";
+  updates: "updates";
+  messages: "messages";
+  tools: "tools";
+  custom: "custom";
+  lifecycle: "lifecycle";
+  input: "input.requested";
+  debug: "debug";
+  checkpoints: "checkpoints";
+  tasks: "tasks";
+};
+type EventForChannel<TChannel extends Channel> = TChannel extends keyof EventMethodByChannel ? Extract<Event, {
+  method: EventMethodByChannel[TChannel];
+}> : TChannel extends `custom:${string}` ? Extract<Event, {
+  method: "custom";
+}> : never;
+type EventForChannels<TChannels extends readonly Channel[]> = EventForChannel<TChannels[number]>;
+/**
+ * Maps a subscribable channel to the type yielded by its subscription handle.
+ *
+ * - `"custom:name"` channels yield `unknown` (the raw emitted payload).
+ * - All other channels yield the full protocol `Event`.
+ */
+type YieldForChannel<TChannel extends Channel> = TChannel extends `custom:${string}` ? unknown : EventForChannel<TChannel>;
+type YieldForChannels<TChannels extends readonly Channel[]> = YieldForChannel<TChannels[number]>;
+/**
+ * Built-in wire transport used by {@link ThreadStream}.
+ *
+ * - `"sse"`: HTTP commands + one SSE event stream per subscription.
+ *   Works in browsers without extra setup.
+ * - `"websocket"`: single bidirectional WebSocket. Lower overhead for
+ *   long-lived, multi-subscription sessions.
+ */
+type ThreadStreamTransportKind = "sse" | "websocket";
+/**
+ * Accepted values for `ThreadStreamOptions["transport"]`.
+ *
+ * - A {@link ThreadStreamTransportKind} string picks one of the
+ *   built-in factories; `fetch` / `webSocketFactory` tune that path.
+ * - An {@link AgentServerAdapter} bypasses the built-in factories
+ *   entirely; the adapter is used for every command and subscription.
+ */
+type ThreadStreamTransport = ThreadStreamTransportKind | AgentServerAdapter;
+/**
+ * Options for {@link ThreadStream} construction.
+ */
+interface ThreadStreamOptions {
+  /**
+   * Assistant that this thread runs on. A thread is bound to one
+   * assistant for its lifetime — subsequent `run.start` calls always
+   * use this assistant.
+   */
+  assistantId: string;
+  /**
+   * How this thread talks to the agent server. Accepts either a
+   * built-in transport string or a custom {@link AgentServerAdapter}:
+   *
+   * - `"sse"`: HTTP commands + one SSE event stream per subscription.
+   * - `"websocket"`: single bidirectional WebSocket.
+   * - an {@link AgentServerAdapter}: custom transport that replaces
+   *   the built-in factories entirely. `fetch` / `webSocketFactory`
+   *   are ignored in this mode.
+   *
+   * Defaults to the client-level `streamProtocol`
+   * (`"v2-websocket"` → `"websocket"`, otherwise `"sse"`).
+   */
+  transport?: ThreadStreamTransport;
+  /**
+   * Starting command ID for the internal command counter. Mostly
+   * useful for tests.
+   */
+  startingCommandId?: number;
+  /**
+   * Optional `fetch` implementation for the built-in SSE transport.
+   * Useful for test environments, custom auth/proxy layers, or
+   * non-global fetch (e.g. Node without a global fetch, or injected
+   * mocks). Ignored for the WebSocket transport and for custom
+   * {@link AgentServerAdapter}s.
+   */
+  fetch?: typeof fetch;
+  /**
+   * Optional WebSocket factory for the built-in WebSocket transport.
+   * Useful for test environments that don't ship a global `WebSocket`,
+   * or to wrap the socket with custom headers/subprotocols. Ignored
+   * for the SSE transport and for custom {@link AgentServerAdapter}s.
+   */
+  webSocketFactory?: (url: string) => WebSocket;
+}
+interface SessionOrderingState {
+  lastSeenSeq?: number;
+  lastAppliedThroughSeq?: number;
+  lastEventId?: string;
+}
+interface EventSubscription<TYield = Event> extends AsyncIterable<TYield> {
+  readonly subscriptionId: string;
+  readonly params: SubscribeParams;
+  unsubscribe(): Promise<void>;
+}
+interface MessageSubscription extends AsyncIterable<AssembledMessage> {
+  readonly subscriptionId: string;
+  readonly params: SubscribeParams;
+  unsubscribe(): Promise<void>;
+}
+interface InputModule {
+  respond(params: InputRespondParams): Promise<void>;
+  inject(params: InputInjectParams): Promise<void>;
+}
+interface StateModule {
+  get(params: StateGetParams): Promise<StateGetResult>;
+  listCheckpoints(params: ListCheckpointsParams): Promise<ListCheckpointsResult>;
+  fork(params: StateForkParams): Promise<StateForkResult>;
+}
+/**
+ * Modules exposed by the high-level {@link ThreadStream} wrapper.
+ */
+interface ThreadModules {
+  run: {
+    /**
+     * Start a new run, resume an interrupted run, or inject input into
+     * an active run on this thread. The assistant is fixed by the
+     * {@link ThreadStream} constructor and cannot be changed per-call.
+     */
+    start(params: Omit<ExtendedRunStartParams, "assistant_id">): Promise<RunResult>;
+  };
+  agent: {
+    getTree(params?: {
+      run_id?: string;
+    }): Promise<AgentResult>;
+  };
+  input: InputModule;
+  state: StateModule;
+}
+/**
+ * Human-in-the-loop interrupt payload surfaced from lifecycle events.
+ * Matches the in-process `InterruptPayload` type.
+ */
+interface InterruptPayload<TPayload = unknown> {
+  interruptId: string;
+  payload: TPayload;
+  namespace: string[];
+}
+/**
+ * Remote counterpart of an in-process `run.extensions.<name>` projection.
+ *
+ * Each extension is the client-side view of a compile-time
+ * {@link StreamTransformer} projection. The server auto-forwards named
+ * `StreamChannel.remote(name)` outputs on the `custom:<name>` channel, and
+ * this handle exposes them via two dual interfaces:
+ *
+ *  - `AsyncIterable<T>` — iterate every item pushed by a streaming
+ *    transformer (e.g. a `StreamChannel`).
+ *  - `PromiseLike<T>` — `await` resolves with the final value observed
+ *    when the run terminates. For streaming transformers this is the
+ *    last item pushed; for final-value transformers it is the single
+ *    value emitted on run end.
+ *
+ * Subscribing is lazy: the underlying `custom:<name>` subscription is
+ * opened on first property access and cached.
+ */
+interface ThreadExtension<T = unknown> extends AsyncIterable<T>, PromiseLike<T> {}
+/**
+ * Unwrap a single in-process projection value to its observable payload
+ * type:
+ *
+ *   - `Promise<T>` / `PromiseLike<T>` → `T` (final-value transformers)
+ *   - `StreamChannel<T>` / `AsyncIterable<T>` → `T` (streaming transformers)
+ *   - anything else → the value itself
+ *
+ * This lets a `ThreadStream<TExtensions>` generic accept the same shape
+ * that `graph.streamEvents(..., { version: "v3" })` returns in-process
+ * (via `InferExtensions<TTransformers>` from `@langchain/langgraph`),
+ * without forcing users to redeclare payload types on the remote side.
+ */
+type UnwrapExtension<T> = T extends PromiseLike<infer U> ? U : T extends AsyncIterable<infer U> ? U : T;
+/**
+ * Keyed map of {@link ThreadExtension} handles, typed off a declared
+ * transformer projection shape.
+ *
+ * Used as the return type of `ThreadStream.extensions`. `TExtensions`
+ * is expected to match the in-process `run.extensions` shape (i.e. the
+ * output of `InferExtensions<TTransformers>` from
+ * `@langchain/langgraph`); each value type is unwrapped via
+ * {@link UnwrapExtension} so `thread.extensions.foo` resolves with the
+ * transformer's emitted payload, not the in-process `Promise<T>` /
+ * `StreamChannel<T>` wrapper.
+ *
+ * Access any string key to obtain a `ThreadExtension<unknown>`; keys
+ * that appear in `TExtensions` narrow to their declared payload type.
+ */
+type ThreadExtensions<TExtensions extends Record<string, unknown> = Record<string, unknown>> = { readonly [K in keyof TExtensions]: ThreadExtension<UnwrapExtension<TExtensions[K]>> } & {
+  readonly [name: string]: ThreadExtension<unknown>;
+};
+//#endregion
+export { EventForChannel, EventForChannels, EventMethodByChannel, EventSubscription, ExtendedRunStartParams, InputModule, InterruptPayload, MessageSubscription, SessionOrderingState, StateModule, SubscribeOptions, ThreadExtension, ThreadExtensions, ThreadModules, ThreadStreamOptions, ThreadStreamTransport, ThreadStreamTransportKind, UnwrapExtension, YieldForChannel, YieldForChannels };
+//# sourceMappingURL=types.d.cts.map

package/dist/client/stream/types.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.cts","names":[],"sources":["../../../src/client/stream/types.ts"],"mappings":";;;;;UAoBiB,sBAAA,SAA+B,cAAA;EAC9C,QAAA;IAAa,YAAA;EAAA;EACb,iBAAA;AAAA;AAAA,KAGU,gBAAA,GAAmB,IAAA,CAAK,eAAA;AAAA,KAExB,oBAAA;EACV,MAAA;EACA,OAAA;EACA,QAAA;EACA,KAAA;EACA,MAAA;EACA,SAAA;EACA,KAAA;EACA,KAAA;EACA,WAAA;EACA,KAAA;AAAA;AAAA,KAGU,eAAA,kBAAiC,OAAA,IAC3C,QAAA,eAAuB,oBAAA,GACnB,OAAA,CAAQ,KAAA;EAAS,MAAA,EAAQ,oBAAA,CAAqB,QAAA;AAAA,KAC9C,QAAA,8BACE,OAAA,CAAQ,KAAA;EAAS,MAAA;AAAA;AAAA,KAGb,gBAAA,4BAA4C,OAAA,MACtD,eAAA,CAAgB,SAAA;;;;;;;KAQN,eAAA,kBAAiC,OAAA,IAC3C,QAAA,wCAAgD,eAAA,CAAgB,QAAA;AAAA,KAEtD,gBAAA,4BAA4C,OAAA,MACtD,eAAA,CAAgB,SAAA;AApBlB;;;;;;;;AAAA,KA8BY,yBAAA;;;;;;;;;KAUA,qBAAA,GACR,yBAAA,GACA,kBAAA;;;;UAKa,mBAAA;EA7Cc;;;;;EAmD7B,WAAA;EAjD6B;;AAG/B;;;;;;;;;;;EA4DE,SAAA,GAAY,qBAAA;EA3Da;;AAQ3B;;EAwDE,iBAAA;EAxD2C;;;;;;;EAgE3C,KAAA,UAAe,KAAA;EA/Df;;;;;AAEF;EAoEE,gBAAA,IAAoB,GAAA,aAAgB,SAAA;AAAA;AAAA,UAGrB,oBAAA;EACf,WAAA;EACA,qBAAA;EACA,WAAA;AAAA;AAAA,UAGe,iBAAA,UACN,KAAA,UACD,aAAA,CAAc,MAAA;EAAA,SACb,cAAA;EAAA,SACA,MAAA,EAAQ,eAAA;EACjB,WAAA,IAAe,OAAA;AAAA;AAAA,UAGA,mBAAA,SAA4B,aAAA,CAAc,gBAAA;EAAA,SAChD,cAAA;EAAA,SACA,MAAA,EAAQ,eAAA;EACjB,WAAA,IAAe,OAAA;AAAA;AAAA,UAGA,WAAA;EACf,OAAA,CAAQ,MAAA,EAAQ,kBAAA,GAAqB,OAAA;EACrC,MAAA,CAAO,MAAA,EAAQ,iBAAA,GAAoB,OAAA;AAAA;AAAA,UAGpB,WAAA;EACf,GAAA,CAAI,MAAA,EAAQ,cAAA,GAAiB,OAAA,CAAQ,cAAA;EACrC,eAAA,CACE,MAAA,EAAQ,qBAAA,GACP,OAAA,CAAQ,qBAAA;EACX,IAAA,CAAK,MAAA,EAAQ,eAAA,GAAkB,OAAA,CAAQ,eAAA;AAAA;;;;UAMxB,aAAA;EACf,GAAA;IA1EA;;;;;IAgFE,KAAA,CACE,MAAA,EAAQ,IAAA,CAAK,sBAAA,oBACZ,OAAA,CAAQ,SAAA;EAAA;EAEb,KAAA;IACE,OAAA,CAAQ,MAAA;MAAW,MAAA;IAAA,IAAoB,OAAA,CAAQ,WAAA;EAAA;EAEjD,KAAA,EAAO,WAAA;EACP,KAAA,EAAO,WAAA;AAAA;;;;;UAOQ,gBAAA;EACf,WAAA;EACA,OAAA,EAAS,QAAA;EACT,SAAA;AAAA;;;;;;;;;;;;;;;;;;AA/CF;UAoEiB,eAAA,sBACP,aAAA,CAAc,CAAA,GAAI,WAAA,CAAY,CAAA;;;;;;;;;;;;;;KAe5B,eAAA,MACV,CAAA,SAAU,WAAA,YAAuB,CAAA,GAAI,CAAA,SAAU,aAAA,YAAyB,CAAA,GAAI,CAAA;;AA/E9E;;;;;;;;;;;;;;KAgGY,gBAAA,qBACU,MAAA,oBAA0B,MAAA,4CAEzB,WAAA,GAAc,eAAA,CACjC,eAAA,CAAgB,WAAA,CAAY,CAAA;EAAA,UAGpB,IAAA,WAAe,eAAA;AAAA"}

package/dist/client/stream/types.d.ts

@@ -0,0 +1,208 @@
+import { AssembledMessage } from "./messages.js";
+import { AgentServerAdapter } from "./transport.js";
+import { AgentResult, Channel, Event, InputInjectParams, InputRespondParams, ListCheckpointsParams, ListCheckpointsResult, RunResult, RunStartParams, StateForkParams, StateForkResult, StateGetParams, StateGetResult, SubscribeParams } from "@langchain/protocol";
+
+//#region src/client/stream/types.d.ts
+interface ExtendedRunStartParams extends RunStartParams {
+  forkFrom?: {
+    checkpointId: string;
+  };
+  multitaskStrategy?: "reject" | "rollback" | "interrupt" | "enqueue";
+}
+type SubscribeOptions = Omit<SubscribeParams, "channels">;
+type EventMethodByChannel = {
+  values: "values";
+  updates: "updates";
+  messages: "messages";
+  tools: "tools";
+  custom: "custom";
+  lifecycle: "lifecycle";
+  input: "input.requested";
+  debug: "debug";
+  checkpoints: "checkpoints";
+  tasks: "tasks";
+};
+type EventForChannel<TChannel extends Channel> = TChannel extends keyof EventMethodByChannel ? Extract<Event, {
+  method: EventMethodByChannel[TChannel];
+}> : TChannel extends `custom:${string}` ? Extract<Event, {
+  method: "custom";
+}> : never;
+type EventForChannels<TChannels extends readonly Channel[]> = EventForChannel<TChannels[number]>;
+/**
+ * Maps a subscribable channel to the type yielded by its subscription handle.
+ *
+ * - `"custom:name"` channels yield `unknown` (the raw emitted payload).
+ * - All other channels yield the full protocol `Event`.
+ */
+type YieldForChannel<TChannel extends Channel> = TChannel extends `custom:${string}` ? unknown : EventForChannel<TChannel>;
+type YieldForChannels<TChannels extends readonly Channel[]> = YieldForChannel<TChannels[number]>;
+/**
+ * Built-in wire transport used by {@link ThreadStream}.
+ *
+ * - `"sse"`: HTTP commands + one SSE event stream per subscription.
+ *   Works in browsers without extra setup.
+ * - `"websocket"`: single bidirectional WebSocket. Lower overhead for
+ *   long-lived, multi-subscription sessions.
+ */
+type ThreadStreamTransportKind = "sse" | "websocket";
+/**
+ * Accepted values for `ThreadStreamOptions["transport"]`.
+ *
+ * - A {@link ThreadStreamTransportKind} string picks one of the
+ *   built-in factories; `fetch` / `webSocketFactory` tune that path.
+ * - An {@link AgentServerAdapter} bypasses the built-in factories
+ *   entirely; the adapter is used for every command and subscription.
+ */
+type ThreadStreamTransport = ThreadStreamTransportKind | AgentServerAdapter;
+/**
+ * Options for {@link ThreadStream} construction.
+ */
+interface ThreadStreamOptions {
+  /**
+   * Assistant that this thread runs on. A thread is bound to one
+   * assistant for its lifetime — subsequent `run.start` calls always
+   * use this assistant.
+   */
+  assistantId: string;
+  /**
+   * How this thread talks to the agent server. Accepts either a
+   * built-in transport string or a custom {@link AgentServerAdapter}:
+   *
+   * - `"sse"`: HTTP commands + one SSE event stream per subscription.
+   * - `"websocket"`: single bidirectional WebSocket.
+   * - an {@link AgentServerAdapter}: custom transport that replaces
+   *   the built-in factories entirely. `fetch` / `webSocketFactory`
+   *   are ignored in this mode.
+   *
+   * Defaults to the client-level `streamProtocol`
+   * (`"v2-websocket"` → `"websocket"`, otherwise `"sse"`).
+   */
+  transport?: ThreadStreamTransport;
+  /**
+   * Starting command ID for the internal command counter. Mostly
+   * useful for tests.
+   */
+  startingCommandId?: number;
+  /**
+   * Optional `fetch` implementation for the built-in SSE transport.
+   * Useful for test environments, custom auth/proxy layers, or
+   * non-global fetch (e.g. Node without a global fetch, or injected
+   * mocks). Ignored for the WebSocket transport and for custom
+   * {@link AgentServerAdapter}s.
+   */
+  fetch?: typeof fetch;
+  /**
+   * Optional WebSocket factory for the built-in WebSocket transport.
+   * Useful for test environments that don't ship a global `WebSocket`,
+   * or to wrap the socket with custom headers/subprotocols. Ignored
+   * for the SSE transport and for custom {@link AgentServerAdapter}s.
+   */
+  webSocketFactory?: (url: string) => WebSocket;
+}
+interface SessionOrderingState {
+  lastSeenSeq?: number;
+  lastAppliedThroughSeq?: number;
+  lastEventId?: string;
+}
+interface EventSubscription<TYield = Event> extends AsyncIterable<TYield> {
+  readonly subscriptionId: string;
+  readonly params: SubscribeParams;
+  unsubscribe(): Promise<void>;
+}
+interface MessageSubscription extends AsyncIterable<AssembledMessage> {
+  readonly subscriptionId: string;
+  readonly params: SubscribeParams;
+  unsubscribe(): Promise<void>;
+}
+interface InputModule {
+  respond(params: InputRespondParams): Promise<void>;
+  inject(params: InputInjectParams): Promise<void>;
+}
+interface StateModule {
+  get(params: StateGetParams): Promise<StateGetResult>;
+  listCheckpoints(params: ListCheckpointsParams): Promise<ListCheckpointsResult>;
+  fork(params: StateForkParams): Promise<StateForkResult>;
+}
+/**
+ * Modules exposed by the high-level {@link ThreadStream} wrapper.
+ */
+interface ThreadModules {
+  run: {
+    /**
+     * Start a new run, resume an interrupted run, or inject input into
+     * an active run on this thread. The assistant is fixed by the
+     * {@link ThreadStream} constructor and cannot be changed per-call.
+     */
+    start(params: Omit<ExtendedRunStartParams, "assistant_id">): Promise<RunResult>;
+  };
+  agent: {
+    getTree(params?: {
+      run_id?: string;
+    }): Promise<AgentResult>;
+  };
+  input: InputModule;
+  state: StateModule;
+}
+/**
+ * Human-in-the-loop interrupt payload surfaced from lifecycle events.
+ * Matches the in-process `InterruptPayload` type.
+ */
+interface InterruptPayload<TPayload = unknown> {
+  interruptId: string;
+  payload: TPayload;
+  namespace: string[];
+}
+/**
+ * Remote counterpart of an in-process `run.extensions.<name>` projection.
+ *
+ * Each extension is the client-side view of a compile-time
+ * {@link StreamTransformer} projection. The server auto-forwards named
+ * `StreamChannel.remote(name)` outputs on the `custom:<name>` channel, and
+ * this handle exposes them via two dual interfaces:
+ *
+ *  - `AsyncIterable<T>` — iterate every item pushed by a streaming
+ *    transformer (e.g. a `StreamChannel`).
+ *  - `PromiseLike<T>` — `await` resolves with the final value observed
+ *    when the run terminates. For streaming transformers this is the
+ *    last item pushed; for final-value transformers it is the single
+ *    value emitted on run end.
+ *
+ * Subscribing is lazy: the underlying `custom:<name>` subscription is
+ * opened on first property access and cached.
+ */
+interface ThreadExtension<T = unknown> extends AsyncIterable<T>, PromiseLike<T> {}
+/**
+ * Unwrap a single in-process projection value to its observable payload
+ * type:
+ *
+ *   - `Promise<T>` / `PromiseLike<T>` → `T` (final-value transformers)
+ *   - `StreamChannel<T>` / `AsyncIterable<T>` → `T` (streaming transformers)
+ *   - anything else → the value itself
+ *
+ * This lets a `ThreadStream<TExtensions>` generic accept the same shape
+ * that `graph.streamEvents(..., { version: "v3" })` returns in-process
+ * (via `InferExtensions<TTransformers>` from `@langchain/langgraph`),
+ * without forcing users to redeclare payload types on the remote side.
+ */
+type UnwrapExtension<T> = T extends PromiseLike<infer U> ? U : T extends AsyncIterable<infer U> ? U : T;
+/**
+ * Keyed map of {@link ThreadExtension} handles, typed off a declared
+ * transformer projection shape.
+ *
+ * Used as the return type of `ThreadStream.extensions`. `TExtensions`
+ * is expected to match the in-process `run.extensions` shape (i.e. the
+ * output of `InferExtensions<TTransformers>` from
+ * `@langchain/langgraph`); each value type is unwrapped via
+ * {@link UnwrapExtension} so `thread.extensions.foo` resolves with the
+ * transformer's emitted payload, not the in-process `Promise<T>` /
+ * `StreamChannel<T>` wrapper.
+ *
+ * Access any string key to obtain a `ThreadExtension<unknown>`; keys
+ * that appear in `TExtensions` narrow to their declared payload type.
+ */
+type ThreadExtensions<TExtensions extends Record<string, unknown> = Record<string, unknown>> = { readonly [K in keyof TExtensions]: ThreadExtension<UnwrapExtension<TExtensions[K]>> } & {
+  readonly [name: string]: ThreadExtension<unknown>;
+};
+//#endregion
+export { EventForChannel, EventForChannels, EventMethodByChannel, EventSubscription, ExtendedRunStartParams, InputModule, InterruptPayload, MessageSubscription, SessionOrderingState, StateModule, SubscribeOptions, ThreadExtension, ThreadExtensions, ThreadModules, ThreadStreamOptions, ThreadStreamTransport, ThreadStreamTransportKind, UnwrapExtension, YieldForChannel, YieldForChannels };
+//# sourceMappingURL=types.d.ts.map

package/dist/client/stream/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/client/stream/types.ts"],"mappings":";;;;;UAoBiB,sBAAA,SAA+B,cAAA;EAC9C,QAAA;IAAa,YAAA;EAAA;EACb,iBAAA;AAAA;AAAA,KAGU,gBAAA,GAAmB,IAAA,CAAK,eAAA;AAAA,KAExB,oBAAA;EACV,MAAA;EACA,OAAA;EACA,QAAA;EACA,KAAA;EACA,MAAA;EACA,SAAA;EACA,KAAA;EACA,KAAA;EACA,WAAA;EACA,KAAA;AAAA;AAAA,KAGU,eAAA,kBAAiC,OAAA,IAC3C,QAAA,eAAuB,oBAAA,GACnB,OAAA,CAAQ,KAAA;EAAS,MAAA,EAAQ,oBAAA,CAAqB,QAAA;AAAA,KAC9C,QAAA,8BACE,OAAA,CAAQ,KAAA;EAAS,MAAA;AAAA;AAAA,KAGb,gBAAA,4BAA4C,OAAA,MACtD,eAAA,CAAgB,SAAA;;;;;;;KAQN,eAAA,kBAAiC,OAAA,IAC3C,QAAA,wCAAgD,eAAA,CAAgB,QAAA;AAAA,KAEtD,gBAAA,4BAA4C,OAAA,MACtD,eAAA,CAAgB,SAAA;AApBlB;;;;;;;;AAAA,KA8BY,yBAAA;;;;;;;;;KAUA,qBAAA,GACR,yBAAA,GACA,kBAAA;;;;UAKa,mBAAA;EA7Cc;;;;;EAmD7B,WAAA;EAjD6B;;AAG/B;;;;;;;;;;;EA4DE,SAAA,GAAY,qBAAA;EA3Da;;AAQ3B;;EAwDE,iBAAA;EAxD2C;;;;;;;EAgE3C,KAAA,UAAe,KAAA;EA/Df;;;;;AAEF;EAoEE,gBAAA,IAAoB,GAAA,aAAgB,SAAA;AAAA;AAAA,UAGrB,oBAAA;EACf,WAAA;EACA,qBAAA;EACA,WAAA;AAAA;AAAA,UAGe,iBAAA,UACN,KAAA,UACD,aAAA,CAAc,MAAA;EAAA,SACb,cAAA;EAAA,SACA,MAAA,EAAQ,eAAA;EACjB,WAAA,IAAe,OAAA;AAAA;AAAA,UAGA,mBAAA,SAA4B,aAAA,CAAc,gBAAA;EAAA,SAChD,cAAA;EAAA,SACA,MAAA,EAAQ,eAAA;EACjB,WAAA,IAAe,OAAA;AAAA;AAAA,UAGA,WAAA;EACf,OAAA,CAAQ,MAAA,EAAQ,kBAAA,GAAqB,OAAA;EACrC,MAAA,CAAO,MAAA,EAAQ,iBAAA,GAAoB,OAAA;AAAA;AAAA,UAGpB,WAAA;EACf,GAAA,CAAI,MAAA,EAAQ,cAAA,GAAiB,OAAA,CAAQ,cAAA;EACrC,eAAA,CACE,MAAA,EAAQ,qBAAA,GACP,OAAA,CAAQ,qBAAA;EACX,IAAA,CAAK,MAAA,EAAQ,eAAA,GAAkB,OAAA,CAAQ,eAAA;AAAA;;;;UAMxB,aAAA;EACf,GAAA;IA1EA;;;;;IAgFE,KAAA,CACE,MAAA,EAAQ,IAAA,CAAK,sBAAA,oBACZ,OAAA,CAAQ,SAAA;EAAA;EAEb,KAAA;IACE,OAAA,CAAQ,MAAA;MAAW,MAAA;IAAA,IAAoB,OAAA,CAAQ,WAAA;EAAA;EAEjD,KAAA,EAAO,WAAA;EACP,KAAA,EAAO,WAAA;AAAA;;;;;UAOQ,gBAAA;EACf,WAAA;EACA,OAAA,EAAS,QAAA;EACT,SAAA;AAAA;;;;;;;;;;;;;;;;;;AA/CF;UAoEiB,eAAA,sBACP,aAAA,CAAc,CAAA,GAAI,WAAA,CAAY,CAAA;;;;;;;;;;;;;;KAe5B,eAAA,MACV,CAAA,SAAU,WAAA,YAAuB,CAAA,GAAI,CAAA,SAAU,aAAA,YAAyB,CAAA,GAAI,CAAA;;AA/E9E;;;;;;;;;;;;;;KAgGY,gBAAA,qBACU,MAAA,oBAA0B,MAAA,4CAEzB,WAAA,GAAc,eAAA,CACjC,eAAA,CAAgB,WAAA,CAAY,CAAA;EAAA,UAGpB,IAAA,WAAe,eAAA;AAAA"}