@langchain/angular 0.4.7 → 1.0.1

package/dist/selectors.js

@@ -0,0 +1,136 @@
+import { getRegistry } from "./use-stream.js";
+import { injectProjection } from "./inject-projection.js";
+import { computed, isSignal } from "@angular/core";
+import { NAMESPACE_SEPARATOR, audioProjection, channelProjection, extensionProjection, filesProjection, imagesProjection, messagesProjection, toolCallsProjection, valuesProjection, videoProjection } from "@langchain/langgraph-sdk/stream";
+//#region src/selectors.ts
+const EMPTY_NAMESPACE = [];
+function resolveNamespace(target) {
+	if (target == null) return EMPTY_NAMESPACE;
+	if (Array.isArray(target)) return target;
+	return target.namespace ?? EMPTY_NAMESPACE;
+}
+function isRoot(namespace) {
+	return namespace.length === 0;
+}
+function namespaceKey(namespace) {
+	return namespace.join(NAMESPACE_SEPARATOR);
+}
+/**
+* Resolve a target or target-signal into a reactive
+* `[namespace, key]` pair. The helper returns plain signals so
+* `injectProjection` can track them via its internal effect.
+*/
+function normalizeTarget(target, prefix) {
+	if (isSignal(target)) {
+		const namespace = computed(() => resolveNamespace(target()));
+		return {
+			namespace,
+			key: computed(() => `${prefix}|${namespaceKey(namespace())}`),
+			isRootSignal: computed(() => isRoot(namespace()))
+		};
+	}
+	const ns = resolveNamespace(target);
+	const staticKey = `${prefix}|${namespaceKey(ns)}`;
+	return {
+		namespace: computed(() => ns),
+		key: computed(() => staticKey),
+		isRootSignal: computed(() => isRoot(ns))
+	};
+}
+/**
+* Subscribe to a scoped `messages` stream.
+*
+* Contract:
+*  - At the root (no `target`) this returns `stream.messages` — the
+*    always-on root projection; no extra subscription is opened.
+*  - For any non-root namespace, call-time triggers a ref-counted
+*    `messages` subscription scoped to that namespace. The
+*    subscription is released automatically when the calling
+*    component / service is destroyed (and the registry closes the
+*    underlying server subscription when the last consumer leaves).
+*
+* Messages are always `BaseMessage` class instances from
+* `@langchain/core/messages`.
+*/
+function injectMessages(stream, target) {
+	const { namespace, key, isRootSignal } = normalizeTarget(target, "messages");
+	const scoped = injectProjection(computed(() => isRootSignal() ? null : getRegistry(stream)), () => messagesProjection(namespace()), key, EMPTY_MESSAGES);
+	return computed(() => isRootSignal() ? stream.messages() : scoped());
+}
+const EMPTY_MESSAGES = [];
+/**
+* Subscribe to a scoped `tools` (tool-call) stream. Same target and
+* lifecycle rules as {@link injectMessages}; at the root this returns
+* `stream.toolCalls` directly.
+*/
+function injectToolCalls(stream, target) {
+	const { namespace, key, isRootSignal } = normalizeTarget(target, "toolCalls");
+	const scoped = injectProjection(computed(() => isRootSignal() ? null : getRegistry(stream)), () => toolCallsProjection(namespace()), key, EMPTY_TOOLCALLS);
+	return computed(() => isRootSignal() ? stream.toolCalls() : scoped());
+}
+const EMPTY_TOOLCALLS = [];
+function injectValues(stream, target, options) {
+	const messagesKey = options?.messagesKey ?? "messages";
+	const { namespace, key, isRootSignal } = normalizeTarget(target, `values|${messagesKey}`);
+	const scoped = injectProjection(computed(() => isRootSignal() ? null : getRegistry(stream)), () => valuesProjection(namespace(), messagesKey), key, void 0);
+	return computed(() => isRootSignal() ? stream.values() : scoped());
+}
+/**
+* Subscribe to a `custom:<name>` stream extension — the most recent
+* payload emitted by the transformer, scoped to the target namespace.
+*/
+function injectExtension(stream, name, target) {
+	const { namespace, key } = normalizeTarget(target, `extension|${name}`);
+	return injectProjection(getRegistry(stream), () => extensionProjection(name, namespace()), key, void 0);
+}
+function injectChannel(stream, channels, target, options) {
+	const sortedChannels = [...channels].sort().join(",");
+	const { namespace, key } = normalizeTarget(target, `channel|${options?.bufferSize ?? "default"}|${options?.replay ?? true ? "replay" : "live"}|${sortedChannels}`);
+	return injectProjection(getRegistry(stream), () => channelProjection(channels, namespace(), options), key, EMPTY_EVENTS);
+}
+const EMPTY_EVENTS = [];
+/**
+* Subscribe to a scoped audio-media stream. Each handle is yielded
+* on its first matching `content-block-start`, exposes
+* `.partialBytes` for live access, settles `.blob` / `.objectURL` /
+* `.transcript` on `message-finish`, and surfaces errors via
+* `.error`.
+*
+* Pair with `injectMediaUrl` to turn a handle into an `<audio src>`.
+*/
+function injectAudio(stream, target) {
+	const { namespace, key } = normalizeTarget(target, "audio");
+	return injectProjection(getRegistry(stream), () => audioProjection(namespace()), key, EMPTY_AUDIO);
+}
+const EMPTY_AUDIO = [];
+/**
+* Subscribe to a scoped image-media stream. Pair with
+* `injectMediaUrl` for `<img src>`.
+*/
+function injectImages(stream, target) {
+	const { namespace, key } = normalizeTarget(target, "images");
+	return injectProjection(getRegistry(stream), () => imagesProjection(namespace()), key, EMPTY_IMAGES);
+}
+const EMPTY_IMAGES = [];
+/**
+* Subscribe to a scoped video-media stream. Pair with
+* `injectMediaUrl` for `<video src>`.
+*/
+function injectVideo(stream, target) {
+	const { namespace, key } = normalizeTarget(target, "video");
+	return injectProjection(getRegistry(stream), () => videoProjection(namespace()), key, EMPTY_VIDEO);
+}
+const EMPTY_VIDEO = [];
+/**
+* Subscribe to a scoped file-media stream. Pair with
+* `injectMediaUrl` for an `<a download href>` target.
+*/
+function injectFiles(stream, target) {
+	const { namespace, key } = normalizeTarget(target, "files");
+	return injectProjection(getRegistry(stream), () => filesProjection(namespace()), key, EMPTY_FILES);
+}
+const EMPTY_FILES = [];
+//#endregion
+export { injectAudio, injectChannel, injectExtension, injectFiles, injectImages, injectMessages, injectToolCalls, injectValues, injectVideo };
+
+//# sourceMappingURL=selectors.js.map

