@langchain/langgraph 1.2.9 → 1.3.0

package/dist/stream/types.d.ts

@@ -0,0 +1,255 @@
+import { StreamMode } from "../pregel/types.js";
+import { ChatModelStream } from "@langchain/core/language_models/stream";
+import { ChatModelStreamEvent } from "@langchain/core/language_models/event";
+import { AgentStatus as AgentStatus$1, Checkpoint, LifecycleCause, LifecycleData as LifecycleData$1, MessagesData as MessagesEventData, ToolsData as ToolsEventData, UpdatesData as UpdatesEventData, UsageInfo } from "@langchain/protocol";
+
+//#region src/stream/types.d.ts
+/**
+ * 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).
+ */
+type Namespace = string[];
+/**
+ * Channels that can appear on a protocol event.  Beyond the raw
+ * {@link StreamMode} channels emitted by the Pregel stream, the v2
+ * protocol layer synthesizes additional channels (e.g. `lifecycle`,
+ * `input`) via built-in {@link StreamTransformer}s and exposes
+ * user-defined channels created with {@link StreamChannel}.
+ */
+type ProtocolMethod = StreamMode | "lifecycle" | "input" | (string & {});
+/**
+ * Single envelope for a streaming protocol emission: sequence, channel
+ * (`method`), and payload (`params`).
+ */
+interface ProtocolEvent {
+  /** Discriminator; always `"event"` for this shape. */
+  readonly type: "event";
+  /** Monotonic sequence number for ordering and deduplication within a run. */
+  readonly seq: number;
+  /**
+   * Logical stream channel.  Built-in channels match {@link StreamMode}
+   * (e.g. `messages`, `updates`); transformer-synthesized channels
+   * include `lifecycle` and `input`; user-defined channels carry their
+   * {@link StreamChannel.channelName}.
+   */
+  readonly method: ProtocolMethod;
+  /** Channel-specific payload and routing metadata. */
+  readonly params: {
+    /** Namespace of the node or scope that emitted this event. */readonly namespace: Namespace; /** Wall-clock or logical timestamp for the emission (milliseconds). */
+    readonly timestamp: number;
+    /**
+     * Graph node id when the engine can attribute the event to a single node;
+     * omitted for run-level or ambiguous emissions.
+     */
+    readonly node?: string; /** Opaque channel payload; shape depends on `method`. */
+    readonly data: unknown;
+  };
+}
+/**
+ * Infers the merged extensions type from a tuple of transformer factory functions.
+ *
+ * Given `[() => StreamTransformer<{ a: number }>, () => StreamTransformer<{ b: string }>]`,
+ * produces `{ a: number } & { b: string }`.
+ */
+type InferExtensions<T extends ReadonlyArray<() => StreamTransformer<any>>> = T extends readonly [] ? Record<string, never> : T extends readonly [() => StreamTransformer<infer P>, ...infer Rest extends ReadonlyArray<() => StreamTransformer<any>>] ? P & InferExtensions<Rest> : Record<string, unknown>;
+/**
+ * Observes {@link ProtocolEvent}s 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 {@link StreamChannel.local} for local streaming
+ * values, {@link 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 {@link StreamMux} detects named
+ * `StreamChannel` instances in the `init()` return and auto-forwards every
+ * `push()` as a {@link ProtocolEvent} on the channel's named method.  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`).
+ *
+ * @typeParam TProjection - Shape returned by {@link init}, merged into
+ *   `GraphRunStream.extensions`.
+ */
+interface StreamTransformer<TProjection = unknown> {
+  /**
+   * Called once before the run starts.
+   *
+   * @returns Initial projection merged into `GraphRunStream.extensions`.
+   *   Any named {@link StreamChannel} instances in the return value are
+   *   automatically wired to the protocol event stream by the mux. Unnamed
+   *   channels stay in-process-only.
+   */
+  init(): TProjection;
+  /**
+   * Optional hook invoked by {@link StreamMux.addTransformer} immediately
+   * after the transformer is attached to the mux. Receives a limited
+   * handle that exposes only {@link StreamEmitter.push} — enough for
+   * the transformer to emit synthesized {@link ProtocolEvent}s on any
+   * namespace it chooses (e.g. a deepagents `SubagentTransformer`
+   * fabricating `lifecycle`/`messages`/`values` events under a
+   * `["tools:<tool_call_id>"]` namespace when a `task` tool starts).
+   *
+   * Transformers that do not synthesize events can omit this hook.
+   *
+   * The {@link StreamEmitter} handle is only safe to call *from within*
+   * {@link StreamTransformer.process}. Emitting from an unrelated async
+   * context (e.g. after `process` has returned, from a `setTimeout`,
+   * etc.) races with the mux's close/fail cycle and may land events in
+   * an already-closed log.
+   */
+  onRegister?(emitter: StreamEmitter): void;
+  /**
+   * Called for each {@link ProtocolEvent} before it is appended to the main log.
+   *
+   * @param event - Next protocol envelope for this run.
+   * @returns `false` to drop the original event from the main log (use
+   *   sparingly; prefer keeping events visible and adding derived data
+   *   alongside).
+   */
+  process(event: ProtocolEvent): boolean;
+  /**
+   * Called once when the underlying Pregel run completes without throwing.
+   * Optional — only needed for non-channel teardown (e.g. resolving promises).
+   *
+   * May return a `PromiseLike<void>` to defer the main event log close
+   * until the async work (e.g. emitting terminal lifecycle events) has
+   * completed.  The mux awaits all returned promises before closing its
+   * event log.
+   */
+  finalize?(): void | PromiseLike<void>;
+  /**
+   * Called once when the run fails; `err` is the rejection or error value.
+   * Optional — only needed for non-channel teardown (e.g. rejecting promises).
+   *
+   * @param err - Failure reason from the engine or user code.
+   */
+  fail?(err: unknown): void;
+}
+/**
+ * Narrow capability handle passed to
+ * {@link 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.
+ */
+interface StreamEmitter {
+  /**
+   * Injects a new {@link ProtocolEvent} into the mux pipeline. The
+   * event is routed through every registered transformer (including
+   * the emitting transformer — implementers must guard against
+   * re-entrant self-processing) and, if not suppressed, appended to
+   * the main event log.
+   *
+   * @param ns - Target namespace for the synthetic event.
+   * @param event - The event envelope to inject. ``event.seq`` is
+   *   overwritten by the mux; callers can pass any placeholder.
+   */
+  push(ns: Namespace, event: ProtocolEvent): void;
+}
+type ChatModelStream$1 = Omit<ChatModelStream, typeof Symbol.asyncIterator> & {
+  /** Namespace of the graph node that produced this stream. */readonly namespace: Namespace; /** Graph node id for this stream, if the runtime attributed it. */
+  readonly node: string | undefined;
+  /**
+   * Low-level async iteration over message lifecycle events.
+   *
+   * @returns Iterator yielding Core-compatible chat model stream events.
+   */
+  [Symbol.asyncIterator](): AsyncIterator<ChatModelStreamEvent>;
+};
+/**
+ * Public view yielded by `run.messages`.
+ *
+ * `ChatModelStream` is PromiseLike to mirror Core, but TypeScript applies
+ * `Awaited<T>` to values produced by `for await`. Exposing a non-thenable view
+ * keeps loop variables typed as the streaming handle instead of `AIMessage`.
+ */
+type ChatModelStreamHandle = Omit<ChatModelStream$1, "then">;
+/**
+ * High-level outcome of a single tool call for UI or aggregators.
+ */
+type ToolCallStatus = /** Invocation in flight or output still streaming. */"running" /** Completed without error. */ | "finished" /** Failed or aborted; see {@link ToolCallStream.error}. */ | "error";
+/**
+ * Stable handle for one tool call: name, arguments, and async results.
+ *
+ * Emitted when `content-block-finish` delivers a finalized `tool_call` block.
+ *
+ * @typeParam TName - Registered tool name.
+ * @typeParam TInput - Parsed or raw input type for the call.
+ * @typeParam TOutput - Successful result type after the tool returns.
+ */
+interface ToolCallStream<TName extends string = string, TInput = unknown, TOutput = unknown> {
+  /** Tool identifier as registered on the graph or model schema. */
+  readonly name: TName;
+  /** Correlates with protocol `toolCallId` when the runtime provides one. */
+  readonly callId: string;
+  /** Arguments passed to the tool (finalized when the call is observable). */
+  readonly input: TInput;
+  /**
+   * Resolves to the tool return value on success.
+   *
+   * @remarks
+   * Rejection or hang semantics depend on the runner; pairing with
+   * {@link ToolCallStream.status} and {@link ToolCallStream.error} is recommended.
+   */
+  readonly output: Promise<TOutput>;
+  /**
+   * Resolves to {@link ToolCallStatus} when the call leaves the running state.
+   */
+  readonly status: Promise<ToolCallStatus>;
+  /**
+   * Resolves to an error message string if {@link ToolCallStream.status} is
+   * `"error"`, otherwise `undefined`.
+   */
+  readonly error: Promise<string | undefined>;
+}
+/**
+ * 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.
+ */
+interface NativeStreamTransformer<TProjection = unknown> extends StreamTransformer<TProjection> {
+  readonly __native: true;
+}
+/**
+ * Type guard that tests whether a transformer is a {@link NativeStreamTransformer}.
+ */
+declare function isNativeTransformer(t: StreamTransformer<unknown>): t is NativeStreamTransformer;
+/**
+ * Human-in-the-loop interrupt: stable id plus opaque payload for resume UIs.
+ */
+interface InterruptPayload<TPayload = unknown> {
+  /** Idempotent key for this interrupt instance within the run. */
+  interruptId: string;
+  /** Arbitrary data supplied by the graph (e.g. questions, draft state). */
+  payload: TPayload;
+}
+//#endregion
+export { type AgentStatus$1 as AgentStatus, ChatModelStream$1 as ChatModelStream, ChatModelStreamHandle, type Checkpoint, InferExtensions, InterruptPayload, type LifecycleCause, type LifecycleData$1 as LifecycleData, type MessagesEventData, Namespace, NativeStreamTransformer, ProtocolEvent, StreamEmitter, StreamTransformer, ToolCallStatus, ToolCallStream, type ToolsEventData, type UpdatesEventData, type UsageInfo, isNativeTransformer };
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../src/stream/types.ts"],"mappings":";;;;;;;;;;;;KAkDY,SAAA;;;;;AAuDZ;;;KA9CY,cAAA,GAAiB,UAAA;;;;;UAMZ,aAAA;EAgDiC;EAAA,SA9CvC,IAAA;EAgDL;EAAA,SA7CK,GAAA;EA6CD;;;;;;EAAA,SArCC,MAAA,EAAQ,cAAA;EA8Bf;EAAA,SA3BO,MAAA;IA6BP,uEA3BS,SAAA,EAAW,SAAA,EA4Bc;IAAA,SAzBzB,SAAA;IA2BiB;;;;IAAA,SArBjB,IAAA,WAwBP;IAAA,SArBO,IAAA;EAAA;AAAA;;;;;;;KAUD,eAAA,WAEA,aAAA,OAAoB,iBAAA,UAC5B,CAAA,uBACA,MAAA,kBACA,CAAA,yBACU,iBAAA,iCAEgB,aAAA,OAAoB,iBAAA,UAE5C,CAAA,GAAI,eAAA,CAAgB,IAAA,IACpB,MAAA;;;;;;;;;;;;;;AA+FN;;;;;;;;;;;AAeA;;UAlFiB,iBAAA;EAmFf;;;;;;;;EA1EA,IAAA,IAAQ,WAAA;EA0ER;;;;;;;;;;;;;AAwBF;;;;EA/EE,UAAA,EAAY,OAAA,EAAS,aAAA;EAoFX;;;;;AAiBZ;;;EA3FE,OAAA,CAAQ,KAAA,EAAO,aAAA;EAuGC;;;;;;;;;EA5FhB,QAAA,YAAoB,WAAA;EAmFpB;;;;;;EA3EA,IAAA,EAAM,GAAA;AAAA;;;;;;;;UAUS,aAAA;EAuHA;;;;;;;;;;AASjB;EApHE,IAAA,CAAK,EAAA,EAAI,SAAA,EAAW,KAAA,EAAO,aAAA;AAAA;AAAA,KAGjB,iBAAA,GAAkB,IAAA,CAC5B,eAAA,SACO,MAAA,CAAO,aAAA;EAgHX,sEA7GM,SAAA,EAAW,SAAA,EA8GnB;EAAA,SA3GQ,IAAA;EA2GoB;;AAO/B;;;EAP+B,CApG5B,MAAA,CAAO,aAAP,KAAyB,aAAA,CAAc,oBAAA;AAAA;;;;;;;;KAU9B,qBAAA,GAAwB,IAAA,CAAK,iBAAA;;;;KAK7B,cAAA;;;;;;;;;;UAiBK,cAAA;;WAMN,IAAA,EAAM,KAAA;;WAGN,MAAA;;WAGA,KAAA,EAAO,MAAA;;;;;;;;WASP,MAAA,EAAQ,OAAA,CAAQ,OAAA;;;;WAKhB,MAAA,EAAQ,OAAA,CAAQ,cAAA;;;;;WAMhB,KAAA,EAAO,OAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;UAyBD,uBAAA,gCAEP,iBAAA,CAAkB,WAAA;EAAA,SACjB,QAAA;AAAA;;;;iBAMK,mBAAA,CACd,CAAA,EAAG,iBAAA,YACF,CAAA,IAAK,uBAAA;;;;UAOS,gBAAA;;EAEf,WAAA;;EAGA,OAAA,EAAS,QAAA;AAAA"}

