@langchain/angular 0.1.2 → 0.2.0

package/dist/context.d.ts

@@ -0,0 +1,175 @@
+import { BaseMessage as BaseMessage$1 } from "./node_modules/.pnpm/langchain@1.2.30_@langchain_core@1.1.31_@opentelemetry_api@1.9.0_openai@6.27.0_ws@8.19._0520fb05d9e85da5f9e061dfe28cdbc8/node_modules/langchain/dist/index.js";
+import { useStream } from "./index.js";
+import * as _angular_core0 from "@angular/core";
+import { EnvironmentProviders, InjectionToken } from "@angular/core";
+import * as _langchain_langgraph_sdk_ui0 from "@langchain/langgraph-sdk/ui";
+import { InferBag, InferStateType, ResolveStreamOptions, UseStreamCustomOptions } from "@langchain/langgraph-sdk/ui";
+import * as _langchain_langgraph_sdk0 from "@langchain/langgraph-sdk";
+import { BagTemplate, Client } from "@langchain/langgraph-sdk";
+import * as _langchain_core_messages0 from "@langchain/core/messages";
+
+//#region src/context.d.ts
+/**
+ * Configuration defaults for `useStream` and `injectStream` calls.
+ */
+interface StreamDefaults {
+  /** Base URL of the LangGraph API. */
+  apiUrl?: string;
+  /** API key for authenticating with the LangGraph API. */
+  apiKey?: string;
+  /** Pre-configured Client instance. */
+  client?: Client;
+}
+/**
+ * Injection token for stream default configuration.
+ * Provide via `provideStreamDefaults()` in your application config.
+ */
+declare const STREAM_DEFAULTS: InjectionToken<StreamDefaults>;
+/**
+ * Injection token for a shared stream instance.
+ * Provide via `provideStream()` at the component level.
+ */
+declare const STREAM_INSTANCE: InjectionToken<any>;
+/**
+ * Provides default LangGraph configuration at the application level.
+ *
+ * Use this in your application's `providers` array to set defaults like
+ * `apiUrl` that will be used by all `useStream` and `injectStream` calls.
+ *
+ * @example
+ * ```typescript
+ * // app.config.ts
+ * import { ApplicationConfig } from "@angular/core";
+ * import { provideStreamDefaults } from "@langchain/angular";
+ *
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideStreamDefaults({
+ *       apiUrl: "http://localhost:2024",
+ *     }),
+ *   ],
+ * };
+ * ```
+ */
+declare function provideStreamDefaults(defaults: StreamDefaults): EnvironmentProviders;
+/**
+ * Creates a provider for a shared `useStream` instance at the component level.
+ *
+ * Add the returned provider to a component's `providers` array so that all
+ * child components can access the same stream via `injectStream()`.
+ *
+ * @example
+ * ```typescript
+ * import { Component } from "@angular/core";
+ * import { provideStream, injectStream } from "@langchain/angular";
+ *
+ * @Component({
+ *   providers: [provideStream({ assistantId: "agent" })],
+ *   template: `
+ *     <app-message-list />
+ *     <app-message-input />
+ *   `,
+ * })
+ * export class ChatContainer {}
+ *
+ * // In child components:
+ * @Component({
+ *   template: `
+ *     @for (msg of stream.messages(); track msg.id) {
+ *       <div>{{ msg.content }}</div>
+ *     }
+ *   `,
+ * })
+ * export class MessageListComponent {
+ *   stream = injectStream();
+ * }
+ * ```
+ */
+declare function provideStream<T = Record<string, unknown>, Bag extends BagTemplate = BagTemplate>(options: ResolveStreamOptions<T, InferBag<T, Bag>> | UseStreamCustomOptions<InferStateType<T>, InferBag<T, Bag>>): {
+  provide: InjectionToken<any>;
+  useFactory: () => {
+    values: _angular_core0.Signal<Record<string, unknown>>;
+    error: _angular_core0.Signal<unknown>;
+    isLoading: _angular_core0.WritableSignal<boolean>;
+    isThreadLoading: _angular_core0.Signal<boolean>;
+    interrupt: _angular_core0.Signal<_langchain_langgraph_sdk0.Interrupt<unknown> | undefined>;
+    interrupts: _angular_core0.Signal<_langchain_langgraph_sdk0.Interrupt<unknown>[]>;
+    stop: () => Promise<void>;
+    branch: _angular_core0.WritableSignal<string>;
+    setBranch: (branch: string) => void;
+    experimental_branchTree: _angular_core0.Signal<_langchain_langgraph_sdk_ui0.Sequence<Record<string, unknown>>>;
+    toolProgress: _angular_core0.Signal<_langchain_langgraph_sdk0.ToolProgress[]>;
+    client: Client<_langchain_langgraph_sdk0.DefaultValues, _langchain_langgraph_sdk0.DefaultValues, unknown>;
+    assistantId: string;
+    joinStream: (runId: string, lastEventId?: string | undefined, options?: {
+      streamMode?: _langchain_langgraph_sdk0.StreamMode[] | _langchain_langgraph_sdk0.StreamMode | undefined;
+      filter?: ((event: {
+        id?: string | undefined;
+        event: _langchain_langgraph_sdk0.StreamEvent;
+        data: unknown;
+      }) => boolean) | undefined;
+    } | undefined) => Promise<void>;
+    switchThread: (newThreadId: string | null) => void;
+    queue: {
+      entries: _angular_core0.WritableSignal<readonly _langchain_langgraph_sdk_ui0.QueueEntry<Record<string, unknown>, _langchain_langgraph_sdk_ui0.SubmitOptions<Record<string, unknown>, Record<string, unknown>>>[]>;
+      size: _angular_core0.WritableSignal<number>;
+      cancel: (id: string) => Promise<boolean>;
+      clear: () => Promise<void>;
+    };
+    messages: _angular_core0.Signal<BaseMessage$1<_langchain_core_messages0.MessageStructure<_langchain_core_messages0.MessageToolSet>, _langchain_core_messages0.MessageType>[]>;
+    getMessagesMetadata: (message: BaseMessage$1<_langchain_core_messages0.MessageStructure<_langchain_core_messages0.MessageToolSet>, _langchain_core_messages0.MessageType>, index?: number | undefined) => _langchain_langgraph_sdk_ui0.MessageMetadata<Record<string, unknown>> | undefined;
+    history: _angular_core0.Signal<_langchain_langgraph_sdk0.ThreadState<Omit<Record<string, unknown>, "messages"> & {
+      messages: BaseMessage$1<_langchain_core_messages0.MessageStructure<_langchain_core_messages0.MessageToolSet>, _langchain_core_messages0.MessageType>[];
+    }>[]>;
+    submit: (values: {
+      [x: string]: unknown;
+    } | null | undefined, options?: _langchain_langgraph_sdk_ui0.SubmitOptions<Record<string, unknown>, Record<string, unknown>> | undefined) => Promise<void>;
+  };
+};
+/**
+ * Injects the shared stream instance from the nearest ancestor that
+ * provided one via `provideStream()`.
+ *
+ * Throws if no ancestor provides a stream instance.
+ *
+ * @example
+ * ```typescript
+ * import { Component } from "@angular/core";
+ * import { injectStream } from "@langchain/angular";
+ *
+ * @Component({
+ *   template: `
+ *     @for (msg of stream.messages(); track msg.id) {
+ *       <div>{{ msg.content }}</div>
+ *     }
+ *     <button
+ *       [disabled]="stream.isLoading()"
+ *       (click)="onSubmit()"
+ *     >Send</button>
+ *   `,
+ * })
+ * export class ChatComponent {
+ *   stream = injectStream();
+ *
+ *   onSubmit() {
+ *     void this.stream.submit({
+ *       messages: [{ type: "human", content: "Hello!" }],
+ *     });
+ *   }
+ * }
+ * ```
+ *
+ * @example With type parameters for full type safety:
+ * ```typescript
+ * import type { agent } from "./agent";
+ *
+ * export class ChatComponent {
+ *   stream = injectStream<typeof agent>();
+ *   // stream.messages() returns typed messages
+ * }
+ * ```
+ */
+declare function injectStream<T = Record<string, unknown>, Bag extends BagTemplate = BagTemplate>(): ReturnType<typeof useStream<T, Bag>>;
+//#endregion
+export { STREAM_DEFAULTS, STREAM_INSTANCE, StreamDefaults, injectStream, provideStream, provideStreamDefaults };
+//# sourceMappingURL=context.d.ts.map