package/dist/selectors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectors.js","names":[],"sources":["../src/selectors.ts"],"sourcesContent":["import { computed, isSignal, type Signal } from \"@angular/core\";\nimport type { BaseMessage } from \"@langchain/core/messages\";\nimport {\n  NAMESPACE_SEPARATOR,\n  audioProjection,\n  channelProjection,\n  extensionProjection,\n  filesProjection,\n  imagesProjection,\n  messagesProjection,\n  toolCallsProjection,\n  valuesProjection,\n  videoProjection,\n  type AssembledToolCall,\n  type AudioMedia,\n  type Channel,\n  type ChannelProjectionOptions,\n  type Event,\n  type FileMedia,\n  type ImageMedia,\n  type InferStateType,\n  type SubagentDiscoverySnapshot,\n  type SubgraphDiscoverySnapshot,\n  type VideoMedia,\n} from \"@langchain/langgraph-sdk/stream\";\nimport {\n  getRegistry,\n  type AnyStream,\n  type UseStreamReturn,\n} from \"./use-stream.js\";\nimport { injectProjection } from \"./inject-projection.js\";\n\n/**\n * Selector primitives don't need to carry `InterruptType` /\n * `ConfigurableType`. Parameterising on `StateType` alone lets\n * callers with a full `injectStream<S, I, C>()` handle pass it in\n * without redeclaring those generics at every call site.\n */\ntype StreamHandle<StateType extends object> = UseStreamReturn<\n  StateType,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  any,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  any\n>;\n\n/**\n * What a selector primitive can be targeted at. Callers can pass:\n *  - `undefined` / `null` — root namespace (served by the always-on\n *    root store — no extra subscription);\n *  - a {@link SubagentDiscoverySnapshot} (`stream.subagents().get(...)`);\n *  - a {@link SubgraphDiscoverySnapshot} (`stream.subgraphs().get(...)`);\n *  - an explicit `{ namespace: string[] }`;\n *  - a raw `string[]` escape hatch.\n *\n * Selectors also accept a `Signal<SelectorTarget>` so callers can\n * feed a `computed(() => ...)` and have the projection rebind\n * automatically.\n */\nexport type SelectorTarget =\n  | undefined\n  | null\n  | readonly string[]\n  | { namespace: readonly string[] }\n  | SubagentDiscoverySnapshot\n  | SubgraphDiscoverySnapshot;\n\nconst EMPTY_NAMESPACE: readonly string[] = [];\n\nfunction resolveNamespace(target: SelectorTarget): readonly string[] {\n  if (target == null) return EMPTY_NAMESPACE;\n  if (Array.isArray(target)) return target as readonly string[];\n  const obj = target as { namespace?: readonly string[] };\n  return obj.namespace ?? EMPTY_NAMESPACE;\n}\n\nfunction isRoot(namespace: readonly string[]): boolean {\n  return namespace.length === 0;\n}\n\nfunction namespaceKey(namespace: readonly string[]): string {\n  return namespace.join(NAMESPACE_SEPARATOR);\n}\n\n/**\n * Resolve a target or target-signal into a reactive\n * `[namespace, key]` pair. The helper returns plain signals so\n * `injectProjection` can track them via its internal effect.\n */\nfunction normalizeTarget(\n  target: SelectorTarget | Signal<SelectorTarget>,\n  prefix: string\n): {\n  namespace: Signal<readonly string[]>;\n  key: Signal<string>;\n  isRootSignal: Signal<boolean>;\n} {\n  if (isSignal(target)) {\n    const namespace = computed(() =>\n      resolveNamespace((target as Signal<SelectorTarget>)())\n    );\n    const key = computed(() => `${prefix}|${namespaceKey(namespace())}`);\n    const isRootSignal = computed(() => isRoot(namespace()));\n    return { namespace, key, isRootSignal };\n  }\n  const ns = resolveNamespace(target as SelectorTarget);\n  const staticKey = `${prefix}|${namespaceKey(ns)}`;\n  return {\n    namespace: computed(() => ns),\n    key: computed(() => staticKey),\n    isRootSignal: computed(() => isRoot(ns)),\n  };\n}\n\n/**\n * Subscribe to a scoped `messages` stream.\n *\n * Contract:\n *  - At the root (no `target`) this returns `stream.messages` — the\n *    always-on root projection; no extra subscription is opened.\n *  - For any non-root namespace, call-time triggers a ref-counted\n *    `messages` subscription scoped to that namespace. The\n *    subscription is released automatically when the calling\n *    component / service is destroyed (and the registry closes the\n *    underlying server subscription when the last consumer leaves).\n *\n * Messages are always `BaseMessage` class instances from\n * `@langchain/core/messages`.\n */\nexport function injectMessages(\n  stream: AnyStream,\n  target?: SelectorTarget | Signal<SelectorTarget>\n): Signal<BaseMessage[]> {\n  const { namespace, key, isRootSignal } = normalizeTarget(\n    target as SelectorTarget | Signal<SelectorTarget>,\n    \"messages\"\n  );\n  const registry = computed(() =>\n    isRootSignal() ? null : getRegistry(stream)\n  );\n  const scoped = injectProjection<BaseMessage[]>(\n    registry,\n    () => messagesProjection(namespace()),\n    key,\n    EMPTY_MESSAGES\n  );\n  return computed(() => (isRootSignal() ? stream.messages() : scoped()));\n}\n\nconst EMPTY_MESSAGES: BaseMessage[] = [];\n\n/**\n * Subscribe to a scoped `tools` (tool-call) stream. Same target and\n * lifecycle rules as {@link injectMessages}; at the root this returns\n * `stream.toolCalls` directly.\n */\nexport function injectToolCalls(\n  stream: AnyStream,\n  target?: SelectorTarget | Signal<SelectorTarget>\n): Signal<AssembledToolCall[]> {\n  const { namespace, key, isRootSignal } = normalizeTarget(\n    target as SelectorTarget | Signal<SelectorTarget>,\n    \"toolCalls\"\n  );\n  const registry = computed(() =>\n    isRootSignal() ? null : getRegistry(stream)\n  );\n  const scoped = injectProjection<AssembledToolCall[]>(\n    registry,\n    () => toolCallsProjection(namespace()),\n    key,\n    EMPTY_TOOLCALLS\n  );\n  return computed(() => (isRootSignal() ? stream.toolCalls() : scoped()));\n}\n\nconst EMPTY_TOOLCALLS: AssembledToolCall[] = [];\n\n/**\n * Subscribe to a scoped `values` stream — the most recent state\n * payload for a namespace. At the root returns `stream.values`.\n *\n * Typing:\n *  - **Root** (`injectValues(stream)`): returns the `StateType`\n *    declared on `injectStream<State>()` — non-nullable (the root\n *    snapshot always has values, falling back to `initialValues ??\n *    {}`).\n *  - **Scoped** (`injectValues(stream, target)`): scoped payloads can\n *    differ from the root state; callers should annotate the expected\n *    shape explicitly (`injectValues<SubagentState>(stream, sub)`).\n *    Defaults to `unknown` when not annotated.\n */\nexport function injectValues<StateType extends object>(\n  stream: StreamHandle<StateType>\n): Signal<StateType>;\nexport function injectValues<T>(stream: AnyStream): Signal<InferStateType<T>>;\nexport function injectValues<T = unknown>(\n  stream: AnyStream,\n  target: SelectorTarget | Signal<SelectorTarget>,\n  options?: { messagesKey?: string }\n): Signal<T | undefined>;\nexport function injectValues(\n  stream: AnyStream,\n  target?: SelectorTarget | Signal<SelectorTarget>,\n  options?: { messagesKey?: string }\n): Signal<unknown> {\n  const messagesKey = options?.messagesKey ?? \"messages\";\n  const { namespace, key, isRootSignal } = normalizeTarget(\n    target as SelectorTarget | Signal<SelectorTarget>,\n    `values|${messagesKey}`\n  );\n  const registry = computed(() =>\n    isRootSignal() ? null : getRegistry(stream)\n  );\n  const scoped = injectProjection<unknown>(\n    registry,\n    () => valuesProjection<unknown>(namespace(), messagesKey),\n    key,\n    undefined\n  );\n  return computed(() => (isRootSignal() ? stream.values() : scoped()));\n}\n\n/**\n * Subscribe to a `custom:<name>` stream extension — the most recent\n * payload emitted by the transformer, scoped to the target namespace.\n */\nexport function injectExtension<T = unknown>(\n  stream: AnyStream,\n  name: string,\n  target?: SelectorTarget | Signal<SelectorTarget>\n): Signal<T | undefined> {\n  const { namespace, key } = normalizeTarget(\n    target as SelectorTarget | Signal<SelectorTarget>,\n    `extension|${name}`\n  );\n  return injectProjection<T | undefined>(\n    getRegistry(stream),\n    () => extensionProjection<T>(name, namespace()),\n    key,\n    undefined\n  );\n}\n\n/**\n * Raw-events escape hatch. Subscribes to one or more channels at a\n * namespace and returns a bounded buffer of raw protocol events.\n * Prefer {@link injectMessages} / {@link injectToolCalls} /\n * {@link injectValues} for the common cases.\n */\nexport type InjectChannelOptions = ChannelProjectionOptions;\n\nexport function injectChannel(\n  stream: AnyStream,\n  channels: readonly Channel[],\n  target?: SelectorTarget | Signal<SelectorTarget>,\n  options?: InjectChannelOptions\n): Signal<Event[]> {\n  const sortedChannels = [...channels].sort().join(\",\");\n  const prefix = `channel|${options?.bufferSize ?? \"default\"}|${(options?.replay ?? true) ? \"replay\" : \"live\"}|${sortedChannels}`;\n  const { namespace, key } = normalizeTarget(\n    target as SelectorTarget | Signal<SelectorTarget>,\n    prefix\n  );\n  return injectProjection<Event[]>(\n    getRegistry(stream),\n    () => channelProjection(channels, namespace(), options),\n    key,\n    EMPTY_EVENTS\n  );\n}\n\nconst EMPTY_EVENTS: Event[] = [];\n\n/**\n * Subscribe to a scoped audio-media stream. Each handle is yielded\n * on its first matching `content-block-start`, exposes\n * `.partialBytes` for live access, settles `.blob` / `.objectURL` /\n * `.transcript` on `message-finish`, and surfaces errors via\n * `.error`.\n *\n * Pair with `injectMediaUrl` to turn a handle into an `<audio src>`.\n */\nexport function injectAudio(\n  stream: AnyStream,\n  target?: SelectorTarget | Signal<SelectorTarget>\n): Signal<AudioMedia[]> {\n  const { namespace, key } = normalizeTarget(\n    target as SelectorTarget | Signal<SelectorTarget>,\n    \"audio\"\n  );\n  return injectProjection<AudioMedia[]>(\n    getRegistry(stream),\n    () => audioProjection(namespace()),\n    key,\n    EMPTY_AUDIO\n  );\n}\n\nconst EMPTY_AUDIO: AudioMedia[] = [];\n\n/**\n * Subscribe to a scoped image-media stream. Pair with\n * `injectMediaUrl` for `<img src>`.\n */\nexport function injectImages(\n  stream: AnyStream,\n  target?: SelectorTarget | Signal<SelectorTarget>\n): Signal<ImageMedia[]> {\n  const { namespace, key } = normalizeTarget(\n    target as SelectorTarget | Signal<SelectorTarget>,\n    \"images\"\n  );\n  return injectProjection<ImageMedia[]>(\n    getRegistry(stream),\n    () => imagesProjection(namespace()),\n    key,\n    EMPTY_IMAGES\n  );\n}\n\nconst EMPTY_IMAGES: ImageMedia[] = [];\n\n/**\n * Subscribe to a scoped video-media stream. Pair with\n * `injectMediaUrl` for `<video src>`.\n */\nexport function injectVideo(\n  stream: AnyStream,\n  target?: SelectorTarget | Signal<SelectorTarget>\n): Signal<VideoMedia[]> {\n  const { namespace, key } = normalizeTarget(\n    target as SelectorTarget | Signal<SelectorTarget>,\n    \"video\"\n  );\n  return injectProjection<VideoMedia[]>(\n    getRegistry(stream),\n    () => videoProjection(namespace()),\n    key,\n    EMPTY_VIDEO\n  );\n}\n\nconst EMPTY_VIDEO: VideoMedia[] = [];\n\n/**\n * Subscribe to a scoped file-media stream. Pair with\n * `injectMediaUrl` for an `<a download href>` target.\n */\nexport function injectFiles(\n  stream: AnyStream,\n  target?: SelectorTarget | Signal<SelectorTarget>\n): Signal<FileMedia[]> {\n  const { namespace, key } = normalizeTarget(\n    target as SelectorTarget | Signal<SelectorTarget>,\n    \"files\"\n  );\n  return injectProjection<FileMedia[]>(\n    getRegistry(stream),\n    () => filesProjection(namespace()),\n    key,\n    EMPTY_FILES\n  );\n}\n\nconst EMPTY_FILES: FileMedia[] = [];\n"],"mappings":"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"}