package/dist/stream/types.js

@@ -0,0 +1,11 @@
+//#region src/stream/types.ts
+/**
+* Type guard that tests whether a transformer is a {@link NativeStreamTransformer}.
+*/
+function isNativeTransformer(t) {
+	return "__native" in t && t.__native === true;
+}
+//#endregion
+export { isNativeTransformer };
+
+//# sourceMappingURL=types.js.map

package/dist/stream/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":[],"sources":["../../src/stream/types.ts"],"sourcesContent":["/**\n * Core type definitions for the v2 streaming interface.\n *\n * Channel event data types (`MessagesEventData`, `ToolsEventData`,\n * `UpdatesEventData`, `UsageInfo`, `Checkpoint`, `CheckpointSource`) are\n * re-exported from `@langchain/protocol` — the generated TypeScript\n * bindings for the canonical CDDL schema.  Stream-specific types\n * (`StreamTransformer`, `ChatModelStream`, `ToolCallStream`,\n * `InterruptPayload`) are defined here.\n */\n\nimport type { ChatModelStream as CoreChatModelStream } from \"@langchain/core/language_models/stream\";\nimport type { ChatModelStreamEvent as CoreChatModelStreamEvent } from \"@langchain/core/language_models/event\";\nimport type { StreamMode } from \"../pregel/types.js\";\n\n/**\n * Re-exports from `@langchain/protocol`.\n *\n * These are the canonical wire-format types generated from `protocol.cddl`.\n * They are re-exported with local aliases so that consumers of this module\n * do not need a direct dependency on `@langchain/protocol`.\n */\nexport type {\n  MessagesData as MessagesEventData,\n  ToolsData as ToolsEventData,\n  UpdatesData as UpdatesEventData,\n  UsageInfo,\n  MessageStartData,\n  ContentBlockStartData,\n  ContentBlockDeltaData,\n  ContentBlockFinishData,\n  MessageFinishData,\n  MessageErrorData,\n  ToolStartedData,\n  ToolOutputDeltaData,\n  ToolFinishedData,\n  ToolErrorData,\n  Checkpoint,\n  CheckpointSource,\n  AgentStatus,\n  LifecycleData,\n  LifecycleCause,\n} from \"@langchain/protocol\";\n\n/**\n * Hierarchical path identifying a position in the agent tree.\n *\n * Each element is one segment; longer arrays mean deeper nesting (e.g.\n * subgraph or multi-agent scopes).\n */\nexport type Namespace = string[];\n\n/**\n * Channels that can appear on a protocol event.  Beyond the raw\n * {@link StreamMode} channels emitted by the Pregel stream, the v2\n * protocol layer synthesizes additional channels (e.g. `lifecycle`,\n * `input`) via built-in {@link StreamTransformer}s and exposes\n * user-defined channels created with {@link StreamChannel}.\n */\nexport type ProtocolMethod = StreamMode | \"lifecycle\" | \"input\" | (string & {});\n\n/**\n * Single envelope for a streaming protocol emission: sequence, channel\n * (`method`), and payload (`params`).\n */\nexport interface ProtocolEvent {\n  /** Discriminator; always `\"event\"` for this shape. */\n  readonly type: \"event\";\n\n  /** Monotonic sequence number for ordering and deduplication within a run. */\n  readonly seq: number;\n\n  /**\n   * Logical stream channel.  Built-in channels match {@link StreamMode}\n   * (e.g. `messages`, `updates`); transformer-synthesized channels\n   * include `lifecycle` and `input`; user-defined channels carry their\n   * {@link StreamChannel.channelName}.\n   */\n  readonly method: ProtocolMethod;\n\n  /** Channel-specific payload and routing metadata. */\n  readonly params: {\n    /** Namespace of the node or scope that emitted this event. */\n    readonly namespace: Namespace;\n\n    /** Wall-clock or logical timestamp for the emission (milliseconds). */\n    readonly timestamp: number;\n\n    /**\n     * Graph node id when the engine can attribute the event to a single node;\n     * omitted for run-level or ambiguous emissions.\n     */\n    readonly node?: string;\n\n    /** Opaque channel payload; shape depends on `method`. */\n    readonly data: unknown;\n  };\n}\n\n/**\n * Infers the merged extensions type from a tuple of transformer factory functions.\n *\n * Given `[() => StreamTransformer<{ a: number }>, () => StreamTransformer<{ b: string }>]`,\n * produces `{ a: number } & { b: string }`.\n */\nexport type InferExtensions<\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  T extends ReadonlyArray<() => StreamTransformer<any>>,\n> = T extends readonly []\n  ? Record<string, never>\n  : T extends readonly [\n        () => StreamTransformer<infer P>,\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        ...infer Rest extends ReadonlyArray<() => StreamTransformer<any>>,\n      ]\n    ? P & InferExtensions<Rest>\n    : Record<string, unknown>;\n\n/**\n * Observes {@link ProtocolEvent}s during a graph run and builds typed derived\n * projections (secondary event logs, promises, etc.).\n *\n * Data is surfaced to consumers through **projections** returned from\n * `init()`.  Projections are merged into `GraphRunStream.extensions` for\n * in-process consumers.  Use {@link StreamChannel.local} for local streaming\n * values, {@link StreamChannel.remote} for values that should also be visible\n * to remote clients, or `Promise<T>` for final values.\n *\n * To make projection data available to **remote** clients (SDK consumers\n * over WebSocket / SSE), create a named channel with\n * `StreamChannel.remote(name)`.  The {@link StreamMux} detects named\n * `StreamChannel` instances in the `init()` return and auto-forwards every\n * `push()` as a {@link ProtocolEvent} on the channel's named method.  Remote\n * clients subscribe via `session.subscribe(\"custom:<name>\")`.\n *\n * `finalize` and `fail` are optional.  When a transformer uses\n * `StreamChannel`, the mux auto-closes/fails the channels on run\n * completion — no manual lifecycle management needed.  Implement\n * `finalize`/`fail` only for non-channel teardown (e.g. resolving a\n * `Promise`).\n *\n * @typeParam TProjection - Shape returned by {@link init}, merged into\n *   `GraphRunStream.extensions`.\n */\nexport interface StreamTransformer<TProjection = unknown> {\n  /**\n   * Called once before the run starts.\n   *\n   * @returns Initial projection merged into `GraphRunStream.extensions`.\n   *   Any named {@link StreamChannel} instances in the return value are\n   *   automatically wired to the protocol event stream by the mux. Unnamed\n   *   channels stay in-process-only.\n   */\n  init(): TProjection;\n\n  /**\n   * Optional hook invoked by {@link StreamMux.addTransformer} immediately\n   * after the transformer is attached to the mux. Receives a limited\n   * handle that exposes only {@link StreamEmitter.push} — enough for\n   * the transformer to emit synthesized {@link ProtocolEvent}s on any\n   * namespace it chooses (e.g. a deepagents `SubagentTransformer`\n   * fabricating `lifecycle`/`messages`/`values` events under a\n   * `[\"tools:<tool_call_id>\"]` namespace when a `task` tool starts).\n   *\n   * Transformers that do not synthesize events can omit this hook.\n   *\n   * The {@link StreamEmitter} handle is only safe to call *from within*\n   * {@link StreamTransformer.process}. Emitting from an unrelated async\n   * context (e.g. after `process` has returned, from a `setTimeout`,\n   * etc.) races with the mux's close/fail cycle and may land events in\n   * an already-closed log.\n   */\n  onRegister?(emitter: StreamEmitter): void;\n\n  /**\n   * Called for each {@link ProtocolEvent} before it is appended to the main log.\n   *\n   * @param event - Next protocol envelope for this run.\n   * @returns `false` to drop the original event from the main log (use\n   *   sparingly; prefer keeping events visible and adding derived data\n   *   alongside).\n   */\n  process(event: ProtocolEvent): boolean;\n\n  /**\n   * Called once when the underlying Pregel run completes without throwing.\n   * Optional — only needed for non-channel teardown (e.g. resolving promises).\n   *\n   * May return a `PromiseLike<void>` to defer the main event log close\n   * until the async work (e.g. emitting terminal lifecycle events) has\n   * completed.  The mux awaits all returned promises before closing its\n   * event log.\n   */\n  finalize?(): void | PromiseLike<void>;\n\n  /**\n   * Called once when the run fails; `err` is the rejection or error value.\n   * Optional — only needed for non-channel teardown (e.g. rejecting promises).\n   *\n   * @param err - Failure reason from the engine or user code.\n   */\n  fail?(err: unknown): void;\n}\n\n/**\n * Narrow capability handle passed to\n * {@link StreamTransformer.onRegister}. Exposes only the minimal mux\n * surface required for synthetic event emission — intentionally does\n * not expose close/fail/register/etc. to keep the transformer contract\n * small and tamper-resistant.\n */\nexport interface StreamEmitter {\n  /**\n   * Injects a new {@link ProtocolEvent} into the mux pipeline. The\n   * event is routed through every registered transformer (including\n   * the emitting transformer — implementers must guard against\n   * re-entrant self-processing) and, if not suppressed, appended to\n   * the main event log.\n   *\n   * @param ns - Target namespace for the synthetic event.\n   * @param event - The event envelope to inject. ``event.seq`` is\n   *   overwritten by the mux; callers can pass any placeholder.\n   */\n  push(ns: Namespace, event: ProtocolEvent): void;\n}\n\nexport type ChatModelStream = Omit<\n  CoreChatModelStream,\n  typeof Symbol.asyncIterator\n> & {\n  /** Namespace of the graph node that produced this stream. */\n  readonly namespace: Namespace;\n\n  /** Graph node id for this stream, if the runtime attributed it. */\n  readonly node: string | undefined;\n\n  /**\n   * Low-level async iteration over message lifecycle events.\n   *\n   * @returns Iterator yielding Core-compatible chat model stream events.\n   */\n  [Symbol.asyncIterator](): AsyncIterator<CoreChatModelStreamEvent>;\n};\n\n/**\n * Public view yielded by `run.messages`.\n *\n * `ChatModelStream` is PromiseLike to mirror Core, but TypeScript applies\n * `Awaited<T>` to values produced by `for await`. Exposing a non-thenable view\n * keeps loop variables typed as the streaming handle instead of `AIMessage`.\n */\nexport type ChatModelStreamHandle = Omit<ChatModelStream, \"then\">;\n\n/**\n * High-level outcome of a single tool call for UI or aggregators.\n */\nexport type ToolCallStatus =\n  /** Invocation in flight or output still streaming. */\n  | \"running\"\n  /** Completed without error. */\n  | \"finished\"\n  /** Failed or aborted; see {@link ToolCallStream.error}. */\n  | \"error\";\n\n/**\n * Stable handle for one tool call: name, arguments, and async results.\n *\n * Emitted when `content-block-finish` delivers a finalized `tool_call` block.\n *\n * @typeParam TName - Registered tool name.\n * @typeParam TInput - Parsed or raw input type for the call.\n * @typeParam TOutput - Successful result type after the tool returns.\n */\nexport interface ToolCallStream<\n  TName extends string = string,\n  TInput = unknown,\n  TOutput = unknown,\n> {\n  /** Tool identifier as registered on the graph or model schema. */\n  readonly name: TName;\n\n  /** Correlates with protocol `toolCallId` when the runtime provides one. */\n  readonly callId: string;\n\n  /** Arguments passed to the tool (finalized when the call is observable). */\n  readonly input: TInput;\n\n  /**\n   * Resolves to the tool return value on success.\n   *\n   * @remarks\n   * Rejection or hang semantics depend on the runner; pairing with\n   * {@link ToolCallStream.status} and {@link ToolCallStream.error} is recommended.\n   */\n  readonly output: Promise<TOutput>;\n\n  /**\n   * Resolves to {@link ToolCallStatus} when the call leaves the running state.\n   */\n  readonly status: Promise<ToolCallStatus>;\n\n  /**\n   * Resolves to an error message string if {@link ToolCallStream.status} is\n   * `\"error\"`, otherwise `undefined`.\n   */\n  readonly error: Promise<string | undefined>;\n}\n\n/**\n * Marker interface for transformers provided by internal LangChain products\n * (e.g. ReactAgent's ToolCallTransformer, DeepAgent's SubagentTransformer).\n *\n * Native transformers differ from user-defined extension transformers in\n * where their projection lands on the run stream:\n *\n *   - **Native** — projections become direct getters on a\n *     `GraphRunStream` subclass (e.g. `run.toolCalls`, `run.subagents`).\n *     They emit events on protocol-defined channels (`tools`, `lifecycle`,\n *     `tasks`, etc.).\n *\n *   - **Extension** (user-defined) — projections are merged into\n *     `run.extensions`.  Events emitted via `emit()` use an\n *     application-chosen method name (e.g. `emit(\"a2a\", data)`) and are\n *     accessible to remote clients via `session.subscribe(\"custom:<name>\")`.\n *\n * The `__native` brand is used by downstream stream factory functions\n * to distinguish native transformers from extension transformers at\n * registration time.  See `docs/native-stream-transformers.md` for the\n * full pattern.\n */\nexport interface NativeStreamTransformer<\n  TProjection = unknown,\n> extends StreamTransformer<TProjection> {\n  readonly __native: true;\n}\n\n/**\n * Type guard that tests whether a transformer is a {@link NativeStreamTransformer}.\n */\nexport function isNativeTransformer(\n  t: StreamTransformer<unknown>\n): t is NativeStreamTransformer {\n  return \"__native\" in t && (t as NativeStreamTransformer).__native === true;\n}\n\n/**\n * Human-in-the-loop interrupt: stable id plus opaque payload for resume UIs.\n */\nexport interface InterruptPayload<TPayload = unknown> {\n  /** Idempotent key for this interrupt instance within the run. */\n  interruptId: string;\n\n  /** Arbitrary data supplied by the graph (e.g. questions, draft state). */\n  payload: TPayload;\n}\n"],"mappings":";;;;AAmVA,SAAgB,oBACd,GAC8B;AAC9B,QAAO,cAAc,KAAM,EAA8B,aAAa"}