package/dist/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","names":[],"sources":["../src/context.ts"],"mappings":";;;;;;;;;;;;;;UAmBiB,cAAA;;EAEf,MAAA;EAFe;EAIf,MAAA;;EAEA,MAAA,GAAS,MAAA;AAAA;;;;;cAOE,eAAA,EAAe,cAAA,CAAA,cAAA;AAA5B;;;;AAAA,cASa,eAAA,EAAe,cAAA;AAA5B;;;;;AAyBA;;;;;;;;;AAyCA;;;;;;;AAlEA,iBAyBgB,qBAAA,CACd,QAAA,EAAU,cAAA,GACT,oBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuCa,aAAA,KACV,MAAA,+BACQ,WAAA,GAAc,WAAA,CAAA,CAE1B,OAAA,EACI,oBAAA,CAAqB,CAAA,EAAG,QAAA,CAAS,CAAA,EAAG,GAAA,KACpC,sBAAA,CAAuB,cAAA,CAAe,CAAA,GAAI,QAAA,CAAS,CAAA,EAAG,GAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6D5C,YAAA,KACV,MAAA,+BACQ,WAAA,GAAc,WAAA,CAAA,CAAA,GACvB,UAAA,QAAkB,SAAA,CAAU,CAAA,EAAG,GAAA"}