package/dist/stream-service.cjs

@@ -0,0 +1,84 @@
+const require_use_stream = require("./use-stream.cjs");
+const require_decorate = require("./_virtual/_@oxc-project_runtime@0.115.0/helpers/decorate.cjs");
+let _angular_core = require("@angular/core");
+//#region src/stream-service.ts
+let StreamService = class StreamService {
+	/** Underlying `StreamApi` returned by {@link useStream}. */
+	stream;
+	constructor(options) {
+		const injector = (0, _angular_core.inject)(_angular_core.EnvironmentInjector);
+		const destroyRef = (0, _angular_core.inject)(_angular_core.DestroyRef);
+		this.stream = (0, _angular_core.runInInjectionContext)(injector, () => require_use_stream.useStream(options, destroyRef));
+	}
+	get values() {
+		return this.stream.values;
+	}
+	get messages() {
+		return this.stream.messages;
+	}
+	get toolCalls() {
+		return this.stream.toolCalls;
+	}
+	get interrupts() {
+		return this.stream.interrupts;
+	}
+	get interrupt() {
+		return this.stream.interrupt;
+	}
+	get isLoading() {
+		return this.stream.isLoading;
+	}
+	get isThreadLoading() {
+		return this.stream.isThreadLoading;
+	}
+	get error() {
+		return this.stream.error;
+	}
+	get threadId() {
+		return this.stream.threadId;
+	}
+	get hydrationPromise() {
+		return this.stream.hydrationPromise;
+	}
+	get subagents() {
+		return this.stream.subagents;
+	}
+	get subgraphs() {
+		return this.stream.subgraphs;
+	}
+	get subgraphsByNode() {
+		return this.stream.subgraphsByNode;
+	}
+	get client() {
+		return this.stream.client;
+	}
+	get assistantId() {
+		return this.stream.assistantId;
+	}
+	submit(input, options) {
+		return this.stream.submit(input, options);
+	}
+	stop() {
+		return this.stream.stop();
+	}
+	respond(response, target) {
+		return this.stream.respond(response, target);
+	}
+	getThread() {
+		return this.stream.getThread();
+	}
+	/** @internal Lets selector primitives resolve the controller. */
+	get [require_use_stream.STREAM_CONTROLLER]() {
+		return this.stream[require_use_stream.STREAM_CONTROLLER];
+	}
+};
+StreamService = require_decorate.__decorate([(0, _angular_core.Injectable)()], StreamService);
+//#endregion
+Object.defineProperty(exports, "StreamService", {
+	enumerable: true,
+	get: function() {
+		return StreamService;
+	}
+});
+
+//# sourceMappingURL=stream-service.cjs.map

