@langchain/langgraph 1.2.9 → 1.3.0

package/dist/stream/run-stream.js

@@ -0,0 +1,434 @@
+import { REJECT_VALUES, RESOLVE_VALUES, StreamMux, pump } from "./mux.js";
+import { createLifecycleTransformer, filterLifecycleEntries } from "./transformers/lifecycle.js";
+import { createMessagesTransformer } from "./transformers/messages.js";
+import { createSubgraphDiscoveryTransformer, filterSubgraphHandles } from "./transformers/subgraphs.js";
+import { createValuesTransformer } from "./transformers/values.js";
+import "./transformers/index.js";
+import { isNativeTransformer } from "./types.js";
+//#region src/stream/run-stream.ts
+/**
+* Symbol key for attaching the values log to a stream handle.
+* Using a symbol keeps this off the public autocomplete surface.
+*/
+const SET_VALUES_LOG = Symbol("setValuesLog");
+/**
+* Symbol key for attaching the messages iterable to a stream handle.
+* Using a symbol keeps this off the public autocomplete surface.
+*/
+const SET_MESSAGES_ITERABLE = Symbol("setMessagesIterable");
+/**
+* Symbol key for attaching the lifecycle iterable to a stream handle.
+* Using a symbol keeps this off the public autocomplete surface.
+*/
+const SET_LIFECYCLE_ITERABLE = Symbol("setLifecycleIterable");
+/**
+* Symbol key for attaching the subgraphs iterable to a stream handle.
+* Using a symbol keeps this off the public autocomplete surface.
+*/
+const SET_SUBGRAPHS_ITERABLE = Symbol("setSubgraphsIterable");
+/**
+* Shared empty async iterable, returned from getters that haven't
+* been wired by {@link createGraphRunStream}.  Avoids allocating a
+* fresh empty iterable on every access.
+*/
+const EMPTY_ASYNC_ITERABLE = { [Symbol.asyncIterator]() {
+	return { next: () => Promise.resolve({
+		value: void 0,
+		done: true
+	}) };
+} };
+/**
+* Primary run stream for a LangGraph execution.
+*
+* Implements {@link AsyncIterable} over {@link ProtocolEvent} and exposes
+* ergonomic projections for values, messages, subgraphs, output, and
+* interrupts. Created by {@link createGraphRunStream}.
+*
+* @typeParam TValues - Shape of the graph's state values.
+* @typeParam TExtensions - Shape of additional transformer projections merged
+*   into {@link GraphRunStream.extensions}.
+*/
+var GraphRunStream = class {
+	/**
+	* Namespace path identifying this stream's position in the agent tree.
+	* An empty array for the root stream.
+	*/
+	path;
+	/**
+	* Merged projections from user-supplied {@link StreamTransformer} factories.
+	* Each transformer's `init()` return value is spread into this object.
+	*/
+	extensions;
+	/**
+	* The central stream multiplexer that drives event dispatch and transformer
+	* pipelines. Accessible to subclasses for direct event subscription.
+	*
+	* @internal
+	*/
+	_mux;
+	#eventStart;
+	#discoveryStart;
+	#abortController;
+	#resolveValuesFn;
+	#rejectValuesFn;
+	#valuesDone;
+	#valuesLog;
+	#messagesIterable;
+	#lifecycleIterable;
+	#subgraphsIterable;
+	/**
+	* @param path - Namespace path for this stream (empty array for root).
+	* @param mux - The {@link StreamMux} driving this run.
+	* @param discoveryStart - Cursor offset into the mux discovery log.
+	* @param eventStart - Cursor offset into the mux event log.
+	* @param extensions - Pre-initialized transformer projections.
+	* @param abortController - Controller for programmatic cancellation.
+	*/
+	constructor(path, mux, discoveryStart = 0, eventStart = 0, extensions, abortController) {
+		this.path = path;
+		this._mux = mux;
+		this.#discoveryStart = discoveryStart;
+		this.#eventStart = eventStart;
+		this.extensions = extensions ?? {};
+		this.#abortController = abortController ?? new AbortController();
+		this.#valuesDone = new Promise((resolve, reject) => {
+			this.#resolveValuesFn = resolve;
+			this.#rejectValuesFn = reject;
+		});
+		this.#valuesDone.catch(() => {});
+	}
+	/**
+	* Async iterator over all {@link ProtocolEvent}s at or below this
+	* stream's namespace, starting from the configured event offset.
+	*
+	* @returns An async iterator yielding protocol events in arrival order.
+	*/
+	[Symbol.asyncIterator]() {
+		return this._mux.subscribeEvents(this.path, this.#eventStart);
+	}
+	/**
+	* Async iterable of child {@link SubgraphRunStream} instances discovered
+	* during the run. Each yielded stream represents a direct child namespace.
+	*
+	* Backed by the shared `_discoveries` log on the mux, populated by
+	* {@link createSubgraphDiscoveryTransformer}.  For streams created
+	* through {@link createGraphRunStream} the iterable is pre-wired
+	* (via {@link SET_SUBGRAPHS_ITERABLE}) so iteration is cheap.
+	* Streams constructed directly (e.g. in unit tests) fall back to
+	* filtering `_mux._discoveries` on demand, preserving the original
+	* behavior without requiring explicit wiring.
+	*
+	* @returns An async iterable of subgraph run streams.
+	*/
+	get subgraphs() {
+		if (this.#subgraphsIterable) return this.#subgraphsIterable;
+		return filterSubgraphHandles(this._mux._discoveries, this.path, this.#discoveryStart);
+	}
+	/**
+	* Dual-interface accessor for graph state snapshots.
+	*
+	* As an {@link AsyncIterable}, yields each intermediate state snapshot
+	* as it arrives. As a {@link PromiseLike}, resolves with the final
+	* state value when the run completes.
+	*
+	* @returns A combined async iterable and promise-like for state values.
+	*/
+	get values() {
+		const log = this.#valuesLog;
+		const done = this.#valuesDone;
+		const mux = this._mux;
+		const eventStart = this.#eventStart;
+		const path = this.path;
+		const iterable = log ? log.toAsyncIterable() : { [Symbol.asyncIterator]: () => {
+			const base = mux.subscribeEvents(path, eventStart);
+			return { async next() {
+				while (true) {
+					const result = await base.next();
+					if (result.done) return {
+						value: void 0,
+						done: true
+					};
+					if (result.value.method === "values" && result.value.params.namespace.length === path.length) return {
+						value: result.value.params.data,
+						done: false
+					};
+				}
+			} };
+		} };
+		return {
+			[Symbol.asyncIterator]: () => iterable[Symbol.asyncIterator](),
+			then: done.then.bind(done)
+		};
+	}
+	/**
+	* All AI message lifecycles observed at this namespace level, in order.
+	* Each yielded {@link ChatModelStream} represents one message-start →
+	* message-finish lifecycle with streaming `.text`, `.reasoning`, and
+	* `.usage` projections.
+	*
+	* @returns An async iterable of chat model streams.
+	*/
+	get messages() {
+		if (this.#messagesIterable) return this.#messagesIterable;
+		const transformer = createMessagesTransformer(this.path);
+		const projection = transformer.init();
+		this._mux.addTransformer(transformer);
+		this.#messagesIterable = projection.messages;
+		return this.#messagesIterable;
+	}
+	/**
+	* Sequence of {@link LifecycleEntry} records tracking the
+	* `lifecycle` channel: when the run starts, when each subgraph
+	* enters/exits, and the terminal status of the run as a whole.
+	*
+	* Backed by the built-in {@link createLifecycleTransformer}; the
+	* root stream's iterable is wired during
+	* {@link createGraphRunStream} setup, and each
+	* {@link SubgraphRunStream} is wired in the subgraph discovery
+	* factory with a subtree-scoped view (via
+	* {@link filterLifecycleEntries}).  Streams constructed outside
+	* `createGraphRunStream` and not wired will yield nothing.
+	*
+	* @returns An async iterable of lifecycle entries in emission order.
+	*/
+	get lifecycle() {
+		return this.#lifecycleIterable ?? EMPTY_ASYNC_ITERABLE;
+	}
+	/**
+	* Messages produced by a specific graph node. Use when the run has
+	* multiple model-calling nodes and you only want messages from one.
+	*
+	* @param node - The graph node name to filter messages by.
+	* @returns An async iterable of chat model streams from the given node.
+	*/
+	messagesFrom(node) {
+		const transformer = createMessagesTransformer(this.path, node);
+		const projection = transformer.init();
+		this._mux.addTransformer(transformer);
+		return projection.messages;
+	}
+	/**
+	* Promise that resolves with the final graph state when the run completes,
+	* or rejects if the run fails.
+	*
+	* @returns A promise resolving to the final state values.
+	*/
+	get output() {
+		return this.#valuesDone;
+	}
+	/**
+	* Whether the run ended due to a human-in-the-loop interrupt.
+	*
+	* @returns `true` if the run was interrupted.
+	*/
+	get interrupted() {
+		return this._mux.interrupted;
+	}
+	/**
+	* Interrupt payloads collected during the run, if any.
+	*
+	* @returns A readonly array of interrupt payloads.
+	*/
+	get interrupts() {
+		return this._mux.interrupts;
+	}
+	/**
+	* Programmatically abort this run. Equivalent to calling
+	* `signal.abort(reason)`.
+	*
+	* @param reason - Optional abort reason passed to the signal.
+	*/
+	abort(reason) {
+		this.#abortController.abort(reason);
+	}
+	/**
+	* The {@link AbortSignal} wired into this run for cancellation support.
+	*
+	* @returns The abort signal for this stream.
+	*/
+	get signal() {
+		return this.#abortController.signal;
+	}
+	/**
+	* Resolve the output/values promise with the final state snapshot.
+	* Called by {@link StreamMux.close}.
+	*
+	* @param values - The final state values, or `undefined` if none.
+	* @internal
+	*/
+	[RESOLVE_VALUES](values) {
+		this.#resolveValuesFn?.(values);
+		this.#resolveValuesFn = void 0;
+	}
+	/**
+	* Reject the output/values promise with a run error.
+	* Called by {@link StreamMux.fail}.
+	*
+	* @param err - The error that caused the run to fail.
+	* @internal
+	*/
+	[REJECT_VALUES](err) {
+		this.#rejectValuesFn?.(err);
+		this.#rejectValuesFn = void 0;
+	}
+	/**
+	* Attach the transformer-populated event log backing the `.values` iterable.
+	* Called during stream setup in {@link createGraphRunStream}.
+	*
+	* @param log - The event log from the values transformer projection.
+	* @internal
+	*/
+	[SET_VALUES_LOG](log) {
+		this.#valuesLog = log;
+	}
+	/**
+	* Attach the transformer-populated async iterable backing the `.messages`
+	* accessor. Called during stream setup in {@link createGraphRunStream}.
+	*
+	* @param iterable - The async iterable from the messages transformer projection.
+	* @internal
+	*/
+	[SET_MESSAGES_ITERABLE](iterable) {
+		this.#messagesIterable = iterable;
+	}
+	/**
+	* Attach the transformer-populated async iterable backing the
+	* `.lifecycle` accessor. Called during stream setup in
+	* {@link createGraphRunStream}.
+	*
+	* @param iterable - The async iterable from the lifecycle transformer projection.
+	* @internal
+	*/
+	[SET_LIFECYCLE_ITERABLE](iterable) {
+		this.#lifecycleIterable = iterable;
+	}
+	/**
+	* Attach the transformer-populated async iterable backing the
+	* `.subgraphs` accessor. Called during root stream setup in
+	* {@link createGraphRunStream} and during child stream
+	* construction in the discovery transformer factory.
+	*
+	* @param iterable - The async iterable of direct-child stream handles.
+	* @internal
+	*/
+	[SET_SUBGRAPHS_ITERABLE](iterable) {
+		this.#subgraphsIterable = iterable;
+	}
+};
+/**
+* A run stream for a child subgraph within a parent graph execution.
+*
+* Extends {@link GraphRunStream} with a parsed {@link name} and
+* {@link index} extracted from the last segment of the namespace path.
+* The segment is expected to follow the `"name:index"` convention;
+* when no numeric suffix is present, {@link index} defaults to `0`.
+*
+* @typeParam TValues - Shape of the subgraph's state values.
+* @typeParam TExtensions - Shape of additional transformer projections.
+*/
+var SubgraphRunStream = class extends GraphRunStream {
+	/**
+	* The node name extracted from the last segment of the namespace path
+	* (everything before the final colon, or the full segment if no colon).
+	*/
+	name;
+	/**
+	* The invocation index parsed from the `"name:N"` suffix of the last
+	* namespace segment. Defaults to `0` when no numeric suffix is present.
+	*/
+	index;
+	/**
+	* @param path - Namespace path for this subgraph stream.
+	* @param mux - The {@link StreamMux} driving this run.
+	* @param discoveryStart - Cursor offset into the mux discovery log.
+	* @param eventStart - Cursor offset into the mux event log.
+	* @param extensions - Pre-initialized transformer projections.
+	* @param abortController - Controller for programmatic cancellation.
+	*/
+	constructor(path, mux, discoveryStart = 0, eventStart = 0, extensions, abortController) {
+		super(path, mux, discoveryStart, eventStart, extensions, abortController);
+		const lastSegment = path[path.length - 1] ?? "";
+		const colonIdx = lastSegment.lastIndexOf(":");
+		if (colonIdx >= 0) {
+			this.name = lastSegment.slice(0, colonIdx);
+			const suffix = lastSegment.slice(colonIdx + 1);
+			this.index = /^\d+$/.test(suffix) ? Number(suffix) : 0;
+		} else {
+			this.name = lastSegment;
+			this.index = 0;
+		}
+	}
+};
+/**
+* Creates a {@link GraphRunStream} with built-in transformers and kicks off the
+* background pump that feeds raw stream chunks through the transformer pipeline.
+*
+* Built-in transformers are registered in this order:
+*   1. subgraph discovery — materializes SubgraphRunStream handles
+*      for each newly observed top-level namespace and announces them
+*      on the mux `_discoveries` log.
+*   2. lifecycle — synthesizes `lifecycle` channel events.
+*   3. values — powers `run.values` / `run.output`.
+*   4. messages — powers `run.messages` / `.messagesFrom`.
+*
+* Subgraph discovery is registered first so that downstream
+* transformers (notably lifecycle) observe child namespaces with
+* their stream handles already in place.  User-supplied transformer
+* factories are registered afterwards.
+*
+* @typeParam TValues - Shape of the graph's state values.
+* @param source - Raw async iterable from `graph.stream(…, { subgraphs: true })`.
+* @param transformers - User-supplied transformer factories.
+* @param optionsOrAbortController - Either a full
+*   {@link CreateGraphRunStreamOptions} object or (for backward
+*   compatibility) a bare `AbortController`.
+* @returns A {@link GraphRunStream} for the root namespace.
+*/
+function createGraphRunStream(source, transformers = [], optionsOrAbortController) {
+	const { abortController } = optionsOrAbortController instanceof AbortController ? { abortController: optionsOrAbortController } : optionsOrAbortController ?? {};
+	const mux = new StreamMux();
+	const lifecycleTransformer = createLifecycleTransformer();
+	const lifecycleProjection = lifecycleTransformer.init();
+	const lifecycleLog = lifecycleProjection._lifecycleLog;
+	const subgraphDiscoveryTransformer = createSubgraphDiscoveryTransformer(mux, { createStream: (path, discoveryStart, eventStart) => {
+		const sub = new SubgraphRunStream(path, mux, discoveryStart, eventStart);
+		sub[SET_SUBGRAPHS_ITERABLE](filterSubgraphHandles(mux._discoveries, path, discoveryStart));
+		sub[SET_LIFECYCLE_ITERABLE](filterLifecycleEntries(lifecycleLog, path, lifecycleLog.size));
+		return sub;
+	} });
+	const subgraphsProjection = subgraphDiscoveryTransformer.init();
+	mux.addTransformer(subgraphDiscoveryTransformer);
+	mux.addTransformer(lifecycleTransformer);
+	const valuesTransformer = createValuesTransformer([]);
+	const messagesTransformer = createMessagesTransformer([]);
+	mux.addTransformer(valuesTransformer);
+	mux.addTransformer(messagesTransformer);
+	const extensions = {};
+	const nativeProjections = [];
+	for (const factory of transformers) {
+		const transformer = factory();
+		mux.addTransformer(transformer);
+		const projection = transformer.init();
+		if (isNativeTransformer(transformer)) nativeProjections.push(projection);
+		else Object.assign(extensions, projection);
+		if (typeof projection === "object" && projection !== null && !isNativeTransformer(transformer)) mux.wireChannels(projection);
+	}
+	const root = new GraphRunStream([], mux, 0, 0, extensions, abortController);
+	/**
+	* Assign native transformer projections to the root stream.
+	*/
+	for (const proj of nativeProjections) Object.assign(root, proj);
+	const valuesProjection = valuesTransformer.init();
+	root[SET_VALUES_LOG](valuesProjection._valuesLog);
+	const messagesProjection = messagesTransformer.init();
+	root[SET_MESSAGES_ITERABLE](messagesProjection.messages);
+	root[SET_LIFECYCLE_ITERABLE](lifecycleProjection.lifecycle);
+	root[SET_SUBGRAPHS_ITERABLE](subgraphsProjection.subgraphs);
+	mux.register([], root);
+	pump(source, mux).catch((err) => {});
+	return root;
+}
+//#endregion
+export { GraphRunStream, SET_LIFECYCLE_ITERABLE, SET_MESSAGES_ITERABLE, SET_VALUES_LOG, SubgraphRunStream, createGraphRunStream };
+
+//# sourceMappingURL=run-stream.js.map

package/dist/stream/run-stream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-stream.js","names":["#valuesDone","#discoveryStart","#eventStart","#abortController","#resolveValuesFn","#rejectValuesFn","#subgraphsIterable","#valuesLog","#messagesIterable","#lifecycleIterable"],"sources":["../../src/stream/run-stream.ts"],"sourcesContent":["/**\n * GraphRunStream and SubgraphRunStream — the public run stream classes.\n *\n * Built-in projections:\n *   .subgraphs     — recursive child subgraph discovery\n *   .values        — state snapshots (AsyncIterable & PromiseLike)\n *   .messages      — per-message ChatModelStream lifecycle\n *   .messagesFrom  — node-filtered messages\n *   .output        — final state Promise\n *   .interrupted   — whether the run ended due to an interrupt\n *   .interrupts    — interrupt payloads\n *   .abort()       — programmatic cancellation\n *   .extensions    — merged transformer projections\n *\n * Internal LangChain products (ReactAgent, DeepAgent) can subclass\n * GraphRunStream to add native projections (e.g. `run.toolCalls`,\n * `run.subagents`).  See docs/native-stream-transformers.md for the\n * pattern.\n */\n\nimport type { StreamChunk } from \"../pregel/stream.js\";\nimport {\n  createLifecycleTransformer,\n  createMessagesTransformer,\n  createSubgraphDiscoveryTransformer,\n  createValuesTransformer,\n  filterLifecycleEntries,\n  filterSubgraphHandles,\n  type LifecycleEntry,\n} from \"./transformers/index.js\";\nimport { StreamMux, pump, RESOLVE_VALUES, REJECT_VALUES } from \"./mux.js\";\nimport {\n  isNativeTransformer,\n  type ChatModelStreamHandle,\n  type InferExtensions,\n  type InterruptPayload,\n  type Namespace,\n  type ProtocolEvent,\n  type StreamTransformer,\n} from \"./types.js\";\nimport type { StreamChannel } from \"./stream-channel.js\";\n\n/**\n * Symbol key for attaching the values log to a stream handle.\n * Using a symbol keeps this off the public autocomplete surface.\n */\nexport const SET_VALUES_LOG: unique symbol = Symbol(\"setValuesLog\");\n\n/**\n * Symbol key for attaching the messages iterable to a stream handle.\n * Using a symbol keeps this off the public autocomplete surface.\n */\nexport const SET_MESSAGES_ITERABLE: unique symbol = Symbol(\n  \"setMessagesIterable\"\n);\n\n/**\n * Symbol key for attaching the lifecycle iterable to a stream handle.\n * Using a symbol keeps this off the public autocomplete surface.\n */\nexport const SET_LIFECYCLE_ITERABLE: unique symbol = Symbol(\n  \"setLifecycleIterable\"\n);\n\n/**\n * Symbol key for attaching the subgraphs iterable to a stream handle.\n * Using a symbol keeps this off the public autocomplete surface.\n */\nexport const SET_SUBGRAPHS_ITERABLE: unique symbol = Symbol(\n  \"setSubgraphsIterable\"\n);\n\n/**\n * Shared empty async iterable, returned from getters that haven't\n * been wired by {@link createGraphRunStream}.  Avoids allocating a\n * fresh empty iterable on every access.\n */\nconst EMPTY_ASYNC_ITERABLE: AsyncIterable<never> = {\n  [Symbol.asyncIterator](): AsyncIterator<never> {\n    return {\n      next: () =>\n        Promise.resolve({\n          value: undefined as never,\n          done: true,\n        }),\n    };\n  },\n};\n\n/**\n * Primary run stream for a LangGraph execution.\n *\n * Implements {@link AsyncIterable} over {@link ProtocolEvent} and exposes\n * ergonomic projections for values, messages, subgraphs, output, and\n * interrupts. Created by {@link createGraphRunStream}.\n *\n * @typeParam TValues - Shape of the graph's state values.\n * @typeParam TExtensions - Shape of additional transformer projections merged\n *   into {@link GraphRunStream.extensions}.\n */\nexport class GraphRunStream<\n  TValues = Record<string, unknown>,\n  TExtensions extends Record<string, unknown> = Record<string, unknown>,\n> implements AsyncIterable<ProtocolEvent> {\n  /**\n   * Namespace path identifying this stream's position in the agent tree.\n   * An empty array for the root stream.\n   */\n  readonly path: Namespace;\n\n  /**\n   * Merged projections from user-supplied {@link StreamTransformer} factories.\n   * Each transformer's `init()` return value is spread into this object.\n   */\n  readonly extensions: TExtensions;\n\n  /**\n   * The central stream multiplexer that drives event dispatch and transformer\n   * pipelines. Accessible to subclasses for direct event subscription.\n   *\n   * @internal\n   */\n  protected readonly _mux: StreamMux;\n\n  #eventStart: number;\n  #discoveryStart: number;\n  #abortController: AbortController;\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  #resolveValuesFn?: (v: any) => void;\n  #rejectValuesFn?: (e: unknown) => void;\n  readonly #valuesDone: Promise<TValues>;\n\n  #valuesLog?: StreamChannel<Record<string, unknown>>;\n  #messagesIterable?: AsyncIterable<ChatModelStreamHandle>;\n  #lifecycleIterable?: AsyncIterable<LifecycleEntry>;\n  #subgraphsIterable?: AsyncIterable<SubgraphRunStream>;\n\n  /**\n   * @param path - Namespace path for this stream (empty array for root).\n   * @param mux - The {@link StreamMux} driving this run.\n   * @param discoveryStart - Cursor offset into the mux discovery log.\n   * @param eventStart - Cursor offset into the mux event log.\n   * @param extensions - Pre-initialized transformer projections.\n   * @param abortController - Controller for programmatic cancellation.\n   */\n  constructor(\n    path: Namespace,\n    mux: StreamMux,\n    discoveryStart = 0,\n    eventStart = 0,\n    extensions?: TExtensions,\n    abortController?: AbortController\n  ) {\n    this.path = path;\n    this._mux = mux;\n    this.#discoveryStart = discoveryStart;\n    this.#eventStart = eventStart;\n    this.extensions = extensions ?? ({} as TExtensions);\n    this.#abortController = abortController ?? new AbortController();\n    this.#valuesDone = new Promise<TValues>((resolve, reject) => {\n      this.#resolveValuesFn = resolve;\n      this.#rejectValuesFn = reject;\n    });\n    this.#valuesDone.catch(() => {\n      // Keep run failures observable to explicit `await run.output` callers\n      // without reporting unhandled rejections when consumers only iterate\n      // protocol events.\n    });\n  }\n\n  /**\n   * Async iterator over all {@link ProtocolEvent}s at or below this\n   * stream's namespace, starting from the configured event offset.\n   *\n   * @returns An async iterator yielding protocol events in arrival order.\n   */\n  [Symbol.asyncIterator](): AsyncIterator<ProtocolEvent> {\n    return this._mux.subscribeEvents(this.path, this.#eventStart);\n  }\n\n  /**\n   * Async iterable of child {@link SubgraphRunStream} instances discovered\n   * during the run. Each yielded stream represents a direct child namespace.\n   *\n   * Backed by the shared `_discoveries` log on the mux, populated by\n   * {@link createSubgraphDiscoveryTransformer}.  For streams created\n   * through {@link createGraphRunStream} the iterable is pre-wired\n   * (via {@link SET_SUBGRAPHS_ITERABLE}) so iteration is cheap.\n   * Streams constructed directly (e.g. in unit tests) fall back to\n   * filtering `_mux._discoveries` on demand, preserving the original\n   * behavior without requiring explicit wiring.\n   *\n   * @returns An async iterable of subgraph run streams.\n   */\n  get subgraphs(): AsyncIterable<SubgraphRunStream> {\n    if (this.#subgraphsIterable) return this.#subgraphsIterable;\n    return filterSubgraphHandles<SubgraphRunStream>(\n      this._mux._discoveries,\n      this.path,\n      this.#discoveryStart\n    );\n  }\n\n  /**\n   * Dual-interface accessor for graph state snapshots.\n   *\n   * As an {@link AsyncIterable}, yields each intermediate state snapshot\n   * as it arrives. As a {@link PromiseLike}, resolves with the final\n   * state value when the run completes.\n   *\n   * @returns A combined async iterable and promise-like for state values.\n   */\n  get values(): AsyncIterable<TValues> & PromiseLike<TValues> {\n    const log = this.#valuesLog;\n    const done = this.#valuesDone;\n    const mux = this._mux;\n    const eventStart = this.#eventStart;\n    const path = this.path;\n\n    const iterable: AsyncIterable<TValues> = log\n      ? (log.toAsyncIterable() as AsyncIterable<TValues>)\n      : {\n          [Symbol.asyncIterator]: () => {\n            const base = mux.subscribeEvents(path, eventStart);\n            return {\n              async next(): Promise<IteratorResult<TValues>> {\n                // eslint-disable-next-line no-constant-condition\n                while (true) {\n                  const result = await base.next();\n                  if (result.done) {\n                    return {\n                      value: undefined as unknown as TValues,\n                      done: true,\n                    };\n                  }\n                  if (\n                    result.value.method === \"values\" &&\n                    result.value.params.namespace.length === path.length\n                  ) {\n                    return {\n                      value: result.value.params.data as TValues,\n                      done: false,\n                    };\n                  }\n                }\n              },\n            };\n          },\n        };\n\n    return {\n      [Symbol.asyncIterator]: () => iterable[Symbol.asyncIterator](),\n      then: done.then.bind(done),\n    };\n  }\n\n  /**\n   * All AI message lifecycles observed at this namespace level, in order.\n   * Each yielded {@link ChatModelStream} represents one message-start →\n   * message-finish lifecycle with streaming `.text`, `.reasoning`, and\n   * `.usage` projections.\n   *\n   * @returns An async iterable of chat model streams.\n   */\n  get messages(): AsyncIterable<ChatModelStreamHandle> {\n    if (this.#messagesIterable) return this.#messagesIterable;\n    // Lazily create a messages transformer scoped to this stream's path.\n    // This handles SubgraphRunStream instances that are created\n    // dynamically by StreamMux and don't have a transformer pre-wired.\n    // Uses addTransformer (which replays buffered events) so that\n    // messages emitted before the getter is first accessed are not lost.\n    const transformer = createMessagesTransformer(this.path);\n    const projection = transformer.init();\n    this._mux.addTransformer(transformer);\n    this.#messagesIterable = projection.messages;\n    return this.#messagesIterable;\n  }\n\n  /**\n   * Sequence of {@link LifecycleEntry} records tracking the\n   * `lifecycle` channel: when the run starts, when each subgraph\n   * enters/exits, and the terminal status of the run as a whole.\n   *\n   * Backed by the built-in {@link createLifecycleTransformer}; the\n   * root stream's iterable is wired during\n   * {@link createGraphRunStream} setup, and each\n   * {@link SubgraphRunStream} is wired in the subgraph discovery\n   * factory with a subtree-scoped view (via\n   * {@link filterLifecycleEntries}).  Streams constructed outside\n   * `createGraphRunStream` and not wired will yield nothing.\n   *\n   * @returns An async iterable of lifecycle entries in emission order.\n   */\n  get lifecycle(): AsyncIterable<LifecycleEntry> {\n    return this.#lifecycleIterable ?? EMPTY_ASYNC_ITERABLE;\n  }\n\n  /**\n   * Messages produced by a specific graph node. Use when the run has\n   * multiple model-calling nodes and you only want messages from one.\n   *\n   * @param node - The graph node name to filter messages by.\n   * @returns An async iterable of chat model streams from the given node.\n   */\n  messagesFrom(node: string): AsyncIterable<ChatModelStreamHandle> {\n    const transformer = createMessagesTransformer(this.path, node);\n    const projection = transformer.init();\n    this._mux.addTransformer(transformer);\n    return projection.messages;\n  }\n\n  /**\n   * Promise that resolves with the final graph state when the run completes,\n   * or rejects if the run fails.\n   *\n   * @returns A promise resolving to the final state values.\n   */\n  get output(): Promise<TValues> {\n    return this.#valuesDone;\n  }\n\n  /**\n   * Whether the run ended due to a human-in-the-loop interrupt.\n   *\n   * @returns `true` if the run was interrupted.\n   */\n  get interrupted(): boolean {\n    return this._mux.interrupted;\n  }\n\n  /**\n   * Interrupt payloads collected during the run, if any.\n   *\n   * @returns A readonly array of interrupt payloads.\n   */\n  get interrupts(): readonly InterruptPayload[] {\n    return this._mux.interrupts;\n  }\n\n  /**\n   * Programmatically abort this run. Equivalent to calling\n   * `signal.abort(reason)`.\n   *\n   * @param reason - Optional abort reason passed to the signal.\n   */\n  abort(reason?: unknown): void {\n    this.#abortController.abort(reason);\n  }\n\n  /**\n   * The {@link AbortSignal} wired into this run for cancellation support.\n   *\n   * @returns The abort signal for this stream.\n   */\n  get signal(): AbortSignal {\n    return this.#abortController.signal;\n  }\n\n  /**\n   * Resolve the output/values promise with the final state snapshot.\n   * Called by {@link StreamMux.close}.\n   *\n   * @param values - The final state values, or `undefined` if none.\n   * @internal\n   */\n  [RESOLVE_VALUES](values: TValues | undefined): void {\n    this.#resolveValuesFn?.(values as TValues);\n    this.#resolveValuesFn = undefined;\n  }\n\n  /**\n   * Reject the output/values promise with a run error.\n   * Called by {@link StreamMux.fail}.\n   *\n   * @param err - The error that caused the run to fail.\n   * @internal\n   */\n  [REJECT_VALUES](err: unknown): void {\n    this.#rejectValuesFn?.(err);\n    this.#rejectValuesFn = undefined;\n  }\n\n  /**\n   * Attach the transformer-populated event log backing the `.values` iterable.\n   * Called during stream setup in {@link createGraphRunStream}.\n   *\n   * @param log - The event log from the values transformer projection.\n   * @internal\n   */\n  [SET_VALUES_LOG](log: StreamChannel<Record<string, unknown>>): void {\n    this.#valuesLog = log;\n  }\n\n  /**\n   * Attach the transformer-populated async iterable backing the `.messages`\n   * accessor. Called during stream setup in {@link createGraphRunStream}.\n   *\n   * @param iterable - The async iterable from the messages transformer projection.\n   * @internal\n   */\n  [SET_MESSAGES_ITERABLE](\n    iterable: AsyncIterable<ChatModelStreamHandle>\n  ): void {\n    this.#messagesIterable = iterable;\n  }\n\n  /**\n   * Attach the transformer-populated async iterable backing the\n   * `.lifecycle` accessor. Called during stream setup in\n   * {@link createGraphRunStream}.\n   *\n   * @param iterable - The async iterable from the lifecycle transformer projection.\n   * @internal\n   */\n  [SET_LIFECYCLE_ITERABLE](iterable: AsyncIterable<LifecycleEntry>): void {\n    this.#lifecycleIterable = iterable;\n  }\n\n  /**\n   * Attach the transformer-populated async iterable backing the\n   * `.subgraphs` accessor. Called during root stream setup in\n   * {@link createGraphRunStream} and during child stream\n   * construction in the discovery transformer factory.\n   *\n   * @param iterable - The async iterable of direct-child stream handles.\n   * @internal\n   */\n  [SET_SUBGRAPHS_ITERABLE](iterable: AsyncIterable<SubgraphRunStream>): void {\n    this.#subgraphsIterable = iterable;\n  }\n}\n\n/**\n * A run stream for a child subgraph within a parent graph execution.\n *\n * Extends {@link GraphRunStream} with a parsed {@link name} and\n * {@link index} extracted from the last segment of the namespace path.\n * The segment is expected to follow the `\"name:index\"` convention;\n * when no numeric suffix is present, {@link index} defaults to `0`.\n *\n * @typeParam TValues - Shape of the subgraph's state values.\n * @typeParam TExtensions - Shape of additional transformer projections.\n */\nexport class SubgraphRunStream<\n  TValues = Record<string, unknown>,\n  TExtensions extends Record<string, unknown> = Record<string, unknown>,\n> extends GraphRunStream<TValues, TExtensions> {\n  /**\n   * The node name extracted from the last segment of the namespace path\n   * (everything before the final colon, or the full segment if no colon).\n   */\n  readonly name: string;\n\n  /**\n   * The invocation index parsed from the `\"name:N\"` suffix of the last\n   * namespace segment. Defaults to `0` when no numeric suffix is present.\n   */\n  readonly index: number;\n\n  /**\n   * @param path - Namespace path for this subgraph stream.\n   * @param mux - The {@link StreamMux} driving this run.\n   * @param discoveryStart - Cursor offset into the mux discovery log.\n   * @param eventStart - Cursor offset into the mux event log.\n   * @param extensions - Pre-initialized transformer projections.\n   * @param abortController - Controller for programmatic cancellation.\n   */\n  constructor(\n    path: Namespace,\n    mux: StreamMux,\n    discoveryStart = 0,\n    eventStart = 0,\n    extensions?: TExtensions,\n    abortController?: AbortController\n  ) {\n    super(path, mux, discoveryStart, eventStart, extensions, abortController);\n    const lastSegment = path[path.length - 1] ?? \"\";\n    const colonIdx = lastSegment.lastIndexOf(\":\");\n    if (colonIdx >= 0) {\n      this.name = lastSegment.slice(0, colonIdx);\n      const suffix = lastSegment.slice(colonIdx + 1);\n      this.index = /^\\d+$/.test(suffix) ? Number(suffix) : 0;\n    } else {\n      this.name = lastSegment;\n      this.index = 0;\n    }\n  }\n}\n\n/**\n * Options accepted by {@link createGraphRunStream}.\n */\nexport interface CreateGraphRunStreamOptions {\n  /**\n   * Optional abort controller shared with the outer run; if omitted, a\n   * fresh controller is allocated for the returned stream.\n   */\n  abortController?: AbortController;\n}\n\n/**\n * Creates a {@link GraphRunStream} with built-in transformers and kicks off the\n * background pump that feeds raw stream chunks through the transformer pipeline.\n *\n * Built-in transformers are registered in this order:\n *   1. subgraph discovery — materializes SubgraphRunStream handles\n *      for each newly observed top-level namespace and announces them\n *      on the mux `_discoveries` log.\n *   2. lifecycle — synthesizes `lifecycle` channel events.\n *   3. values — powers `run.values` / `run.output`.\n *   4. messages — powers `run.messages` / `.messagesFrom`.\n *\n * Subgraph discovery is registered first so that downstream\n * transformers (notably lifecycle) observe child namespaces with\n * their stream handles already in place.  User-supplied transformer\n * factories are registered afterwards.\n *\n * @typeParam TValues - Shape of the graph's state values.\n * @param source - Raw async iterable from `graph.stream(…, { subgraphs: true })`.\n * @param transformers - User-supplied transformer factories.\n * @param optionsOrAbortController - Either a full\n *   {@link CreateGraphRunStreamOptions} object or (for backward\n *   compatibility) a bare `AbortController`.\n * @returns A {@link GraphRunStream} for the root namespace.\n */\nexport function createGraphRunStream<\n  TValues = Record<string, unknown>,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const TTransformers extends ReadonlyArray<() => StreamTransformer<any>> = [],\n>(\n  source: AsyncIterable<StreamChunk>,\n  transformers: TTransformers = [] as unknown as TTransformers,\n  optionsOrAbortController?: CreateGraphRunStreamOptions | AbortController\n): GraphRunStream<TValues, InferExtensions<TTransformers>> {\n  const options: CreateGraphRunStreamOptions =\n    // oxlint-disable-next-line no-instanceof/no-instanceof\n    optionsOrAbortController instanceof AbortController\n      ? { abortController: optionsOrAbortController }\n      : (optionsOrAbortController ?? {});\n  const { abortController } = options;\n\n  const mux = new StreamMux();\n\n  // Init lifecycle first so the subgraph discovery factory can close\n  // over its log to wire each new child's `.lifecycle` view.\n  const lifecycleTransformer = createLifecycleTransformer();\n  const lifecycleProjection = lifecycleTransformer.init();\n  const lifecycleLog = lifecycleProjection._lifecycleLog;\n\n  const subgraphDiscoveryTransformer =\n    createSubgraphDiscoveryTransformer<SubgraphRunStream>(mux, {\n      createStream: (path, discoveryStart, eventStart) => {\n        const sub = new SubgraphRunStream(\n          path,\n          mux,\n          discoveryStart,\n          eventStart\n        );\n        // Wire the child's `.subgraphs` to the shared discoveries log,\n        // scoped to the child's path and its construction-time offset.\n        sub[SET_SUBGRAPHS_ITERABLE](\n          filterSubgraphHandles<SubgraphRunStream>(\n            mux._discoveries,\n            path,\n            discoveryStart\n          )\n        );\n        // Wire the child's `.lifecycle` to the shared lifecycle log,\n        // filtered to its subtree.  Capture the current log size so\n        // entries emitted before discovery (e.g. root's `started`)\n        // aren't replayed to the child.  Entries emitted for this\n        // discovery event itself land after the factory returns (the\n        // subgraph transformer runs before the lifecycle transformer),\n        // so the child still receives its own `started`.\n        sub[SET_LIFECYCLE_ITERABLE](\n          filterLifecycleEntries(lifecycleLog, path, lifecycleLog.size)\n        );\n        return sub;\n      },\n    });\n  const subgraphsProjection = subgraphDiscoveryTransformer.init();\n\n  // Registration order matters: subgraph discovery runs first so that\n  // lifecycle and downstream transformers see child stream handles\n  // already materialized.\n  mux.addTransformer(subgraphDiscoveryTransformer);\n  mux.addTransformer(lifecycleTransformer);\n\n  const valuesTransformer = createValuesTransformer([]);\n  const messagesTransformer = createMessagesTransformer([]);\n  mux.addTransformer(valuesTransformer);\n  mux.addTransformer(messagesTransformer);\n\n  const extensions: Record<string, unknown> = {};\n  const nativeProjections: Record<string, unknown>[] = [];\n  for (const factory of transformers) {\n    const transformer = factory();\n    mux.addTransformer(transformer);\n    const projection = transformer.init();\n    if (isNativeTransformer(transformer)) {\n      nativeProjections.push(projection);\n    } else {\n      Object.assign(extensions, projection);\n    }\n    // Only wire channels for extension transformers. Native transformers\n    // produce non-serializable projections (Promises, AsyncIterables) that\n    // must stay in-process — wiring them would inject garbage into the\n    // protocol event stream.\n    if (\n      typeof projection === \"object\" &&\n      projection !== null &&\n      !isNativeTransformer(transformer)\n    ) {\n      mux.wireChannels(projection as Record<string, unknown>);\n    }\n  }\n\n  const root = new GraphRunStream<TValues, InferExtensions<TTransformers>>(\n    [],\n    mux,\n    0,\n    0,\n    extensions as InferExtensions<TTransformers>,\n    abortController\n  );\n\n  /**\n   * Assign native transformer projections to the root stream.\n   */\n  for (const proj of nativeProjections) {\n    Object.assign(root, proj);\n  }\n\n  // Wire transformer projections into the root stream.\n  const valuesProjection = valuesTransformer.init();\n  root[SET_VALUES_LOG](valuesProjection._valuesLog);\n\n  const messagesProjection = messagesTransformer.init();\n  root[SET_MESSAGES_ITERABLE](messagesProjection.messages);\n  root[SET_LIFECYCLE_ITERABLE](lifecycleProjection.lifecycle);\n  root[SET_SUBGRAPHS_ITERABLE](subgraphsProjection.subgraphs);\n\n  mux.register([], root);\n\n  // Start background pump.\n  pump(source, mux).catch((err) => {\n    void err;\n  });\n\n  return root;\n}\n"],"mappings":"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"}