@langchain/angular 0.1.3 → 0.3.0

package/README.md

@@ -1,6 +1,8 @@
 # @langchain/angular
 
-Angular SDK for building AI-powered applications with [LangChain](https://js.langchain.com/) and [LangGraph](https://langchain-ai.github.io/langgraphjs/). Provides a `useStream` function that manages streaming, state, branching, and interrupts using Angular's Signals API.
+Angular SDK for building AI-powered applications with [Deep Agents](https://docs.langchain.com/oss/javascript/deepagents/overview), [LangChain](https://docs.langchain.com/oss/javascript/langchain/overview) and [LangGraph](https://docs.langchain.com/oss/javascript/langgraph/overview). It provides an `injectStream` function that manages streaming, state, branching, and interrupts using Angular's Signals API.
+
+> **Migration note:** `useStream` has been renamed to `injectStream` to follow Angular's `inject*` naming convention. `useStream` is still available as a deprecated alias for backwards compatibility.
 
 ## Installation
 
@@ -14,7 +16,7 @@ npm install @langchain/angular @langchain/core
 
 ```typescript
 import { Component } from "@angular/core";
-import { useStream } from "@langchain/angular";
+import { injectStream } from "@langchain/angular";
 
 @Component({
   standalone: true,
@@ -34,7 +36,7 @@ import { useStream } from "@langchain/angular";
   `,
 })
 export class ChatComponent {
-  stream = useStream({
+  stream = injectStream({
     assistantId: "agent",
     apiUrl: "http://localhost:2024",
   });
@@ -51,7 +53,7 @@ export class ChatComponent {
 }
 ```
 
-## `useStream` Options
+## `injectStream` Options
 
 | Option | Type | Description |
 |---|---|---|
@@ -105,7 +107,7 @@ interface MyState {
 
 @Component({ /* ... */ })
 export class ChatComponent {
-  stream = useStream<MyState>({
+  stream = injectStream<MyState>({
     assistantId: "my-graph",
     apiUrl: "http://localhost:2024",
   });
@@ -119,7 +121,7 @@ import type { BaseMessage } from "langchain";
 
 @Component({ /* ... */ })
 export class ChatComponent {
-  stream = useStream<
+  stream = injectStream<
     { messages: BaseMessage[] },
     { InterruptType: { question: string } }
   >({
@@ -136,7 +138,7 @@ export class ChatComponent {
 ```typescript
 import { Component } from "@angular/core";
 import type { BaseMessage } from "langchain";
-import { useStream } from "@langchain/angular";
+import { injectStream } from "@langchain/angular";
 
 @Component({
   standalone: true,
@@ -158,7 +160,7 @@ import { useStream } from "@langchain/angular";
   `,
 })
 export class ChatComponent {
-  stream = useStream<
+  stream = injectStream<
     { messages: BaseMessage[] },
     { InterruptType: { question: string } }
   >({
@@ -188,7 +190,7 @@ Enable conversation branching with `fetchStateHistory: true`:
 
 ```typescript
 import { Component } from "@angular/core";
-import { useStream } from "@langchain/angular";
+import { injectStream } from "@langchain/angular";
 
 @Component({
   standalone: true,
@@ -211,7 +213,7 @@ import { useStream } from "@langchain/angular";
   `,
 })
 export class ChatComponent {
-  stream = useStream({
+  stream = injectStream({
     assistantId: "agent",
     apiUrl: "http://localhost:2024",
     fetchStateHistory: true,
@@ -257,7 +259,7 @@ When `submit()` is called while a stream is already active, the SDK automaticall
 
 ```typescript
 import { Component } from "@angular/core";
-import { useStream } from "@langchain/angular";
+import { injectStream } from "@langchain/angular";
 
 @Component({
   standalone: true,
@@ -285,7 +287,7 @@ import { useStream } from "@langchain/angular";
   `,
 })
 export class ChatComponent {
-  stream = useStream({
+  stream = injectStream({
     assistantId: "agent",
     apiUrl: "http://localhost:2024",
   });
@@ -312,13 +314,149 @@ export class ChatComponent {
 
 Switching threads via `switchThread()` cancels all pending runs and clears the queue.
 
+## Service Pattern
+
+For projects that prefer Angular's dependency injection, `StreamService` provides an `@Injectable()` base class that wraps `useStream`. Extend it with your own service to enable DI, testability, and shared state across components:
+
+```typescript
+import { Injectable, Component, inject } from "@angular/core";
+import { StreamService } from "@langchain/angular";
+import type { BaseMessage } from "langchain";
+
+interface ChatState {
+  messages: BaseMessage[];
+}
+
+@Injectable({ providedIn: "root" })
+export class ChatService extends StreamService<ChatState> {
+  constructor() {
+    super({
+      assistantId: "agent",
+      apiUrl: "http://localhost:2024",
+    });
+  }
+}
+
+@Component({
+  standalone: true,
+  template: `
+    <div>
+      @for (msg of chat.messages(); track msg.id ?? $index) {
+        <div>{{ str(msg.content) }}</div>
+      }
+
+      <button
+        [disabled]="chat.isLoading()"
+        (click)="onSubmit()"
+      >
+        Send
+      </button>
+    </div>
+  `,
+})
+export class ChatComponent {
+  chat = inject(ChatService);
+
+  str(v: unknown) {
+    return typeof v === "string" ? v : JSON.stringify(v);
+  }
+
+  onSubmit() {
+    void this.chat.submit({
+      messages: [{ type: "human", content: "Hello!" }],
+    });
+  }
+}
+```
+
+The service exposes the same signals and methods as `useStream` (`values`, `messages`, `isLoading`, `submit`, `stop`, etc.).
+
+### Shared State Across Components
+
+Because the service is provided through DI, multiple components can inject the same instance and share stream state:
+
+```typescript
+@Component({
+  standalone: true,
+  selector: "app-message-list",
+  template: `
+    @for (msg of chat.messages(); track msg.id ?? $index) {
+      <div>{{ msg.content }}</div>
+    }
+  `,
+})
+export class MessageListComponent {
+  chat = inject(ChatService);
+}
+
+@Component({
+  standalone: true,
+  imports: [MessageListComponent],
+  template: `
+    <app-message-list />
+    <button (click)="onSubmit()">Send</button>
+  `,
+})
+export class ChatPageComponent {
+  chat = inject(ChatService);
+
+  onSubmit() {
+    void this.chat.submit({
+      messages: [{ type: "human", content: "Hello!" }],
+    });
+  }
+}
+```
+
+### Custom Transport with StreamService
+
+```typescript
+import { Injectable } from "@angular/core";
+import { StreamService, FetchStreamTransport } from "@langchain/angular";
+import type { BaseMessage } from "langchain";
+
+@Injectable({ providedIn: "root" })
+export class CustomChatService extends StreamService<{
+  messages: BaseMessage[];
+}> {
+  constructor() {
+    super({
+      transport: new FetchStreamTransport({
+        url: "https://my-api.example.com/stream",
+      }),
+      threadId: null,
+      onThreadId: (id) => console.log("Thread created:", id),
+    });
+  }
+}
+```
+
+### Testing
+
+Services can be mocked or overridden in tests using Angular's standard DI testing utilities:
+
+```typescript
+import { TestBed } from "@angular/core/testing";
+
+const mockService = {
+  messages: signal([]),
+  isLoading: signal(false),
+  submit: vi.fn(),
+  stop: vi.fn(),
+};
+
+TestBed.configureTestingModule({
+  providers: [{ provide: ChatService, useValue: mockService }],
+});
+```
+
 ## Custom Transport
 
 Instead of connecting to a LangGraph API, you can provide your own streaming transport. Pass a `transport` object instead of `assistantId` to use a custom backend:
 
 ```typescript
 import { Component } from "@angular/core";
-import { useStream, FetchStreamTransport } from "@langchain/angular";
+import { injectStream, FetchStreamTransport } from "@langchain/angular";
 import type { BaseMessage } from "langchain";
 
 @Component({
@@ -346,7 +484,7 @@ import type { BaseMessage } from "langchain";
   `,
 })
 export class ChatComponent {
-  stream = useStream<{ messages: BaseMessage[] }>({
+  stream = injectStream<{ messages: BaseMessage[] }>({
     transport: new FetchStreamTransport({
       url: "https://my-api.example.com/stream",
     }),
@@ -371,11 +509,132 @@ export class ChatComponent {
 }
 ```
 
-The custom transport interface returns the same properties as the standard `useStream` function, including `getMessagesMetadata`, `branch`, `setBranch`, `switchThread`, and all message/interrupt/subagent helpers. When using a custom transport, `getMessagesMetadata` returns stream metadata sent alongside messages during streaming; `branch` and `setBranch` provide local branch state management.
+The custom transport interface returns the same properties as the standard `injectStream` function, including `getMessagesMetadata`, `branch`, `setBranch`, `switchThread`, and all message/interrupt/subagent helpers. When using a custom transport, `getMessagesMetadata` returns stream metadata sent alongside messages during streaming; `branch` and `setBranch` provide local branch state management. `onFinish` is also supported and receives a synthetic `ThreadState` built from the final locally streamed values; the run metadata argument is `undefined`.
+
+## Sharing State with `provideStream`
+
+When multiple components need the same stream (a message list, a header, an input bar), use `provideStream` and `injectStream` to share a single stream instance via Angular's dependency injection:
+
+```typescript
+import { Component } from "@angular/core";
+import { provideStream, injectStream } from "@langchain/angular";
+
+@Component({
+  selector: "app-chat-container",
+  providers: [provideStream({ assistantId: "agent", apiUrl: "http://localhost:2024" })],
+  template: `
+    <app-chat-header />
+    <app-message-list />
+    <app-message-input />
+  `,
+})
+export class ChatContainerComponent {}
+
+@Component({
+  selector: "app-chat-header",
+  template: `
+    <header>
+      <h1>Chat</h1>
+      @if (stream.isLoading()) {
+        <span>Thinking...</span>
+      }
+      @if (stream.error()) {
+        <span>Error occurred</span>
+      }
+    </header>
+  `,
+})
+export class ChatHeaderComponent {
+  stream = injectStream();
+}
+
+@Component({
+  selector: "app-message-list",
+  template: `
+    @for (msg of stream.messages(); track msg.id ?? $index) {
+      <div>{{ str(msg.content) }}</div>
+    }
+  `,
+})
+export class MessageListComponent {
+  stream = injectStream();
+
+  str(v: unknown) {
+    return typeof v === "string" ? v : JSON.stringify(v);
+  }
+}
+
+@Component({
+  selector: "app-message-input",
+  template: `
+    <button
+      [disabled]="stream.isLoading()"
+      (click)="onSubmit()"
+    >Send</button>
+  `,
+})
+export class MessageInputComponent {
+  stream = injectStream();
+
+  onSubmit() {
+    void this.stream.submit({
+      messages: [{ type: "human", content: "Hello!" }],
+    });
+  }
+}
+```
+
+### App-Level Configuration with `provideStreamDefaults`
+
+Set default configuration for all `useStream` and `injectStream` calls application-wide:
+
+```typescript
+// app.config.ts
+import { ApplicationConfig } from "@angular/core";
+import { provideStreamDefaults } from "@langchain/angular";
+
+export const appConfig: ApplicationConfig = {
+  providers: [
+    provideStreamDefaults({
+      apiUrl: "http://localhost:2024",
+    }),
+  ],
+};
+```
+
+Then in components, `apiUrl` is inherited automatically:
+
+```typescript
+@Component({
+  providers: [provideStream({ assistantId: "agent" })],
+  template: `...`,
+})
+export class ChatComponent {}
+```
+
+### Multiple Agents
+
+Use separate `provideStream` entries on different components — Angular's hierarchical injector ensures each subtree gets its own isolated stream:
+
+```typescript
+@Component({
+  selector: "app-research-panel",
+  providers: [provideStream({ assistantId: "researcher", apiUrl: "http://localhost:2024" })],
+  template: `<app-message-list /> <app-message-input />`,
+})
+export class ResearchPanelComponent {}
+
+@Component({
+  selector: "app-writer-panel",
+  providers: [provideStream({ assistantId: "writer", apiUrl: "http://localhost:2024" })],
+  template: `<app-message-list /> <app-message-input />`,
+})
+export class WriterPanelComponent {}
+```
 
 ## Playground
 
-For complete end-to-end examples with full agentic UIs, visit the [LangGraph Playground](https://github.com/langchain-ai/langgraphjs).
+For complete end-to-end examples with full agentic UIs, visit the [LangChain UI Playground](https://docs.langchain.com/playground).
 
 ## License
 

package/dist/_virtual/_@oxc-project_runtime@0.115.0/helpers/decorate.cjs

@@ -0,0 +1,9 @@
+//#region \0@oxc-project+runtime@0.115.0/helpers/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+//#endregion
+exports.__decorate = __decorate;

package/dist/_virtual/_@oxc-project_runtime@0.115.0/helpers/decorate.js

@@ -0,0 +1,9 @@
+//#region \0@oxc-project+runtime@0.115.0/helpers/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+//#endregion
+export { __decorate };

package/dist/context.cjs

@@ -0,0 +1,94 @@
+const require_index = require("./index.cjs");
+let _angular_core = require("@angular/core");
+//#region src/context.ts
+/**
+* Injection token for stream default configuration.
+* Provide via `provideStreamDefaults()` in your application config.
+*/
+const STREAM_DEFAULTS = new _angular_core.InjectionToken("LANGCHAIN_STREAM_DEFAULTS");
+/**
+* Injection token for a shared stream instance.
+* Provide via `provideStream()` at the component level.
+*/
+const STREAM_INSTANCE = new _angular_core.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 (0, _angular_core.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 = (0, _angular_core.inject)(STREAM_DEFAULTS, { optional: true });
+			return require_index.useStream({
+				...defaults ?? {},
+				...options,
+				apiUrl: options.apiUrl ?? defaults?.apiUrl,
+				client: options.client ?? defaults?.client
+			});
+		}
+	};
+}
+//#endregion
+exports.STREAM_DEFAULTS = STREAM_DEFAULTS;
+exports.STREAM_INSTANCE = STREAM_INSTANCE;
+exports.provideStream = provideStream;
+exports.provideStreamDefaults = provideStreamDefaults;
+
+//# sourceMappingURL=context.cjs.map

package/dist/context.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.cjs","names":["InjectionToken","useStream"],"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"],"mappings":";;;;;;;AAgCA,MAAa,kBAAkB,IAAIA,cAAAA,eACjC,4BACD;;;;;AAOD,MAAa,kBAAkB,IAAIA,cAAAA,eACjC,4BACD;;;;;;;;;;;;;;;;;;;;;;AAuBD,SAAgB,sBACd,UACsB;AACtB,SAAA,GAAA,cAAA,0BAAgC,CAC9B;EAAE,SAAS;EAAiB,UAAU;EAAU,CACjD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCJ,SAAgB,cAId,SAGA;AACA,QAAO;EACL,SAAS;EACT,kBAAkB;GAChB,MAAM,YAAA,GAAA,cAAA,QAAyB,iBAAiB,EAAE,UAAU,MAAM,CAAC;AAQnE,UAAOC,cAAAA,UAPQ;IACb,GAAI,YAAY,EAAE;IAClB,GAAG;IACH,QAAS,QAAoC,UAAU,UAAU;IACjE,QAAS,QAAoC,UAAU,UAAU;IAClE,CAE8B;;EAElC"}

package/dist/context.d.cts

@@ -0,0 +1,130 @@
+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.cjs";
+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";
+import * as _langchain_langgraph_sdk_ui0 from "@langchain/langgraph-sdk/ui";
+import { InferBag, InferStateType, ResolveStreamOptions, UseStreamCustomOptions } from "@langchain/langgraph-sdk/ui";
+import * as _angular_core0 from "@angular/core";
+import { EnvironmentProviders, InjectionToken } from "@angular/core";
+
+//#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>;
+  };
+};
+//#endregion
+export { STREAM_DEFAULTS, STREAM_INSTANCE, StreamDefaults, provideStream, provideStreamDefaults };
+//# sourceMappingURL=context.d.cts.map

package/dist/context.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.cts","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"}