package/dist/stream-service.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-service.cjs","names":["EnvironmentInjector","DestroyRef","useStream","STREAM_CONTROLLER"],"sources":["../src/stream-service.ts"],"sourcesContent":["import {\n  DestroyRef,\n  EnvironmentInjector,\n  Injectable,\n  inject,\n  runInInjectionContext,\n  type Signal,\n} from \"@angular/core\";\nimport type { BaseMessage } from \"@langchain/core/messages\";\nimport type { Client, Interrupt } from \"@langchain/langgraph-sdk\";\nimport type {\n  AssembledToolCall,\n  InferStateType,\n  StreamSubmitOptions,\n  SubgraphDiscoverySnapshot,\n  WidenUpdateMessages,\n} from \"@langchain/langgraph-sdk/stream\";\nimport type { ThreadStream } from \"@langchain/langgraph-sdk/client\";\nimport {\n  useStream,\n  STREAM_CONTROLLER,\n  type StreamApi,\n  type UseStreamOptions,\n  type UseStreamReturn,\n} from \"./use-stream.js\";\n\n/**\n * `@Injectable()` wrapper around {@link useStream}. Extend this class\n * with your own service when you want a DI-scoped, shareable\n * {@link StreamApi}:\n *\n * ```ts\n * @Injectable({ providedIn: \"root\" })\n * export class ChatStream extends StreamService<ChatState> {\n *   constructor() {\n *     super({\n *       transport: new HttpAgentServerAdapter({ apiUrl: \"/api/graph\" }),\n *       assistantId: \"chat\",\n *     });\n *   }\n * }\n * ```\n *\n * The service exposes the same `StreamApi` surface as\n * `injectStream()` — read data via signals (`service.messages()`,\n * `service.isLoading()`) and use the imperative methods\n * (`service.submit(...)`, `service.stop()`).\n *\n * Must be instantiated inside an Angular injection context. Its\n * {@link DestroyRef} owns the controller lifetime, so scoping the\n * service to a component tears down the stream when the component\n * is destroyed.\n */\n@Injectable()\nexport class StreamService<\n  T = Record<string, unknown>,\n  InterruptType = unknown,\n  ConfigurableType extends object = Record<string, unknown>,\n> {\n  /** Underlying `StreamApi` returned by {@link useStream}. */\n  readonly stream: UseStreamReturn<T, InterruptType, ConfigurableType>;\n\n  constructor(options: UseStreamOptions<InferStateType<T>>) {\n    const injector = inject(EnvironmentInjector);\n    const destroyRef = inject(DestroyRef);\n    this.stream = runInInjectionContext(injector, () =>\n      useStream<T, InterruptType, ConfigurableType>(options, destroyRef)\n    );\n  }\n\n  // ─── Reactive accessors (pass-through) ────────────────────────────\n\n  get values(): UseStreamReturn<T, InterruptType, ConfigurableType>[\"values\"] {\n    return this.stream.values;\n  }\n\n  get messages(): Signal<BaseMessage[]> {\n    return this.stream.messages;\n  }\n\n  get toolCalls(): Signal<AssembledToolCall[]> {\n    return this.stream.toolCalls;\n  }\n\n  get interrupts(): Signal<Interrupt<InterruptType>[]> {\n    return this.stream.interrupts;\n  }\n\n  get interrupt(): Signal<Interrupt<InterruptType> | undefined> {\n    return this.stream.interrupt;\n  }\n\n  get isLoading(): Signal<boolean> {\n    return this.stream.isLoading;\n  }\n\n  get isThreadLoading(): Signal<boolean> {\n    return this.stream.isThreadLoading;\n  }\n\n  get error(): Signal<unknown> {\n    return this.stream.error;\n  }\n\n  get threadId(): Signal<string | null> {\n    return this.stream.threadId;\n  }\n\n  get hydrationPromise(): Signal<Promise<void>> {\n    return this.stream.hydrationPromise;\n  }\n\n  get subagents(): UseStreamReturn<\n    T,\n    InterruptType,\n    ConfigurableType\n  >[\"subagents\"] {\n    return this.stream.subagents;\n  }\n\n  get subgraphs(): Signal<ReadonlyMap<string, SubgraphDiscoverySnapshot>> {\n    return this.stream.subgraphs;\n  }\n\n  get subgraphsByNode(): Signal<\n    ReadonlyMap<string, readonly SubgraphDiscoverySnapshot[]>\n  > {\n    return this.stream.subgraphsByNode;\n  }\n\n  // ─── Identity ─────────────────────────────────────────────────────\n\n  get client(): Client {\n    return this.stream.client;\n  }\n\n  get assistantId(): string {\n    return this.stream.assistantId;\n  }\n\n  // ─── Imperatives ──────────────────────────────────────────────────\n\n  submit(\n    input: WidenUpdateMessages<Partial<InferStateType<T>>> | null | undefined,\n    options?: StreamSubmitOptions<InferStateType<T>, ConfigurableType>\n  ): Promise<void> {\n    return this.stream.submit(\n      input as Parameters<this[\"stream\"][\"submit\"]>[0],\n      options as Parameters<this[\"stream\"][\"submit\"]>[1]\n    );\n  }\n\n  stop(): Promise<void> {\n    return this.stream.stop();\n  }\n\n  respond(\n    response: unknown,\n    target?: { interruptId: string; namespace?: string[] }\n  ): Promise<void> {\n    return this.stream.respond(response, target);\n  }\n\n  getThread(): ThreadStream | undefined {\n    return this.stream.getThread();\n  }\n\n  /** @internal Lets selector primitives resolve the controller. */\n  get [STREAM_CONTROLLER](): StreamApi<\n    T,\n    InterruptType,\n    ConfigurableType\n  >[typeof STREAM_CONTROLLER] {\n    return this.stream[STREAM_CONTROLLER];\n  }\n}\n"],"mappings":";;;;AAsDO,IAAA,gBAAA,MAAM,cAIX;;CAEA;CAEA,YAAY,SAA8C;EACxD,MAAM,YAAA,GAAA,cAAA,QAAkBA,cAAAA,oBAAoB;EAC5C,MAAM,cAAA,GAAA,cAAA,QAAoBC,cAAAA,WAAW;AACrC,OAAK,UAAA,GAAA,cAAA,uBAA+B,gBAClCC,mBAAAA,UAA8C,SAAS,WAAW,CACnE;;CAKH,IAAI,SAAwE;AAC1E,SAAO,KAAK,OAAO;;CAGrB,IAAI,WAAkC;AACpC,SAAO,KAAK,OAAO;;CAGrB,IAAI,YAAyC;AAC3C,SAAO,KAAK,OAAO;;CAGrB,IAAI,aAAiD;AACnD,SAAO,KAAK,OAAO;;CAGrB,IAAI,YAA0D;AAC5D,SAAO,KAAK,OAAO;;CAGrB,IAAI,YAA6B;AAC/B,SAAO,KAAK,OAAO;;CAGrB,IAAI,kBAAmC;AACrC,SAAO,KAAK,OAAO;;CAGrB,IAAI,QAAyB;AAC3B,SAAO,KAAK,OAAO;;CAGrB,IAAI,WAAkC;AACpC,SAAO,KAAK,OAAO;;CAGrB,IAAI,mBAA0C;AAC5C,SAAO,KAAK,OAAO;;CAGrB,IAAI,YAIW;AACb,SAAO,KAAK,OAAO;;CAGrB,IAAI,YAAoE;AACtE,SAAO,KAAK,OAAO;;CAGrB,IAAI,kBAEF;AACA,SAAO,KAAK,OAAO;;CAKrB,IAAI,SAAiB;AACnB,SAAO,KAAK,OAAO;;CAGrB,IAAI,cAAsB;AACxB,SAAO,KAAK,OAAO;;CAKrB,OACE,OACA,SACe;AACf,SAAO,KAAK,OAAO,OACjB,OACA,QACD;;CAGH,OAAsB;AACpB,SAAO,KAAK,OAAO,MAAM;;CAG3B,QACE,UACA,QACe;AACf,SAAO,KAAK,OAAO,QAAQ,UAAU,OAAO;;CAG9C,YAAsC;AACpC,SAAO,KAAK,OAAO,WAAW;;;CAIhC,KAAKC,mBAAAA,qBAIuB;AAC1B,SAAO,KAAK,OAAOA,mBAAAA;;;4EAxHV,CAAA,EAAA,cAAA"}

