@langchain/angular 0.2.0 → 0.3.1

package/dist/context.js

@@ -1,4 +1,5 @@
-import { useStream } from "./index.js";
+import { injectStreamCustom } from "./stream.custom.js";
+import { useStreamLGP } from "./stream.lgp.js";
 import { InjectionToken, inject, makeEnvironmentProviders } from "@angular/core";
 //#region src/context.ts
 /**
@@ -76,64 +77,18 @@ function provideStream(options) {
 		provide: STREAM_INSTANCE,
 		useFactory: () => {
 			const defaults = inject(STREAM_DEFAULTS, { optional: true });
-			return useStream({
+			const merged = {
 				...defaults ?? {},
 				...options,
 				apiUrl: options.apiUrl ?? defaults?.apiUrl,
 				client: options.client ?? defaults?.client
-			});
+			};
+			if ("transport" in merged) return injectStreamCustom(merged);
+			return useStreamLGP(merged);
 		}
 	};
 }
-/**
-* 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 };
+export { STREAM_DEFAULTS, STREAM_INSTANCE, provideStream, provideStreamDefaults };
 
 //# sourceMappingURL=context.js.map

package/dist/context.js.map

@@ -1 +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"}
+{"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 type { StreamServiceInstance } from \"./stream-service-instance.js\";\nimport { useStreamLGP } from \"./stream.lgp.js\";\nimport { injectStreamCustom } from \"./stream.custom.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 */\nexport const STREAM_INSTANCE = new InjectionToken<StreamServiceInstance>(\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      if (\"transport\" in merged) {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        return injectStreamCustom(merged as any);\n      }\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      return useStreamLGP(merged as any);\n    },\n  };\n}\n"],"mappings":";;;;;;;;AAkCA,MAAa,kBAAkB,IAAI,eACjC,4BACD;;;;;AAMD,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;GACnE,MAAM,SAAS;IACb,GAAI,YAAY,EAAE;IAClB,GAAG;IACH,QAAS,QAAoC,UAAU,UAAU;IACjE,QAAS,QAAoC,UAAU,UAAU;IAClE;AACD,OAAI,eAAe,OAEjB,QAAO,mBAAmB,OAAc;AAG1C,UAAO,aAAa,OAAc;;EAErC"}

package/dist/index.cjs

@@ -1,471 +1,33 @@
 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_stream_lgp = require("./stream.lgp.cjs");
 const require_context = require("./context.cjs");
+const require_decorate = require("./_virtual/_@oxc-project_runtime@0.115.0/helpers/decorate.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");
-let _langchain_langgraph_sdk_utils = require("@langchain/langgraph-sdk/utils");
 //#region src/index.ts