package/dist/web.cjs

@@ -5,9 +5,18 @@ const require_base = require("./channels/base.cjs");
 const require_binop = require("./channels/binop.cjs");
 const require_annotation = require("./graph/annotation.cjs");
 const require_config = require("./pregel/utils/config.cjs");
+const require_stream_channel = require("./stream/stream-channel.cjs");
+const require_convert = require("./stream/convert.cjs");
+const require_lifecycle = require("./stream/transformers/lifecycle.cjs");
+const require_messages = require("./stream/transformers/messages.cjs");
+const require_subgraphs = require("./stream/transformers/subgraphs.cjs");
+const require_values = require("./stream/transformers/values.cjs");
+const require_types = require("./stream/types.cjs");
+const require_run_stream = require("./stream/run-stream.cjs");
+require("./stream/index.cjs");
 const require_interrupt = require("./interrupt.cjs");
 const require_graph = require("./graph/graph.cjs");
-const require_types = require("./state/types.cjs");
+const require_types$1 = require("./state/types.cjs");
 const require_adapter = require("./state/adapter.cjs");
 const require_untracked_value = require("./channels/untracked_value.cjs");
 require("./channels/index.cjs");
@@ -15,15 +24,16 @@ const require_reduced = require("./state/values/reduced.cjs");
 const require_untracked = require("./state/values/untracked.cjs");
 const require_schema = require("./state/schema.cjs");
 const require_messages_reducer = require("./graph/messages_reducer.cjs");