package/dist/stream-service.d.cts

@@ -0,0 +1,67 @@
+import { STREAM_CONTROLLER, StreamApi, UseStreamOptions as UseStreamOptions$1, UseStreamReturn } from "./use-stream.cjs";
+import { AssembledToolCall, InferStateType, StreamSubmitOptions, SubgraphDiscoverySnapshot, WidenUpdateMessages } from "@langchain/langgraph-sdk/stream";
+import { Signal } from "@angular/core";
+import { BaseMessage } from "@langchain/core/messages";
+import { Client, Interrupt } from "@langchain/langgraph-sdk";
+import { ThreadStream } from "@langchain/langgraph-sdk/client";
+
+//#region src/stream-service.d.ts
+/**
+ * `@Injectable()` wrapper around {@link useStream}. Extend this class
+ * with your own service when you want a DI-scoped, shareable
+ * {@link StreamApi}:
+ *
+ * ```ts
+ * @Injectable({ providedIn: "root" })
+ * export class ChatStream extends StreamService<ChatState> {
+ *   constructor() {
+ *     super({
+ *       transport: new HttpAgentServerAdapter({ apiUrl: "/api/graph" }),
+ *       assistantId: "chat",
+ *     });
+ *   }
+ * }
+ * ```
+ *
+ * The service exposes the same `StreamApi` surface as
+ * `injectStream()` — read data via signals (`service.messages()`,
+ * `service.isLoading()`) and use the imperative methods
+ * (`service.submit(...)`, `service.stop()`).
+ *
+ * Must be instantiated inside an Angular injection context. Its
+ * {@link DestroyRef} owns the controller lifetime, so scoping the
+ * service to a component tears down the stream when the component
+ * is destroyed.
+ */
+declare class StreamService<T = Record<string, unknown>, InterruptType = unknown, ConfigurableType extends object = Record<string, unknown>> {
+  /** Underlying `StreamApi` returned by {@link useStream}. */
+  readonly stream: UseStreamReturn<T, InterruptType, ConfigurableType>;
+  constructor(options: UseStreamOptions$1<InferStateType<T>>);
+  get values(): UseStreamReturn<T, InterruptType, ConfigurableType>["values"];
+  get messages(): Signal<BaseMessage[]>;
+  get toolCalls(): Signal<AssembledToolCall[]>;
+  get interrupts(): Signal<Interrupt<InterruptType>[]>;
+  get interrupt(): Signal<Interrupt<InterruptType> | undefined>;
+  get isLoading(): Signal<boolean>;
+  get isThreadLoading(): Signal<boolean>;
+  get error(): Signal<unknown>;
+  get threadId(): Signal<string | null>;
+  get hydrationPromise(): Signal<Promise<void>>;
+  get subagents(): UseStreamReturn<T, InterruptType, ConfigurableType>["subagents"];
+  get subgraphs(): Signal<ReadonlyMap<string, SubgraphDiscoverySnapshot>>;
+  get subgraphsByNode(): Signal<ReadonlyMap<string, readonly SubgraphDiscoverySnapshot[]>>;
+  get client(): Client;
+  get assistantId(): string;
+  submit(input: WidenUpdateMessages<Partial<InferStateType<T>>> | null | undefined, options?: StreamSubmitOptions<InferStateType<T>, ConfigurableType>): Promise<void>;
+  stop(): Promise<void>;
+  respond(response: unknown, target?: {
+    interruptId: string;
+    namespace?: string[];
+  }): Promise<void>;
+  getThread(): ThreadStream | undefined;
+  /** @internal Lets selector primitives resolve the controller. */
+  get [STREAM_CONTROLLER](): StreamApi<T, InterruptType, ConfigurableType>[typeof STREAM_CONTROLLER];
+}
+//#endregion
+export { StreamService };
+//# sourceMappingURL=stream-service.d.cts.map

