@langchain/angular 0.2.0 → 0.3.0

package/README.md

@@ -1,6 +1,8 @@
 # @langchain/angular
 
-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 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",
   });
@@ -454,7 +456,7 @@ Instead of connecting to a LangGraph API, you can provide your own streaming tra
 
 ```typescript
 import { Component } from "@angular/core";
-import { useStream, FetchStreamTransport } from "@langchain/angular";
+import { injectStream, FetchStreamTransport } from "@langchain/angular";
 import type { BaseMessage } from "langchain";
 
 @Component({
@@ -482,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",
     }),
@@ -507,7 +509,7 @@ 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. `onFinish` is also supported and receives a synthetic `ThreadState` built from the final locally streamed values; the run metadata argument is `undefined`.
+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`
 

package/dist/context.cjs

@@ -85,58 +85,9 @@ function provideStream(options) {
 		}
 	};
 }
-/**
-* 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 = (0, _angular_core.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
 exports.STREAM_DEFAULTS = STREAM_DEFAULTS;
 exports.STREAM_INSTANCE = STREAM_INSTANCE;
-exports.injectStream = injectStream;
 exports.provideStream = provideStream;
 exports.provideStreamDefaults = provideStreamDefaults;
 

package/dist/context.cjs.map

@@ -1 +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\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,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8CH,SAAgB,eAG0B;CACxC,MAAM,YAAA,GAAA,cAAA,QAAyB,iBAAiB,EAAE,UAAU,MAAM,CAAC;AACnE,KAAI,YAAY,KACd,OAAM,IAAI,MACR,8MAGD;AAEH,QAAO"}
+{"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

@@ -1,5 +1,4 @@
 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 { useStream } from "./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";
@@ -126,50 +125,6 @@ declare function provideStream<T = Record<string, unknown>, Bag extends BagTempl
     } | 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 };
+export { STREAM_DEFAULTS, STREAM_INSTANCE, StreamDefaults, provideStream, provideStreamDefaults };
 //# sourceMappingURL=context.d.cts.map

package/dist/context.d.cts.map

@@ -1 +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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6D5C,YAAA,KACV,MAAA,+BACQ,WAAA,GAAc,WAAA,CAAA,CAAA,GACvB,UAAA,QAAkB,SAAA,CAAU,CAAA,EAAG,GAAA"}
+{"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"}

package/dist/context.d.ts

@@ -1,5 +1,4 @@
 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";
@@ -126,50 +125,6 @@ declare function provideStream<T = Record<string, unknown>, Bag extends BagTempl
     } | 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 };
+export { STREAM_DEFAULTS, STREAM_INSTANCE, StreamDefaults, provideStream, provideStreamDefaults };
 //# sourceMappingURL=context.d.ts.map

package/dist/context.d.ts.map

@@ -1 +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"}
+{"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"}

package/dist/context.js

@@ -85,55 +85,7 @@ function provideStream(options) {
 		}
 	};
 }
-/**
-* 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 { 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,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"}