package/dist/context.js

@@ -0,0 +1,139 @@
+import { useStream } from "./index.js";
+import { InjectionToken, inject, makeEnvironmentProviders } from "@angular/core";
+//#region src/context.ts
+/**
+* Injection token for stream default configuration.
+* Provide via `provideStreamDefaults()` in your application config.
+*/
+const STREAM_DEFAULTS = new InjectionToken("LANGCHAIN_STREAM_DEFAULTS");
+/**
+* Injection token for a shared stream instance.
+* Provide via `provideStream()` at the component level.
+*/
+const STREAM_INSTANCE = new InjectionToken("LANGCHAIN_STREAM_INSTANCE");
+/**
+* Provides default LangGraph configuration at the application level.
+*
+* Use this in your application's `providers` array to set defaults like
+* `apiUrl` that will be used by all `useStream` and `injectStream` calls.
+*
+* @example
+* ```typescript
+* // app.config.ts
+* import { ApplicationConfig } from "@angular/core";
+* import { provideStreamDefaults } from "@langchain/angular";
+*
+* export const appConfig: ApplicationConfig = {
+*   providers: [
+*     provideStreamDefaults({
+*       apiUrl: "http://localhost:2024",
+*     }),
+*   ],
+* };
+* ```
+*/
+function provideStreamDefaults(defaults) {
+	return makeEnvironmentProviders([{
+		provide: STREAM_DEFAULTS,
+		useValue: defaults
+	}]);
+}
+/**
+* Creates a provider for a shared `useStream` instance at the component level.
+*
+* Add the returned provider to a component's `providers` array so that all
+* child components can access the same stream via `injectStream()`.
+*
+* @example
+* ```typescript
+* import { Component } from "@angular/core";
+* import { provideStream, injectStream } from "@langchain/angular";
+*
+* @Component({
+*   providers: [provideStream({ assistantId: "agent" })],
+*   template: `
+*     <app-message-list />
+*     <app-message-input />
+*   `,
+* })
+* export class ChatContainer {}
+*
+* // In child components:
+* @Component({
+*   template: `
+*     @for (msg of stream.messages(); track msg.id) {
+*       <div>{{ msg.content }}</div>
+*     }
+*   `,
+* })
+* export class MessageListComponent {
+*   stream = injectStream();
+* }
+* ```
+*/
+function provideStream(options) {
+	return {
+		provide: STREAM_INSTANCE,
+		useFactory: () => {
+			const defaults = inject(STREAM_DEFAULTS, { optional: true });
+			return useStream({
+				...defaults ?? {},
+				...options,
+				apiUrl: options.apiUrl ?? defaults?.apiUrl,
+				client: options.client ?? defaults?.client
+			});
+		}
+	};
+}
+/**
+* Injects the shared stream instance from the nearest ancestor that
+* provided one via `provideStream()`.
+*
+* Throws if no ancestor provides a stream instance.
+*
+* @example
+* ```typescript
+* import { Component } from "@angular/core";
+* import { injectStream } from "@langchain/angular";
+*
+* @Component({
+*   template: `
+*     @for (msg of stream.messages(); track msg.id) {
+*       <div>{{ msg.content }}</div>
+*     }
+*     <button
+*       [disabled]="stream.isLoading()"
+*       (click)="onSubmit()"
+*     >Send</button>
+*   `,
+* })
+* export class ChatComponent {
+*   stream = injectStream();
+*
+*   onSubmit() {
+*     void this.stream.submit({
+*       messages: [{ type: "human", content: "Hello!" }],
+*     });
+*   }
+* }
+* ```
+*
+* @example With type parameters for full type safety:
+* ```typescript
+* import type { agent } from "./agent";
+*
+* export class ChatComponent {
+*   stream = injectStream<typeof agent>();
+*   // stream.messages() returns typed messages
+* }
+* ```
+*/
+function injectStream() {
+	const instance = inject(STREAM_INSTANCE, { optional: true });
+	if (instance == null) throw new Error("injectStream() requires an ancestor component to provide a stream via provideStream(). Add provideStream({ assistantId: '...' }) to the providers array of a parent component, or use useStream() directly.");
+	return instance;
+}
+//#endregion
+export { STREAM_DEFAULTS, STREAM_INSTANCE, injectStream, provideStream, provideStreamDefaults };
+
+//# sourceMappingURL=context.js.map