package/dist/stream-service.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-service.d.cts","names":[],"sources":["../src/stream-service.ts"],"mappings":";;;;;;;;;;AAqDA;;;;;;;;;;;;;;;;;;;;;;;;;cACa,aAAA,KACP,MAAA,8EAE8B,MAAA;EAmCjB;EAAA,SAhCR,MAAA,EAAQ,eAAA,CAAgB,CAAA,EAAG,aAAA,EAAe,gBAAA;EAEnD,WAAA,CAAY,OAAA,EAAS,kBAAA,CAAiB,cAAA,CAAe,CAAA;EAAA,IAUjD,MAAA,CAAA,GAAU,eAAA,CAAgB,CAAA,EAAG,aAAA,EAAe,gBAAA;EAAA,IAI5C,QAAA,CAAA,GAAY,MAAA,CAAO,WAAA;EAAA,IAInB,SAAA,CAAA,GAAa,MAAA,CAAO,iBAAA;EAAA,IAIpB,UAAA,CAAA,GAAc,MAAA,CAAO,SAAA,CAAU,aAAA;EAAA,IAI/B,SAAA,CAAA,GAAa,MAAA,CAAO,SAAA,CAAU,aAAA;EAAA,IAI9B,SAAA,CAAA,GAAa,MAAA;EAAA,IAIb,eAAA,CAAA,GAAmB,MAAA;EAAA,IAInB,KAAA,CAAA,GAAS,MAAA;EAAA,IAIT,QAAA,CAAA,GAAY,MAAA;EAAA,IAIZ,gBAAA,CAAA,GAAoB,MAAA,CAAO,OAAA;EAAA,IAI3B,SAAA,CAAA,GAAa,eAAA,CACf,CAAA,EACA,aAAA,EACA,gBAAA;EAAA,IAKE,SAAA,CAAA,GAAa,MAAA,CAAO,WAAA,SAAoB,yBAAA;EAAA,IAIxC,eAAA,CAAA,GAAmB,MAAA,CACrB,WAAA,kBAA6B,yBAAA;EAAA,IAO3B,MAAA,CAAA,GAAU,MAAA;EAAA,IAIV,WAAA,CAAA;EAMJ,MAAA,CACE,KAAA,EAAO,mBAAA,CAAoB,OAAA,CAAQ,cAAA,CAAe,CAAA,wBAClD,OAAA,GAAU,mBAAA,CAAoB,cAAA,CAAe,CAAA,GAAI,gBAAA,IAChD,OAAA;EAOH,IAAA,CAAA,GAAQ,OAAA;EAIR,OAAA,CACE,QAAA,WACA,MAAA;IAAW,WAAA;IAAqB,SAAA;EAAA,IAC/B,OAAA;EAIH,SAAA,CAAA,GAAa,YAAA;EAlBV;EAAA,KAuBE,iBAAA,KAAsB,SAAA,CACzB,CAAA,EACA,aAAA,EACA,gBAAA,SACO,iBAAA;AAAA"}

package/dist/stream-service.d.ts

@@ -0,0 +1,67 @@
+import { STREAM_CONTROLLER, StreamApi, UseStreamOptions as UseStreamOptions$1, UseStreamReturn } from "./use-stream.js";
+import { Signal } from "@angular/core";
+import { Client, Interrupt } from "@langchain/langgraph-sdk";
+import { ThreadStream } from "@langchain/langgraph-sdk/client";
+import { AssembledToolCall, InferStateType, StreamSubmitOptions, SubgraphDiscoverySnapshot, WidenUpdateMessages } from "@langchain/langgraph-sdk/stream";
+import { BaseMessage } from "@langchain/core/messages";
+
+//#region src/stream-service.d.ts
+/**
+ * `@Injectable()` wrapper around {@link useStream}. Extend this class
+ * with your own service when you want a DI-scoped, shareable
+ * {@link StreamApi}:
+ *
+ * ```ts
+ * @Injectable({ providedIn: "root" })
+ * export class ChatStream extends StreamService<ChatState> {
+ *   constructor() {
+ *     super({
+ *       transport: new HttpAgentServerAdapter({ apiUrl: "/api/graph" }),
+ *       assistantId: "chat",
+ *     });
+ *   }
+ * }
+ * ```
+ *
+ * The service exposes the same `StreamApi` surface as
+ * `injectStream()` — read data via signals (`service.messages()`,
+ * `service.isLoading()`) and use the imperative methods
+ * (`service.submit(...)`, `service.stop()`).
+ *
+ * Must be instantiated inside an Angular injection context. Its
+ * {@link DestroyRef} owns the controller lifetime, so scoping the
+ * service to a component tears down the stream when the component
+ * is destroyed.
+ */
+declare class StreamService<T = Record<string, unknown>, InterruptType = unknown, ConfigurableType extends object = Record<string, unknown>> {
+  /** Underlying `StreamApi` returned by {@link useStream}. */
+  readonly stream: UseStreamReturn<T, InterruptType, ConfigurableType>;
+  constructor(options: UseStreamOptions$1<InferStateType<T>>);
+  get values(): UseStreamReturn<T, InterruptType, ConfigurableType>["values"];
+  get messages(): Signal<BaseMessage[]>;
+  get toolCalls(): Signal<AssembledToolCall[]>;
+  get interrupts(): Signal<Interrupt<InterruptType>[]>;
+  get interrupt(): Signal<Interrupt<InterruptType> | undefined>;
+  get isLoading(): Signal<boolean>;
+  get isThreadLoading(): Signal<boolean>;
+  get error(): Signal<unknown>;
+  get threadId(): Signal<string | null>;
+  get hydrationPromise(): Signal<Promise<void>>;
+  get subagents(): UseStreamReturn<T, InterruptType, ConfigurableType>["subagents"];
+  get subgraphs(): Signal<ReadonlyMap<string, SubgraphDiscoverySnapshot>>;
+  get subgraphsByNode(): Signal<ReadonlyMap<string, readonly SubgraphDiscoverySnapshot[]>>;
+  get client(): Client;
+  get assistantId(): string;
+  submit(input: WidenUpdateMessages<Partial<InferStateType<T>>> | null | undefined, options?: StreamSubmitOptions<InferStateType<T>, ConfigurableType>): Promise<void>;
+  stop(): Promise<void>;
+  respond(response: unknown, target?: {
+    interruptId: string;
+    namespace?: string[];
+  }): Promise<void>;
+  getThread(): ThreadStream | undefined;
+  /** @internal Lets selector primitives resolve the controller. */
+  get [STREAM_CONTROLLER](): StreamApi<T, InterruptType, ConfigurableType>[typeof STREAM_CONTROLLER];
+}
+//#endregion
+export { StreamService };
+//# sourceMappingURL=stream-service.d.ts.map