-function fetchHistory(client, threadId, options) {
-	if (options?.limit === false) return client.threads.getState(threadId).then((state) => {
-		if (state.checkpoint == null) return [];
-		return [state];
-	});
-	const limit = typeof options?.limit === "number" ? options.limit : 10;
-	return client.threads.getHistory(threadId, { limit });
-}
-function useStream(options) {
-	if ("transport" in options) return require_stream_custom.useStreamCustom(options);
-	return useStreamLGP(options);
-}
-function resolveRunMetadataStorage(reconnectOnMount) {
-	if (typeof globalThis.window === "undefined") return null;
-	if (reconnectOnMount === true) return globalThis.window.sessionStorage;
-	if (typeof reconnectOnMount === "function") return reconnectOnMount();
-	return null;
-}
-function useStreamLGP(options) {
-	const runMetadataStorage = resolveRunMetadataStorage(options.reconnectOnMount);
-	const getMessages = (value) => {
-		const messagesKey = options.messagesKey ?? "messages";
-		return Array.isArray(value[messagesKey]) ? value[messagesKey] : [];
-	};
-	const setMessages = (current, messages) => {
-		const messagesKey = options.messagesKey ?? "messages";
-		return {
-			...current,
-			[messagesKey]: messages
-		};
-	};
-	const historyLimit = typeof options.fetchStateHistory === "object" && options.fetchStateHistory != null ? options.fetchStateHistory.limit ?? false : options.fetchStateHistory ?? false;
-	const threadId = (0, _angular_core.signal)(void 0);
-	let threadIdPromise = null;
-	const client = options.client ?? new _langchain_langgraph_sdk.Client({ apiUrl: options.apiUrl });
-	const history = (0, _angular_core.signal)({
-		data: void 0,
-		error: void 0,
-		isLoading: false,
-		mutate: async () => void 0
-	});
-	async function mutate(mutateId) {
-		const tid = mutateId ?? threadId();
-		if (!tid) return void 0;
-		try {
-			const data = await fetchHistory(client, tid, { limit: historyLimit });
-			history.set({
-				data,
-				error: void 0,
-				isLoading: false,
-				mutate
-			});
-			return data;
-		} catch (err) {
-			history.update((prev) => ({
-				...prev,
-				error: err,
-				isLoading: false
-			}));
-			options.onError?.(err, void 0);
-			return;
-		}
-	}
-	history.update((prev) => ({
-		...prev,
-		mutate
-	}));
-	const branch = (0, _angular_core.signal)("");
-	const branchContext = (0, _angular_core.computed)(() => (0, _langchain_langgraph_sdk_ui.getBranchContext)(branch(), history().data ?? void 0));
-	const messageManager = new _langchain_langgraph_sdk_ui.MessageTupleManager();
-	const stream = new _langchain_langgraph_sdk_ui.StreamManager(messageManager, {
-		throttle: options.throttle ?? false,
-		subagentToolNames: options.subagentToolNames,
-		filterSubagentMessages: options.filterSubagentMessages,
-		toMessage: _langchain_langgraph_sdk_ui.toMessageClass
-	});
-	const pendingRuns = new _langchain_langgraph_sdk_ui.PendingRunsTracker();
-	const queueEntries = (0, _angular_core.signal)(pendingRuns.entries);
-	const queueSize = (0, _angular_core.signal)(pendingRuns.size);
-	const historyValues = (0, _angular_core.computed)(() => branchContext().threadHead?.values ?? options.initialValues ?? {});
-	const historyError = (0, _angular_core.computed)(() => {
-		const error = branchContext().threadHead?.tasks?.at(-1)?.error;
-		if (error == null) return void 0;
-		try {
-			const parsed = JSON.parse(error);
-			if (_langchain_langgraph_sdk_ui.StreamError.isStructuredError(parsed)) return new _langchain_langgraph_sdk_ui.StreamError(parsed);
-			return parsed;
-		} catch {}
-		return error;
-	});
-	const streamValues = (0, _angular_core.signal)(stream.values);
-	const streamError = (0, _angular_core.signal)(stream.error);
-	const isLoading = (0, _angular_core.signal)(stream.isLoading);
-	const values = (0, _angular_core.computed)(() => streamValues() ?? historyValues());
-	const error = (0, _angular_core.computed)(() => streamError() ?? historyError() ?? history().error);
-	const messageMetadata = (0, _angular_core.computed)(() => (0, _langchain_langgraph_sdk_ui.getMessagesMetadataMap)({
-		initialValues: options.initialValues,
-		history: history().data,
-		getMessages,
-		branchContext: branchContext()
-	}));
-	const subagentVersion = (0, _angular_core.signal)(0);
-	(0, _angular_core.effect)((onCleanup) => {
-		const unsubscribe = stream.subscribe(() => {
-			streamValues.set(stream.values);
-			streamError.set(stream.error);
-			isLoading.set(stream.isLoading);
-			subagentVersion.update((v) => v + 1);
-		});
-		onCleanup(() => unsubscribe());
-	});
-	pendingRuns.subscribe(() => {
-		queueEntries.set(pendingRuns.entries);
-		queueSize.set(pendingRuns.size);
-	});
-	(0, _angular_core.effect)((onCleanup) => {
-		const hvMessages = getMessages(historyValues());
-		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) => {
-			if (runMetadataStorage && threadId()) {
-				const tid = threadId();
-				const runId = runMetadataStorage.getItem(`lg:stream:${tid}`);
-				if (runId) client.runs.cancel(tid, runId);
-				runMetadataStorage.removeItem(`lg:stream:${tid}`);
-			}
-			options.onStop?.(args);
-		} });
-	}
-	function setBranch(value) {
-		branch.set(value);
-	}
-	function submitDirect(values, submitOptions) {
-		const currentBranchContext = branchContext();
-		const checkpointId = submitOptions?.checkpoint?.checkpoint_id;
-		branch.set(checkpointId != null ? currentBranchContext.branchByCheckpoint[checkpointId]?.branch ?? "" : "");
-		const includeImplicitBranch = historyLimit === true || typeof historyLimit === "number";
-		const shouldRefetch = options.onFinish != null || includeImplicitBranch;
-		let checkpoint = submitOptions?.checkpoint ?? (includeImplicitBranch ? currentBranchContext.threadHead?.checkpoint : void 0) ?? void 0;
-		if (submitOptions?.checkpoint === null) checkpoint = void 0;
-		if (checkpoint != null) delete checkpoint.thread_id;
-		const streamResumable = submitOptions?.streamResumable ?? !!runMetadataStorage;
-		let callbackMeta;
-		let rejoinKey;
-		let usableThreadId;
-		return stream.start(async (signal) => {
-			usableThreadId = threadId();
-			if (!usableThreadId) {
-				const threadPromise = client.threads.create({
-					threadId: submitOptions?.threadId,
-					metadata: submitOptions?.metadata
-				});
-				threadIdPromise = threadPromise.then((t) => t.thread_id);
-				usableThreadId = (await threadPromise).thread_id;
-				threadId.set(usableThreadId);
-				options.onThreadId?.(usableThreadId);
-			}
-			const streamMode = new Set([
-				...submitOptions?.streamMode ?? [],
-				"values",
-				"messages-tuple",
-				"updates"
-			]);
-			if (options.onUpdateEvent) streamMode.add("updates");
-			if (options.onCustomEvent) streamMode.add("custom");
-			if (options.onCheckpointEvent) streamMode.add("checkpoints");
-			if (options.onTaskEvent) streamMode.add("tasks");
-			if ("onDebugEvent" in options && options.onDebugEvent) streamMode.add("debug");
-			if ("onLangChainEvent" in options && options.onLangChainEvent) streamMode.add("events");
-			stream.setStreamValues(() => {
-				const prev = {
-					...historyValues(),
-					...stream.values
-				};
-				if (submitOptions?.optimisticValues != null) return {
-					...prev,
-					...typeof submitOptions.optimisticValues === "function" ? submitOptions.optimisticValues(prev) : submitOptions.optimisticValues
-				};
-				return { ...prev };
-			});
-			return client.runs.stream(usableThreadId, options.assistantId, {
-				input: values,
-				config: submitOptions?.config,
-				context: submitOptions?.context,
-				command: submitOptions?.command,
-				interruptBefore: submitOptions?.interruptBefore,
-				interruptAfter: submitOptions?.interruptAfter,
-				metadata: submitOptions?.metadata,
-				multitaskStrategy: submitOptions?.multitaskStrategy,
-				onCompletion: submitOptions?.onCompletion,
-				onDisconnect: submitOptions?.onDisconnect ?? (streamResumable ? "continue" : "cancel"),
-				signal,
-				checkpoint,
-				streamMode: [...streamMode],
-				streamSubgraphs: submitOptions?.streamSubgraphs,
-				streamResumable,
-				durability: submitOptions?.durability,
-				onRunCreated(params) {
-					callbackMeta = {
-						run_id: params.run_id,
-						thread_id: params.thread_id ?? usableThreadId
-					};
-					if (runMetadataStorage) {
-						rejoinKey = `lg:stream:${usableThreadId}`;
-						runMetadataStorage.setItem(rejoinKey, callbackMeta.run_id);
-					}
-					options.onCreated?.(callbackMeta);
-				}
-			});
-		}, {
-			getMessages,
-			setMessages,
-			initialValues: historyValues(),
-			callbacks: options,
-			async onSuccess() {
-				if (rejoinKey) runMetadataStorage?.removeItem(rejoinKey);
-				if (shouldRefetch && usableThreadId) {
-					const lastHead = (await mutate(usableThreadId))?.at(0);
-					if (lastHead) {
-						options.onFinish?.(lastHead, callbackMeta);
-						return null;
-					}
-				}
-			},
-			onError: (error) => {
-				options.onError?.(error, callbackMeta);
-				submitOptions?.onError?.(error, callbackMeta);
-			},
-			onFinish: () => {}
-		});
-	}
-	let submitting = false;
-	function drainQueue() {
-		if (!isLoading() && !submitting && pendingRuns.size > 0) {
-			const next = pendingRuns.shift();
-			if (next) {
-				submitting = true;
-				joinStream(next.id).finally(() => {
-					submitting = false;
-					drainQueue();
-				});
-			}
-		}
-	}
-	(0, _angular_core.effect)(() => {
-		drainQueue();
-	});
-	async function submit(values, submitOptions) {
-		if (stream.isLoading || submitting) {
-			if (submitOptions?.multitaskStrategy === "interrupt" || submitOptions?.multitaskStrategy === "rollback") {
-				submitting = true;
-				try {
-					await submitDirect(values, submitOptions);
-				} finally {
-					submitting = false;
-				}
-				return;
-			}
-			let usableThreadId = threadId();
-			if (!usableThreadId && threadIdPromise) usableThreadId = await threadIdPromise;
-			if (usableThreadId) {
-				try {
-					const run = await client.runs.create(usableThreadId, options.assistantId, {
-						input: values,
-						config: submitOptions?.config,
-						context: submitOptions?.context,
-						command: submitOptions?.command,
-						interruptBefore: submitOptions?.interruptBefore,
-						interruptAfter: submitOptions?.interruptAfter,
-						metadata: submitOptions?.metadata,
-						multitaskStrategy: "enqueue",
-						streamResumable: true,
-						streamSubgraphs: submitOptions?.streamSubgraphs,
-						durability: submitOptions?.durability
-					});
-					pendingRuns.add({
-						id: run.run_id,
-						values,
-						options: submitOptions,
-						createdAt: new Date(run.created_at)
-					});
-				} catch (error) {
-					options.onError?.(error, void 0);
-					submitOptions?.onError?.(error, void 0);
-				}
-				return;
-			}
-		}
-		submitting = true;
-		const result = submitDirect(values, submitOptions);
-		Promise.resolve(result).finally(() => {
-			submitting = false;
-			drainQueue();
-		});
-		return result;
-	}
-	async function joinStream(runId, lastEventId, joinOptions) {
-		lastEventId ??= "-1";
-		const tid = threadId();
-		if (!tid) return;
-		const callbackMeta = {
-			thread_id: tid,
-			run_id: runId
-		};
-		await stream.start(async (signal) => {
-			const rawStream = client.runs.joinStream(tid, runId, {
-				signal,
-				lastEventId,
-				streamMode: joinOptions?.streamMode
-			});
-			return joinOptions?.filter != null ? (0, _langchain_langgraph_sdk_ui.filterStream)(rawStream, joinOptions.filter) : rawStream;
-		}, {
-			getMessages,
-			setMessages,
-			initialValues: historyValues(),
-			callbacks: options,
-			async onSuccess() {
-				runMetadataStorage?.removeItem(`lg:stream:${tid}`);
-				const lastHead = (await mutate(tid))?.at(0);
-				if (lastHead) options.onFinish?.(lastHead, callbackMeta);
-			},
-			onError(error) {
-				options.onError?.(error, callbackMeta);
-			},
-			onFinish() {}
-		});
-	}
-	const shouldReconnect = !!runMetadataStorage;
-	let hasReconnected = false;
-	(0, _angular_core.effect)(() => {
-		const tid = threadId();
-		if (!hasReconnected && shouldReconnect && runMetadataStorage && tid && !isLoading()) {
-			const runId = runMetadataStorage.getItem(`lg:stream:${tid}`);
-			if (runId) {
-				hasReconnected = true;
-				joinStream(runId);
-			}
-		}
-	});
-	const messages = (0, _angular_core.computed)(() => (0, _langchain_langgraph_sdk_ui.ensureMessageInstances)(getMessages(values())));
-	const toolCalls = (0, _angular_core.computed)(() => (0, _langchain_langgraph_sdk_utils.getToolCallsWithResults)(getMessages(values())));
-	function getToolCalls(message) {
-		return (0, _langchain_langgraph_sdk_utils.getToolCallsWithResults)(getMessages(values())).filter((tc) => tc.aiMessage.id === message.id);
-	}
-	const interrupt = (0, _angular_core.computed)(() => (0, _langchain_langgraph_sdk_ui.extractInterrupts)(values(), {
-		isLoading: isLoading(),
-		threadState: branchContext().threadHead,
-		error: error()
-	}));
-	const interrupts = (0, _angular_core.computed)(() => {
-		const vals = values();
-		if (vals != null && "__interrupt__" in vals && Array.isArray(vals.__interrupt__)) {
-			const valueInterrupts = vals.__interrupt__;
-			if (valueInterrupts.length === 0) return [{ when: "breakpoint" }];
-			return valueInterrupts;
-		}
-		if (isLoading()) return [];
-		const allInterrupts = (branchContext().threadHead?.tasks ?? []).flatMap((t) => t.interrupts ?? []);
-		if (allInterrupts.length > 0) return allInterrupts;
-		if (!(branchContext().threadHead?.next ?? []).length || error() != null) return [];
-		return [{ when: "breakpoint" }];
-	});
-	const historyList = (0, _angular_core.computed)(() => {
-		if (historyLimit === false) throw new Error("`fetchStateHistory` must be set to `true` to use `history`");
-		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)(() => {
-		if (historyLimit === false) throw new Error("`fetchStateHistory` must be set to `true` to use `experimental_branchTree`");
-		return branchContext().branchTree;
-	});
-	function getMessagesMetadata(message, index) {
-		const streamMetadata = messageManager.get(message.id)?.metadata;
-		const historyMetadata = messageMetadata().find((m) => m.messageId === (message.id ?? index));
-		if (streamMetadata != null || historyMetadata != null) return {
-			...historyMetadata,
-			streamMetadata
-		};
-	}
-	return {
-		assistantId: options.assistantId,
-		client,
-		values,
-		error,
-		isLoading,
-		branch,
-		setBranch,
-		messages,
-		toolCalls,
-		getToolCalls,
-		interrupt,
-		interrupts,
-		history: historyList,
-		isThreadLoading,
-		experimental_branchTree: experimentalBranchTree,
-		getMessagesMetadata,
-		submit,
-		stop,
-		joinStream,
-		queue: {
-			entries: queueEntries,
-			size: queueSize,
-			async cancel(id) {
-				const tid = threadId();
-				const removed = pendingRuns.remove(id);
-				if (removed && tid) await client.runs.cancel(tid, id);
-				return removed;
-			},
-			async clear() {
-				const tid = threadId();
-				const removed = pendingRuns.removeAll();
-				if (tid && removed.length > 0) await Promise.all(removed.map((e) => client.runs.cancel(tid, e.id)));
-			}
-		},
-		switchThread(newThreadId) {
-			if (newThreadId !== (threadId() ?? null)) {
-				const prevThreadId = threadId();
-				threadId.set(newThreadId ?? void 0);
-				stream.clear();
-				const removed = pendingRuns.removeAll();
-				if (prevThreadId && removed.length > 0) Promise.all(removed.map((e) => client.runs.cancel(prevThreadId, e.id)));
-				if (newThreadId != null) options.onThreadId?.(newThreadId);
-			}
-		},
-		get subagents() {
-			subagentVersion();
-			return stream.getSubagents();
-		},
-		get activeSubagents() {
-			subagentVersion();
-			return stream.getActiveSubagents();
-		},
-		getSubagent(toolCallId) {
-			return stream.getSubagent(toolCallId);
-		},
-		getSubagentsByType(type) {
-			return stream.getSubagentsByType(type);
-		},
-		getSubagentsByMessage(messageId) {
-			return stream.getSubagentsByMessage(messageId);
-		}
-	};
+/**
+* @internal Merges DI, LangGraph Platform, and custom transport overloads.
+*/
+function injectStream(options) {
+	if (arguments.length === 0) {
+		const instance = (0, _angular_core.inject)(require_context.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 injectStream(options) directly.");
+		return instance;
+	}
+	if ("transport" in options) return require_stream_custom.injectStreamCustom(options);
+	return require_stream_lgp.useStreamLGP(options);
 }
+/**
+* @deprecated Use `injectStream` instead. `useStream` will be removed in a
+* future major version. `injectStream` follows Angular's `inject*` naming
+* convention for injection-based patterns.
+*/
+const useStream = injectStream;
 let StreamService = class StreamService {
 	_stream;
 	constructor(options) {
-		this._stream = useStream(options);
+		this._stream = injectStream(options);
 	}
 	get values() {
 		return this._stream.values;
@@ -518,8 +80,8 @@ let StreamService = class StreamService {
 	submit(values, options) {
 		return this._stream.submit(values, options);
 	}
-	stop() {
-		return this._stream.stop();
+	async stop() {
+		await this._stream.stop();
 	}
 	setBranch(value) {
 		this._stream.setBranch(value);
@@ -586,7 +148,8 @@ Object.defineProperty(exports, "extractToolCallIdFromNamespace", {
 		return _langchain_langgraph_sdk_ui.extractToolCallIdFromNamespace;
 	}
 });
-exports.injectStream = require_context.injectStream;
+exports.injectStream = injectStream;
+exports.injectStreamCustom = require_stream_custom.injectStreamCustom;
 Object.defineProperty(exports, "isSubagentNamespace", {
 	enumerable: true,
 	get: function() {
@@ -596,6 +159,7 @@ Object.defineProperty(exports, "isSubagentNamespace", {
 exports.provideStream = require_context.provideStream;
 exports.provideStreamDefaults = require_context.provideStreamDefaults;
 exports.useStream = useStream;
-exports.useStreamLGP = useStreamLGP;
+exports.useStreamCustom = require_stream_custom.useStreamCustom;
+exports.useStreamLGP = require_stream_lgp.useStreamLGP;
 
 //# sourceMappingURL=index.cjs.map