package/dist/context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.js","names":["angularInject"],"sources":["../src/context.ts"],"sourcesContent":["import {\n  InjectionToken,\n  inject as angularInject,\n  type EnvironmentProviders,\n  makeEnvironmentProviders,\n} from \"@angular/core\";\nimport type { BagTemplate } from \"@langchain/langgraph-sdk\";\nimport { Client } from \"@langchain/langgraph-sdk\";\nimport type {\n  ResolveStreamOptions,\n  InferBag,\n  InferStateType,\n  UseStreamCustomOptions,\n} from \"@langchain/langgraph-sdk/ui\";\nimport { useStream } from \"./index.js\";\n\n/**\n * Configuration defaults for `useStream` and `injectStream` calls.\n */\nexport interface StreamDefaults {\n  /** Base URL of the LangGraph API. */\n  apiUrl?: string;\n  /** API key for authenticating with the LangGraph API. */\n  apiKey?: string;\n  /** Pre-configured Client instance. */\n  client?: Client;\n}\n\n/**\n * Injection token for stream default configuration.\n * Provide via `provideStreamDefaults()` in your application config.\n */\nexport const STREAM_DEFAULTS = new InjectionToken<StreamDefaults>(\n  \"LANGCHAIN_STREAM_DEFAULTS\",\n);\n\n/**\n * Injection token for a shared stream instance.\n * Provide via `provideStream()` at the component level.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport const STREAM_INSTANCE = new InjectionToken<any>(\n  \"LANGCHAIN_STREAM_INSTANCE\",\n);\n\n/**\n * Provides default LangGraph configuration at the application level.\n *\n * Use this in your application's `providers` array to set defaults like\n * `apiUrl` that will be used by all `useStream` and `injectStream` calls.\n *\n * @example\n * ```typescript\n * // app.config.ts\n * import { ApplicationConfig } from \"@angular/core\";\n * import { provideStreamDefaults } from \"@langchain/angular\";\n *\n * export const appConfig: ApplicationConfig = {\n *   providers: [\n *     provideStreamDefaults({\n *       apiUrl: \"http://localhost:2024\",\n *     }),\n *   ],\n * };\n * ```\n */\nexport function provideStreamDefaults(\n  defaults: StreamDefaults,\n): EnvironmentProviders {\n  return makeEnvironmentProviders([\n    { provide: STREAM_DEFAULTS, useValue: defaults },\n  ]);\n}\n\n/**\n * Creates a provider for a shared `useStream` instance at the component level.\n *\n * Add the returned provider to a component's `providers` array so that all\n * child components can access the same stream via `injectStream()`.\n *\n * @example\n * ```typescript\n * import { Component } from \"@angular/core\";\n * import { provideStream, injectStream } from \"@langchain/angular\";\n *\n * @Component({\n *   providers: [provideStream({ assistantId: \"agent\" })],\n *   template: `\n *     <app-message-list />\n *     <app-message-input />\n *   `,\n * })\n * export class ChatContainer {}\n *\n * // In child components:\n * @Component({\n *   template: `\n *     @for (msg of stream.messages(); track msg.id) {\n *       <div>{{ msg.content }}</div>\n *     }\n *   `,\n * })\n * export class MessageListComponent {\n *   stream = injectStream();\n * }\n * ```\n */\nexport function provideStream<\n  T = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate,\n>(\n  options:\n    | ResolveStreamOptions<T, InferBag<T, Bag>>\n    | UseStreamCustomOptions<InferStateType<T>, InferBag<T, Bag>>,\n) {\n  return {\n    provide: STREAM_INSTANCE,\n    useFactory: () => {\n      const defaults = angularInject(STREAM_DEFAULTS, { optional: true });\n      const merged = {\n        ...(defaults ?? {}),\n        ...options,\n        apiUrl: (options as Record<string, unknown>).apiUrl ?? defaults?.apiUrl,\n        client: (options as Record<string, unknown>).client ?? defaults?.client,\n      };\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      return useStream(merged as any);\n    },\n  };\n}\n\n/**\n * Injects the shared stream instance from the nearest ancestor that\n * provided one via `provideStream()`.\n *\n * Throws if no ancestor provides a stream instance.\n *\n * @example\n * ```typescript\n * import { Component } from \"@angular/core\";\n * import { injectStream } from \"@langchain/angular\";\n *\n * @Component({\n *   template: `\n *     @for (msg of stream.messages(); track msg.id) {\n *       <div>{{ msg.content }}</div>\n *     }\n *     <button\n *       [disabled]=\"stream.isLoading()\"\n *       (click)=\"onSubmit()\"\n *     >Send</button>\n *   `,\n * })\n * export class ChatComponent {\n *   stream = injectStream();\n *\n *   onSubmit() {\n *     void this.stream.submit({\n *       messages: [{ type: \"human\", content: \"Hello!\" }],\n *     });\n *   }\n * }\n * ```\n *\n * @example With type parameters for full type safety:\n * ```typescript\n * import type { agent } from \"./agent\";\n *\n * export class ChatComponent {\n *   stream = injectStream<typeof agent>();\n *   // stream.messages() returns typed messages\n * }\n * ```\n */\nexport function injectStream<\n  T = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate,\n>(): ReturnType<typeof useStream<T, Bag>> {\n  const instance = angularInject(STREAM_INSTANCE, { optional: true });\n  if (instance == null) {\n    throw new Error(\n      \"injectStream() requires an ancestor component to provide a stream via provideStream(). \" +\n        \"Add provideStream({ assistantId: '...' }) to the providers array of a parent component, \" +\n        \"or use useStream() directly.\",\n    );\n  }\n  return instance;\n}\n"],"mappings":";;;;;;;AAgCA,MAAa,kBAAkB,IAAI,eACjC,4BACD;;;;;AAOD,MAAa,kBAAkB,IAAI,eACjC,4BACD;;;;;;;;;;;;;;;;;;;;;;AAuBD,SAAgB,sBACd,UACsB;AACtB,QAAO,yBAAyB,CAC9B;EAAE,SAAS;EAAiB,UAAU;EAAU,CACjD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCJ,SAAgB,cAId,SAGA;AACA,QAAO;EACL,SAAS;EACT,kBAAkB;GAChB,MAAM,WAAWA,OAAc,iBAAiB,EAAE,UAAU,MAAM,CAAC;AAQnE,UAAO,UAPQ;IACb,GAAI,YAAY,EAAE;IAClB,GAAG;IACH,QAAS,QAAoC,UAAU,UAAU;IACjE,QAAS,QAAoC,UAAU,UAAU;IAClE,CAE8B;;EAElC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8CH,SAAgB,eAG0B;CACxC,MAAM,WAAWA,OAAc,iBAAiB,EAAE,UAAU,MAAM,CAAC;AACnE,KAAI,YAAY,KACd,OAAM,IAAI,MACR,8MAGD;AAEH,QAAO"}