package/dist/stream-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-service.d.ts","names":[],"sources":["../src/stream-service.ts"],"mappings":";;;;;;;;;;AAqDA;;;;;;;;;;;;;;;;;;;;;;;;;cACa,aAAA,KACP,MAAA,8EAE8B,MAAA;EAmCjB;EAAA,SAhCR,MAAA,EAAQ,eAAA,CAAgB,CAAA,EAAG,aAAA,EAAe,gBAAA;EAEnD,WAAA,CAAY,OAAA,EAAS,kBAAA,CAAiB,cAAA,CAAe,CAAA;EAAA,IAUjD,MAAA,CAAA,GAAU,eAAA,CAAgB,CAAA,EAAG,aAAA,EAAe,gBAAA;EAAA,IAI5C,QAAA,CAAA,GAAY,MAAA,CAAO,WAAA;EAAA,IAInB,SAAA,CAAA,GAAa,MAAA,CAAO,iBAAA;EAAA,IAIpB,UAAA,CAAA,GAAc,MAAA,CAAO,SAAA,CAAU,aAAA;EAAA,IAI/B,SAAA,CAAA,GAAa,MAAA,CAAO,SAAA,CAAU,aAAA;EAAA,IAI9B,SAAA,CAAA,GAAa,MAAA;EAAA,IAIb,eAAA,CAAA,GAAmB,MAAA;EAAA,IAInB,KAAA,CAAA,GAAS,MAAA;EAAA,IAIT,QAAA,CAAA,GAAY,MAAA;EAAA,IAIZ,gBAAA,CAAA,GAAoB,MAAA,CAAO,OAAA;EAAA,IAI3B,SAAA,CAAA,GAAa,eAAA,CACf,CAAA,EACA,aAAA,EACA,gBAAA;EAAA,IAKE,SAAA,CAAA,GAAa,MAAA,CAAO,WAAA,SAAoB,yBAAA;EAAA,IAIxC,eAAA,CAAA,GAAmB,MAAA,CACrB,WAAA,kBAA6B,yBAAA;EAAA,IAO3B,MAAA,CAAA,GAAU,MAAA;EAAA,IAIV,WAAA,CAAA;EAMJ,MAAA,CACE,KAAA,EAAO,mBAAA,CAAoB,OAAA,CAAQ,cAAA,CAAe,CAAA,wBAClD,OAAA,GAAU,mBAAA,CAAoB,cAAA,CAAe,CAAA,GAAI,gBAAA,IAChD,OAAA;EAOH,IAAA,CAAA,GAAQ,OAAA;EAIR,OAAA,CACE,QAAA,WACA,MAAA;IAAW,WAAA;IAAqB,SAAA;EAAA,IAC/B,OAAA;EAIH,SAAA,CAAA,GAAa,YAAA;EAlBV;EAAA,KAuBE,iBAAA,KAAsB,SAAA,CACzB,CAAA,EACA,aAAA,EACA,gBAAA,SACO,iBAAA;AAAA"}

package/dist/stream-service.js

@@ -0,0 +1,79 @@
+import { STREAM_CONTROLLER, useStream } from "./use-stream.js";
+import { __decorate } from "./_virtual/_@oxc-project_runtime@0.115.0/helpers/decorate.js";
+import { DestroyRef, EnvironmentInjector, Injectable, inject, runInInjectionContext } from "@angular/core";
+//#region src/stream-service.ts
+let StreamService = class StreamService {
+	/** Underlying `StreamApi` returned by {@link useStream}. */
+	stream;
+	constructor(options) {
+		const injector = inject(EnvironmentInjector);
+		const destroyRef = inject(DestroyRef);
+		this.stream = runInInjectionContext(injector, () => useStream(options, destroyRef));
+	}
+	get values() {
+		return this.stream.values;
+	}
+	get messages() {
+		return this.stream.messages;
+	}
+	get toolCalls() {
+		return this.stream.toolCalls;
+	}
+	get interrupts() {
+		return this.stream.interrupts;
+	}
+	get interrupt() {
+		return this.stream.interrupt;
+	}
+	get isLoading() {
+		return this.stream.isLoading;
+	}
+	get isThreadLoading() {
+		return this.stream.isThreadLoading;
+	}
+	get error() {
+		return this.stream.error;
+	}
+	get threadId() {
+		return this.stream.threadId;
+	}
+	get hydrationPromise() {
+		return this.stream.hydrationPromise;
+	}
+	get subagents() {
+		return this.stream.subagents;
+	}
+	get subgraphs() {
+		return this.stream.subgraphs;
+	}
+	get subgraphsByNode() {
+		return this.stream.subgraphsByNode;
+	}
+	get client() {
+		return this.stream.client;
+	}
+	get assistantId() {
+		return this.stream.assistantId;
+	}
+	submit(input, options) {
+		return this.stream.submit(input, options);
+	}
+	stop() {
+		return this.stream.stop();
+	}
+	respond(response, target) {
+		return this.stream.respond(response, target);
+	}
+	getThread() {
+		return this.stream.getThread();
+	}
+	/** @internal Lets selector primitives resolve the controller. */
+	get [STREAM_CONTROLLER]() {
+		return this.stream[STREAM_CONTROLLER];
+	}
+};
+StreamService = __decorate([Injectable()], StreamService);
+//#endregion
+export { StreamService };
+
+//# sourceMappingURL=stream-service.js.map