-const require_messages = require("./state/prebuilt/messages.cjs");
+const require_messages$1 = require("./state/prebuilt/messages.cjs");
 require("./state/index.cjs");
 const require_state = require("./graph/state.cjs");
 const require_message = require("./graph/message.cjs");
 require("./graph/index.cjs");
-const require_index$2 = require("./func/index.cjs");
+const require_index$3 = require("./func/index.cjs");
 const require_messages_annotation = require("./graph/messages_annotation.cjs");
 const require_writer = require("./writer.cjs");
 let _langchain_langgraph_checkpoint = require("@langchain/langgraph-checkpoint");
+let _langchain_core_language_models_stream = require("@langchain/core/language_models/stream");
 exports.Annotation = require_annotation.Annotation;
 Object.defineProperty(exports, "AsyncBatchedStore", {
 	enumerable: true,
@@ -47,16 +57,24 @@ Object.defineProperty(exports, "BaseStore", {
 });
 exports.BinaryOperatorAggregate = require_binop.BinaryOperatorAggregate;
 exports.COMMAND_SYMBOL = require_constants.COMMAND_SYMBOL;
+Object.defineProperty(exports, "ChatModelStreamImpl", {
+	enumerable: true,
+	get: function() {
+		return _langchain_core_language_models_stream.ChatModelStream;
+	}
+});
 exports.Command = require_constants.Command;
 exports.CommandInstance = require_constants.CommandInstance;
 exports.CompiledStateGraph = require_state.CompiledStateGraph;
 exports.END = require_constants.END;
 exports.EmptyChannelError = require_errors.EmptyChannelError;
 exports.EmptyInputError = require_errors.EmptyInputError;
+exports.EventLog = require_stream_channel.StreamChannel;
 exports.Graph = require_graph.Graph;
 exports.GraphBubbleUp = require_errors.GraphBubbleUp;
 exports.GraphInterrupt = require_errors.GraphInterrupt;
 exports.GraphRecursionError = require_errors.GraphRecursionError;
+exports.GraphRunStream = require_run_stream.GraphRunStream;
 exports.GraphValueError = require_errors.GraphValueError;
 exports.INTERRUPT = require_constants.INTERRUPT;
 Object.defineProperty(exports, "InMemoryStore", {
@@ -74,7 +92,7 @@ Object.defineProperty(exports, "MemorySaver", {
 });
 exports.MessageGraph = require_message.MessageGraph;
 exports.MessagesAnnotation = require_messages_annotation.MessagesAnnotation;
-exports.MessagesValue = require_messages.MessagesValue;
+exports.MessagesValue = require_messages$1.MessagesValue;
 exports.MessagesZodMeta = require_messages_annotation.MessagesZodMeta;
 exports.MessagesZodState = require_messages_annotation.MessagesZodState;
 exports.MultipleSubgraphsError = require_errors.MultipleSubgraphsError;
@@ -85,31 +103,42 @@ exports.REMOVE_ALL_MESSAGES = require_messages_reducer.REMOVE_ALL_MESSAGES;
 exports.ReducedValue = require_reduced.ReducedValue;
 exports.RemoteException = require_errors.RemoteException;
 exports.START = require_constants.START;
+exports.STREAM_EVENTS_V3_MODES = require_convert.STREAM_EVENTS_V3_MODES;
 exports.Send = require_constants.Send;
 exports.StateGraph = require_state.StateGraph;
 exports.StateGraphInputError = require_errors.StateGraphInputError;
 exports.StateSchema = require_schema.StateSchema;
+exports.StreamChannel = require_stream_channel.StreamChannel;
+exports.SubgraphRunStream = require_run_stream.SubgraphRunStream;
 exports.UnreachableNodeError = require_errors.UnreachableNodeError;
 exports.UntrackedValue = require_untracked.UntrackedValue;
 exports.UntrackedValueChannel = require_untracked_value.UntrackedValueChannel;
 exports.addMessages = require_messages_reducer.messagesStateReducer;
+exports.convertToProtocolEvent = require_convert.convertToProtocolEvent;
 Object.defineProperty(exports, "copyCheckpoint", {
 	enumerable: true,
 	get: function() {
 		return _langchain_langgraph_checkpoint.copyCheckpoint;
 	}
 });
+exports.createGraphRunStream = require_run_stream.createGraphRunStream;
+exports.createLifecycleTransformer = require_lifecycle.createLifecycleTransformer;
+exports.createMessagesTransformer = require_messages.createMessagesTransformer;
+exports.createSubgraphDiscoveryTransformer = require_subgraphs.createSubgraphDiscoveryTransformer;
+exports.createValuesTransformer = require_values.createValuesTransformer;
 Object.defineProperty(exports, "emptyCheckpoint", {
 	enumerable: true,
 	get: function() {
 		return _langchain_langgraph_checkpoint.emptyCheckpoint;
 	}
 });
-exports.entrypoint = require_index$2.entrypoint;
+exports.entrypoint = require_index$3.entrypoint;
+exports.filterLifecycleEntries = require_lifecycle.filterLifecycleEntries;
+exports.filterSubgraphHandles = require_subgraphs.filterSubgraphHandles;
 exports.getConfig = require_config.getConfig;
 exports.getCurrentTaskInput = require_config.getCurrentTaskInput;
 exports.getJsonSchemaFromSchema = require_adapter.getJsonSchemaFromSchema;
-exports.getPreviousState = require_index$2.getPreviousState;
+exports.getPreviousState = require_index$3.getPreviousState;
 exports.getSchemaDefaultGetter = require_adapter.getSchemaDefaultGetter;
 exports.getStore = require_config.getStore;
 exports.getSubgraphsSeenSet = require_errors.getSubgraphsSeenSet;
@@ -119,10 +148,11 @@ exports.isCommand = require_constants.isCommand;
 exports.isGraphBubbleUp = require_errors.isGraphBubbleUp;
 exports.isGraphInterrupt = require_errors.isGraphInterrupt;
 exports.isInterrupted = require_constants.isInterrupted;
+exports.isNativeTransformer = require_types.isNativeTransformer;
 exports.isParentCommand = require_errors.isParentCommand;
-exports.isSerializableSchema = require_types.isSerializableSchema;
-exports.isStandardSchema = require_types.isStandardSchema;
+exports.isSerializableSchema = require_types$1.isSerializableSchema;
+exports.isStandardSchema = require_types$1.isStandardSchema;
 exports.messagesStateReducer = require_messages_reducer.messagesStateReducer;
 exports.pushMessage = require_message.pushMessage;
-exports.task = require_index$2.task;
+exports.task = require_index$3.task;
 exports.writer = require_writer.writer;

package/dist/web.d.cts

@@ -12,9 +12,19 @@ import { ExecutionInfo, LangGraphRunnableConfig, Runtime, ServerInfo } from "./p
 import { Annotation, AnnotationRoot, NodeType, SingleReducer, StateDefinition, StateType, UpdateType } from "./graph/annotation.cjs";
 import { CachePolicy, RetryPolicy } from "./pregel/utils/index.cjs";
 import { PregelNode } from "./pregel/read.cjs";
+import { AgentStatus, ChatModelStream, InferExtensions, InterruptPayload, LifecycleCause, LifecycleData, MessagesEventData, Namespace, NativeStreamTransformer, ProtocolEvent, StreamEmitter, StreamTransformer, ToolCallStatus, ToolCallStream, ToolsEventData, UpdatesEventData, UsageInfo, isNativeTransformer } from "./stream/types.cjs";
 import { GetStateOptions, MultipleChannelSubscriptionOptions, PregelOptions, PregelParams, SingleChannelSubscriptionOptions, StateSnapshot, StreamMode, StreamOutputMap } from "./pregel/types.cjs";
+import { StreamChannel } from "./stream/stream-channel.cjs";
+import { ConvertToProtocolEventOptions, STREAM_EVENTS_V3_MODES, convertToProtocolEvent } from "./stream/convert.cjs";
+import { LifecycleEntry, LifecycleTransformerOptions } from "./stream/transformers/types.cjs";
+import { LifecycleProjection, createLifecycleTransformer, filterLifecycleEntries } from "./stream/transformers/lifecycle.cjs";
+import { createMessagesTransformer } from "./stream/transformers/messages.cjs";
+import { SubgraphDiscoveryProjection, SubgraphDiscoveryTransformerOptions, createSubgraphDiscoveryTransformer, filterSubgraphHandles } from "./stream/transformers/subgraphs.cjs";
+import { createValuesTransformer } from "./stream/transformers/values.cjs";
+import { CreateGraphRunStreamOptions, GraphRunStream, SubgraphRunStream, createGraphRunStream } from "./stream/run-stream.cjs";
+import { ChatModelStreamImpl } from "./stream/index.cjs";
 import { Pregel } from "./pregel/index.cjs";
-import { AddNodeOptions, CompiledGraph, Graph, NodeSpec } from "./graph/graph.cjs";
+import { AddNodeOptions, CompiledGraph, CompiledGraphType, Graph, NodeSpec } from "./graph/graph.cjs";
 import { InferInterruptInputType, InferInterruptResumeType, interrupt } from "./interrupt.cjs";
 import { InferWriterType, writer } from "./writer.cjs";
 import { isSerializableSchema, isStandardSchema } from "./state/types.cjs";
@@ -32,4 +42,4 @@ import { getJsonSchemaFromSchema, getSchemaDefaultGetter } from "./state/adapter
 import { MessagesValue } from "./state/prebuilt/messages.cjs";
 import { getConfig, getCurrentTaskInput, getStore, getWriter } from "./pregel/utils/config.cjs";
 import { AsyncBatchedStore, BaseCheckpointSaver, BaseStore, Checkpoint, CheckpointMetadata, CheckpointTuple, GetOperation, InMemoryStore, Item, ListNamespacesOperation, MatchCondition, MemorySaver, NameSpacePath, NamespaceMatchType, Operation, OperationResults, PutOperation, SearchOperation, copyCheckpoint, emptyCheckpoint } from "@langchain/langgraph-checkpoint";
-export { type AddNodeOptions, Annotation, type AnnotationRoot, AnyStateSchema, type AnyValue, AsyncBatchedStore, BaseChannel, BaseCheckpointSaver, BaseLangGraphError, BaseLangGraphErrorFields, BaseStore, type BinaryOperator, BinaryOperatorAggregate, COMMAND_SYMBOL, type CachePolicy, type Checkpoint, type CheckpointMetadata, type CheckpointTuple, Command, CommandInstance, type CommandParams, type CompiledGraph, CompiledStateGraph, type ConditionalEdgeRouter, type ConditionalEdgeRouterTypes, type ContextSchemaInit, type DynamicBarrierValue, END, EmptyChannelError, EmptyInputError, type EntrypointOptions, type EphemeralValue, type ExecutionInfo, type ExtractStateType, type ExtractUpdateType, type GetOperation, type GetStateOptions, Graph, GraphBubbleUp, GraphInterrupt, type GraphNode, type GraphNodeReturnValue, type GraphNodeTypes, GraphRecursionError, GraphValueError, INTERRUPT, InMemoryStore, type InferInterruptInputType, type InferInterruptResumeType, InferStateSchemaUpdate, InferStateSchemaValue, type InferWriterType, type Interrupt, InvalidUpdateError, type Item, type LangGraphRunnableConfig, type LastValue, type ListNamespacesOperation, type MatchCondition, MemorySaver, MessageGraph, type Messages, MessagesAnnotation, MessagesValue, MessagesZodMeta, MessagesZodState, type MultipleChannelSubscriptionOptions, MultipleSubgraphsError, type NameSpacePath, type NamedBarrierValue, type NamespaceMatchType, NodeInterrupt, type NodeSpec, type NodeType, type Operation, type OperationResults, Overwrite, type OverwriteValue, ParentCommand, type Pregel, type PregelNode, type PregelOptions, type PregelParams, type PutOperation, REMOVE_ALL_MESSAGES, ReducedValue, ReducedValueInit, RemoteException, type RetryPolicy, type Runtime, START, type SearchOperation, Send, type ServerInfo, type SingleChannelSubscriptionOptions, type SingleReducer, type StateDefinition, type StateDefinitionInit, StateGraph, type StateGraphAddNodeOptions, type StateGraphArgs, type StateGraphArgsWithInputOutputSchemas, type StateGraphArgsWithStateSchema, type StateGraphInit, StateGraphInputError, type StateGraphNodeSpec, type StateGraphOptions, StateSchema, StateSchemaField, StateSchemaFieldToChannel, StateSchemaFields, StateSchemaFieldsToStateDefinition, type StateSnapshot, type StateType, type StreamMode, type StreamOutputMap, type TaskOptions, type ToStateDefinition, type Topic, UnreachableNodeError, UntrackedValue, UntrackedValueChannel, UntrackedValueInit, type UpdateType, type WaitForNames, messagesStateReducer as addMessages, copyCheckpoint, emptyCheckpoint, entrypoint, getConfig, getCurrentTaskInput, getJsonSchemaFromSchema, getPreviousState, getSchemaDefaultGetter, getStore, getSubgraphsSeenSet, getWriter, interrupt, isCommand, isGraphBubbleUp, isGraphInterrupt, isInterrupted, isParentCommand, isSerializableSchema, isStandardSchema, messagesStateReducer, pushMessage, task, writer };
+export { type AddNodeOptions, type AgentStatus, Annotation, type AnnotationRoot, AnyStateSchema, type AnyValue, AsyncBatchedStore, BaseChannel, BaseCheckpointSaver, BaseLangGraphError, BaseLangGraphErrorFields, BaseStore, type BinaryOperator, BinaryOperatorAggregate, COMMAND_SYMBOL, type CachePolicy, type ChatModelStream, ChatModelStreamImpl, type Checkpoint, type CheckpointMetadata, type CheckpointTuple, Command, CommandInstance, type CommandParams, type CompiledGraph, type CompiledGraphType, CompiledStateGraph, type ConditionalEdgeRouter, type ConditionalEdgeRouterTypes, type ContextSchemaInit, type ConvertToProtocolEventOptions, type CreateGraphRunStreamOptions, type DynamicBarrierValue, END, EmptyChannelError, EmptyInputError, type EntrypointOptions, type EphemeralValue, StreamChannel as EventLog, type ExecutionInfo, type ExtractStateType, type ExtractUpdateType, type GetOperation, type GetStateOptions, Graph, GraphBubbleUp, GraphInterrupt, type GraphNode, type GraphNodeReturnValue, type GraphNodeTypes, GraphRecursionError, GraphRunStream, GraphValueError, INTERRUPT, InMemoryStore, type InferExtensions, type InferInterruptInputType, type InferInterruptResumeType, InferStateSchemaUpdate, InferStateSchemaValue, type InferWriterType, type Interrupt, type InterruptPayload, InvalidUpdateError, type Item, type LangGraphRunnableConfig, type LastValue, type LifecycleCause, type LifecycleData, type LifecycleEntry, type LifecycleProjection, type LifecycleTransformerOptions, type ListNamespacesOperation, type MatchCondition, MemorySaver, MessageGraph, type Messages, MessagesAnnotation, type MessagesEventData, MessagesValue, MessagesZodMeta, MessagesZodState, type MultipleChannelSubscriptionOptions, MultipleSubgraphsError, type NameSpacePath, type NamedBarrierValue, type Namespace, type NamespaceMatchType, type NativeStreamTransformer, NodeInterrupt, type NodeSpec, type NodeType, type Operation, type OperationResults, Overwrite, type OverwriteValue, ParentCommand, type Pregel, type PregelNode, type PregelOptions, type PregelParams, type ProtocolEvent, type PutOperation, REMOVE_ALL_MESSAGES, ReducedValue, ReducedValueInit, RemoteException, type RetryPolicy, type Runtime, START, STREAM_EVENTS_V3_MODES, type SearchOperation, Send, type ServerInfo, type SingleChannelSubscriptionOptions, type SingleReducer, type StateDefinition, type StateDefinitionInit, StateGraph, type StateGraphAddNodeOptions, type StateGraphArgs, type StateGraphArgsWithInputOutputSchemas, type StateGraphArgsWithStateSchema, type StateGraphInit, StateGraphInputError, type StateGraphNodeSpec, type StateGraphOptions, StateSchema, StateSchemaField, StateSchemaFieldToChannel, StateSchemaFields, StateSchemaFieldsToStateDefinition, type StateSnapshot, type StateType, StreamChannel, type StreamEmitter, type StreamMode, type StreamOutputMap, type StreamTransformer, type SubgraphDiscoveryProjection, type SubgraphDiscoveryTransformerOptions, SubgraphRunStream, type TaskOptions, type ToStateDefinition, type ToolCallStatus, type ToolCallStream, type ToolsEventData, type Topic, UnreachableNodeError, UntrackedValue, UntrackedValueChannel, UntrackedValueInit, type UpdateType, type UpdatesEventData, type UsageInfo, type WaitForNames, messagesStateReducer as addMessages, convertToProtocolEvent, copyCheckpoint, createGraphRunStream, createLifecycleTransformer, createMessagesTransformer, createSubgraphDiscoveryTransformer, createValuesTransformer, emptyCheckpoint, entrypoint, filterLifecycleEntries, filterSubgraphHandles, getConfig, getCurrentTaskInput, getJsonSchemaFromSchema, getPreviousState, getSchemaDefaultGetter, getStore, getSubgraphsSeenSet, getWriter, interrupt, isCommand, isGraphBubbleUp, isGraphInterrupt, isInterrupted, isNativeTransformer, isParentCommand, isSerializableSchema, isStandardSchema, messagesStateReducer, pushMessage, task, writer };

package/dist/web.d.ts

@@ -12,9 +12,19 @@ import { ExecutionInfo, LangGraphRunnableConfig, Runtime, ServerInfo } from "./p
 import { Annotation, AnnotationRoot, NodeType, SingleReducer, StateDefinition, StateType, UpdateType } from "./graph/annotation.js";
 import { CachePolicy, RetryPolicy } from "./pregel/utils/index.js";
 import { PregelNode } from "./pregel/read.js";
+import { AgentStatus, ChatModelStream, InferExtensions, InterruptPayload, LifecycleCause, LifecycleData, MessagesEventData, Namespace, NativeStreamTransformer, ProtocolEvent, StreamEmitter, StreamTransformer, ToolCallStatus, ToolCallStream, ToolsEventData, UpdatesEventData, UsageInfo, isNativeTransformer } from "./stream/types.js";
 import { GetStateOptions, MultipleChannelSubscriptionOptions, PregelOptions, PregelParams, SingleChannelSubscriptionOptions, StateSnapshot, StreamMode, StreamOutputMap } from "./pregel/types.js";
+import { StreamChannel } from "./stream/stream-channel.js";
+import { ConvertToProtocolEventOptions, STREAM_EVENTS_V3_MODES, convertToProtocolEvent } from "./stream/convert.js";
+import { LifecycleEntry, LifecycleTransformerOptions } from "./stream/transformers/types.js";
+import { LifecycleProjection, createLifecycleTransformer, filterLifecycleEntries } from "./stream/transformers/lifecycle.js";
+import { createMessagesTransformer } from "./stream/transformers/messages.js";
+import { SubgraphDiscoveryProjection, SubgraphDiscoveryTransformerOptions, createSubgraphDiscoveryTransformer, filterSubgraphHandles } from "./stream/transformers/subgraphs.js";
+import { createValuesTransformer } from "./stream/transformers/values.js";
+import { CreateGraphRunStreamOptions, GraphRunStream, SubgraphRunStream, createGraphRunStream } from "./stream/run-stream.js";
+import { ChatModelStreamImpl } from "./stream/index.js";
 import { Pregel } from "./pregel/index.js";
-import { AddNodeOptions, CompiledGraph, Graph, NodeSpec } from "./graph/graph.js";
+import { AddNodeOptions, CompiledGraph, CompiledGraphType, Graph, NodeSpec } from "./graph/graph.js";
 import { InferInterruptInputType, InferInterruptResumeType, interrupt } from "./interrupt.js";
 import { InferWriterType, writer } from "./writer.js";
 import { isSerializableSchema, isStandardSchema } from "./state/types.js";
@@ -32,4 +42,4 @@ import { getJsonSchemaFromSchema, getSchemaDefaultGetter } from "./state/adapter
 import { MessagesValue } from "./state/prebuilt/messages.js";
 import { getConfig, getCurrentTaskInput, getStore, getWriter } from "./pregel/utils/config.js";
 import { AsyncBatchedStore, BaseCheckpointSaver, BaseStore, Checkpoint, CheckpointMetadata, CheckpointTuple, GetOperation, InMemoryStore, Item, ListNamespacesOperation, MatchCondition, MemorySaver, NameSpacePath, NamespaceMatchType, Operation, OperationResults, PutOperation, SearchOperation, copyCheckpoint, emptyCheckpoint } from "@langchain/langgraph-checkpoint";
-export { type AddNodeOptions, Annotation, type AnnotationRoot, AnyStateSchema, type AnyValue, AsyncBatchedStore, BaseChannel, BaseCheckpointSaver, BaseLangGraphError, BaseLangGraphErrorFields, BaseStore, type BinaryOperator, BinaryOperatorAggregate, COMMAND_SYMBOL, type CachePolicy, type Checkpoint, type CheckpointMetadata, type CheckpointTuple, Command, CommandInstance, type CommandParams, type CompiledGraph, CompiledStateGraph, type ConditionalEdgeRouter, type ConditionalEdgeRouterTypes, type ContextSchemaInit, type DynamicBarrierValue, END, EmptyChannelError, EmptyInputError, type EntrypointOptions, type EphemeralValue, type ExecutionInfo, type ExtractStateType, type ExtractUpdateType, type GetOperation, type GetStateOptions, Graph, GraphBubbleUp, GraphInterrupt, type GraphNode, type GraphNodeReturnValue, type GraphNodeTypes, GraphRecursionError, GraphValueError, INTERRUPT, InMemoryStore, type InferInterruptInputType, type InferInterruptResumeType, InferStateSchemaUpdate, InferStateSchemaValue, type InferWriterType, type Interrupt, InvalidUpdateError, type Item, type LangGraphRunnableConfig, type LastValue, type ListNamespacesOperation, type MatchCondition, MemorySaver, MessageGraph, type Messages, MessagesAnnotation, MessagesValue, MessagesZodMeta, MessagesZodState, type MultipleChannelSubscriptionOptions, MultipleSubgraphsError, type NameSpacePath, type NamedBarrierValue, type NamespaceMatchType, NodeInterrupt, type NodeSpec, type NodeType, type Operation, type OperationResults, Overwrite, type OverwriteValue, ParentCommand, type Pregel, type PregelNode, type PregelOptions, type PregelParams, type PutOperation, REMOVE_ALL_MESSAGES, ReducedValue, ReducedValueInit, RemoteException, type RetryPolicy, type Runtime, START, type SearchOperation, Send, type ServerInfo, type SingleChannelSubscriptionOptions, type SingleReducer, type StateDefinition, type StateDefinitionInit, StateGraph, type StateGraphAddNodeOptions, type StateGraphArgs, type StateGraphArgsWithInputOutputSchemas, type StateGraphArgsWithStateSchema, type StateGraphInit, StateGraphInputError, type StateGraphNodeSpec, type StateGraphOptions, StateSchema, StateSchemaField, StateSchemaFieldToChannel, StateSchemaFields, StateSchemaFieldsToStateDefinition, type StateSnapshot, type StateType, type StreamMode, type StreamOutputMap, type TaskOptions, type ToStateDefinition, type Topic, UnreachableNodeError, UntrackedValue, UntrackedValueChannel, UntrackedValueInit, type UpdateType, type WaitForNames, messagesStateReducer as addMessages, copyCheckpoint, emptyCheckpoint, entrypoint, getConfig, getCurrentTaskInput, getJsonSchemaFromSchema, getPreviousState, getSchemaDefaultGetter, getStore, getSubgraphsSeenSet, getWriter, interrupt, isCommand, isGraphBubbleUp, isGraphInterrupt, isInterrupted, isParentCommand, isSerializableSchema, isStandardSchema, messagesStateReducer, pushMessage, task, writer };
+export { type AddNodeOptions, type AgentStatus, Annotation, type AnnotationRoot, AnyStateSchema, type AnyValue, AsyncBatchedStore, BaseChannel, BaseCheckpointSaver, BaseLangGraphError, BaseLangGraphErrorFields, BaseStore, type BinaryOperator, BinaryOperatorAggregate, COMMAND_SYMBOL, type CachePolicy, type ChatModelStream, ChatModelStreamImpl, type Checkpoint, type CheckpointMetadata, type CheckpointTuple, Command, CommandInstance, type CommandParams, type CompiledGraph, type CompiledGraphType, CompiledStateGraph, type ConditionalEdgeRouter, type ConditionalEdgeRouterTypes, type ContextSchemaInit, type ConvertToProtocolEventOptions, type CreateGraphRunStreamOptions, type DynamicBarrierValue, END, EmptyChannelError, EmptyInputError, type EntrypointOptions, type EphemeralValue, StreamChannel as EventLog, type ExecutionInfo, type ExtractStateType, type ExtractUpdateType, type GetOperation, type GetStateOptions, Graph, GraphBubbleUp, GraphInterrupt, type GraphNode, type GraphNodeReturnValue, type GraphNodeTypes, GraphRecursionError, GraphRunStream, GraphValueError, INTERRUPT, InMemoryStore, type InferExtensions, type InferInterruptInputType, type InferInterruptResumeType, InferStateSchemaUpdate, InferStateSchemaValue, type InferWriterType, type Interrupt, type InterruptPayload, InvalidUpdateError, type Item, type LangGraphRunnableConfig, type LastValue, type LifecycleCause, type LifecycleData, type LifecycleEntry, type LifecycleProjection, type LifecycleTransformerOptions, type ListNamespacesOperation, type MatchCondition, MemorySaver, MessageGraph, type Messages, MessagesAnnotation, type MessagesEventData, MessagesValue, MessagesZodMeta, MessagesZodState, type MultipleChannelSubscriptionOptions, MultipleSubgraphsError, type NameSpacePath, type NamedBarrierValue, type Namespace, type NamespaceMatchType, type NativeStreamTransformer, NodeInterrupt, type NodeSpec, type NodeType, type Operation, type OperationResults, Overwrite, type OverwriteValue, ParentCommand, type Pregel, type PregelNode, type PregelOptions, type PregelParams, type ProtocolEvent, type PutOperation, REMOVE_ALL_MESSAGES, ReducedValue, ReducedValueInit, RemoteException, type RetryPolicy, type Runtime, START, STREAM_EVENTS_V3_MODES, type SearchOperation, Send, type ServerInfo, type SingleChannelSubscriptionOptions, type SingleReducer, type StateDefinition, type StateDefinitionInit, StateGraph, type StateGraphAddNodeOptions, type StateGraphArgs, type StateGraphArgsWithInputOutputSchemas, type StateGraphArgsWithStateSchema, type StateGraphInit, StateGraphInputError, type StateGraphNodeSpec, type StateGraphOptions, StateSchema, StateSchemaField, StateSchemaFieldToChannel, StateSchemaFields, StateSchemaFieldsToStateDefinition, type StateSnapshot, type StateType, StreamChannel, type StreamEmitter, type StreamMode, type StreamOutputMap, type StreamTransformer, type SubgraphDiscoveryProjection, type SubgraphDiscoveryTransformerOptions, SubgraphRunStream, type TaskOptions, type ToStateDefinition, type ToolCallStatus, type ToolCallStream, type ToolsEventData, type Topic, UnreachableNodeError, UntrackedValue, UntrackedValueChannel, UntrackedValueInit, type UpdateType, type UpdatesEventData, type UsageInfo, type WaitForNames, messagesStateReducer as addMessages, convertToProtocolEvent, copyCheckpoint, createGraphRunStream, createLifecycleTransformer, createMessagesTransformer, createSubgraphDiscoveryTransformer, createValuesTransformer, emptyCheckpoint, entrypoint, filterLifecycleEntries, filterSubgraphHandles, getConfig, getCurrentTaskInput, getJsonSchemaFromSchema, getPreviousState, getSchemaDefaultGetter, getStore, getSubgraphsSeenSet, getWriter, interrupt, isCommand, isGraphBubbleUp, isGraphInterrupt, isInterrupted, isNativeTransformer, isParentCommand, isSerializableSchema, isStandardSchema, messagesStateReducer, pushMessage, task, writer };

package/dist/web.js

@@ -4,6 +4,15 @@ import { BaseChannel } from "./channels/base.js";
 import { BinaryOperatorAggregate } from "./channels/binop.js";
 import { Annotation } from "./graph/annotation.js";
 import { getConfig, getCurrentTaskInput, getStore, getWriter } from "./pregel/utils/config.js";
+import { StreamChannel } from "./stream/stream-channel.js";
+import { STREAM_EVENTS_V3_MODES, convertToProtocolEvent } from "./stream/convert.js";
+import { createLifecycleTransformer, filterLifecycleEntries } from "./stream/transformers/lifecycle.js";
+import { createMessagesTransformer } from "./stream/transformers/messages.js";
+import { createSubgraphDiscoveryTransformer, filterSubgraphHandles } from "./stream/transformers/subgraphs.js";
+import { createValuesTransformer } from "./stream/transformers/values.js";
+import { isNativeTransformer } from "./stream/types.js";
+import { GraphRunStream, SubgraphRunStream, createGraphRunStream } from "./stream/run-stream.js";
+import { ChatModelStreamImpl } from "./stream/index.js";
 import { interrupt } from "./interrupt.js";
 import { Graph } from "./graph/graph.js";
 import { isSerializableSchema, isStandardSchema } from "./state/types.js";
@@ -23,4 +32,4 @@ import { entrypoint, getPreviousState, task } from "./func/index.js";
 import { MessagesAnnotation, MessagesZodMeta, MessagesZodState } from "./graph/messages_annotation.js";
 import { writer } from "./writer.js";
 import { AsyncBatchedStore, BaseCheckpointSaver, BaseStore, InMemoryStore, MemorySaver, copyCheckpoint, emptyCheckpoint } from "@langchain/langgraph-checkpoint";
-export { Annotation, AsyncBatchedStore, BaseChannel, BaseCheckpointSaver, BaseLangGraphError, BaseStore, BinaryOperatorAggregate, COMMAND_SYMBOL, Command, CommandInstance, CompiledStateGraph, END, EmptyChannelError, EmptyInputError, Graph, GraphBubbleUp, GraphInterrupt, GraphRecursionError, GraphValueError, INTERRUPT, InMemoryStore, InvalidUpdateError, MemorySaver, MessageGraph, MessagesAnnotation, MessagesValue, MessagesZodMeta, MessagesZodState, MultipleSubgraphsError, NodeInterrupt, Overwrite, ParentCommand, REMOVE_ALL_MESSAGES, ReducedValue, RemoteException, START, Send, StateGraph, StateGraphInputError, StateSchema, UnreachableNodeError, UntrackedValue, UntrackedValueChannel, messagesStateReducer as addMessages, copyCheckpoint, emptyCheckpoint, entrypoint, getConfig, getCurrentTaskInput, getJsonSchemaFromSchema, getPreviousState, getSchemaDefaultGetter, getStore, getSubgraphsSeenSet, getWriter, interrupt, isCommand, isGraphBubbleUp, isGraphInterrupt, isInterrupted, isParentCommand, isSerializableSchema, isStandardSchema, messagesStateReducer, pushMessage, task, writer };
+export { Annotation, AsyncBatchedStore, BaseChannel, BaseCheckpointSaver, BaseLangGraphError, BaseStore, BinaryOperatorAggregate, COMMAND_SYMBOL, ChatModelStreamImpl, Command, CommandInstance, CompiledStateGraph, END, EmptyChannelError, EmptyInputError, StreamChannel as EventLog, Graph, GraphBubbleUp, GraphInterrupt, GraphRecursionError, GraphRunStream, GraphValueError, INTERRUPT, InMemoryStore, InvalidUpdateError, MemorySaver, MessageGraph, MessagesAnnotation, MessagesValue, MessagesZodMeta, MessagesZodState, MultipleSubgraphsError, NodeInterrupt, Overwrite, ParentCommand, REMOVE_ALL_MESSAGES, ReducedValue, RemoteException, START, STREAM_EVENTS_V3_MODES, Send, StateGraph, StateGraphInputError, StateSchema, StreamChannel, SubgraphRunStream, UnreachableNodeError, UntrackedValue, UntrackedValueChannel, messagesStateReducer as addMessages, convertToProtocolEvent, copyCheckpoint, createGraphRunStream, createLifecycleTransformer, createMessagesTransformer, createSubgraphDiscoveryTransformer, createValuesTransformer, emptyCheckpoint, entrypoint, filterLifecycleEntries, filterSubgraphHandles, getConfig, getCurrentTaskInput, getJsonSchemaFromSchema, getPreviousState, getSchemaDefaultGetter, getStore, getSubgraphsSeenSet, getWriter, interrupt, isCommand, isGraphBubbleUp, isGraphInterrupt, isInterrupted, isNativeTransformer, isParentCommand, isSerializableSchema, isStandardSchema, messagesStateReducer, pushMessage, task, writer };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/langgraph",
-  "version": "1.2.9",
+  "version": "1.3.0",
   "description": "LangGraph",
   "type": "module",
   "engines": {
@@ -16,13 +16,14 @@
   "author": "LangChain",
   "license": "MIT",
   "dependencies": {
+    "@langchain/protocol": "^0.0.15",
     "@standard-schema/spec": "1.1.0",
     "uuid": "^10.0.0",
-    "@langchain/langgraph-checkpoint": "^1.0.1",
-    "@langchain/langgraph-sdk": "~1.8.9"
+    "@langchain/langgraph-checkpoint": "^1.0.2",
+    "@langchain/langgraph-sdk": "~1.9.0"
   },
   "peerDependencies": {
-    "@langchain/core": "^1.1.40",
+    "@langchain/core": "^1.1.44",
     "zod": "^3.25.32 || ^4.2.0",
     "zod-to-json-schema": "^3.x"
   },
@@ -32,9 +33,9 @@
     }
   },
   "devDependencies": {
-    "@langchain/anthropic": "^1.3.26",
-    "@langchain/core": "^1.1.40",
-    "@langchain/openai": "^1.4.1",
+    "@langchain/anthropic": "^1.3.28",
+    "@langchain/core": "^1.1.44",
+    "@langchain/openai": "^1.4.5",
     "@langchain/scripts": ">=0.1.3 <0.2.0",
     "@langchain/tavily": "^1.0.0",
     "@swc/core": "^1.3.90",
@@ -47,7 +48,7 @@
     "cheerio": "1.0.0-rc.12",
     "dotenv": "^16.3.1",
     "dpdm": "^3.12.0",
-    "langchain": "^1.3.0",
+    "langchain": "^1.3.5",
     "pg": "^8.13.0",
     "playwright": "^1.55.1",
     "rollup": "^4.37.0",