package/dist/index.cjs

@@ -1,5 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_stream_custom = require("./stream.custom.cjs");
+const require_decorate = require("./_virtual/_@oxc-project_runtime@0.115.0/helpers/decorate.cjs");
+const require_context = require("./context.cjs");
 let _angular_core = require("@angular/core");
 let _langchain_langgraph_sdk_ui = require("@langchain/langgraph-sdk/ui");
 let _langchain_langgraph_sdk = require("@langchain/langgraph-sdk");
@@ -120,9 +122,20 @@ function useStreamLGP(options) {
 		queueEntries.set(pendingRuns.entries);
 		queueSize.set(pendingRuns.size);
 	});
-	(0, _angular_core.effect)(() => {
+	(0, _angular_core.effect)((onCleanup) => {
 		const hvMessages = getMessages(historyValues());
-		if (options.filterSubagentMessages && !isLoading() && !history().isLoading && hvMessages.length > 0) stream.reconstructSubagents(hvMessages, { skipIfPopulated: true });
+		if (options.filterSubagentMessages && !isLoading() && !history().isLoading && hvMessages.length > 0) {
+			stream.reconstructSubagents(hvMessages, { skipIfPopulated: true });
+			const tid = threadId();
+			if (tid) {
+				const controller = new AbortController();
+				stream.fetchSubagentHistory(client.threads, tid, {
+					messagesKey: options.messagesKey ?? "messages",
+					signal: controller.signal
+				});
+				onCleanup(() => controller.abort());
+			}
+		}
 	});
 	function stop() {
 		return stream.stop(historyValues(), { onStop: (args) => {
@@ -370,7 +383,7 @@ function useStreamLGP(options) {
 	});
 	const historyList = (0, _angular_core.computed)(() => {
 		if (historyLimit === false) throw new Error("`fetchStateHistory` must be set to `true` to use `history`");
-		return branchContext().flatHistory;
+		return (0, _langchain_langgraph_sdk_ui.ensureHistoryMessageInstances)(branchContext().flatHistory, options.messagesKey ?? "messages");
 	});
 	const isThreadLoading = (0, _angular_core.computed)(() => history().isLoading && history().data == null);
 	const experimentalBranchTree = (0, _angular_core.computed)(() => {
@@ -449,6 +462,91 @@ function useStreamLGP(options) {
 		}
 	};
 }
+let StreamService = class StreamService {
+	_stream;
+	constructor(options) {
+		this._stream = useStream(options);
+	}
+	get values() {
+		return this._stream.values;
+	}
+	get messages() {
+		return this._stream.messages;
+	}
+	get isLoading() {
+		return this._stream.isLoading;
+	}
+	get error() {
+		return this._stream.error;
+	}
+	get branch() {
+		return this._stream.branch;
+	}
+	get interrupt() {
+		return this._stream.interrupt;
+	}
+	get interrupts() {
+		return this._stream.interrupts;
+	}
+	get toolCalls() {
+		return this._stream.toolCalls;
+	}
+	get queue() {
+		return this._stream.queue;
+	}
+	get subagents() {
+		return this._stream.subagents;
+	}
+	get activeSubagents() {
+		return this._stream.activeSubagents;
+	}
+	get history() {
+		return this._stream.history;
+	}
+	get isThreadLoading() {
+		return this._stream.isThreadLoading;
+	}
+	get experimental_branchTree() {
+		return this._stream.experimental_branchTree;
+	}
+	get client() {
+		return this._stream.client;
+	}
+	get assistantId() {
+		return this._stream.assistantId;
+	}
+	submit(values, options) {
+		return this._stream.submit(values, options);
+	}
+	stop() {
+		return this._stream.stop();
+	}
+	setBranch(value) {
+		this._stream.setBranch(value);
+	}
+	switchThread(newThreadId) {
+		this._stream.switchThread(newThreadId);
+	}
+	joinStream(runId, lastEventId, options) {
+		return this._stream.joinStream(runId, lastEventId, options);
+	}
+	getMessagesMetadata(message, index) {
+		return this._stream.getMessagesMetadata(message, index);
+	}
+	getToolCalls(message) {
+		return this._stream.getToolCalls(message);
+	}
+	getSubagent(toolCallId) {
+		return this._stream.getSubagent(toolCallId);
+	}
+	getSubagentsByType(type) {
+		return this._stream.getSubagentsByType(type);
+	}
+	getSubagentsByMessage(messageId) {
+		return this._stream.getSubagentsByMessage(messageId);
+	}
+};
+StreamService = require_decorate.__decorate([(0, _angular_core.Injectable)()], StreamService);
 //#endregion
 Object.defineProperty(exports, "FetchStreamTransport", {
 	enumerable: true,
@@ -456,6 +554,14 @@ Object.defineProperty(exports, "FetchStreamTransport", {
 		return _langchain_langgraph_sdk_ui.FetchStreamTransport;
 	}
 });
+exports.STREAM_DEFAULTS = require_context.STREAM_DEFAULTS;
+exports.STREAM_INSTANCE = require_context.STREAM_INSTANCE;
+Object.defineProperty(exports, "StreamService", {
+	enumerable: true,
+	get: function() {
+		return StreamService;
+	}
+});
 Object.defineProperty(exports, "SubagentManager", {
 	enumerable: true,
 	get: function() {
@@ -480,12 +586,15 @@ Object.defineProperty(exports, "extractToolCallIdFromNamespace", {
 		return _langchain_langgraph_sdk_ui.extractToolCallIdFromNamespace;
 	}
 });
+exports.injectStream = require_context.injectStream;
 Object.defineProperty(exports, "isSubagentNamespace", {
 	enumerable: true,
 	get: function() {
 		return _langchain_langgraph_sdk_ui.isSubagentNamespace;
 	}
 });
+exports.provideStream = require_context.provideStream;
+exports.provideStreamDefaults = require_context.provideStreamDefaults;
 exports.useStream = useStream;
 exports.useStreamLGP = useStreamLGP;