package/dist/stream-service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-service.js","names":[],"sources":["../src/stream-service.ts"],"sourcesContent":["import {\n  DestroyRef,\n  EnvironmentInjector,\n  Injectable,\n  inject,\n  runInInjectionContext,\n  type Signal,\n} from \"@angular/core\";\nimport type { BaseMessage } from \"@langchain/core/messages\";\nimport type { Client, Interrupt } from \"@langchain/langgraph-sdk\";\nimport type {\n  AssembledToolCall,\n  InferStateType,\n  StreamSubmitOptions,\n  SubgraphDiscoverySnapshot,\n  WidenUpdateMessages,\n} from \"@langchain/langgraph-sdk/stream\";\nimport type { ThreadStream } from \"@langchain/langgraph-sdk/client\";\nimport {\n  useStream,\n  STREAM_CONTROLLER,\n  type StreamApi,\n  type UseStreamOptions,\n  type UseStreamReturn,\n} from \"./use-stream.js\";\n\n/**\n * `@Injectable()` wrapper around {@link useStream}. Extend this class\n * with your own service when you want a DI-scoped, shareable\n * {@link StreamApi}:\n *\n * ```ts\n * @Injectable({ providedIn: \"root\" })\n * export class ChatStream extends StreamService<ChatState> {\n *   constructor() {\n *     super({\n *       transport: new HttpAgentServerAdapter({ apiUrl: \"/api/graph\" }),\n *       assistantId: \"chat\",\n *     });\n *   }\n * }\n * ```\n *\n * The service exposes the same `StreamApi` surface as\n * `injectStream()` — read data via signals (`service.messages()`,\n * `service.isLoading()`) and use the imperative methods\n * (`service.submit(...)`, `service.stop()`).\n *\n * Must be instantiated inside an Angular injection context. Its\n * {@link DestroyRef} owns the controller lifetime, so scoping the\n * service to a component tears down the stream when the component\n * is destroyed.\n */\n@Injectable()\nexport class StreamService<\n  T = Record<string, unknown>,\n  InterruptType = unknown,\n  ConfigurableType extends object = Record<string, unknown>,\n> {\n  /** Underlying `StreamApi` returned by {@link useStream}. */\n  readonly stream: UseStreamReturn<T, InterruptType, ConfigurableType>;\n\n  constructor(options: UseStreamOptions<InferStateType<T>>) {\n    const injector = inject(EnvironmentInjector);\n    const destroyRef = inject(DestroyRef);\n    this.stream = runInInjectionContext(injector, () =>\n      useStream<T, InterruptType, ConfigurableType>(options, destroyRef)\n    );\n  }\n\n  // ─── Reactive accessors (pass-through) ────────────────────────────\n\n  get values(): UseStreamReturn<T, InterruptType, ConfigurableType>[\"values\"] {\n    return this.stream.values;\n  }\n\n  get messages(): Signal<BaseMessage[]> {\n    return this.stream.messages;\n  }\n\n  get toolCalls(): Signal<AssembledToolCall[]> {\n    return this.stream.toolCalls;\n  }\n\n  get interrupts(): Signal<Interrupt<InterruptType>[]> {\n    return this.stream.interrupts;\n  }\n\n  get interrupt(): Signal<Interrupt<InterruptType> | undefined> {\n    return this.stream.interrupt;\n  }\n\n  get isLoading(): Signal<boolean> {\n    return this.stream.isLoading;\n  }\n\n  get isThreadLoading(): Signal<boolean> {\n    return this.stream.isThreadLoading;\n  }\n\n  get error(): Signal<unknown> {\n    return this.stream.error;\n  }\n\n  get threadId(): Signal<string | null> {\n    return this.stream.threadId;\n  }\n\n  get hydrationPromise(): Signal<Promise<void>> {\n    return this.stream.hydrationPromise;\n  }\n\n  get subagents(): UseStreamReturn<\n    T,\n    InterruptType,\n    ConfigurableType\n  >[\"subagents\"] {\n    return this.stream.subagents;\n  }\n\n  get subgraphs(): Signal<ReadonlyMap<string, SubgraphDiscoverySnapshot>> {\n    return this.stream.subgraphs;\n  }\n\n  get subgraphsByNode(): Signal<\n    ReadonlyMap<string, readonly SubgraphDiscoverySnapshot[]>\n  > {\n    return this.stream.subgraphsByNode;\n  }\n\n  // ─── Identity ─────────────────────────────────────────────────────\n\n  get client(): Client {\n    return this.stream.client;\n  }\n\n  get assistantId(): string {\n    return this.stream.assistantId;\n  }\n\n  // ─── Imperatives ──────────────────────────────────────────────────\n\n  submit(\n    input: WidenUpdateMessages<Partial<InferStateType<T>>> | null | undefined,\n    options?: StreamSubmitOptions<InferStateType<T>, ConfigurableType>\n  ): Promise<void> {\n    return this.stream.submit(\n      input as Parameters<this[\"stream\"][\"submit\"]>[0],\n      options as Parameters<this[\"stream\"][\"submit\"]>[1]\n    );\n  }\n\n  stop(): Promise<void> {\n    return this.stream.stop();\n  }\n\n  respond(\n    response: unknown,\n    target?: { interruptId: string; namespace?: string[] }\n  ): Promise<void> {\n    return this.stream.respond(response, target);\n  }\n\n  getThread(): ThreadStream | undefined {\n    return this.stream.getThread();\n  }\n\n  /** @internal Lets selector primitives resolve the controller. */\n  get [STREAM_CONTROLLER](): StreamApi<\n    T,\n    InterruptType,\n    ConfigurableType\n  >[typeof STREAM_CONTROLLER] {\n    return this.stream[STREAM_CONTROLLER];\n  }\n}\n"],"mappings":";;;;AAsDO,IAAA,gBAAA,MAAM,cAIX;;CAEA;CAEA,YAAY,SAA8C;EACxD,MAAM,WAAW,OAAO,oBAAoB;EAC5C,MAAM,aAAa,OAAO,WAAW;AACrC,OAAK,SAAS,sBAAsB,gBAClC,UAA8C,SAAS,WAAW,CACnE;;CAKH,IAAI,SAAwE;AAC1E,SAAO,KAAK,OAAO;;CAGrB,IAAI,WAAkC;AACpC,SAAO,KAAK,OAAO;;CAGrB,IAAI,YAAyC;AAC3C,SAAO,KAAK,OAAO;;CAGrB,IAAI,aAAiD;AACnD,SAAO,KAAK,OAAO;;CAGrB,IAAI,YAA0D;AAC5D,SAAO,KAAK,OAAO;;CAGrB,IAAI,YAA6B;AAC/B,SAAO,KAAK,OAAO;;CAGrB,IAAI,kBAAmC;AACrC,SAAO,KAAK,OAAO;;CAGrB,IAAI,QAAyB;AAC3B,SAAO,KAAK,OAAO;;CAGrB,IAAI,WAAkC;AACpC,SAAO,KAAK,OAAO;;CAGrB,IAAI,mBAA0C;AAC5C,SAAO,KAAK,OAAO;;CAGrB,IAAI,YAIW;AACb,SAAO,KAAK,OAAO;;CAGrB,IAAI,YAAoE;AACtE,SAAO,KAAK,OAAO;;CAGrB,IAAI,kBAEF;AACA,SAAO,KAAK,OAAO;;CAKrB,IAAI,SAAiB;AACnB,SAAO,KAAK,OAAO;;CAGrB,IAAI,cAAsB;AACxB,SAAO,KAAK,OAAO;;CAKrB,OACE,OACA,SACe;AACf,SAAO,KAAK,OAAO,OACjB,OACA,QACD;;CAGH,OAAsB;AACpB,SAAO,KAAK,OAAO,MAAM;;CAG3B,QACE,UACA,QACe;AACf,SAAO,KAAK,OAAO,QAAQ,UAAU,OAAO;;CAG9C,YAAsC;AACpC,SAAO,KAAK,OAAO,WAAW;;;CAIhC,KAAK,qBAIuB;AAC1B,SAAO,KAAK,OAAO;;;4BAxHtB,YAAY,CAAA,EAAA,cAAA"}