@langchain/angular 0.4.1 → 0.4.3

package/dist/context.d.cts

@@ -121,8 +121,8 @@ declare function provideStream<T = Record<string, unknown>, Bag extends BagTempl
       clear: () => Promise<void>;
     };
     switchThread(newThreadId: string | null): void;
-    subagents: _angular_core0.Signal<ReadonlyMap<string, _langchain_langgraph_sdk_ui0.SubagentStreamInterface<Record<string, unknown>, _langchain_langgraph_sdk0.DefaultToolCall, string>>>;
-    activeSubagents: _angular_core0.Signal<readonly _langchain_langgraph_sdk_ui0.SubagentStreamInterface<Record<string, unknown>, _langchain_langgraph_sdk0.DefaultToolCall, string>[]>;
+    subagents: _angular_core0.Signal<Map<string, _langchain_langgraph_sdk_ui0.SubagentStreamInterface<Record<string, unknown>, _langchain_langgraph_sdk0.DefaultToolCall, string>>>;
+    activeSubagents: _angular_core0.Signal<_langchain_langgraph_sdk_ui0.SubagentStreamInterface<Record<string, unknown>, _langchain_langgraph_sdk0.DefaultToolCall, string>[]>;
     getSubagent(toolCallId: string): _langchain_langgraph_sdk_ui0.SubagentStreamInterface<Record<string, unknown>, _langchain_langgraph_sdk0.DefaultToolCall, string> | undefined;
     getSubagentsByType(type: string): _langchain_langgraph_sdk_ui0.SubagentStreamInterface<Record<string, unknown>, _langchain_langgraph_sdk0.DefaultToolCall, string>[];
     getSubagentsByMessage(messageId: string): _langchain_langgraph_sdk_ui0.SubagentStreamInterface<Record<string, unknown>, _langchain_langgraph_sdk0.DefaultToolCall, string>[];

package/dist/context.d.ts

@@ -121,8 +121,8 @@ declare function provideStream<T = Record<string, unknown>, Bag extends BagTempl
       clear: () => Promise<void>;
     };
     switchThread(newThreadId: string | null): void;
-    subagents: _angular_core0.Signal<ReadonlyMap<string, _langchain_langgraph_sdk_ui0.SubagentStreamInterface<Record<string, unknown>, _langchain_langgraph_sdk0.DefaultToolCall, string>>>;
-    activeSubagents: _angular_core0.Signal<readonly _langchain_langgraph_sdk_ui0.SubagentStreamInterface<Record<string, unknown>, _langchain_langgraph_sdk0.DefaultToolCall, string>[]>;
+    subagents: _angular_core0.Signal<Map<string, _langchain_langgraph_sdk_ui0.SubagentStreamInterface<Record<string, unknown>, _langchain_langgraph_sdk0.DefaultToolCall, string>>>;
+    activeSubagents: _angular_core0.Signal<_langchain_langgraph_sdk_ui0.SubagentStreamInterface<Record<string, unknown>, _langchain_langgraph_sdk0.DefaultToolCall, string>[]>;
     getSubagent(toolCallId: string): _langchain_langgraph_sdk_ui0.SubagentStreamInterface<Record<string, unknown>, _langchain_langgraph_sdk0.DefaultToolCall, string> | undefined;
     getSubagentsByType(type: string): _langchain_langgraph_sdk_ui0.SubagentStreamInterface<Record<string, unknown>, _langchain_langgraph_sdk0.DefaultToolCall, string>[];
     getSubagentsByMessage(messageId: string): _langchain_langgraph_sdk_ui0.SubagentStreamInterface<Record<string, unknown>, _langchain_langgraph_sdk0.DefaultToolCall, string>[];

package/dist/index.cjs

@@ -5,6 +5,7 @@ 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");
 //#region src/index.ts
 /**
 * @internal Merges DI, LangGraph Platform, and custom transport overloads.
@@ -136,6 +137,12 @@ Object.defineProperty(exports, "calculateDepthFromNamespace", {
 		return _langchain_langgraph_sdk_ui.calculateDepthFromNamespace;
 	}
 });
+Object.defineProperty(exports, "executeHeadlessTool", {
+	enumerable: true,
+	get: function() {
+		return _langchain_langgraph_sdk.executeHeadlessTool;
+	}
+});
 Object.defineProperty(exports, "extractParentIdFromNamespace", {
 	enumerable: true,
 	get: function() {
@@ -148,14 +155,56 @@ Object.defineProperty(exports, "extractToolCallIdFromNamespace", {
 		return _langchain_langgraph_sdk_ui.extractToolCallIdFromNamespace;
 	}
 });
+Object.defineProperty(exports, "filterOutHeadlessToolInterrupts", {
+	enumerable: true,
+	get: function() {
+		return _langchain_langgraph_sdk.filterOutHeadlessToolInterrupts;
+	}
+});
+Object.defineProperty(exports, "findHeadlessTool", {
+	enumerable: true,
+	get: function() {
+		return _langchain_langgraph_sdk.findHeadlessTool;
+	}
+});
+Object.defineProperty(exports, "flushPendingHeadlessToolInterrupts", {
+	enumerable: true,
+	get: function() {
+		return _langchain_langgraph_sdk.flushPendingHeadlessToolInterrupts;
+	}
+});
+Object.defineProperty(exports, "handleHeadlessToolInterrupt", {
+	enumerable: true,
+	get: function() {
+		return _langchain_langgraph_sdk.handleHeadlessToolInterrupt;
+	}
+});
+Object.defineProperty(exports, "headlessToolResumeCommand", {
+	enumerable: true,
+	get: function() {
+		return _langchain_langgraph_sdk.headlessToolResumeCommand;
+	}
+});
 exports.injectStream = injectStream;
 exports.injectStreamCustom = require_stream_custom.injectStreamCustom;
+Object.defineProperty(exports, "isHeadlessToolInterrupt", {
+	enumerable: true,
+	get: function() {
+		return _langchain_langgraph_sdk.isHeadlessToolInterrupt;
+	}
+});
 Object.defineProperty(exports, "isSubagentNamespace", {
 	enumerable: true,
 	get: function() {
 		return _langchain_langgraph_sdk_ui.isSubagentNamespace;
 	}
 });
+Object.defineProperty(exports, "parseHeadlessToolInterruptPayload", {
+	enumerable: true,
+	get: function() {
+		return _langchain_langgraph_sdk.parseHeadlessToolInterruptPayload;
+	}
+});
 exports.provideStream = require_context.provideStream;
 exports.provideStreamDefaults = require_context.provideStreamDefaults;
 exports.useStream = useStream;

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":["STREAM_INSTANCE","injectStreamCustom","useStreamLGP"],"sources":["../src/index.ts"],"sourcesContent":["import { Injectable, inject as angularInject } from \"@angular/core\";\nimport type { Signal, WritableSignal } from \"@angular/core\";\nimport type {\n  BaseMessage,\n  ToolMessage as CoreToolMessage,\n  AIMessage as CoreAIMessage,\n} from \"@langchain/core/messages\";\nimport type {\n  MessageMetadata,\n  SubmitOptions,\n  ResolveStreamOptions,\n  ResolveStreamInterface,\n  InferBag,\n  InferStateType,\n  AcceptBaseMessages,\n  UseStreamCustomOptions,\n  SubagentStreamInterface,\n  WithClassMessages,\n  GetConfigurableType,\n  GetInterruptType,\n} from \"@langchain/langgraph-sdk/ui\";\n\nimport {\n  Client,\n  type StreamEvent,\n  type StreamMode,\n  type Message,\n  type Interrupt,\n  type BagTemplate,\n  type ToolCallWithResult as SdkToolCallWithResult,\n  type DefaultToolCall,\n} from \"@langchain/langgraph-sdk\";\nimport type { StreamServiceInstance } from \"./stream-service-instance.js\";\nimport { injectStreamCustom } from \"./stream.custom.js\";\nimport { useStreamLGP } from \"./stream.lgp.js\";\nimport { STREAM_INSTANCE } from \"./context.js\";\n\nexport { injectStreamCustom, useStreamCustom } from \"./stream.custom.js\";\nexport { FetchStreamTransport } from \"@langchain/langgraph-sdk/ui\";\nexport {\n  provideStreamDefaults,\n  provideStream,\n  STREAM_DEFAULTS,\n  STREAM_INSTANCE,\n} from \"./context.js\";\nexport type { StreamDefaults } from \"./context.js\";\nexport type { ClassSubagentStreamInterface } from \"@langchain/langgraph-sdk/ui\";\n\ntype AngularWritableKeys = \"isLoading\" | \"branch\";\n\ntype AngularPlainKeys =\n  | \"submit\"\n  | \"stop\"\n  | \"joinStream\"\n  | \"switchThread\"\n  | \"setBranch\"\n  | \"getMessagesMetadata\"\n  | \"getToolCalls\"\n  | \"getSubagent\"\n  | \"getSubagentsByType\"\n  | \"getSubagentsByMessage\"\n  | \"client\"\n  | \"assistantId\";\n\ntype AngularQueueInterface<T> = T extends {\n  entries: infer E;\n  size: infer S;\n  cancel: infer C;\n  clear: infer Cl;\n}\n  ? {\n      entries: WritableSignal<E>;\n      size: WritableSignal<S>;\n      cancel: C;\n      clear: Cl;\n    }\n  : T;\n\ntype AngularSignalWrap<T> = {\n  [K in keyof T]: K extends AngularPlainKeys\n    ? T[K]\n    : K extends AngularWritableKeys\n      ? WritableSignal<T[K]>\n      : K extends \"queue\"\n        ? AngularQueueInterface<T[K]>\n        : Signal<T[K]>;\n};\n\n/**\n * Injects the shared stream instance from the nearest ancestor that provided\n * one via {@link provideStream}. Throws if no ancestor provides a stream\n * 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 */\nfunction injectStream<\n  T = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate,\n>(): AngularSignalWrap<\n  WithClassMessages<ResolveStreamInterface<T, InferBag<T, Bag>>>\n>;\n\n/**\n * Angular entry point for LangGraph streaming. Call from a component, directive,\n * or service field initializer to get a **Signals-based** stream controller\n * connected to the LangGraph Platform (HTTP + threads API).\n *\n * The returned object mirrors the shared `useStream` API from\n * `@langchain/langgraph-sdk/ui`, but reactive fields are\n * {@link https://angular.dev/guide/signals | Angular `Signal`s}:\n * read state with calls like `stream.messages()`, `stream.values()`, and\n * `stream.isLoading()`, and use `WritableSignal` setters where exposed (for\n * example `stream.branch` for branch selection).\n *\n * ## Typing with `createDeepAgent`\n *\n * Expect `export const agent = createDeepAgent({ ... })` from `deepagents`. In\n * UI code, `import { type agent } from \"./agent\"` (or `import type { agent }`)\n * is a **type-only** import: it is erased when compiling, so the agent module\n * does not run in the browser. You still pass **`typeof agent`** to\n * `injectStream`, not `agent` alone — `agent` is a value; TypeScript only\n * accepts it in a type position via `typeof` (otherwise: *refers to a value,\n * but is being used as a type*). If you prefer a named type in generics, add\n * `export type Agent = typeof agent` next to the const and use\n * `injectStream<Agent>(...)`.\n *\n * @example\n * ```typescript\n * // agent.ts\n * import { createDeepAgent } from \"deepagents\";\n * import { tool } from \"langchain\";\n * import { z } from \"zod\";\n *\n * const getWeather = tool(\n *   async ({ location }) => `Weather in ${location}`,\n *   { name: \"get_weather\", schema: z.object({ location: z.string() }) },\n * );\n *\n * export const agent = createDeepAgent({\n *   model: \"openai:gpt-4o\",\n *   tools: [getWeather],\n * });\n *\n * // chat.component.ts — type-only import; no agent runtime in the frontend\n * import { Component } from \"@angular/core\";\n * import { injectStream } from \"@langchain/angular\";\n * import { type agent } from \"./agent\";\n *\n * @Component({\n *   standalone: true,\n *   template: `\n *     @for (msg of stream.messages(); track msg.id ?? $index) {\n *       <p>{{ msg.content }}</p>\n *     }\n *   `,\n * })\n * export class ChatComponent {\n *   readonly stream = injectStream<typeof agent>({\n *     assistantId: \"agent\",\n *     apiUrl: \"http://localhost:2024\",\n *   });\n *   // stream.toolCalls()[0].call.name is typed as \"get_weather\"\n * }\n * ```\n *\n * ## Typing with `StateGraph` / custom graph state\n *\n * Use your graph state interface as `T` and embed tool call unions in\n * `Message<...>[]` when you need discriminated tool types.\n *\n * @example\n * ```typescript\n * import { Message } from \"@langchain/langgraph-sdk\";\n * import { Component } from \"@angular/core\";\n * import { injectStream } from \"@langchain/angular\";\n *\n * type MyToolCalls =\n *   | { name: \"search\"; args: { query: string }; id?: string }\n *   | { name: \"calculate\"; args: { expression: string }; id?: string };\n *\n * interface MyGraphState {\n *   messages: Message<MyToolCalls>[];\n *   context?: string;\n * }\n *\n * @Component({ standalone: true, template: \"\" })\n * export class ChatComponent {\n *   readonly stream = injectStream<MyGraphState>({\n *     assistantId: \"my-graph\",\n *     apiUrl: \"http://localhost:2024\",\n *   });\n *   // stream.values() is typed as MyGraphState | null\n * }\n * ```\n *\n * @example\n * ```typescript\n * // Optional bag for interrupts, configurable, custom events, and updates\n * import { Component } from \"@angular/core\";\n * import { injectStream } from \"@langchain/angular\";\n * import type { Message } from \"@langchain/langgraph-sdk\";\n *\n * interface MyGraphState {\n *   messages: Message[];\n * }\n *\n * @Component({ standalone: true, template: \"\" })\n * export class ChatComponent {\n *   readonly stream = injectStream<\n *     MyGraphState,\n *     {\n *       InterruptType: { question: string };\n *       ConfigurableType: { userId: string };\n *     }\n *   >({\n *     assistantId: \"my-graph\",\n *     apiUrl: \"http://localhost:2024\",\n *   });\n *   // stream.interrupt() is typed as { question: string } | undefined\n * }\n * ```\n *\n * ## Subagent streaming\n *\n * For `createDeepAgent` agents with `subagents`, set `filterSubagentMessages`\n * and use `streamSubgraphs` on `submit` to populate `stream.subagents` and\n * related helpers.\n *\n * @example\n * ```typescript\n * import { Component } from \"@angular/core\";\n * import { injectStream } from \"@langchain/angular\";\n * import { type agent } from \"./agent\";\n *\n * @Component({ standalone: true, template: \"\" })\n * export class DeepAgentChatComponent {\n *   readonly stream = injectStream<typeof agent>({\n *     assistantId: \"deepagent\",\n *     apiUrl: \"http://localhost:2024\",\n *     filterSubagentMessages: true,\n *   });\n *\n *   send(content: string) {\n *     void this.stream.submit(\n *       { messages: [{ content, type: \"human\" }] },\n *       { streamSubgraphs: true },\n *     );\n *   }\n * }\n * ```\n *\n * @param options - LangGraph Platform client options (`apiUrl` or `client`),\n *   `assistantId`, stream modes, history, reconnect, subagent settings, etc.\n *\n * @returns A stream controller backed by Signals: graph values, messages,\n *   loading and error state, interrupts, tool calls, branching, queue, and\n *   `submit` / `stop` / `switchThread` helpers (writable where the UI layer\n *   requires mutation).\n *\n * @template T Agent type (with `~agentTypes`) from `createDeepAgent` or\n *   `createAgent`, or a state shape extending `Record<string, unknown>`.\n * @template Bag Optional configuration bag:\n *   - `ConfigurableType` — `config.configurable` typing\n *   - `InterruptType` — human-in-the-loop interrupt payloads\n *   - `CustomEventType` — custom stream events\n *   - `UpdateType` — payload typing for `submit`\n *\n * @see {@link https://docs.langchain.com/oss/javascript/langgraph/overview | LangGraph JavaScript overview}\n * @see {@link https://docs.langchain.com/oss/javascript/langchain/overview | LangChain JavaScript overview}\n * @see {@link https://docs.langchain.com/oss/javascript/deepagents/overview | Deep Agents JavaScript overview}\n */\nfunction injectStream<\n  T = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate,\n>(\n  options: ResolveStreamOptions<T, InferBag<T, Bag>>\n): AngularSignalWrap<\n  WithClassMessages<ResolveStreamInterface<T, InferBag<T, Bag>>>\n>;\n\n/**\n * Overload for a **custom transport** (`options.transport`), for example\n * {@link FetchStreamTransport} or any implementation compatible with\n * {@link injectStreamCustom}. Prefer {@link injectStreamCustom} directly when\n * you only use custom transports and want a narrower import.\n *\n * @param options - Custom transport and stream options (must include\n *   `transport`).\n *\n * @returns The same Signals-based controller shape as the LangGraph Platform\n *   overload.\n *\n * @template T Agent type or state shape, matching the custom transport.\n * @template Bag Same optional bag as the platform overload.\n *\n * @see {@link injectStreamCustom}\n */\nfunction injectStream<\n  T = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate,\n>(\n  options: UseStreamCustomOptions<InferStateType<T>, InferBag<T, Bag>>\n): AngularSignalWrap<\n  WithClassMessages<ResolveStreamInterface<T, InferBag<T, Bag>>>\n>;\n\n/**\n * @internal Merges DI, LangGraph Platform, and custom transport overloads.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction injectStream(options?: any): any {\n  if (arguments.length === 0) {\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 injectStream(options) directly.\"\n      );\n    }\n    return instance;\n  }\n  if (\"transport\" in options) {\n    return injectStreamCustom(options);\n  }\n  return useStreamLGP(options);\n}\n\nexport { injectStream };\n\n/**\n * @deprecated Use `injectStream` instead. `useStream` will be removed in a\n * future major version. `injectStream` follows Angular's `inject*` naming\n * convention for injection-based patterns.\n */\nexport const useStream = injectStream;\n\nexport { useStreamLGP } from \"./stream.lgp.js\";\n\n/**\n * Injectable Angular service that wraps {@link injectStream}.\n *\n * Extend this class with your own `@Injectable()` service and call\n * `super(options)` in the constructor:\n *\n * ```ts\n * \\@Injectable({ providedIn: 'root' })\n * export class ChatService extends StreamService {\n *   constructor() {\n *     super({ assistantId: 'agent', apiUrl: '...' });\n *   }\n * }\n * ```\n *\n * The service exposes the same signals and methods as `injectStream`\n * (e.g. `values`, `messages`, `isLoading`, `submit`, `stop`).\n *\n * Must be created within an Angular injection context (via DI or\n * `runInInjectionContext`).\n */\n@Injectable()\nexport class StreamService<\n  T = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate,\n> {\n  private readonly _stream: StreamServiceInstance<T, Bag>;\n\n  constructor(\n    options:\n      | ResolveStreamOptions<T, InferBag<T, Bag>>\n      | UseStreamCustomOptions<InferStateType<T>, InferBag<T, Bag>>\n  ) {\n    this._stream = injectStream(\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      options as any\n    ) as unknown as StreamServiceInstance<T, Bag>;\n  }\n\n  get values(): Signal<T> {\n    return this._stream.values;\n  }\n\n  get messages(): Signal<BaseMessage[]> {\n    return this._stream.messages;\n  }\n\n  get isLoading(): WritableSignal<boolean> {\n    return this._stream.isLoading;\n  }\n\n  get error(): Signal<unknown> {\n    return this._stream.error;\n  }\n\n  get branch(): WritableSignal<string> {\n    return this._stream.branch;\n  }\n\n  get interrupt(): Signal<Interrupt<GetInterruptType<Bag>> | undefined> {\n    return this._stream.interrupt;\n  }\n\n  get interrupts(): Signal<Interrupt<GetInterruptType<Bag>>[]> {\n    return this._stream.interrupts;\n  }\n\n  get toolCalls(): Signal<SdkToolCallWithResult<DefaultToolCall>[]> {\n    return this._stream.toolCalls;\n  }\n\n  get queue(): AngularQueueInterface<{\n    entries: readonly { id: string; values: Partial<T> | null | undefined }[];\n    size: number;\n    cancel: (id: string) => Promise<boolean>;\n    clear: () => Promise<void>;\n  }> {\n    return this._stream.queue;\n  }\n\n  get subagents(): Signal<ReadonlyMap<string, SubagentStreamInterface>> {\n    return this._stream.subagents;\n  }\n\n  get activeSubagents(): Signal<readonly SubagentStreamInterface[]> {\n    return this._stream.activeSubagents;\n  }\n\n  get history(): Signal<unknown> {\n    return this._stream.history;\n  }\n\n  get isThreadLoading(): Signal<boolean> {\n    return this._stream.isThreadLoading;\n  }\n\n  get experimental_branchTree(): Signal<unknown> {\n    return this._stream.experimental_branchTree;\n  }\n\n  get client(): Client {\n    return this._stream.client;\n  }\n\n  get assistantId(): string {\n    return this._stream.assistantId;\n  }\n\n  submit(\n    values: AcceptBaseMessages<Exclude<T, null | undefined>> | null | undefined,\n    options?: SubmitOptions<\n      T extends Record<string, unknown> ? T : Record<string, unknown>,\n      GetConfigurableType<Bag>\n    >\n  ): ReturnType<typeof this._stream.submit> {\n    return this._stream.submit(values, options);\n  }\n\n  async stop(): Promise<void> {\n    await this._stream.stop();\n  }\n\n  setBranch(value: string): void {\n    this._stream.setBranch(value);\n  }\n\n  switchThread(newThreadId: string | null): void {\n    this._stream.switchThread(newThreadId);\n  }\n\n  joinStream(\n    runId: string,\n    lastEventId?: string,\n    options?: {\n      streamMode?: StreamMode | StreamMode[];\n      filter?: (event: {\n        id?: string;\n        event: StreamEvent;\n        data: unknown;\n      }) => boolean;\n    }\n  ): Promise<void> {\n    return this._stream.joinStream(runId, lastEventId, options);\n  }\n\n  getMessagesMetadata(\n    message: BaseMessage,\n    index?: number\n  ):\n    | MessageMetadata<\n        T extends Record<string, unknown> ? T : Record<string, unknown>\n      >\n    | undefined {\n    return this._stream.getMessagesMetadata(message as Message, index);\n  }\n\n  getToolCalls(message: BaseMessage): SdkToolCallWithResult<DefaultToolCall>[] {\n    return this._stream.getToolCalls(message as Message);\n  }\n\n  getSubagent(toolCallId: string): SubagentStreamInterface | undefined {\n    return this._stream.getSubagent(toolCallId);\n  }\n\n  getSubagentsByType(type: string): SubagentStreamInterface[] {\n    return this._stream.getSubagentsByType(type);\n  }\n\n  getSubagentsByMessage(messageId: string): SubagentStreamInterface[] {\n    return this._stream.getSubagentsByMessage(messageId);\n  }\n}\n\nexport type {\n  BaseStream,\n  UseAgentStream,\n  UseAgentStreamOptions,\n  UseDeepAgentStream,\n  UseDeepAgentStreamOptions,\n  ResolveStreamInterface,\n  ResolveStreamOptions,\n  InferStateType,\n  InferToolCalls,\n  InferSubagentStates,\n  InferNodeNames,\n  InferBag,\n  MessageMetadata,\n  UseStreamOptions,\n  UseStreamCustomOptions,\n  UseStreamTransport,\n  UseStreamThread,\n  GetToolCallsType,\n  AgentTypeConfigLike,\n  IsAgentLike,\n  ExtractAgentConfig,\n  InferAgentToolCalls,\n  SubagentToolCall,\n  SubagentStatus,\n  SubagentApi,\n  SubagentStream,\n  SubagentStreamInterface,\n  SubAgentLike,\n  CompiledSubAgentLike,\n  DeepAgentTypeConfigLike,\n  IsDeepAgentLike,\n  ExtractDeepAgentConfig,\n  ExtractSubAgentMiddleware,\n  InferDeepAgentSubagents,\n  InferSubagentByName,\n  InferSubagentState,\n  InferSubagentNames,\n  SubagentStateMap,\n  DefaultSubagentStates,\n  BaseSubagentState,\n  QueueEntry,\n  QueueInterface,\n} from \"@langchain/langgraph-sdk/ui\";\n\nexport type ToolCallWithResult<ToolCall = DefaultToolCall> =\n  SdkToolCallWithResult<ToolCall, CoreToolMessage, CoreAIMessage>;\nexport type {\n  ToolCallState,\n  DefaultToolCall,\n  ToolCallFromTool,\n  ToolCallsFromTools,\n} from \"@langchain/langgraph-sdk\";\n\nexport {\n  SubagentManager,\n  extractToolCallIdFromNamespace,\n  calculateDepthFromNamespace,\n  extractParentIdFromNamespace,\n  isSubagentNamespace,\n} from \"@langchain/langgraph-sdk/ui\";\n"],"mappings":";;;;;;;;;;;AAyVA,SAAS,aAAa,SAAoB;AACxC,KAAI,UAAU,WAAW,GAAG;EAC1B,MAAM,YAAA,GAAA,cAAA,QAAyBA,gBAAAA,iBAAiB,EAAE,UAAU,MAAM,CAAC;AACnE,MAAI,YAAY,KACd,OAAM,IAAI,MACR,wNAGD;AAEH,SAAO;;AAET,KAAI,eAAe,QACjB,QAAOC,sBAAAA,mBAAmB,QAAQ;AAEpC,QAAOC,mBAAAA,aAAa,QAAQ;;;;;;;AAU9B,MAAa,YAAY;AA0BlB,IAAA,gBAAA,MAAM,cAGX;CACA;CAEA,YACE,SAGA;AACA,OAAK,UAAU,aAEb,QACD;;CAGH,IAAI,SAAoB;AACtB,SAAO,KAAK,QAAQ;;CAGtB,IAAI,WAAkC;AACpC,SAAO,KAAK,QAAQ;;CAGtB,IAAI,YAAqC;AACvC,SAAO,KAAK,QAAQ;;CAGtB,IAAI,QAAyB;AAC3B,SAAO,KAAK,QAAQ;;CAGtB,IAAI,SAAiC;AACnC,SAAO,KAAK,QAAQ;;CAGtB,IAAI,YAAkE;AACpE,SAAO,KAAK,QAAQ;;CAGtB,IAAI,aAAyD;AAC3D,SAAO,KAAK,QAAQ;;CAGtB,IAAI,YAA8D;AAChE,SAAO,KAAK,QAAQ;;CAGtB,IAAI,QAKD;AACD,SAAO,KAAK,QAAQ;;CAGtB,IAAI,YAAkE;AACpE,SAAO,KAAK,QAAQ;;CAGtB,IAAI,kBAA8D;AAChE,SAAO,KAAK,QAAQ;;CAGtB,IAAI,UAA2B;AAC7B,SAAO,KAAK,QAAQ;;CAGtB,IAAI,kBAAmC;AACrC,SAAO,KAAK,QAAQ;;CAGtB,IAAI,0BAA2C;AAC7C,SAAO,KAAK,QAAQ;;CAGtB,IAAI,SAAiB;AACnB,SAAO,KAAK,QAAQ;;CAGtB,IAAI,cAAsB;AACxB,SAAO,KAAK,QAAQ;;CAGtB,OACE,QACA,SAIwC;AACxC,SAAO,KAAK,QAAQ,OAAO,QAAQ,QAAQ;;CAG7C,MAAM,OAAsB;AAC1B,QAAM,KAAK,QAAQ,MAAM;;CAG3B,UAAU,OAAqB;AAC7B,OAAK,QAAQ,UAAU,MAAM;;CAG/B,aAAa,aAAkC;AAC7C,OAAK,QAAQ,aAAa,YAAY;;CAGxC,WACE,OACA,aACA,SAQe;AACf,SAAO,KAAK,QAAQ,WAAW,OAAO,aAAa,QAAQ;;CAG7D,oBACE,SACA,OAKY;AACZ,SAAO,KAAK,QAAQ,oBAAoB,SAAoB,MAAM;;CAGpE,aAAa,SAAgE;AAC3E,SAAO,KAAK,QAAQ,aAAa,QAAmB;;CAGtD,YAAY,YAAyD;AACnE,SAAO,KAAK,QAAQ,YAAY,WAAW;;CAG7C,mBAAmB,MAAyC;AAC1D,SAAO,KAAK,QAAQ,mBAAmB,KAAK;;CAG9C,sBAAsB,WAA8C;AAClE,SAAO,KAAK,QAAQ,sBAAsB,UAAU;;;4EApJ3C,CAAA,EAAA,cAAA"}
+{"version":3,"file":"index.cjs","names":["STREAM_INSTANCE","injectStreamCustom","useStreamLGP"],"sources":["../src/index.ts"],"sourcesContent":["import { Injectable, inject as angularInject } from \"@angular/core\";\nimport type { Signal, WritableSignal } from \"@angular/core\";\nimport type {\n  BaseMessage,\n  ToolMessage as CoreToolMessage,\n  AIMessage as CoreAIMessage,\n} from \"@langchain/core/messages\";\nimport type {\n  MessageMetadata,\n  SubmitOptions,\n  ResolveStreamOptions,\n  ResolveStreamInterface,\n  InferBag,\n  InferStateType,\n  AcceptBaseMessages,\n  UseStreamCustomOptions,\n  SubagentStreamInterface,\n  WithClassMessages,\n  GetConfigurableType,\n  GetInterruptType,\n} from \"@langchain/langgraph-sdk/ui\";\n\nimport {\n  Client,\n  type StreamEvent,\n  type StreamMode,\n  type Message,\n  type Interrupt,\n  type BagTemplate,\n  type ToolCallWithResult as SdkToolCallWithResult,\n  type DefaultToolCall,\n} from \"@langchain/langgraph-sdk\";\nimport type { StreamServiceInstance } from \"./stream-service-instance.js\";\nimport { injectStreamCustom } from \"./stream.custom.js\";\nimport { useStreamLGP } from \"./stream.lgp.js\";\nimport { STREAM_INSTANCE } from \"./context.js\";\n\nexport { injectStreamCustom, useStreamCustom } from \"./stream.custom.js\";\nexport { FetchStreamTransport } from \"@langchain/langgraph-sdk/ui\";\nexport {\n  provideStreamDefaults,\n  provideStream,\n  STREAM_DEFAULTS,\n  STREAM_INSTANCE,\n} from \"./context.js\";\nexport type { StreamDefaults } from \"./context.js\";\nexport type { ClassSubagentStreamInterface } from \"@langchain/langgraph-sdk/ui\";\n\ntype AngularWritableKeys = \"isLoading\" | \"branch\";\n\ntype AngularPlainKeys =\n  | \"submit\"\n  | \"stop\"\n  | \"joinStream\"\n  | \"switchThread\"\n  | \"setBranch\"\n  | \"getMessagesMetadata\"\n  | \"getToolCalls\"\n  | \"getSubagent\"\n  | \"getSubagentsByType\"\n  | \"getSubagentsByMessage\"\n  | \"client\"\n  | \"assistantId\";\n\ntype AngularQueueInterface<T> = T extends {\n  entries: infer E;\n  size: infer S;\n  cancel: infer C;\n  clear: infer Cl;\n}\n  ? {\n      entries: WritableSignal<E>;\n      size: WritableSignal<S>;\n      cancel: C;\n      clear: Cl;\n    }\n  : T;\n\ntype AngularSignalWrap<T> = {\n  [K in keyof T]: K extends AngularPlainKeys\n    ? T[K]\n    : K extends AngularWritableKeys\n      ? WritableSignal<T[K]>\n      : K extends \"queue\"\n        ? AngularQueueInterface<T[K]>\n        : Signal<T[K]>;\n};\n\n/**\n * Injects the shared stream instance from the nearest ancestor that provided\n * one via {@link provideStream}. Throws if no ancestor provides a stream\n * 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 */\nfunction injectStream<\n  T = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate,\n>(): AngularSignalWrap<\n  WithClassMessages<ResolveStreamInterface<T, InferBag<T, Bag>>>\n>;\n\n/**\n * Angular entry point for LangGraph streaming. Call from a component, directive,\n * or service field initializer to get a **Signals-based** stream controller\n * connected to the LangGraph Platform (HTTP + threads API).\n *\n * The returned object mirrors the shared `useStream` API from\n * `@langchain/langgraph-sdk/ui`, but reactive fields are\n * {@link https://angular.dev/guide/signals | Angular `Signal`s}:\n * read state with calls like `stream.messages()`, `stream.values()`, and\n * `stream.isLoading()`, and use `WritableSignal` setters where exposed (for\n * example `stream.branch` for branch selection).\n *\n * ## Typing with `createDeepAgent`\n *\n * Expect `export const agent = createDeepAgent({ ... })` from `deepagents`. In\n * UI code, `import { type agent } from \"./agent\"` (or `import type { agent }`)\n * is a **type-only** import: it is erased when compiling, so the agent module\n * does not run in the browser. You still pass **`typeof agent`** to\n * `injectStream`, not `agent` alone — `agent` is a value; TypeScript only\n * accepts it in a type position via `typeof` (otherwise: *refers to a value,\n * but is being used as a type*). If you prefer a named type in generics, add\n * `export type Agent = typeof agent` next to the const and use\n * `injectStream<Agent>(...)`.\n *\n * @example\n * ```typescript\n * // agent.ts\n * import { createDeepAgent } from \"deepagents\";\n * import { tool } from \"langchain\";\n * import { z } from \"zod\";\n *\n * const getWeather = tool(\n *   async ({ location }) => `Weather in ${location}`,\n *   { name: \"get_weather\", schema: z.object({ location: z.string() }) },\n * );\n *\n * export const agent = createDeepAgent({\n *   model: \"openai:gpt-4o\",\n *   tools: [getWeather],\n * });\n *\n * // chat.component.ts — type-only import; no agent runtime in the frontend\n * import { Component } from \"@angular/core\";\n * import { injectStream } from \"@langchain/angular\";\n * import { type agent } from \"./agent\";\n *\n * @Component({\n *   standalone: true,\n *   template: `\n *     @for (msg of stream.messages(); track msg.id ?? $index) {\n *       <p>{{ msg.content }}</p>\n *     }\n *   `,\n * })\n * export class ChatComponent {\n *   readonly stream = injectStream<typeof agent>({\n *     assistantId: \"agent\",\n *     apiUrl: \"http://localhost:2024\",\n *   });\n *   // stream.toolCalls()[0].call.name is typed as \"get_weather\"\n * }\n * ```\n *\n * ## Typing with `StateGraph` / custom graph state\n *\n * Use your graph state interface as `T` and embed tool call unions in\n * `Message<...>[]` when you need discriminated tool types.\n *\n * @example\n * ```typescript\n * import { Message } from \"@langchain/langgraph-sdk\";\n * import { Component } from \"@angular/core\";\n * import { injectStream } from \"@langchain/angular\";\n *\n * type MyToolCalls =\n *   | { name: \"search\"; args: { query: string }; id?: string }\n *   | { name: \"calculate\"; args: { expression: string }; id?: string };\n *\n * interface MyGraphState {\n *   messages: Message<MyToolCalls>[];\n *   context?: string;\n * }\n *\n * @Component({ standalone: true, template: \"\" })\n * export class ChatComponent {\n *   readonly stream = injectStream<MyGraphState>({\n *     assistantId: \"my-graph\",\n *     apiUrl: \"http://localhost:2024\",\n *   });\n *   // stream.values() is typed as MyGraphState | null\n * }\n * ```\n *\n * @example\n * ```typescript\n * // Optional bag for interrupts, configurable, custom events, and updates\n * import { Component } from \"@angular/core\";\n * import { injectStream } from \"@langchain/angular\";\n * import type { Message } from \"@langchain/langgraph-sdk\";\n *\n * interface MyGraphState {\n *   messages: Message[];\n * }\n *\n * @Component({ standalone: true, template: \"\" })\n * export class ChatComponent {\n *   readonly stream = injectStream<\n *     MyGraphState,\n *     {\n *       InterruptType: { question: string };\n *       ConfigurableType: { userId: string };\n *     }\n *   >({\n *     assistantId: \"my-graph\",\n *     apiUrl: \"http://localhost:2024\",\n *   });\n *   // stream.interrupt() is typed as { question: string } | undefined\n * }\n * ```\n *\n * ## Subagent streaming\n *\n * For `createDeepAgent` agents with `subagents`, set `filterSubagentMessages`\n * and use `streamSubgraphs` on `submit` to populate `stream.subagents` and\n * related helpers.\n *\n * @example\n * ```typescript\n * import { Component } from \"@angular/core\";\n * import { injectStream } from \"@langchain/angular\";\n * import { type agent } from \"./agent\";\n *\n * @Component({ standalone: true, template: \"\" })\n * export class DeepAgentChatComponent {\n *   readonly stream = injectStream<typeof agent>({\n *     assistantId: \"deepagent\",\n *     apiUrl: \"http://localhost:2024\",\n *     filterSubagentMessages: true,\n *   });\n *\n *   send(content: string) {\n *     void this.stream.submit(\n *       { messages: [{ content, type: \"human\" }] },\n *       { streamSubgraphs: true },\n *     );\n *   }\n * }\n * ```\n *\n * @param options - LangGraph Platform client options (`apiUrl` or `client`),\n *   `assistantId`, stream modes, history, reconnect, subagent settings, etc.\n *\n * @returns A stream controller backed by Signals: graph values, messages,\n *   loading and error state, interrupts, tool calls, branching, queue, and\n *   `submit` / `stop` / `switchThread` helpers (writable where the UI layer\n *   requires mutation).\n *\n * @template T Agent type (with `~agentTypes`) from `createDeepAgent` or\n *   `createAgent`, or a state shape extending `Record<string, unknown>`.\n * @template Bag Optional configuration bag:\n *   - `ConfigurableType` — `config.configurable` typing\n *   - `InterruptType` — human-in-the-loop interrupt payloads\n *   - `CustomEventType` — custom stream events\n *   - `UpdateType` — payload typing for `submit`\n *\n * @see {@link https://docs.langchain.com/oss/javascript/langgraph/overview | LangGraph JavaScript overview}\n * @see {@link https://docs.langchain.com/oss/javascript/langchain/overview | LangChain JavaScript overview}\n * @see {@link https://docs.langchain.com/oss/javascript/deepagents/overview | Deep Agents JavaScript overview}\n */\nfunction injectStream<\n  T = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate,\n>(\n  options: ResolveStreamOptions<T, InferBag<T, Bag>>\n): AngularSignalWrap<\n  WithClassMessages<ResolveStreamInterface<T, InferBag<T, Bag>>>\n>;\n\n/**\n * Overload for a **custom transport** (`options.transport`), for example\n * {@link FetchStreamTransport} or any implementation compatible with\n * {@link injectStreamCustom}. Prefer {@link injectStreamCustom} directly when\n * you only use custom transports and want a narrower import.\n *\n * @param options - Custom transport and stream options (must include\n *   `transport`).\n *\n * @returns The same Signals-based controller shape as the LangGraph Platform\n *   overload.\n *\n * @template T Agent type or state shape, matching the custom transport.\n * @template Bag Same optional bag as the platform overload.\n *\n * @see {@link injectStreamCustom}\n */\nfunction injectStream<\n  T = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate,\n>(\n  options: UseStreamCustomOptions<InferStateType<T>, InferBag<T, Bag>>\n): AngularSignalWrap<\n  WithClassMessages<ResolveStreamInterface<T, InferBag<T, Bag>>>\n>;\n\n/**\n * @internal Merges DI, LangGraph Platform, and custom transport overloads.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction injectStream(options?: any): any {\n  if (arguments.length === 0) {\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 injectStream(options) directly.\"\n      );\n    }\n    return instance;\n  }\n  if (\"transport\" in options) {\n    return injectStreamCustom(options);\n  }\n  return useStreamLGP(options);\n}\n\nexport { injectStream };\n\n/**\n * @deprecated Use `injectStream` instead. `useStream` will be removed in a\n * future major version. `injectStream` follows Angular's `inject*` naming\n * convention for injection-based patterns.\n */\nexport const useStream = injectStream;\n\nexport { useStreamLGP } from \"./stream.lgp.js\";\n\n/**\n * Injectable Angular service that wraps {@link injectStream}.\n *\n * Extend this class with your own `@Injectable()` service and call\n * `super(options)` in the constructor:\n *\n * ```ts\n * \\@Injectable({ providedIn: 'root' })\n * export class ChatService extends StreamService {\n *   constructor() {\n *     super({ assistantId: 'agent', apiUrl: '...' });\n *   }\n * }\n * ```\n *\n * The service exposes the same signals and methods as `injectStream`\n * (e.g. `values`, `messages`, `isLoading`, `submit`, `stop`).\n *\n * Must be created within an Angular injection context (via DI or\n * `runInInjectionContext`).\n */\n@Injectable()\nexport class StreamService<\n  T = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate,\n> {\n  private readonly _stream: StreamServiceInstance<T, Bag>;\n\n  constructor(\n    options:\n      | ResolveStreamOptions<T, InferBag<T, Bag>>\n      | UseStreamCustomOptions<InferStateType<T>, InferBag<T, Bag>>\n  ) {\n    this._stream = injectStream(\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      options as any\n    ) as unknown as StreamServiceInstance<T, Bag>;\n  }\n\n  get values(): Signal<T> {\n    return this._stream.values;\n  }\n\n  get messages(): Signal<BaseMessage[]> {\n    return this._stream.messages;\n  }\n\n  get isLoading(): WritableSignal<boolean> {\n    return this._stream.isLoading;\n  }\n\n  get error(): Signal<unknown> {\n    return this._stream.error;\n  }\n\n  get branch(): WritableSignal<string> {\n    return this._stream.branch;\n  }\n\n  get interrupt(): Signal<Interrupt<GetInterruptType<Bag>> | undefined> {\n    return this._stream.interrupt;\n  }\n\n  get interrupts(): Signal<Interrupt<GetInterruptType<Bag>>[]> {\n    return this._stream.interrupts;\n  }\n\n  get toolCalls(): Signal<SdkToolCallWithResult<DefaultToolCall>[]> {\n    return this._stream.toolCalls;\n  }\n\n  get queue(): AngularQueueInterface<{\n    entries: readonly { id: string; values: Partial<T> | null | undefined }[];\n    size: number;\n    cancel: (id: string) => Promise<boolean>;\n    clear: () => Promise<void>;\n  }> {\n    return this._stream.queue;\n  }\n\n  get subagents(): Signal<ReadonlyMap<string, SubagentStreamInterface>> {\n    return this._stream.subagents;\n  }\n\n  get activeSubagents(): Signal<readonly SubagentStreamInterface[]> {\n    return this._stream.activeSubagents;\n  }\n\n  get history(): Signal<unknown> {\n    return this._stream.history;\n  }\n\n  get isThreadLoading(): Signal<boolean> {\n    return this._stream.isThreadLoading;\n  }\n\n  get experimental_branchTree(): Signal<unknown> {\n    return this._stream.experimental_branchTree;\n  }\n\n  get client(): Client {\n    return this._stream.client;\n  }\n\n  get assistantId(): string {\n    return this._stream.assistantId;\n  }\n\n  submit(\n    values: AcceptBaseMessages<Exclude<T, null | undefined>> | null | undefined,\n    options?: SubmitOptions<\n      T extends Record<string, unknown> ? T : Record<string, unknown>,\n      GetConfigurableType<Bag>\n    >\n  ): ReturnType<typeof this._stream.submit> {\n    return this._stream.submit(values, options);\n  }\n\n  async stop(): Promise<void> {\n    await this._stream.stop();\n  }\n\n  setBranch(value: string): void {\n    this._stream.setBranch(value);\n  }\n\n  switchThread(newThreadId: string | null): void {\n    this._stream.switchThread(newThreadId);\n  }\n\n  joinStream(\n    runId: string,\n    lastEventId?: string,\n    options?: {\n      streamMode?: StreamMode | StreamMode[];\n      filter?: (event: {\n        id?: string;\n        event: StreamEvent;\n        data: unknown;\n      }) => boolean;\n    }\n  ): Promise<void> {\n    return this._stream.joinStream(runId, lastEventId, options);\n  }\n\n  getMessagesMetadata(\n    message: BaseMessage,\n    index?: number\n  ):\n    | MessageMetadata<\n        T extends Record<string, unknown> ? T : Record<string, unknown>\n      >\n    | undefined {\n    return this._stream.getMessagesMetadata(message as Message, index);\n  }\n\n  getToolCalls(message: BaseMessage): SdkToolCallWithResult<DefaultToolCall>[] {\n    return this._stream.getToolCalls(message as Message);\n  }\n\n  getSubagent(toolCallId: string): SubagentStreamInterface | undefined {\n    return this._stream.getSubagent(toolCallId);\n  }\n\n  getSubagentsByType(type: string): SubagentStreamInterface[] {\n    return this._stream.getSubagentsByType(type);\n  }\n\n  getSubagentsByMessage(messageId: string): SubagentStreamInterface[] {\n    return this._stream.getSubagentsByMessage(messageId);\n  }\n}\n\nexport type {\n  BaseStream,\n  UseAgentStream,\n  UseAgentStreamOptions,\n  UseDeepAgentStream,\n  UseDeepAgentStreamOptions,\n  ResolveStreamInterface,\n  ResolveStreamOptions,\n  InferStateType,\n  InferToolCalls,\n  InferSubagentStates,\n  InferNodeNames,\n  InferBag,\n  MessageMetadata,\n  UseStreamOptions,\n  UseStreamCustomOptions,\n  UseStreamTransport,\n  UseStreamThread,\n  GetToolCallsType,\n  AgentTypeConfigLike,\n  IsAgentLike,\n  ExtractAgentConfig,\n  InferAgentToolCalls,\n  SubagentToolCall,\n  SubagentStatus,\n  SubagentApi,\n  SubagentStream,\n  SubagentStreamInterface,\n  SubAgentLike,\n  CompiledSubAgentLike,\n  DeepAgentTypeConfigLike,\n  IsDeepAgentLike,\n  ExtractDeepAgentConfig,\n  ExtractSubAgentMiddleware,\n  InferDeepAgentSubagents,\n  InferSubagentByName,\n  InferSubagentState,\n  InferSubagentNames,\n  SubagentStateMap,\n  DefaultSubagentStates,\n  BaseSubagentState,\n  QueueEntry,\n  QueueInterface,\n} from \"@langchain/langgraph-sdk/ui\";\n\nexport type ToolCallWithResult<ToolCall = DefaultToolCall> =\n  SdkToolCallWithResult<ToolCall, CoreToolMessage, CoreAIMessage>;\nexport type {\n  ToolCallState,\n  DefaultToolCall,\n  ToolCallFromTool,\n  ToolCallsFromTools,\n} from \"@langchain/langgraph-sdk\";\nexport type {\n  HeadlessToolImplementation,\n  AnyHeadlessToolImplementation,\n  ToolEvent,\n  HeadlessToolInterrupt,\n  OnToolCallback,\n  FlushPendingHeadlessToolInterruptsOptions,\n} from \"@langchain/langgraph-sdk\";\n\nexport {\n  SubagentManager,\n  extractToolCallIdFromNamespace,\n  calculateDepthFromNamespace,\n  extractParentIdFromNamespace,\n  isSubagentNamespace,\n} from \"@langchain/langgraph-sdk/ui\";\nexport {\n  isHeadlessToolInterrupt,\n  parseHeadlessToolInterruptPayload,\n  filterOutHeadlessToolInterrupts,\n  findHeadlessTool,\n  executeHeadlessTool,\n  handleHeadlessToolInterrupt,\n  headlessToolResumeCommand,\n  flushPendingHeadlessToolInterrupts,\n} from \"@langchain/langgraph-sdk\";\n"],"mappings":";;;;;;;;;;;;AAyVA,SAAS,aAAa,SAAoB;AACxC,KAAI,UAAU,WAAW,GAAG;EAC1B,MAAM,YAAA,GAAA,cAAA,QAAyBA,gBAAAA,iBAAiB,EAAE,UAAU,MAAM,CAAC;AACnE,MAAI,YAAY,KACd,OAAM,IAAI,MACR,wNAGD;AAEH,SAAO;;AAET,KAAI,eAAe,QACjB,QAAOC,sBAAAA,mBAAmB,QAAQ;AAEpC,QAAOC,mBAAAA,aAAa,QAAQ;;;;;;;AAU9B,MAAa,YAAY;AA0BlB,IAAA,gBAAA,MAAM,cAGX;CACA;CAEA,YACE,SAGA;AACA,OAAK,UAAU,aAEb,QACD;;CAGH,IAAI,SAAoB;AACtB,SAAO,KAAK,QAAQ;;CAGtB,IAAI,WAAkC;AACpC,SAAO,KAAK,QAAQ;;CAGtB,IAAI,YAAqC;AACvC,SAAO,KAAK,QAAQ;;CAGtB,IAAI,QAAyB;AAC3B,SAAO,KAAK,QAAQ;;CAGtB,IAAI,SAAiC;AACnC,SAAO,KAAK,QAAQ;;CAGtB,IAAI,YAAkE;AACpE,SAAO,KAAK,QAAQ;;CAGtB,IAAI,aAAyD;AAC3D,SAAO,KAAK,QAAQ;;CAGtB,IAAI,YAA8D;AAChE,SAAO,KAAK,QAAQ;;CAGtB,IAAI,QAKD;AACD,SAAO,KAAK,QAAQ;;CAGtB,IAAI,YAAkE;AACpE,SAAO,KAAK,QAAQ;;CAGtB,IAAI,kBAA8D;AAChE,SAAO,KAAK,QAAQ;;CAGtB,IAAI,UAA2B;AAC7B,SAAO,KAAK,QAAQ;;CAGtB,IAAI,kBAAmC;AACrC,SAAO,KAAK,QAAQ;;CAGtB,IAAI,0BAA2C;AAC7C,SAAO,KAAK,QAAQ;;CAGtB,IAAI,SAAiB;AACnB,SAAO,KAAK,QAAQ;;CAGtB,IAAI,cAAsB;AACxB,SAAO,KAAK,QAAQ;;CAGtB,OACE,QACA,SAIwC;AACxC,SAAO,KAAK,QAAQ,OAAO,QAAQ,QAAQ;;CAG7C,MAAM,OAAsB;AAC1B,QAAM,KAAK,QAAQ,MAAM;;CAG3B,UAAU,OAAqB;AAC7B,OAAK,QAAQ,UAAU,MAAM;;CAG/B,aAAa,aAAkC;AAC7C,OAAK,QAAQ,aAAa,YAAY;;CAGxC,WACE,OACA,aACA,SAQe;AACf,SAAO,KAAK,QAAQ,WAAW,OAAO,aAAa,QAAQ;;CAG7D,oBACE,SACA,OAKY;AACZ,SAAO,KAAK,QAAQ,oBAAoB,SAAoB,MAAM;;CAGpE,aAAa,SAAgE;AAC3E,SAAO,KAAK,QAAQ,aAAa,QAAmB;;CAGtD,YAAY,YAAyD;AACnE,SAAO,KAAK,QAAQ,YAAY,WAAW;;CAG7C,mBAAmB,MAAyC;AAC1D,SAAO,KAAK,QAAQ,mBAAmB,KAAK;;CAG9C,sBAAsB,WAA8C;AAClE,SAAO,KAAK,QAAQ,sBAAsB,UAAU;;;4EApJ3C,CAAA,EAAA,cAAA"}

package/dist/index.d.cts

@@ -4,7 +4,7 @@ import { useStreamLGP } from "./stream.lgp.cjs";
 import { Signal, WritableSignal } from "@angular/core";
 import { AIMessage, BaseMessage, ToolMessage } from "@langchain/core/messages";
 import { AcceptBaseMessages, AgentTypeConfigLike, BaseStream, BaseSubagentState, ClassSubagentStreamInterface, CompiledSubAgentLike, DeepAgentTypeConfigLike, DefaultSubagentStates, ExtractAgentConfig, ExtractDeepAgentConfig, ExtractSubAgentMiddleware, FetchStreamTransport, GetConfigurableType, GetInterruptType, GetToolCallsType, InferAgentToolCalls, InferBag, InferBag as InferBag$1, InferDeepAgentSubagents, InferNodeNames, InferStateType, InferStateType as InferStateType$1, InferSubagentByName, InferSubagentNames, InferSubagentState, InferSubagentStates, InferToolCalls, IsAgentLike, IsDeepAgentLike, MessageMetadata, MessageMetadata as MessageMetadata$1, QueueEntry, QueueInterface, ResolveStreamInterface, ResolveStreamInterface as ResolveStreamInterface$1, ResolveStreamOptions, ResolveStreamOptions as ResolveStreamOptions$1, SubAgentLike, SubagentApi, SubagentManager, SubagentStateMap, SubagentStatus, SubagentStream, SubagentStreamInterface, SubagentStreamInterface as SubagentStreamInterface$1, SubagentToolCall, SubmitOptions, UseAgentStream, UseAgentStreamOptions, UseDeepAgentStream, UseDeepAgentStreamOptions, UseStreamCustomOptions, UseStreamCustomOptions as UseStreamCustomOptions$1, UseStreamOptions, UseStreamThread, UseStreamTransport, WithClassMessages, calculateDepthFromNamespace, extractParentIdFromNamespace, extractToolCallIdFromNamespace, isSubagentNamespace } from "@langchain/langgraph-sdk/ui";
-import { BagTemplate, Client, DefaultToolCall, DefaultToolCall as DefaultToolCall$1, Interrupt, StreamEvent, StreamMode, ToolCallFromTool, ToolCallState, ToolCallWithResult as ToolCallWithResult$1, ToolCallsFromTools } from "@langchain/langgraph-sdk";
+import { AnyHeadlessToolImplementation, BagTemplate, Client, DefaultToolCall, DefaultToolCall as DefaultToolCall$1, FlushPendingHeadlessToolInterruptsOptions, HeadlessToolImplementation, HeadlessToolInterrupt, Interrupt, OnToolCallback, StreamEvent, StreamMode, ToolCallFromTool, ToolCallState, ToolCallWithResult as ToolCallWithResult$1, ToolCallsFromTools, ToolEvent, executeHeadlessTool, filterOutHeadlessToolInterrupts, findHeadlessTool, flushPendingHeadlessToolInterrupts, handleHeadlessToolInterrupt, headlessToolResumeCommand, isHeadlessToolInterrupt, parseHeadlessToolInterruptPayload } from "@langchain/langgraph-sdk";
 
 //#region src/index.d.ts
 type AngularWritableKeys = "isLoading" | "branch";
@@ -326,5 +326,5 @@ declare class StreamService<T = Record<string, unknown>, Bag extends BagTemplate
 }
 type ToolCallWithResult<ToolCall = DefaultToolCall$1> = ToolCallWithResult$1<ToolCall, ToolMessage, AIMessage>;
 //#endregion
-export { type AgentTypeConfigLike, type BaseStream, type BaseSubagentState, type ClassSubagentStreamInterface, type CompiledSubAgentLike, type DeepAgentTypeConfigLike, type DefaultSubagentStates, type DefaultToolCall, type ExtractAgentConfig, type ExtractDeepAgentConfig, type ExtractSubAgentMiddleware, FetchStreamTransport, type GetToolCallsType, type InferAgentToolCalls, type InferBag, type InferDeepAgentSubagents, type InferNodeNames, type InferStateType, type InferSubagentByName, type InferSubagentNames, type InferSubagentState, type InferSubagentStates, type InferToolCalls, type IsAgentLike, type IsDeepAgentLike, type MessageMetadata, type QueueEntry, type QueueInterface, type ResolveStreamInterface, type ResolveStreamOptions, STREAM_DEFAULTS, STREAM_INSTANCE, type StreamDefaults, StreamService, type SubAgentLike, type SubagentApi, SubagentManager, type SubagentStateMap, type SubagentStatus, type SubagentStream, type SubagentStreamInterface, type SubagentToolCall, type ToolCallFromTool, type ToolCallState, ToolCallWithResult, type ToolCallsFromTools, type UseAgentStream, type UseAgentStreamOptions, type UseDeepAgentStream, type UseDeepAgentStreamOptions, type UseStreamCustomOptions, type UseStreamOptions, type UseStreamThread, type UseStreamTransport, calculateDepthFromNamespace, extractParentIdFromNamespace, extractToolCallIdFromNamespace, injectStream, injectStreamCustom, isSubagentNamespace, provideStream, provideStreamDefaults, useStream, useStreamCustom, useStreamLGP };
+export { type AgentTypeConfigLike, type AnyHeadlessToolImplementation, type BaseStream, type BaseSubagentState, type ClassSubagentStreamInterface, type CompiledSubAgentLike, type DeepAgentTypeConfigLike, type DefaultSubagentStates, type DefaultToolCall, type ExtractAgentConfig, type ExtractDeepAgentConfig, type ExtractSubAgentMiddleware, FetchStreamTransport, type FlushPendingHeadlessToolInterruptsOptions, type GetToolCallsType, type HeadlessToolImplementation, type HeadlessToolInterrupt, type InferAgentToolCalls, type InferBag, type InferDeepAgentSubagents, type InferNodeNames, type InferStateType, type InferSubagentByName, type InferSubagentNames, type InferSubagentState, type InferSubagentStates, type InferToolCalls, type IsAgentLike, type IsDeepAgentLike, type MessageMetadata, type OnToolCallback, type QueueEntry, type QueueInterface, type ResolveStreamInterface, type ResolveStreamOptions, STREAM_DEFAULTS, STREAM_INSTANCE, type StreamDefaults, StreamService, type SubAgentLike, type SubagentApi, SubagentManager, type SubagentStateMap, type SubagentStatus, type SubagentStream, type SubagentStreamInterface, type SubagentToolCall, type ToolCallFromTool, type ToolCallState, ToolCallWithResult, type ToolCallsFromTools, type ToolEvent, type UseAgentStream, type UseAgentStreamOptions, type UseDeepAgentStream, type UseDeepAgentStreamOptions, type UseStreamCustomOptions, type UseStreamOptions, type UseStreamThread, type UseStreamTransport, calculateDepthFromNamespace, executeHeadlessTool, extractParentIdFromNamespace, extractToolCallIdFromNamespace, filterOutHeadlessToolInterrupts, findHeadlessTool, flushPendingHeadlessToolInterrupts, handleHeadlessToolInterrupt, headlessToolResumeCommand, injectStream, injectStreamCustom, isHeadlessToolInterrupt, isSubagentNamespace, parseHeadlessToolInterruptPayload, provideStream, provideStreamDefaults, useStream, useStreamCustom, useStreamLGP };
 //# sourceMappingURL=index.d.cts.map

package/dist/index.d.ts

@@ -3,7 +3,7 @@ import { STREAM_DEFAULTS, STREAM_INSTANCE, StreamDefaults, provideStream, provid
 import { useStreamLGP } from "./stream.lgp.js";
 import { Signal, WritableSignal } from "@angular/core";
 import { AcceptBaseMessages, AgentTypeConfigLike, BaseStream, BaseSubagentState, ClassSubagentStreamInterface, CompiledSubAgentLike, DeepAgentTypeConfigLike, DefaultSubagentStates, ExtractAgentConfig, ExtractDeepAgentConfig, ExtractSubAgentMiddleware, FetchStreamTransport, GetConfigurableType, GetInterruptType, GetToolCallsType, InferAgentToolCalls, InferBag, InferBag as InferBag$1, InferDeepAgentSubagents, InferNodeNames, InferStateType, InferStateType as InferStateType$1, InferSubagentByName, InferSubagentNames, InferSubagentState, InferSubagentStates, InferToolCalls, IsAgentLike, IsDeepAgentLike, MessageMetadata, MessageMetadata as MessageMetadata$1, QueueEntry, QueueInterface, ResolveStreamInterface, ResolveStreamInterface as ResolveStreamInterface$1, ResolveStreamOptions, ResolveStreamOptions as ResolveStreamOptions$1, SubAgentLike, SubagentApi, SubagentManager, SubagentStateMap, SubagentStatus, SubagentStream, SubagentStreamInterface, SubagentStreamInterface as SubagentStreamInterface$1, SubagentToolCall, SubmitOptions, UseAgentStream, UseAgentStreamOptions, UseDeepAgentStream, UseDeepAgentStreamOptions, UseStreamCustomOptions, UseStreamCustomOptions as UseStreamCustomOptions$1, UseStreamOptions, UseStreamThread, UseStreamTransport, WithClassMessages, calculateDepthFromNamespace, extractParentIdFromNamespace, extractToolCallIdFromNamespace, isSubagentNamespace } from "@langchain/langgraph-sdk/ui";
-import { BagTemplate, Client, DefaultToolCall, DefaultToolCall as DefaultToolCall$1, Interrupt, StreamEvent, StreamMode, ToolCallFromTool, ToolCallState, ToolCallWithResult as ToolCallWithResult$1, ToolCallsFromTools } from "@langchain/langgraph-sdk";
+import { AnyHeadlessToolImplementation, BagTemplate, Client, DefaultToolCall, DefaultToolCall as DefaultToolCall$1, FlushPendingHeadlessToolInterruptsOptions, HeadlessToolImplementation, HeadlessToolInterrupt, Interrupt, OnToolCallback, StreamEvent, StreamMode, ToolCallFromTool, ToolCallState, ToolCallWithResult as ToolCallWithResult$1, ToolCallsFromTools, ToolEvent, executeHeadlessTool, filterOutHeadlessToolInterrupts, findHeadlessTool, flushPendingHeadlessToolInterrupts, handleHeadlessToolInterrupt, headlessToolResumeCommand, isHeadlessToolInterrupt, parseHeadlessToolInterruptPayload } from "@langchain/langgraph-sdk";
 import { AIMessage, BaseMessage, ToolMessage } from "@langchain/core/messages";
 
 //#region src/index.d.ts
@@ -326,5 +326,5 @@ declare class StreamService<T = Record<string, unknown>, Bag extends BagTemplate
 }
 type ToolCallWithResult<ToolCall = DefaultToolCall$1> = ToolCallWithResult$1<ToolCall, ToolMessage, AIMessage>;
 //#endregion
-export { type AgentTypeConfigLike, type BaseStream, type BaseSubagentState, type ClassSubagentStreamInterface, type CompiledSubAgentLike, type DeepAgentTypeConfigLike, type DefaultSubagentStates, type DefaultToolCall, type ExtractAgentConfig, type ExtractDeepAgentConfig, type ExtractSubAgentMiddleware, FetchStreamTransport, type GetToolCallsType, type InferAgentToolCalls, type InferBag, type InferDeepAgentSubagents, type InferNodeNames, type InferStateType, type InferSubagentByName, type InferSubagentNames, type InferSubagentState, type InferSubagentStates, type InferToolCalls, type IsAgentLike, type IsDeepAgentLike, type MessageMetadata, type QueueEntry, type QueueInterface, type ResolveStreamInterface, type ResolveStreamOptions, STREAM_DEFAULTS, STREAM_INSTANCE, type StreamDefaults, StreamService, type SubAgentLike, type SubagentApi, SubagentManager, type SubagentStateMap, type SubagentStatus, type SubagentStream, type SubagentStreamInterface, type SubagentToolCall, type ToolCallFromTool, type ToolCallState, ToolCallWithResult, type ToolCallsFromTools, type UseAgentStream, type UseAgentStreamOptions, type UseDeepAgentStream, type UseDeepAgentStreamOptions, type UseStreamCustomOptions, type UseStreamOptions, type UseStreamThread, type UseStreamTransport, calculateDepthFromNamespace, extractParentIdFromNamespace, extractToolCallIdFromNamespace, injectStream, injectStreamCustom, isSubagentNamespace, provideStream, provideStreamDefaults, useStream, useStreamCustom, useStreamLGP };
+export { type AgentTypeConfigLike, type AnyHeadlessToolImplementation, type BaseStream, type BaseSubagentState, type ClassSubagentStreamInterface, type CompiledSubAgentLike, type DeepAgentTypeConfigLike, type DefaultSubagentStates, type DefaultToolCall, type ExtractAgentConfig, type ExtractDeepAgentConfig, type ExtractSubAgentMiddleware, FetchStreamTransport, type FlushPendingHeadlessToolInterruptsOptions, type GetToolCallsType, type HeadlessToolImplementation, type HeadlessToolInterrupt, type InferAgentToolCalls, type InferBag, type InferDeepAgentSubagents, type InferNodeNames, type InferStateType, type InferSubagentByName, type InferSubagentNames, type InferSubagentState, type InferSubagentStates, type InferToolCalls, type IsAgentLike, type IsDeepAgentLike, type MessageMetadata, type OnToolCallback, type QueueEntry, type QueueInterface, type ResolveStreamInterface, type ResolveStreamOptions, STREAM_DEFAULTS, STREAM_INSTANCE, type StreamDefaults, StreamService, type SubAgentLike, type SubagentApi, SubagentManager, type SubagentStateMap, type SubagentStatus, type SubagentStream, type SubagentStreamInterface, type SubagentToolCall, type ToolCallFromTool, type ToolCallState, ToolCallWithResult, type ToolCallsFromTools, type ToolEvent, type UseAgentStream, type UseAgentStreamOptions, type UseDeepAgentStream, type UseDeepAgentStreamOptions, type UseStreamCustomOptions, type UseStreamOptions, type UseStreamThread, type UseStreamTransport, calculateDepthFromNamespace, executeHeadlessTool, extractParentIdFromNamespace, extractToolCallIdFromNamespace, filterOutHeadlessToolInterrupts, findHeadlessTool, flushPendingHeadlessToolInterrupts, handleHeadlessToolInterrupt, headlessToolResumeCommand, injectStream, injectStreamCustom, isHeadlessToolInterrupt, isSubagentNamespace, parseHeadlessToolInterruptPayload, provideStream, provideStreamDefaults, useStream, useStreamCustom, useStreamLGP };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -4,6 +4,7 @@ import { STREAM_DEFAULTS, STREAM_INSTANCE, provideStream, provideStreamDefaults
 import { __decorate } from "./_virtual/_@oxc-project_runtime@0.115.0/helpers/decorate.js";
 import { Injectable, inject } from "@angular/core";
 import { FetchStreamTransport, SubagentManager, calculateDepthFromNamespace, extractParentIdFromNamespace, extractToolCallIdFromNamespace, isSubagentNamespace } from "@langchain/langgraph-sdk/ui";
+import { executeHeadlessTool, filterOutHeadlessToolInterrupts, findHeadlessTool, flushPendingHeadlessToolInterrupts, handleHeadlessToolInterrupt, headlessToolResumeCommand, isHeadlessToolInterrupt, parseHeadlessToolInterruptPayload } from "@langchain/langgraph-sdk";
 //#region src/index.ts
 /**
 * @internal Merges DI, LangGraph Platform, and custom transport overloads.
@@ -109,6 +110,6 @@ let StreamService = class StreamService {
 };
 StreamService = __decorate([Injectable()], StreamService);
 //#endregion
-export { FetchStreamTransport, STREAM_DEFAULTS, STREAM_INSTANCE, StreamService, SubagentManager, calculateDepthFromNamespace, extractParentIdFromNamespace, extractToolCallIdFromNamespace, injectStream, injectStreamCustom, isSubagentNamespace, provideStream, provideStreamDefaults, useStream, useStreamCustom, useStreamLGP };
+export { FetchStreamTransport, STREAM_DEFAULTS, STREAM_INSTANCE, StreamService, SubagentManager, calculateDepthFromNamespace, executeHeadlessTool, extractParentIdFromNamespace, extractToolCallIdFromNamespace, filterOutHeadlessToolInterrupts, findHeadlessTool, flushPendingHeadlessToolInterrupts, handleHeadlessToolInterrupt, headlessToolResumeCommand, injectStream, injectStreamCustom, isHeadlessToolInterrupt, isSubagentNamespace, parseHeadlessToolInterruptPayload, provideStream, provideStreamDefaults, useStream, useStreamCustom, useStreamLGP };
 
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["angularInject"],"sources":["../src/index.ts"],"sourcesContent":["import { Injectable, inject as angularInject } from \"@angular/core\";\nimport type { Signal, WritableSignal } from \"@angular/core\";\nimport type {\n  BaseMessage,\n  ToolMessage as CoreToolMessage,\n  AIMessage as CoreAIMessage,\n} from \"@langchain/core/messages\";\nimport type {\n  MessageMetadata,\n  SubmitOptions,\n  ResolveStreamOptions,\n  ResolveStreamInterface,\n  InferBag,\n  InferStateType,\n  AcceptBaseMessages,\n  UseStreamCustomOptions,\n  SubagentStreamInterface,\n  WithClassMessages,\n  GetConfigurableType,\n  GetInterruptType,\n} from \"@langchain/langgraph-sdk/ui\";\n\nimport {\n  Client,\n  type StreamEvent,\n  type StreamMode,\n  type Message,\n  type Interrupt,\n  type BagTemplate,\n  type ToolCallWithResult as SdkToolCallWithResult,\n  type DefaultToolCall,\n} from \"@langchain/langgraph-sdk\";\nimport type { StreamServiceInstance } from \"./stream-service-instance.js\";\nimport { injectStreamCustom } from \"./stream.custom.js\";\nimport { useStreamLGP } from \"./stream.lgp.js\";\nimport { STREAM_INSTANCE } from \"./context.js\";\n\nexport { injectStreamCustom, useStreamCustom } from \"./stream.custom.js\";\nexport { FetchStreamTransport } from \"@langchain/langgraph-sdk/ui\";\nexport {\n  provideStreamDefaults,\n  provideStream,\n  STREAM_DEFAULTS,\n  STREAM_INSTANCE,\n} from \"./context.js\";\nexport type { StreamDefaults } from \"./context.js\";\nexport type { ClassSubagentStreamInterface } from \"@langchain/langgraph-sdk/ui\";\n\ntype AngularWritableKeys = \"isLoading\" | \"branch\";\n\ntype AngularPlainKeys =\n  | \"submit\"\n  | \"stop\"\n  | \"joinStream\"\n  | \"switchThread\"\n  | \"setBranch\"\n  | \"getMessagesMetadata\"\n  | \"getToolCalls\"\n  | \"getSubagent\"\n  | \"getSubagentsByType\"\n  | \"getSubagentsByMessage\"\n  | \"client\"\n  | \"assistantId\";\n\ntype AngularQueueInterface<T> = T extends {\n  entries: infer E;\n  size: infer S;\n  cancel: infer C;\n  clear: infer Cl;\n}\n  ? {\n      entries: WritableSignal<E>;\n      size: WritableSignal<S>;\n      cancel: C;\n      clear: Cl;\n    }\n  : T;\n\ntype AngularSignalWrap<T> = {\n  [K in keyof T]: K extends AngularPlainKeys\n    ? T[K]\n    : K extends AngularWritableKeys\n      ? WritableSignal<T[K]>\n      : K extends \"queue\"\n        ? AngularQueueInterface<T[K]>\n        : Signal<T[K]>;\n};\n\n/**\n * Injects the shared stream instance from the nearest ancestor that provided\n * one via {@link provideStream}. Throws if no ancestor provides a stream\n * 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 */\nfunction injectStream<\n  T = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate,\n>(): AngularSignalWrap<\n  WithClassMessages<ResolveStreamInterface<T, InferBag<T, Bag>>>\n>;\n\n/**\n * Angular entry point for LangGraph streaming. Call from a component, directive,\n * or service field initializer to get a **Signals-based** stream controller\n * connected to the LangGraph Platform (HTTP + threads API).\n *\n * The returned object mirrors the shared `useStream` API from\n * `@langchain/langgraph-sdk/ui`, but reactive fields are\n * {@link https://angular.dev/guide/signals | Angular `Signal`s}:\n * read state with calls like `stream.messages()`, `stream.values()`, and\n * `stream.isLoading()`, and use `WritableSignal` setters where exposed (for\n * example `stream.branch` for branch selection).\n *\n * ## Typing with `createDeepAgent`\n *\n * Expect `export const agent = createDeepAgent({ ... })` from `deepagents`. In\n * UI code, `import { type agent } from \"./agent\"` (or `import type { agent }`)\n * is a **type-only** import: it is erased when compiling, so the agent module\n * does not run in the browser. You still pass **`typeof agent`** to\n * `injectStream`, not `agent` alone — `agent` is a value; TypeScript only\n * accepts it in a type position via `typeof` (otherwise: *refers to a value,\n * but is being used as a type*). If you prefer a named type in generics, add\n * `export type Agent = typeof agent` next to the const and use\n * `injectStream<Agent>(...)`.\n *\n * @example\n * ```typescript\n * // agent.ts\n * import { createDeepAgent } from \"deepagents\";\n * import { tool } from \"langchain\";\n * import { z } from \"zod\";\n *\n * const getWeather = tool(\n *   async ({ location }) => `Weather in ${location}`,\n *   { name: \"get_weather\", schema: z.object({ location: z.string() }) },\n * );\n *\n * export const agent = createDeepAgent({\n *   model: \"openai:gpt-4o\",\n *   tools: [getWeather],\n * });\n *\n * // chat.component.ts — type-only import; no agent runtime in the frontend\n * import { Component } from \"@angular/core\";\n * import { injectStream } from \"@langchain/angular\";\n * import { type agent } from \"./agent\";\n *\n * @Component({\n *   standalone: true,\n *   template: `\n *     @for (msg of stream.messages(); track msg.id ?? $index) {\n *       <p>{{ msg.content }}</p>\n *     }\n *   `,\n * })\n * export class ChatComponent {\n *   readonly stream = injectStream<typeof agent>({\n *     assistantId: \"agent\",\n *     apiUrl: \"http://localhost:2024\",\n *   });\n *   // stream.toolCalls()[0].call.name is typed as \"get_weather\"\n * }\n * ```\n *\n * ## Typing with `StateGraph` / custom graph state\n *\n * Use your graph state interface as `T` and embed tool call unions in\n * `Message<...>[]` when you need discriminated tool types.\n *\n * @example\n * ```typescript\n * import { Message } from \"@langchain/langgraph-sdk\";\n * import { Component } from \"@angular/core\";\n * import { injectStream } from \"@langchain/angular\";\n *\n * type MyToolCalls =\n *   | { name: \"search\"; args: { query: string }; id?: string }\n *   | { name: \"calculate\"; args: { expression: string }; id?: string };\n *\n * interface MyGraphState {\n *   messages: Message<MyToolCalls>[];\n *   context?: string;\n * }\n *\n * @Component({ standalone: true, template: \"\" })\n * export class ChatComponent {\n *   readonly stream = injectStream<MyGraphState>({\n *     assistantId: \"my-graph\",\n *     apiUrl: \"http://localhost:2024\",\n *   });\n *   // stream.values() is typed as MyGraphState | null\n * }\n * ```\n *\n * @example\n * ```typescript\n * // Optional bag for interrupts, configurable, custom events, and updates\n * import { Component } from \"@angular/core\";\n * import { injectStream } from \"@langchain/angular\";\n * import type { Message } from \"@langchain/langgraph-sdk\";\n *\n * interface MyGraphState {\n *   messages: Message[];\n * }\n *\n * @Component({ standalone: true, template: \"\" })\n * export class ChatComponent {\n *   readonly stream = injectStream<\n *     MyGraphState,\n *     {\n *       InterruptType: { question: string };\n *       ConfigurableType: { userId: string };\n *     }\n *   >({\n *     assistantId: \"my-graph\",\n *     apiUrl: \"http://localhost:2024\",\n *   });\n *   // stream.interrupt() is typed as { question: string } | undefined\n * }\n * ```\n *\n * ## Subagent streaming\n *\n * For `createDeepAgent` agents with `subagents`, set `filterSubagentMessages`\n * and use `streamSubgraphs` on `submit` to populate `stream.subagents` and\n * related helpers.\n *\n * @example\n * ```typescript\n * import { Component } from \"@angular/core\";\n * import { injectStream } from \"@langchain/angular\";\n * import { type agent } from \"./agent\";\n *\n * @Component({ standalone: true, template: \"\" })\n * export class DeepAgentChatComponent {\n *   readonly stream = injectStream<typeof agent>({\n *     assistantId: \"deepagent\",\n *     apiUrl: \"http://localhost:2024\",\n *     filterSubagentMessages: true,\n *   });\n *\n *   send(content: string) {\n *     void this.stream.submit(\n *       { messages: [{ content, type: \"human\" }] },\n *       { streamSubgraphs: true },\n *     );\n *   }\n * }\n * ```\n *\n * @param options - LangGraph Platform client options (`apiUrl` or `client`),\n *   `assistantId`, stream modes, history, reconnect, subagent settings, etc.\n *\n * @returns A stream controller backed by Signals: graph values, messages,\n *   loading and error state, interrupts, tool calls, branching, queue, and\n *   `submit` / `stop` / `switchThread` helpers (writable where the UI layer\n *   requires mutation).\n *\n * @template T Agent type (with `~agentTypes`) from `createDeepAgent` or\n *   `createAgent`, or a state shape extending `Record<string, unknown>`.\n * @template Bag Optional configuration bag:\n *   - `ConfigurableType` — `config.configurable` typing\n *   - `InterruptType` — human-in-the-loop interrupt payloads\n *   - `CustomEventType` — custom stream events\n *   - `UpdateType` — payload typing for `submit`\n *\n * @see {@link https://docs.langchain.com/oss/javascript/langgraph/overview | LangGraph JavaScript overview}\n * @see {@link https://docs.langchain.com/oss/javascript/langchain/overview | LangChain JavaScript overview}\n * @see {@link https://docs.langchain.com/oss/javascript/deepagents/overview | Deep Agents JavaScript overview}\n */\nfunction injectStream<\n  T = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate,\n>(\n  options: ResolveStreamOptions<T, InferBag<T, Bag>>\n): AngularSignalWrap<\n  WithClassMessages<ResolveStreamInterface<T, InferBag<T, Bag>>>\n>;\n\n/**\n * Overload for a **custom transport** (`options.transport`), for example\n * {@link FetchStreamTransport} or any implementation compatible with\n * {@link injectStreamCustom}. Prefer {@link injectStreamCustom} directly when\n * you only use custom transports and want a narrower import.\n *\n * @param options - Custom transport and stream options (must include\n *   `transport`).\n *\n * @returns The same Signals-based controller shape as the LangGraph Platform\n *   overload.\n *\n * @template T Agent type or state shape, matching the custom transport.\n * @template Bag Same optional bag as the platform overload.\n *\n * @see {@link injectStreamCustom}\n */\nfunction injectStream<\n  T = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate,\n>(\n  options: UseStreamCustomOptions<InferStateType<T>, InferBag<T, Bag>>\n): AngularSignalWrap<\n  WithClassMessages<ResolveStreamInterface<T, InferBag<T, Bag>>>\n>;\n\n/**\n * @internal Merges DI, LangGraph Platform, and custom transport overloads.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction injectStream(options?: any): any {\n  if (arguments.length === 0) {\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 injectStream(options) directly.\"\n      );\n    }\n    return instance;\n  }\n  if (\"transport\" in options) {\n    return injectStreamCustom(options);\n  }\n  return useStreamLGP(options);\n}\n\nexport { injectStream };\n\n/**\n * @deprecated Use `injectStream` instead. `useStream` will be removed in a\n * future major version. `injectStream` follows Angular's `inject*` naming\n * convention for injection-based patterns.\n */\nexport const useStream = injectStream;\n\nexport { useStreamLGP } from \"./stream.lgp.js\";\n\n/**\n * Injectable Angular service that wraps {@link injectStream}.\n *\n * Extend this class with your own `@Injectable()` service and call\n * `super(options)` in the constructor:\n *\n * ```ts\n * \\@Injectable({ providedIn: 'root' })\n * export class ChatService extends StreamService {\n *   constructor() {\n *     super({ assistantId: 'agent', apiUrl: '...' });\n *   }\n * }\n * ```\n *\n * The service exposes the same signals and methods as `injectStream`\n * (e.g. `values`, `messages`, `isLoading`, `submit`, `stop`).\n *\n * Must be created within an Angular injection context (via DI or\n * `runInInjectionContext`).\n */\n@Injectable()\nexport class StreamService<\n  T = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate,\n> {\n  private readonly _stream: StreamServiceInstance<T, Bag>;\n\n  constructor(\n    options:\n      | ResolveStreamOptions<T, InferBag<T, Bag>>\n      | UseStreamCustomOptions<InferStateType<T>, InferBag<T, Bag>>\n  ) {\n    this._stream = injectStream(\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      options as any\n    ) as unknown as StreamServiceInstance<T, Bag>;\n  }\n\n  get values(): Signal<T> {\n    return this._stream.values;\n  }\n\n  get messages(): Signal<BaseMessage[]> {\n    return this._stream.messages;\n  }\n\n  get isLoading(): WritableSignal<boolean> {\n    return this._stream.isLoading;\n  }\n\n  get error(): Signal<unknown> {\n    return this._stream.error;\n  }\n\n  get branch(): WritableSignal<string> {\n    return this._stream.branch;\n  }\n\n  get interrupt(): Signal<Interrupt<GetInterruptType<Bag>> | undefined> {\n    return this._stream.interrupt;\n  }\n\n  get interrupts(): Signal<Interrupt<GetInterruptType<Bag>>[]> {\n    return this._stream.interrupts;\n  }\n\n  get toolCalls(): Signal<SdkToolCallWithResult<DefaultToolCall>[]> {\n    return this._stream.toolCalls;\n  }\n\n  get queue(): AngularQueueInterface<{\n    entries: readonly { id: string; values: Partial<T> | null | undefined }[];\n    size: number;\n    cancel: (id: string) => Promise<boolean>;\n    clear: () => Promise<void>;\n  }> {\n    return this._stream.queue;\n  }\n\n  get subagents(): Signal<ReadonlyMap<string, SubagentStreamInterface>> {\n    return this._stream.subagents;\n  }\n\n  get activeSubagents(): Signal<readonly SubagentStreamInterface[]> {\n    return this._stream.activeSubagents;\n  }\n\n  get history(): Signal<unknown> {\n    return this._stream.history;\n  }\n\n  get isThreadLoading(): Signal<boolean> {\n    return this._stream.isThreadLoading;\n  }\n\n  get experimental_branchTree(): Signal<unknown> {\n    return this._stream.experimental_branchTree;\n  }\n\n  get client(): Client {\n    return this._stream.client;\n  }\n\n  get assistantId(): string {\n    return this._stream.assistantId;\n  }\n\n  submit(\n    values: AcceptBaseMessages<Exclude<T, null | undefined>> | null | undefined,\n    options?: SubmitOptions<\n      T extends Record<string, unknown> ? T : Record<string, unknown>,\n      GetConfigurableType<Bag>\n    >\n  ): ReturnType<typeof this._stream.submit> {\n    return this._stream.submit(values, options);\n  }\n\n  async stop(): Promise<void> {\n    await this._stream.stop();\n  }\n\n  setBranch(value: string): void {\n    this._stream.setBranch(value);\n  }\n\n  switchThread(newThreadId: string | null): void {\n    this._stream.switchThread(newThreadId);\n  }\n\n  joinStream(\n    runId: string,\n    lastEventId?: string,\n    options?: {\n      streamMode?: StreamMode | StreamMode[];\n      filter?: (event: {\n        id?: string;\n        event: StreamEvent;\n        data: unknown;\n      }) => boolean;\n    }\n  ): Promise<void> {\n    return this._stream.joinStream(runId, lastEventId, options);\n  }\n\n  getMessagesMetadata(\n    message: BaseMessage,\n    index?: number\n  ):\n    | MessageMetadata<\n        T extends Record<string, unknown> ? T : Record<string, unknown>\n      >\n    | undefined {\n    return this._stream.getMessagesMetadata(message as Message, index);\n  }\n\n  getToolCalls(message: BaseMessage): SdkToolCallWithResult<DefaultToolCall>[] {\n    return this._stream.getToolCalls(message as Message);\n  }\n\n  getSubagent(toolCallId: string): SubagentStreamInterface | undefined {\n    return this._stream.getSubagent(toolCallId);\n  }\n\n  getSubagentsByType(type: string): SubagentStreamInterface[] {\n    return this._stream.getSubagentsByType(type);\n  }\n\n  getSubagentsByMessage(messageId: string): SubagentStreamInterface[] {\n    return this._stream.getSubagentsByMessage(messageId);\n  }\n}\n\nexport type {\n  BaseStream,\n  UseAgentStream,\n  UseAgentStreamOptions,\n  UseDeepAgentStream,\n  UseDeepAgentStreamOptions,\n  ResolveStreamInterface,\n  ResolveStreamOptions,\n  InferStateType,\n  InferToolCalls,\n  InferSubagentStates,\n  InferNodeNames,\n  InferBag,\n  MessageMetadata,\n  UseStreamOptions,\n  UseStreamCustomOptions,\n  UseStreamTransport,\n  UseStreamThread,\n  GetToolCallsType,\n  AgentTypeConfigLike,\n  IsAgentLike,\n  ExtractAgentConfig,\n  InferAgentToolCalls,\n  SubagentToolCall,\n  SubagentStatus,\n  SubagentApi,\n  SubagentStream,\n  SubagentStreamInterface,\n  SubAgentLike,\n  CompiledSubAgentLike,\n  DeepAgentTypeConfigLike,\n  IsDeepAgentLike,\n  ExtractDeepAgentConfig,\n  ExtractSubAgentMiddleware,\n  InferDeepAgentSubagents,\n  InferSubagentByName,\n  InferSubagentState,\n  InferSubagentNames,\n  SubagentStateMap,\n  DefaultSubagentStates,\n  BaseSubagentState,\n  QueueEntry,\n  QueueInterface,\n} from \"@langchain/langgraph-sdk/ui\";\n\nexport type ToolCallWithResult<ToolCall = DefaultToolCall> =\n  SdkToolCallWithResult<ToolCall, CoreToolMessage, CoreAIMessage>;\nexport type {\n  ToolCallState,\n  DefaultToolCall,\n  ToolCallFromTool,\n  ToolCallsFromTools,\n} from \"@langchain/langgraph-sdk\";\n\nexport {\n  SubagentManager,\n  extractToolCallIdFromNamespace,\n  calculateDepthFromNamespace,\n  extractParentIdFromNamespace,\n  isSubagentNamespace,\n} from \"@langchain/langgraph-sdk/ui\";\n"],"mappings":";;;;;;;;;;AAyVA,SAAS,aAAa,SAAoB;AACxC,KAAI,UAAU,WAAW,GAAG;EAC1B,MAAM,WAAWA,OAAc,iBAAiB,EAAE,UAAU,MAAM,CAAC;AACnE,MAAI,YAAY,KACd,OAAM,IAAI,MACR,wNAGD;AAEH,SAAO;;AAET,KAAI,eAAe,QACjB,QAAO,mBAAmB,QAAQ;AAEpC,QAAO,aAAa,QAAQ;;;;;;;AAU9B,MAAa,YAAY;AA0BlB,IAAA,gBAAA,MAAM,cAGX;CACA;CAEA,YACE,SAGA;AACA,OAAK,UAAU,aAEb,QACD;;CAGH,IAAI,SAAoB;AACtB,SAAO,KAAK,QAAQ;;CAGtB,IAAI,WAAkC;AACpC,SAAO,KAAK,QAAQ;;CAGtB,IAAI,YAAqC;AACvC,SAAO,KAAK,QAAQ;;CAGtB,IAAI,QAAyB;AAC3B,SAAO,KAAK,QAAQ;;CAGtB,IAAI,SAAiC;AACnC,SAAO,KAAK,QAAQ;;CAGtB,IAAI,YAAkE;AACpE,SAAO,KAAK,QAAQ;;CAGtB,IAAI,aAAyD;AAC3D,SAAO,KAAK,QAAQ;;CAGtB,IAAI,YAA8D;AAChE,SAAO,KAAK,QAAQ;;CAGtB,IAAI,QAKD;AACD,SAAO,KAAK,QAAQ;;CAGtB,IAAI,YAAkE;AACpE,SAAO,KAAK,QAAQ;;CAGtB,IAAI,kBAA8D;AAChE,SAAO,KAAK,QAAQ;;CAGtB,IAAI,UAA2B;AAC7B,SAAO,KAAK,QAAQ;;CAGtB,IAAI,kBAAmC;AACrC,SAAO,KAAK,QAAQ;;CAGtB,IAAI,0BAA2C;AAC7C,SAAO,KAAK,QAAQ;;CAGtB,IAAI,SAAiB;AACnB,SAAO,KAAK,QAAQ;;CAGtB,IAAI,cAAsB;AACxB,SAAO,KAAK,QAAQ;;CAGtB,OACE,QACA,SAIwC;AACxC,SAAO,KAAK,QAAQ,OAAO,QAAQ,QAAQ;;CAG7C,MAAM,OAAsB;AAC1B,QAAM,KAAK,QAAQ,MAAM;;CAG3B,UAAU,OAAqB;AAC7B,OAAK,QAAQ,UAAU,MAAM;;CAG/B,aAAa,aAAkC;AAC7C,OAAK,QAAQ,aAAa,YAAY;;CAGxC,WACE,OACA,aACA,SAQe;AACf,SAAO,KAAK,QAAQ,WAAW,OAAO,aAAa,QAAQ;;CAG7D,oBACE,SACA,OAKY;AACZ,SAAO,KAAK,QAAQ,oBAAoB,SAAoB,MAAM;;CAGpE,aAAa,SAAgE;AAC3E,SAAO,KAAK,QAAQ,aAAa,QAAmB;;CAGtD,YAAY,YAAyD;AACnE,SAAO,KAAK,QAAQ,YAAY,WAAW;;CAG7C,mBAAmB,MAAyC;AAC1D,SAAO,KAAK,QAAQ,mBAAmB,KAAK;;CAG9C,sBAAsB,WAA8C;AAClE,SAAO,KAAK,QAAQ,sBAAsB,UAAU;;;4BApJvD,YAAY,CAAA,EAAA,cAAA"}
+{"version":3,"file":"index.js","names":["angularInject"],"sources":["../src/index.ts"],"sourcesContent":["import { Injectable, inject as angularInject } from \"@angular/core\";\nimport type { Signal, WritableSignal } from \"@angular/core\";\nimport type {\n  BaseMessage,\n  ToolMessage as CoreToolMessage,\n  AIMessage as CoreAIMessage,\n} from \"@langchain/core/messages\";\nimport type {\n  MessageMetadata,\n  SubmitOptions,\n  ResolveStreamOptions,\n  ResolveStreamInterface,\n  InferBag,\n  InferStateType,\n  AcceptBaseMessages,\n  UseStreamCustomOptions,\n  SubagentStreamInterface,\n  WithClassMessages,\n  GetConfigurableType,\n  GetInterruptType,\n} from \"@langchain/langgraph-sdk/ui\";\n\nimport {\n  Client,\n  type StreamEvent,\n  type StreamMode,\n  type Message,\n  type Interrupt,\n  type BagTemplate,\n  type ToolCallWithResult as SdkToolCallWithResult,\n  type DefaultToolCall,\n} from \"@langchain/langgraph-sdk\";\nimport type { StreamServiceInstance } from \"./stream-service-instance.js\";\nimport { injectStreamCustom } from \"./stream.custom.js\";\nimport { useStreamLGP } from \"./stream.lgp.js\";\nimport { STREAM_INSTANCE } from \"./context.js\";\n\nexport { injectStreamCustom, useStreamCustom } from \"./stream.custom.js\";\nexport { FetchStreamTransport } from \"@langchain/langgraph-sdk/ui\";\nexport {\n  provideStreamDefaults,\n  provideStream,\n  STREAM_DEFAULTS,\n  STREAM_INSTANCE,\n} from \"./context.js\";\nexport type { StreamDefaults } from \"./context.js\";\nexport type { ClassSubagentStreamInterface } from \"@langchain/langgraph-sdk/ui\";\n\ntype AngularWritableKeys = \"isLoading\" | \"branch\";\n\ntype AngularPlainKeys =\n  | \"submit\"\n  | \"stop\"\n  | \"joinStream\"\n  | \"switchThread\"\n  | \"setBranch\"\n  | \"getMessagesMetadata\"\n  | \"getToolCalls\"\n  | \"getSubagent\"\n  | \"getSubagentsByType\"\n  | \"getSubagentsByMessage\"\n  | \"client\"\n  | \"assistantId\";\n\ntype AngularQueueInterface<T> = T extends {\n  entries: infer E;\n  size: infer S;\n  cancel: infer C;\n  clear: infer Cl;\n}\n  ? {\n      entries: WritableSignal<E>;\n      size: WritableSignal<S>;\n      cancel: C;\n      clear: Cl;\n    }\n  : T;\n\ntype AngularSignalWrap<T> = {\n  [K in keyof T]: K extends AngularPlainKeys\n    ? T[K]\n    : K extends AngularWritableKeys\n      ? WritableSignal<T[K]>\n      : K extends \"queue\"\n        ? AngularQueueInterface<T[K]>\n        : Signal<T[K]>;\n};\n\n/**\n * Injects the shared stream instance from the nearest ancestor that provided\n * one via {@link provideStream}. Throws if no ancestor provides a stream\n * 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 */\nfunction injectStream<\n  T = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate,\n>(): AngularSignalWrap<\n  WithClassMessages<ResolveStreamInterface<T, InferBag<T, Bag>>>\n>;\n\n/**\n * Angular entry point for LangGraph streaming. Call from a component, directive,\n * or service field initializer to get a **Signals-based** stream controller\n * connected to the LangGraph Platform (HTTP + threads API).\n *\n * The returned object mirrors the shared `useStream` API from\n * `@langchain/langgraph-sdk/ui`, but reactive fields are\n * {@link https://angular.dev/guide/signals | Angular `Signal`s}:\n * read state with calls like `stream.messages()`, `stream.values()`, and\n * `stream.isLoading()`, and use `WritableSignal` setters where exposed (for\n * example `stream.branch` for branch selection).\n *\n * ## Typing with `createDeepAgent`\n *\n * Expect `export const agent = createDeepAgent({ ... })` from `deepagents`. In\n * UI code, `import { type agent } from \"./agent\"` (or `import type { agent }`)\n * is a **type-only** import: it is erased when compiling, so the agent module\n * does not run in the browser. You still pass **`typeof agent`** to\n * `injectStream`, not `agent` alone — `agent` is a value; TypeScript only\n * accepts it in a type position via `typeof` (otherwise: *refers to a value,\n * but is being used as a type*). If you prefer a named type in generics, add\n * `export type Agent = typeof agent` next to the const and use\n * `injectStream<Agent>(...)`.\n *\n * @example\n * ```typescript\n * // agent.ts\n * import { createDeepAgent } from \"deepagents\";\n * import { tool } from \"langchain\";\n * import { z } from \"zod\";\n *\n * const getWeather = tool(\n *   async ({ location }) => `Weather in ${location}`,\n *   { name: \"get_weather\", schema: z.object({ location: z.string() }) },\n * );\n *\n * export const agent = createDeepAgent({\n *   model: \"openai:gpt-4o\",\n *   tools: [getWeather],\n * });\n *\n * // chat.component.ts — type-only import; no agent runtime in the frontend\n * import { Component } from \"@angular/core\";\n * import { injectStream } from \"@langchain/angular\";\n * import { type agent } from \"./agent\";\n *\n * @Component({\n *   standalone: true,\n *   template: `\n *     @for (msg of stream.messages(); track msg.id ?? $index) {\n *       <p>{{ msg.content }}</p>\n *     }\n *   `,\n * })\n * export class ChatComponent {\n *   readonly stream = injectStream<typeof agent>({\n *     assistantId: \"agent\",\n *     apiUrl: \"http://localhost:2024\",\n *   });\n *   // stream.toolCalls()[0].call.name is typed as \"get_weather\"\n * }\n * ```\n *\n * ## Typing with `StateGraph` / custom graph state\n *\n * Use your graph state interface as `T` and embed tool call unions in\n * `Message<...>[]` when you need discriminated tool types.\n *\n * @example\n * ```typescript\n * import { Message } from \"@langchain/langgraph-sdk\";\n * import { Component } from \"@angular/core\";\n * import { injectStream } from \"@langchain/angular\";\n *\n * type MyToolCalls =\n *   | { name: \"search\"; args: { query: string }; id?: string }\n *   | { name: \"calculate\"; args: { expression: string }; id?: string };\n *\n * interface MyGraphState {\n *   messages: Message<MyToolCalls>[];\n *   context?: string;\n * }\n *\n * @Component({ standalone: true, template: \"\" })\n * export class ChatComponent {\n *   readonly stream = injectStream<MyGraphState>({\n *     assistantId: \"my-graph\",\n *     apiUrl: \"http://localhost:2024\",\n *   });\n *   // stream.values() is typed as MyGraphState | null\n * }\n * ```\n *\n * @example\n * ```typescript\n * // Optional bag for interrupts, configurable, custom events, and updates\n * import { Component } from \"@angular/core\";\n * import { injectStream } from \"@langchain/angular\";\n * import type { Message } from \"@langchain/langgraph-sdk\";\n *\n * interface MyGraphState {\n *   messages: Message[];\n * }\n *\n * @Component({ standalone: true, template: \"\" })\n * export class ChatComponent {\n *   readonly stream = injectStream<\n *     MyGraphState,\n *     {\n *       InterruptType: { question: string };\n *       ConfigurableType: { userId: string };\n *     }\n *   >({\n *     assistantId: \"my-graph\",\n *     apiUrl: \"http://localhost:2024\",\n *   });\n *   // stream.interrupt() is typed as { question: string } | undefined\n * }\n * ```\n *\n * ## Subagent streaming\n *\n * For `createDeepAgent` agents with `subagents`, set `filterSubagentMessages`\n * and use `streamSubgraphs` on `submit` to populate `stream.subagents` and\n * related helpers.\n *\n * @example\n * ```typescript\n * import { Component } from \"@angular/core\";\n * import { injectStream } from \"@langchain/angular\";\n * import { type agent } from \"./agent\";\n *\n * @Component({ standalone: true, template: \"\" })\n * export class DeepAgentChatComponent {\n *   readonly stream = injectStream<typeof agent>({\n *     assistantId: \"deepagent\",\n *     apiUrl: \"http://localhost:2024\",\n *     filterSubagentMessages: true,\n *   });\n *\n *   send(content: string) {\n *     void this.stream.submit(\n *       { messages: [{ content, type: \"human\" }] },\n *       { streamSubgraphs: true },\n *     );\n *   }\n * }\n * ```\n *\n * @param options - LangGraph Platform client options (`apiUrl` or `client`),\n *   `assistantId`, stream modes, history, reconnect, subagent settings, etc.\n *\n * @returns A stream controller backed by Signals: graph values, messages,\n *   loading and error state, interrupts, tool calls, branching, queue, and\n *   `submit` / `stop` / `switchThread` helpers (writable where the UI layer\n *   requires mutation).\n *\n * @template T Agent type (with `~agentTypes`) from `createDeepAgent` or\n *   `createAgent`, or a state shape extending `Record<string, unknown>`.\n * @template Bag Optional configuration bag:\n *   - `ConfigurableType` — `config.configurable` typing\n *   - `InterruptType` — human-in-the-loop interrupt payloads\n *   - `CustomEventType` — custom stream events\n *   - `UpdateType` — payload typing for `submit`\n *\n * @see {@link https://docs.langchain.com/oss/javascript/langgraph/overview | LangGraph JavaScript overview}\n * @see {@link https://docs.langchain.com/oss/javascript/langchain/overview | LangChain JavaScript overview}\n * @see {@link https://docs.langchain.com/oss/javascript/deepagents/overview | Deep Agents JavaScript overview}\n */\nfunction injectStream<\n  T = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate,\n>(\n  options: ResolveStreamOptions<T, InferBag<T, Bag>>\n): AngularSignalWrap<\n  WithClassMessages<ResolveStreamInterface<T, InferBag<T, Bag>>>\n>;\n\n/**\n * Overload for a **custom transport** (`options.transport`), for example\n * {@link FetchStreamTransport} or any implementation compatible with\n * {@link injectStreamCustom}. Prefer {@link injectStreamCustom} directly when\n * you only use custom transports and want a narrower import.\n *\n * @param options - Custom transport and stream options (must include\n *   `transport`).\n *\n * @returns The same Signals-based controller shape as the LangGraph Platform\n *   overload.\n *\n * @template T Agent type or state shape, matching the custom transport.\n * @template Bag Same optional bag as the platform overload.\n *\n * @see {@link injectStreamCustom}\n */\nfunction injectStream<\n  T = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate,\n>(\n  options: UseStreamCustomOptions<InferStateType<T>, InferBag<T, Bag>>\n): AngularSignalWrap<\n  WithClassMessages<ResolveStreamInterface<T, InferBag<T, Bag>>>\n>;\n\n/**\n * @internal Merges DI, LangGraph Platform, and custom transport overloads.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction injectStream(options?: any): any {\n  if (arguments.length === 0) {\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 injectStream(options) directly.\"\n      );\n    }\n    return instance;\n  }\n  if (\"transport\" in options) {\n    return injectStreamCustom(options);\n  }\n  return useStreamLGP(options);\n}\n\nexport { injectStream };\n\n/**\n * @deprecated Use `injectStream` instead. `useStream` will be removed in a\n * future major version. `injectStream` follows Angular's `inject*` naming\n * convention for injection-based patterns.\n */\nexport const useStream = injectStream;\n\nexport { useStreamLGP } from \"./stream.lgp.js\";\n\n/**\n * Injectable Angular service that wraps {@link injectStream}.\n *\n * Extend this class with your own `@Injectable()` service and call\n * `super(options)` in the constructor:\n *\n * ```ts\n * \\@Injectable({ providedIn: 'root' })\n * export class ChatService extends StreamService {\n *   constructor() {\n *     super({ assistantId: 'agent', apiUrl: '...' });\n *   }\n * }\n * ```\n *\n * The service exposes the same signals and methods as `injectStream`\n * (e.g. `values`, `messages`, `isLoading`, `submit`, `stop`).\n *\n * Must be created within an Angular injection context (via DI or\n * `runInInjectionContext`).\n */\n@Injectable()\nexport class StreamService<\n  T = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate,\n> {\n  private readonly _stream: StreamServiceInstance<T, Bag>;\n\n  constructor(\n    options:\n      | ResolveStreamOptions<T, InferBag<T, Bag>>\n      | UseStreamCustomOptions<InferStateType<T>, InferBag<T, Bag>>\n  ) {\n    this._stream = injectStream(\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      options as any\n    ) as unknown as StreamServiceInstance<T, Bag>;\n  }\n\n  get values(): Signal<T> {\n    return this._stream.values;\n  }\n\n  get messages(): Signal<BaseMessage[]> {\n    return this._stream.messages;\n  }\n\n  get isLoading(): WritableSignal<boolean> {\n    return this._stream.isLoading;\n  }\n\n  get error(): Signal<unknown> {\n    return this._stream.error;\n  }\n\n  get branch(): WritableSignal<string> {\n    return this._stream.branch;\n  }\n\n  get interrupt(): Signal<Interrupt<GetInterruptType<Bag>> | undefined> {\n    return this._stream.interrupt;\n  }\n\n  get interrupts(): Signal<Interrupt<GetInterruptType<Bag>>[]> {\n    return this._stream.interrupts;\n  }\n\n  get toolCalls(): Signal<SdkToolCallWithResult<DefaultToolCall>[]> {\n    return this._stream.toolCalls;\n  }\n\n  get queue(): AngularQueueInterface<{\n    entries: readonly { id: string; values: Partial<T> | null | undefined }[];\n    size: number;\n    cancel: (id: string) => Promise<boolean>;\n    clear: () => Promise<void>;\n  }> {\n    return this._stream.queue;\n  }\n\n  get subagents(): Signal<ReadonlyMap<string, SubagentStreamInterface>> {\n    return this._stream.subagents;\n  }\n\n  get activeSubagents(): Signal<readonly SubagentStreamInterface[]> {\n    return this._stream.activeSubagents;\n  }\n\n  get history(): Signal<unknown> {\n    return this._stream.history;\n  }\n\n  get isThreadLoading(): Signal<boolean> {\n    return this._stream.isThreadLoading;\n  }\n\n  get experimental_branchTree(): Signal<unknown> {\n    return this._stream.experimental_branchTree;\n  }\n\n  get client(): Client {\n    return this._stream.client;\n  }\n\n  get assistantId(): string {\n    return this._stream.assistantId;\n  }\n\n  submit(\n    values: AcceptBaseMessages<Exclude<T, null | undefined>> | null | undefined,\n    options?: SubmitOptions<\n      T extends Record<string, unknown> ? T : Record<string, unknown>,\n      GetConfigurableType<Bag>\n    >\n  ): ReturnType<typeof this._stream.submit> {\n    return this._stream.submit(values, options);\n  }\n\n  async stop(): Promise<void> {\n    await this._stream.stop();\n  }\n\n  setBranch(value: string): void {\n    this._stream.setBranch(value);\n  }\n\n  switchThread(newThreadId: string | null): void {\n    this._stream.switchThread(newThreadId);\n  }\n\n  joinStream(\n    runId: string,\n    lastEventId?: string,\n    options?: {\n      streamMode?: StreamMode | StreamMode[];\n      filter?: (event: {\n        id?: string;\n        event: StreamEvent;\n        data: unknown;\n      }) => boolean;\n    }\n  ): Promise<void> {\n    return this._stream.joinStream(runId, lastEventId, options);\n  }\n\n  getMessagesMetadata(\n    message: BaseMessage,\n    index?: number\n  ):\n    | MessageMetadata<\n        T extends Record<string, unknown> ? T : Record<string, unknown>\n      >\n    | undefined {\n    return this._stream.getMessagesMetadata(message as Message, index);\n  }\n\n  getToolCalls(message: BaseMessage): SdkToolCallWithResult<DefaultToolCall>[] {\n    return this._stream.getToolCalls(message as Message);\n  }\n\n  getSubagent(toolCallId: string): SubagentStreamInterface | undefined {\n    return this._stream.getSubagent(toolCallId);\n  }\n\n  getSubagentsByType(type: string): SubagentStreamInterface[] {\n    return this._stream.getSubagentsByType(type);\n  }\n\n  getSubagentsByMessage(messageId: string): SubagentStreamInterface[] {\n    return this._stream.getSubagentsByMessage(messageId);\n  }\n}\n\nexport type {\n  BaseStream,\n  UseAgentStream,\n  UseAgentStreamOptions,\n  UseDeepAgentStream,\n  UseDeepAgentStreamOptions,\n  ResolveStreamInterface,\n  ResolveStreamOptions,\n  InferStateType,\n  InferToolCalls,\n  InferSubagentStates,\n  InferNodeNames,\n  InferBag,\n  MessageMetadata,\n  UseStreamOptions,\n  UseStreamCustomOptions,\n  UseStreamTransport,\n  UseStreamThread,\n  GetToolCallsType,\n  AgentTypeConfigLike,\n  IsAgentLike,\n  ExtractAgentConfig,\n  InferAgentToolCalls,\n  SubagentToolCall,\n  SubagentStatus,\n  SubagentApi,\n  SubagentStream,\n  SubagentStreamInterface,\n  SubAgentLike,\n  CompiledSubAgentLike,\n  DeepAgentTypeConfigLike,\n  IsDeepAgentLike,\n  ExtractDeepAgentConfig,\n  ExtractSubAgentMiddleware,\n  InferDeepAgentSubagents,\n  InferSubagentByName,\n  InferSubagentState,\n  InferSubagentNames,\n  SubagentStateMap,\n  DefaultSubagentStates,\n  BaseSubagentState,\n  QueueEntry,\n  QueueInterface,\n} from \"@langchain/langgraph-sdk/ui\";\n\nexport type ToolCallWithResult<ToolCall = DefaultToolCall> =\n  SdkToolCallWithResult<ToolCall, CoreToolMessage, CoreAIMessage>;\nexport type {\n  ToolCallState,\n  DefaultToolCall,\n  ToolCallFromTool,\n  ToolCallsFromTools,\n} from \"@langchain/langgraph-sdk\";\nexport type {\n  HeadlessToolImplementation,\n  AnyHeadlessToolImplementation,\n  ToolEvent,\n  HeadlessToolInterrupt,\n  OnToolCallback,\n  FlushPendingHeadlessToolInterruptsOptions,\n} from \"@langchain/langgraph-sdk\";\n\nexport {\n  SubagentManager,\n  extractToolCallIdFromNamespace,\n  calculateDepthFromNamespace,\n  extractParentIdFromNamespace,\n  isSubagentNamespace,\n} from \"@langchain/langgraph-sdk/ui\";\nexport {\n  isHeadlessToolInterrupt,\n  parseHeadlessToolInterruptPayload,\n  filterOutHeadlessToolInterrupts,\n  findHeadlessTool,\n  executeHeadlessTool,\n  handleHeadlessToolInterrupt,\n  headlessToolResumeCommand,\n  flushPendingHeadlessToolInterrupts,\n} from \"@langchain/langgraph-sdk\";\n"],"mappings":";;;;;;;;;;;AAyVA,SAAS,aAAa,SAAoB;AACxC,KAAI,UAAU,WAAW,GAAG;EAC1B,MAAM,WAAWA,OAAc,iBAAiB,EAAE,UAAU,MAAM,CAAC;AACnE,MAAI,YAAY,KACd,OAAM,IAAI,MACR,wNAGD;AAEH,SAAO;;AAET,KAAI,eAAe,QACjB,QAAO,mBAAmB,QAAQ;AAEpC,QAAO,aAAa,QAAQ;;;;;;;AAU9B,MAAa,YAAY;AA0BlB,IAAA,gBAAA,MAAM,cAGX;CACA;CAEA,YACE,SAGA;AACA,OAAK,UAAU,aAEb,QACD;;CAGH,IAAI,SAAoB;AACtB,SAAO,KAAK,QAAQ;;CAGtB,IAAI,WAAkC;AACpC,SAAO,KAAK,QAAQ;;CAGtB,IAAI,YAAqC;AACvC,SAAO,KAAK,QAAQ;;CAGtB,IAAI,QAAyB;AAC3B,SAAO,KAAK,QAAQ;;CAGtB,IAAI,SAAiC;AACnC,SAAO,KAAK,QAAQ;;CAGtB,IAAI,YAAkE;AACpE,SAAO,KAAK,QAAQ;;CAGtB,IAAI,aAAyD;AAC3D,SAAO,KAAK,QAAQ;;CAGtB,IAAI,YAA8D;AAChE,SAAO,KAAK,QAAQ;;CAGtB,IAAI,QAKD;AACD,SAAO,KAAK,QAAQ;;CAGtB,IAAI,YAAkE;AACpE,SAAO,KAAK,QAAQ;;CAGtB,IAAI,kBAA8D;AAChE,SAAO,KAAK,QAAQ;;CAGtB,IAAI,UAA2B;AAC7B,SAAO,KAAK,QAAQ;;CAGtB,IAAI,kBAAmC;AACrC,SAAO,KAAK,QAAQ;;CAGtB,IAAI,0BAA2C;AAC7C,SAAO,KAAK,QAAQ;;CAGtB,IAAI,SAAiB;AACnB,SAAO,KAAK,QAAQ;;CAGtB,IAAI,cAAsB;AACxB,SAAO,KAAK,QAAQ;;CAGtB,OACE,QACA,SAIwC;AACxC,SAAO,KAAK,QAAQ,OAAO,QAAQ,QAAQ;;CAG7C,MAAM,OAAsB;AAC1B,QAAM,KAAK,QAAQ,MAAM;;CAG3B,UAAU,OAAqB;AAC7B,OAAK,QAAQ,UAAU,MAAM;;CAG/B,aAAa,aAAkC;AAC7C,OAAK,QAAQ,aAAa,YAAY;;CAGxC,WACE,OACA,aACA,SAQe;AACf,SAAO,KAAK,QAAQ,WAAW,OAAO,aAAa,QAAQ;;CAG7D,oBACE,SACA,OAKY;AACZ,SAAO,KAAK,QAAQ,oBAAoB,SAAoB,MAAM;;CAGpE,aAAa,SAAgE;AAC3E,SAAO,KAAK,QAAQ,aAAa,QAAmB;;CAGtD,YAAY,YAAyD;AACnE,SAAO,KAAK,QAAQ,YAAY,WAAW;;CAG7C,mBAAmB,MAAyC;AAC1D,SAAO,KAAK,QAAQ,mBAAmB,KAAK;;CAG9C,sBAAsB,WAA8C;AAClE,SAAO,KAAK,QAAQ,sBAAsB,UAAU;;;4BApJvD,YAAY,CAAA,EAAA,cAAA"}

package/dist/stream.custom.cjs

@@ -1,3 +1,4 @@
+const require_subagents = require("./subagents.cjs");
 let _angular_core = require("@angular/core");
 let _langchain_langgraph_sdk_ui = require("@langchain/langgraph-sdk/ui");
 //#region src/stream.custom.ts
@@ -6,6 +7,11 @@ function injectStreamCustom(options) {
 	const version = (0, _angular_core.signal)(0);
 	const subagentVersion = (0, _angular_core.signal)(0);
 	const isLoading = (0, _angular_core.signal)(orchestrator.isLoading);
+	const reactiveSubagents = require_subagents.createReactiveSubagentAccessors({
+		getSubagent: (toolCallId) => orchestrator.getSubagent(toolCallId),
+		getSubagentsByType: (type) => orchestrator.getSubagentsByType(type),
+		getSubagentsByMessage: (messageId) => orchestrator.getSubagentsByMessage(messageId)
+	}, subagentVersion);
 	(0, _angular_core.effect)((onCleanup) => {
 		const unsubscribe = orchestrator.subscribe(() => {
 			version.update((v) => v + 1);
@@ -76,20 +82,20 @@ function injectStreamCustom(options) {
 		},
 		subagents: (0, _angular_core.computed)(() => {
 			subagentVersion();
-			return orchestrator.subagents;
+			return reactiveSubagents.mapSubagents(orchestrator.subagents);
 		}),
 		activeSubagents: (0, _angular_core.computed)(() => {
 			subagentVersion();
-			return orchestrator.activeSubagents;
+			return reactiveSubagents.mapActiveSubagents(orchestrator.activeSubagents);
 		}),
 		getSubagent(toolCallId) {
-			return orchestrator.getSubagent(toolCallId);
+			return reactiveSubagents.getSubagent(toolCallId);
 		},
 		getSubagentsByType(type) {
-			return orchestrator.getSubagentsByType(type);
+			return reactiveSubagents.getSubagentsByType(type);
 		},
 		getSubagentsByMessage(messageId) {
-			return orchestrator.getSubagentsByMessage(messageId);
+			return reactiveSubagents.getSubagentsByMessage(messageId);
 		}
 	};
 }

package/dist/stream.custom.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"stream.custom.cjs","names":["CustomStreamOrchestrator"],"sources":["../src/stream.custom.ts"],"sourcesContent":["import { signal, computed, effect } from \"@angular/core\";\nimport {\n  CustomStreamOrchestrator,\n  ensureMessageInstances,\n  type AnyStreamCustomOptions,\n  type CustomSubmitOptions,\n  type GetUpdateType,\n  type GetInterruptType,\n  type GetConfigurableType,\n  type GetToolCallsType,\n  type MessageMetadata,\n} from \"@langchain/langgraph-sdk/ui\";\nimport type { BagTemplate, Message, Interrupt } from \"@langchain/langgraph-sdk\";\n\nexport function injectStreamCustom<\n  StateType extends Record<string, unknown> = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate,\n>(options: AnyStreamCustomOptions<StateType, Bag>) {\n  type UpdateType = GetUpdateType<Bag, StateType>;\n  type InterruptType = GetInterruptType<Bag>;\n  type ConfigurableType = GetConfigurableType<Bag>;\n  type ToolCallType = GetToolCallsType<StateType>;\n\n  const orchestrator = new CustomStreamOrchestrator<StateType, Bag>(options);\n\n  const version = signal(0);\n  const subagentVersion = signal(0);\n  const isLoading = signal(orchestrator.isLoading);\n\n  effect((onCleanup) => {\n    const unsubscribe = orchestrator.subscribe(() => {\n      version.update((v) => v + 1);\n      subagentVersion.update((v) => v + 1);\n      isLoading.set(orchestrator.isLoading);\n    });\n    onCleanup(() => unsubscribe());\n  });\n\n  effect(() => {\n    void version();\n    const loading = orchestrator.isLoading;\n    const hvMessages = orchestrator.messages;\n    if (options.filterSubagentMessages && !loading && hvMessages.length > 0) {\n      orchestrator.reconstructSubagentsIfNeeded();\n    }\n  });\n\n  const values = computed(() => {\n    void version();\n    return orchestrator.values;\n  });\n\n  const branch = signal<string>(\"\");\n\n  return {\n    values,\n    error: computed(() => {\n      void version();\n      return orchestrator.error;\n    }),\n    isLoading,\n\n    stop: () => orchestrator.stop(),\n\n    async submit(\n      values: UpdateType | null | undefined,\n      submitOptions?: CustomSubmitOptions<StateType, ConfigurableType>\n    ) {\n      await orchestrator.submit(values, submitOptions);\n    },\n\n    switchThread(newThreadId: string | null) {\n      orchestrator.switchThread(newThreadId);\n    },\n\n    branch,\n    setBranch(value: string) {\n      branch.set(value);\n      orchestrator.setBranch(value);\n    },\n\n    getMessagesMetadata(\n      message: Message<ToolCallType>,\n      index?: number\n    ): MessageMetadata<StateType> | undefined {\n      return orchestrator.getMessagesMetadata(message, index);\n    },\n\n    queue: {\n      entries: signal([]),\n      size: signal(0),\n      async cancel() {\n        return false;\n      },\n      async clear() {},\n    },\n\n    interrupts: computed((): Interrupt<InterruptType>[] => {\n      void version();\n      return orchestrator.interrupts as Interrupt<InterruptType>[];\n    }),\n\n    interrupt: computed((): Interrupt<InterruptType> | undefined => {\n      void version();\n      return orchestrator.interrupt as Interrupt<InterruptType> | undefined;\n    }),\n\n    messages: computed(() => {\n      void version();\n      return ensureMessageInstances(orchestrator.messages);\n    }),\n\n    toolCalls: computed(() => {\n      void version();\n      return orchestrator.toolCalls;\n    }),\n\n    getToolCalls(message: Message<ToolCallType>) {\n      return orchestrator.getToolCalls(message);\n    },\n\n    subagents: computed(() => {\n      void subagentVersion();\n      return orchestrator.subagents as ReadonlyMap<\n        string,\n        typeof orchestrator.subagents extends Map<string, infer V> ? V : never\n      >;\n    }),\n\n    activeSubagents: computed(() => {\n      void subagentVersion();\n      return orchestrator.activeSubagents as readonly (typeof orchestrator.activeSubagents extends (infer V)[]\n        ? V\n        : never)[];\n    }),\n\n    getSubagent(toolCallId: string) {\n      return orchestrator.getSubagent(toolCallId);\n    },\n    getSubagentsByType(type: string) {\n      return orchestrator.getSubagentsByType(type);\n    },\n    getSubagentsByMessage(messageId: string) {\n      return orchestrator.getSubagentsByMessage(messageId);\n    },\n  };\n}\n\n/**\n * @deprecated Use `injectStreamCustom` instead. `useStreamCustom` will be\n * removed in a future major version. `injectStreamCustom` follows Angular's\n * `inject*` naming convention for injection-based patterns.\n */\nexport const useStreamCustom = injectStreamCustom;\n"],"mappings":";;;AAcA,SAAgB,mBAGd,SAAiD;CAMjD,MAAM,eAAe,IAAIA,4BAAAA,yBAAyC,QAAQ;CAE1E,MAAM,WAAA,GAAA,cAAA,QAAiB,EAAE;CACzB,MAAM,mBAAA,GAAA,cAAA,QAAyB,EAAE;CACjC,MAAM,aAAA,GAAA,cAAA,QAAmB,aAAa,UAAU;AAEhD,EAAA,GAAA,cAAA,SAAQ,cAAc;EACpB,MAAM,cAAc,aAAa,gBAAgB;AAC/C,WAAQ,QAAQ,MAAM,IAAI,EAAE;AAC5B,mBAAgB,QAAQ,MAAM,IAAI,EAAE;AACpC,aAAU,IAAI,aAAa,UAAU;IACrC;AACF,kBAAgB,aAAa,CAAC;GAC9B;AAEF,EAAA,GAAA,cAAA,cAAa;AACN,WAAS;EACd,MAAM,UAAU,aAAa;EAC7B,MAAM,aAAa,aAAa;AAChC,MAAI,QAAQ,0BAA0B,CAAC,WAAW,WAAW,SAAS,EACpE,cAAa,8BAA8B;GAE7C;CAEF,MAAM,UAAA,GAAA,cAAA,gBAAwB;AACvB,WAAS;AACd,SAAO,aAAa;GACpB;CAEF,MAAM,UAAA,GAAA,cAAA,QAAwB,GAAG;AAEjC,QAAO;EACL;EACA,QAAA,GAAA,cAAA,gBAAsB;AACf,YAAS;AACd,UAAO,aAAa;IACpB;EACF;EAEA,YAAY,aAAa,MAAM;EAE/B,MAAM,OACJ,QACA,eACA;AACA,SAAM,aAAa,OAAO,QAAQ,cAAc;;EAGlD,aAAa,aAA4B;AACvC,gBAAa,aAAa,YAAY;;EAGxC;EACA,UAAU,OAAe;AACvB,UAAO,IAAI,MAAM;AACjB,gBAAa,UAAU,MAAM;;EAG/B,oBACE,SACA,OACwC;AACxC,UAAO,aAAa,oBAAoB,SAAS,MAAM;;EAGzD,OAAO;GACL,UAAA,GAAA,cAAA,QAAgB,EAAE,CAAC;GACnB,OAAA,GAAA,cAAA,QAAa,EAAE;GACf,MAAM,SAAS;AACb,WAAO;;GAET,MAAM,QAAQ;GACf;EAED,aAAA,GAAA,cAAA,gBAAuD;AAChD,YAAS;AACd,UAAO,aAAa;IACpB;EAEF,YAAA,GAAA,cAAA,gBAAgE;AACzD,YAAS;AACd,UAAO,aAAa;IACpB;EAEF,WAAA,GAAA,cAAA,gBAAyB;AAClB,YAAS;AACd,WAAA,GAAA,4BAAA,wBAA8B,aAAa,SAAS;IACpD;EAEF,YAAA,GAAA,cAAA,gBAA0B;AACnB,YAAS;AACd,UAAO,aAAa;IACpB;EAEF,aAAa,SAAgC;AAC3C,UAAO,aAAa,aAAa,QAAQ;;EAG3C,YAAA,GAAA,cAAA,gBAA0B;AACnB,oBAAiB;AACtB,UAAO,aAAa;IAIpB;EAEF,kBAAA,GAAA,cAAA,gBAAgC;AACzB,oBAAiB;AACtB,UAAO,aAAa;IAGpB;EAEF,YAAY,YAAoB;AAC9B,UAAO,aAAa,YAAY,WAAW;;EAE7C,mBAAmB,MAAc;AAC/B,UAAO,aAAa,mBAAmB,KAAK;;EAE9C,sBAAsB,WAAmB;AACvC,UAAO,aAAa,sBAAsB,UAAU;;EAEvD;;;;;;;AAQH,MAAa,kBAAkB"}
+{"version":3,"file":"stream.custom.cjs","names":["CustomStreamOrchestrator","createReactiveSubagentAccessors"],"sources":["../src/stream.custom.ts"],"sourcesContent":["import { signal, computed, effect } from \"@angular/core\";\nimport {\n  CustomStreamOrchestrator,\n  ensureMessageInstances,\n  type AnyStreamCustomOptions,\n  type CustomSubmitOptions,\n  type GetUpdateType,\n  type GetInterruptType,\n  type GetConfigurableType,\n  type GetToolCallsType,\n  type MessageMetadata,\n} from \"@langchain/langgraph-sdk/ui\";\nimport type { BagTemplate, Message, Interrupt } from \"@langchain/langgraph-sdk\";\nimport { createReactiveSubagentAccessors } from \"./subagents.js\";\n\nexport function injectStreamCustom<\n  StateType extends Record<string, unknown> = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate,\n>(options: AnyStreamCustomOptions<StateType, Bag>) {\n  type UpdateType = GetUpdateType<Bag, StateType>;\n  type InterruptType = GetInterruptType<Bag>;\n  type ConfigurableType = GetConfigurableType<Bag>;\n  type ToolCallType = GetToolCallsType<StateType>;\n\n  const orchestrator = new CustomStreamOrchestrator<StateType, Bag>(options);\n\n  const version = signal(0);\n  const subagentVersion = signal(0);\n  const isLoading = signal(orchestrator.isLoading);\n  const reactiveSubagents = createReactiveSubagentAccessors(\n    {\n      getSubagent: (toolCallId) => orchestrator.getSubagent(toolCallId),\n      getSubagentsByType: (type) => orchestrator.getSubagentsByType(type),\n      getSubagentsByMessage: (messageId) =>\n        orchestrator.getSubagentsByMessage(messageId),\n    },\n    subagentVersion\n  );\n\n  effect((onCleanup) => {\n    const unsubscribe = orchestrator.subscribe(() => {\n      version.update((v) => v + 1);\n      subagentVersion.update((v) => v + 1);\n      isLoading.set(orchestrator.isLoading);\n    });\n    onCleanup(() => unsubscribe());\n  });\n\n  effect(() => {\n    void version();\n    const loading = orchestrator.isLoading;\n    const hvMessages = orchestrator.messages;\n    if (options.filterSubagentMessages && !loading && hvMessages.length > 0) {\n      orchestrator.reconstructSubagentsIfNeeded();\n    }\n  });\n\n  const values = computed(() => {\n    void version();\n    return orchestrator.values;\n  });\n\n  const branch = signal<string>(\"\");\n\n  return {\n    values,\n    error: computed(() => {\n      void version();\n      return orchestrator.error;\n    }),\n    isLoading,\n\n    stop: () => orchestrator.stop(),\n\n    async submit(\n      values: UpdateType | null | undefined,\n      submitOptions?: CustomSubmitOptions<StateType, ConfigurableType>\n    ) {\n      await orchestrator.submit(values, submitOptions);\n    },\n\n    switchThread(newThreadId: string | null) {\n      orchestrator.switchThread(newThreadId);\n    },\n\n    branch,\n    setBranch(value: string) {\n      branch.set(value);\n      orchestrator.setBranch(value);\n    },\n\n    getMessagesMetadata(\n      message: Message<ToolCallType>,\n      index?: number\n    ): MessageMetadata<StateType> | undefined {\n      return orchestrator.getMessagesMetadata(message, index);\n    },\n\n    queue: {\n      entries: signal([]),\n      size: signal(0),\n      async cancel() {\n        return false;\n      },\n      async clear() {},\n    },\n\n    interrupts: computed((): Interrupt<InterruptType>[] => {\n      void version();\n      return orchestrator.interrupts as Interrupt<InterruptType>[];\n    }),\n\n    interrupt: computed((): Interrupt<InterruptType> | undefined => {\n      void version();\n      return orchestrator.interrupt as Interrupt<InterruptType> | undefined;\n    }),\n\n    messages: computed(() => {\n      void version();\n      return ensureMessageInstances(orchestrator.messages);\n    }),\n\n    toolCalls: computed(() => {\n      void version();\n      return orchestrator.toolCalls;\n    }),\n\n    getToolCalls(message: Message<ToolCallType>) {\n      return orchestrator.getToolCalls(message);\n    },\n\n    subagents: computed(() => {\n      void subagentVersion();\n      return reactiveSubagents.mapSubagents(\n        orchestrator.subagents\n      ) as ReadonlyMap<\n        string,\n        typeof orchestrator.subagents extends Map<string, infer V> ? V : never\n      >;\n    }),\n\n    activeSubagents: computed(() => {\n      void subagentVersion();\n      return reactiveSubagents.mapActiveSubagents(\n        orchestrator.activeSubagents\n      ) as readonly (typeof orchestrator.activeSubagents extends (infer V)[]\n        ? V\n        : never)[];\n    }),\n\n    getSubagent(toolCallId: string) {\n      return reactiveSubagents.getSubagent(toolCallId);\n    },\n    getSubagentsByType(type: string) {\n      return reactiveSubagents.getSubagentsByType(type);\n    },\n    getSubagentsByMessage(messageId: string) {\n      return reactiveSubagents.getSubagentsByMessage(messageId);\n    },\n  };\n}\n\n/**\n * @deprecated Use `injectStreamCustom` instead. `useStreamCustom` will be\n * removed in a future major version. `injectStreamCustom` follows Angular's\n * `inject*` naming convention for injection-based patterns.\n */\nexport const useStreamCustom = injectStreamCustom;\n"],"mappings":";;;;AAeA,SAAgB,mBAGd,SAAiD;CAMjD,MAAM,eAAe,IAAIA,4BAAAA,yBAAyC,QAAQ;CAE1E,MAAM,WAAA,GAAA,cAAA,QAAiB,EAAE;CACzB,MAAM,mBAAA,GAAA,cAAA,QAAyB,EAAE;CACjC,MAAM,aAAA,GAAA,cAAA,QAAmB,aAAa,UAAU;CAChD,MAAM,oBAAoBC,kBAAAA,gCACxB;EACE,cAAc,eAAe,aAAa,YAAY,WAAW;EACjE,qBAAqB,SAAS,aAAa,mBAAmB,KAAK;EACnE,wBAAwB,cACtB,aAAa,sBAAsB,UAAU;EAChD,EACD,gBACD;AAED,EAAA,GAAA,cAAA,SAAQ,cAAc;EACpB,MAAM,cAAc,aAAa,gBAAgB;AAC/C,WAAQ,QAAQ,MAAM,IAAI,EAAE;AAC5B,mBAAgB,QAAQ,MAAM,IAAI,EAAE;AACpC,aAAU,IAAI,aAAa,UAAU;IACrC;AACF,kBAAgB,aAAa,CAAC;GAC9B;AAEF,EAAA,GAAA,cAAA,cAAa;AACN,WAAS;EACd,MAAM,UAAU,aAAa;EAC7B,MAAM,aAAa,aAAa;AAChC,MAAI,QAAQ,0BAA0B,CAAC,WAAW,WAAW,SAAS,EACpE,cAAa,8BAA8B;GAE7C;CAEF,MAAM,UAAA,GAAA,cAAA,gBAAwB;AACvB,WAAS;AACd,SAAO,aAAa;GACpB;CAEF,MAAM,UAAA,GAAA,cAAA,QAAwB,GAAG;AAEjC,QAAO;EACL;EACA,QAAA,GAAA,cAAA,gBAAsB;AACf,YAAS;AACd,UAAO,aAAa;IACpB;EACF;EAEA,YAAY,aAAa,MAAM;EAE/B,MAAM,OACJ,QACA,eACA;AACA,SAAM,aAAa,OAAO,QAAQ,cAAc;;EAGlD,aAAa,aAA4B;AACvC,gBAAa,aAAa,YAAY;;EAGxC;EACA,UAAU,OAAe;AACvB,UAAO,IAAI,MAAM;AACjB,gBAAa,UAAU,MAAM;;EAG/B,oBACE,SACA,OACwC;AACxC,UAAO,aAAa,oBAAoB,SAAS,MAAM;;EAGzD,OAAO;GACL,UAAA,GAAA,cAAA,QAAgB,EAAE,CAAC;GACnB,OAAA,GAAA,cAAA,QAAa,EAAE;GACf,MAAM,SAAS;AACb,WAAO;;GAET,MAAM,QAAQ;GACf;EAED,aAAA,GAAA,cAAA,gBAAuD;AAChD,YAAS;AACd,UAAO,aAAa;IACpB;EAEF,YAAA,GAAA,cAAA,gBAAgE;AACzD,YAAS;AACd,UAAO,aAAa;IACpB;EAEF,WAAA,GAAA,cAAA,gBAAyB;AAClB,YAAS;AACd,WAAA,GAAA,4BAAA,wBAA8B,aAAa,SAAS;IACpD;EAEF,YAAA,GAAA,cAAA,gBAA0B;AACnB,YAAS;AACd,UAAO,aAAa;IACpB;EAEF,aAAa,SAAgC;AAC3C,UAAO,aAAa,aAAa,QAAQ;;EAG3C,YAAA,GAAA,cAAA,gBAA0B;AACnB,oBAAiB;AACtB,UAAO,kBAAkB,aACvB,aAAa,UACd;IAID;EAEF,kBAAA,GAAA,cAAA,gBAAgC;AACzB,oBAAiB;AACtB,UAAO,kBAAkB,mBACvB,aAAa,gBACd;IAGD;EAEF,YAAY,YAAoB;AAC9B,UAAO,kBAAkB,YAAY,WAAW;;EAElD,mBAAmB,MAAc;AAC/B,UAAO,kBAAkB,mBAAmB,KAAK;;EAEnD,sBAAsB,WAAmB;AACvC,UAAO,kBAAkB,sBAAsB,UAAU;;EAE5D;;;;;;;AAQH,MAAa,kBAAkB"}

package/dist/stream.custom.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"stream.custom.d.cts","names":[],"sources":["../src/stream.custom.ts"],"mappings":";;;;;;;;;iBAcgB,kBAAA,mBACI,MAAA,oBAA0B,MAAA,+BAChC,WAAA,GAAc,WAAA,CAAA,CAC1B,OAAA,EAAS,sBAAA,CAAuB,SAAA,EAAW,GAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwIhC,eAAA,SAAe,kBAAA"}
+{"version":3,"file":"stream.custom.d.cts","names":[],"sources":["../src/stream.custom.ts"],"mappings":";;;;;;;;;iBAegB,kBAAA,mBACI,MAAA,oBAA0B,MAAA,+BAChC,WAAA,GAAc,WAAA,CAAA,CAC1B,OAAA,EAAS,sBAAA,CAAuB,SAAA,EAAW,GAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAqJhC,eAAA,SAAe,kBAAA"}

package/dist/stream.custom.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stream.custom.d.ts","names":[],"sources":["../src/stream.custom.ts"],"mappings":";;;;;;;;;iBAcgB,kBAAA,mBACI,MAAA,oBAA0B,MAAA,+BAChC,WAAA,GAAc,WAAA,CAAA,CAC1B,OAAA,EAAS,sBAAA,CAAuB,SAAA,EAAW,GAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwIhC,eAAA,SAAe,kBAAA"}
+{"version":3,"file":"stream.custom.d.ts","names":[],"sources":["../src/stream.custom.ts"],"mappings":";;;;;;;;;iBAegB,kBAAA,mBACI,MAAA,oBAA0B,MAAA,+BAChC,WAAA,GAAc,WAAA,CAAA,CAC1B,OAAA,EAAS,sBAAA,CAAuB,SAAA,EAAW,GAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAqJhC,eAAA,SAAe,kBAAA"}

package/dist/stream.custom.js

@@ -1,3 +1,4 @@
+import { createReactiveSubagentAccessors } from "./subagents.js";
 import { computed, effect, signal } from "@angular/core";
 import { CustomStreamOrchestrator, ensureMessageInstances } from "@langchain/langgraph-sdk/ui";
 //#region src/stream.custom.ts
@@ -6,6 +7,11 @@ function injectStreamCustom(options) {
 	const version = signal(0);
 	const subagentVersion = signal(0);
 	const isLoading = signal(orchestrator.isLoading);
+	const reactiveSubagents = createReactiveSubagentAccessors({
+		getSubagent: (toolCallId) => orchestrator.getSubagent(toolCallId),
+		getSubagentsByType: (type) => orchestrator.getSubagentsByType(type),
+		getSubagentsByMessage: (messageId) => orchestrator.getSubagentsByMessage(messageId)
+	}, subagentVersion);
 	effect((onCleanup) => {
 		const unsubscribe = orchestrator.subscribe(() => {
 			version.update((v) => v + 1);
@@ -76,20 +82,20 @@ function injectStreamCustom(options) {
 		},
 		subagents: computed(() => {
 			subagentVersion();
-			return orchestrator.subagents;
+			return reactiveSubagents.mapSubagents(orchestrator.subagents);
 		}),
 		activeSubagents: computed(() => {
 			subagentVersion();
-			return orchestrator.activeSubagents;
+			return reactiveSubagents.mapActiveSubagents(orchestrator.activeSubagents);
 		}),
 		getSubagent(toolCallId) {
-			return orchestrator.getSubagent(toolCallId);
+			return reactiveSubagents.getSubagent(toolCallId);
 		},
 		getSubagentsByType(type) {
-			return orchestrator.getSubagentsByType(type);
+			return reactiveSubagents.getSubagentsByType(type);
 		},
 		getSubagentsByMessage(messageId) {
-			return orchestrator.getSubagentsByMessage(messageId);
+			return reactiveSubagents.getSubagentsByMessage(messageId);
 		}
 	};
 }

package/dist/stream.custom.js.map

@@ -1 +1 @@
-{"version":3,"file":"stream.custom.js","names":[],"sources":["../src/stream.custom.ts"],"sourcesContent":["import { signal, computed, effect } from \"@angular/core\";\nimport {\n  CustomStreamOrchestrator,\n  ensureMessageInstances,\n  type AnyStreamCustomOptions,\n  type CustomSubmitOptions,\n  type GetUpdateType,\n  type GetInterruptType,\n  type GetConfigurableType,\n  type GetToolCallsType,\n  type MessageMetadata,\n} from \"@langchain/langgraph-sdk/ui\";\nimport type { BagTemplate, Message, Interrupt } from \"@langchain/langgraph-sdk\";\n\nexport function injectStreamCustom<\n  StateType extends Record<string, unknown> = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate,\n>(options: AnyStreamCustomOptions<StateType, Bag>) {\n  type UpdateType = GetUpdateType<Bag, StateType>;\n  type InterruptType = GetInterruptType<Bag>;\n  type ConfigurableType = GetConfigurableType<Bag>;\n  type ToolCallType = GetToolCallsType<StateType>;\n\n  const orchestrator = new CustomStreamOrchestrator<StateType, Bag>(options);\n\n  const version = signal(0);\n  const subagentVersion = signal(0);\n  const isLoading = signal(orchestrator.isLoading);\n\n  effect((onCleanup) => {\n    const unsubscribe = orchestrator.subscribe(() => {\n      version.update((v) => v + 1);\n      subagentVersion.update((v) => v + 1);\n      isLoading.set(orchestrator.isLoading);\n    });\n    onCleanup(() => unsubscribe());\n  });\n\n  effect(() => {\n    void version();\n    const loading = orchestrator.isLoading;\n    const hvMessages = orchestrator.messages;\n    if (options.filterSubagentMessages && !loading && hvMessages.length > 0) {\n      orchestrator.reconstructSubagentsIfNeeded();\n    }\n  });\n\n  const values = computed(() => {\n    void version();\n    return orchestrator.values;\n  });\n\n  const branch = signal<string>(\"\");\n\n  return {\n    values,\n    error: computed(() => {\n      void version();\n      return orchestrator.error;\n    }),\n    isLoading,\n\n    stop: () => orchestrator.stop(),\n\n    async submit(\n      values: UpdateType | null | undefined,\n      submitOptions?: CustomSubmitOptions<StateType, ConfigurableType>\n    ) {\n      await orchestrator.submit(values, submitOptions);\n    },\n\n    switchThread(newThreadId: string | null) {\n      orchestrator.switchThread(newThreadId);\n    },\n\n    branch,\n    setBranch(value: string) {\n      branch.set(value);\n      orchestrator.setBranch(value);\n    },\n\n    getMessagesMetadata(\n      message: Message<ToolCallType>,\n      index?: number\n    ): MessageMetadata<StateType> | undefined {\n      return orchestrator.getMessagesMetadata(message, index);\n    },\n\n    queue: {\n      entries: signal([]),\n      size: signal(0),\n      async cancel() {\n        return false;\n      },\n      async clear() {},\n    },\n\n    interrupts: computed((): Interrupt<InterruptType>[] => {\n      void version();\n      return orchestrator.interrupts as Interrupt<InterruptType>[];\n    }),\n\n    interrupt: computed((): Interrupt<InterruptType> | undefined => {\n      void version();\n      return orchestrator.interrupt as Interrupt<InterruptType> | undefined;\n    }),\n\n    messages: computed(() => {\n      void version();\n      return ensureMessageInstances(orchestrator.messages);\n    }),\n\n    toolCalls: computed(() => {\n      void version();\n      return orchestrator.toolCalls;\n    }),\n\n    getToolCalls(message: Message<ToolCallType>) {\n      return orchestrator.getToolCalls(message);\n    },\n\n    subagents: computed(() => {\n      void subagentVersion();\n      return orchestrator.subagents as ReadonlyMap<\n        string,\n        typeof orchestrator.subagents extends Map<string, infer V> ? V : never\n      >;\n    }),\n\n    activeSubagents: computed(() => {\n      void subagentVersion();\n      return orchestrator.activeSubagents as readonly (typeof orchestrator.activeSubagents extends (infer V)[]\n        ? V\n        : never)[];\n    }),\n\n    getSubagent(toolCallId: string) {\n      return orchestrator.getSubagent(toolCallId);\n    },\n    getSubagentsByType(type: string) {\n      return orchestrator.getSubagentsByType(type);\n    },\n    getSubagentsByMessage(messageId: string) {\n      return orchestrator.getSubagentsByMessage(messageId);\n    },\n  };\n}\n\n/**\n * @deprecated Use `injectStreamCustom` instead. `useStreamCustom` will be\n * removed in a future major version. `injectStreamCustom` follows Angular's\n * `inject*` naming convention for injection-based patterns.\n */\nexport const useStreamCustom = injectStreamCustom;\n"],"mappings":";;;AAcA,SAAgB,mBAGd,SAAiD;CAMjD,MAAM,eAAe,IAAI,yBAAyC,QAAQ;CAE1E,MAAM,UAAU,OAAO,EAAE;CACzB,MAAM,kBAAkB,OAAO,EAAE;CACjC,MAAM,YAAY,OAAO,aAAa,UAAU;AAEhD,SAAQ,cAAc;EACpB,MAAM,cAAc,aAAa,gBAAgB;AAC/C,WAAQ,QAAQ,MAAM,IAAI,EAAE;AAC5B,mBAAgB,QAAQ,MAAM,IAAI,EAAE;AACpC,aAAU,IAAI,aAAa,UAAU;IACrC;AACF,kBAAgB,aAAa,CAAC;GAC9B;AAEF,cAAa;AACN,WAAS;EACd,MAAM,UAAU,aAAa;EAC7B,MAAM,aAAa,aAAa;AAChC,MAAI,QAAQ,0BAA0B,CAAC,WAAW,WAAW,SAAS,EACpE,cAAa,8BAA8B;GAE7C;CAEF,MAAM,SAAS,eAAe;AACvB,WAAS;AACd,SAAO,aAAa;GACpB;CAEF,MAAM,SAAS,OAAe,GAAG;AAEjC,QAAO;EACL;EACA,OAAO,eAAe;AACf,YAAS;AACd,UAAO,aAAa;IACpB;EACF;EAEA,YAAY,aAAa,MAAM;EAE/B,MAAM,OACJ,QACA,eACA;AACA,SAAM,aAAa,OAAO,QAAQ,cAAc;;EAGlD,aAAa,aAA4B;AACvC,gBAAa,aAAa,YAAY;;EAGxC;EACA,UAAU,OAAe;AACvB,UAAO,IAAI,MAAM;AACjB,gBAAa,UAAU,MAAM;;EAG/B,oBACE,SACA,OACwC;AACxC,UAAO,aAAa,oBAAoB,SAAS,MAAM;;EAGzD,OAAO;GACL,SAAS,OAAO,EAAE,CAAC;GACnB,MAAM,OAAO,EAAE;GACf,MAAM,SAAS;AACb,WAAO;;GAET,MAAM,QAAQ;GACf;EAED,YAAY,eAA2C;AAChD,YAAS;AACd,UAAO,aAAa;IACpB;EAEF,WAAW,eAAqD;AACzD,YAAS;AACd,UAAO,aAAa;IACpB;EAEF,UAAU,eAAe;AAClB,YAAS;AACd,UAAO,uBAAuB,aAAa,SAAS;IACpD;EAEF,WAAW,eAAe;AACnB,YAAS;AACd,UAAO,aAAa;IACpB;EAEF,aAAa,SAAgC;AAC3C,UAAO,aAAa,aAAa,QAAQ;;EAG3C,WAAW,eAAe;AACnB,oBAAiB;AACtB,UAAO,aAAa;IAIpB;EAEF,iBAAiB,eAAe;AACzB,oBAAiB;AACtB,UAAO,aAAa;IAGpB;EAEF,YAAY,YAAoB;AAC9B,UAAO,aAAa,YAAY,WAAW;;EAE7C,mBAAmB,MAAc;AAC/B,UAAO,aAAa,mBAAmB,KAAK;;EAE9C,sBAAsB,WAAmB;AACvC,UAAO,aAAa,sBAAsB,UAAU;;EAEvD;;;;;;;AAQH,MAAa,kBAAkB"}
+{"version":3,"file":"stream.custom.js","names":[],"sources":["../src/stream.custom.ts"],"sourcesContent":["import { signal, computed, effect } from \"@angular/core\";\nimport {\n  CustomStreamOrchestrator,\n  ensureMessageInstances,\n  type AnyStreamCustomOptions,\n  type CustomSubmitOptions,\n  type GetUpdateType,\n  type GetInterruptType,\n  type GetConfigurableType,\n  type GetToolCallsType,\n  type MessageMetadata,\n} from \"@langchain/langgraph-sdk/ui\";\nimport type { BagTemplate, Message, Interrupt } from \"@langchain/langgraph-sdk\";\nimport { createReactiveSubagentAccessors } from \"./subagents.js\";\n\nexport function injectStreamCustom<\n  StateType extends Record<string, unknown> = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate,\n>(options: AnyStreamCustomOptions<StateType, Bag>) {\n  type UpdateType = GetUpdateType<Bag, StateType>;\n  type InterruptType = GetInterruptType<Bag>;\n  type ConfigurableType = GetConfigurableType<Bag>;\n  type ToolCallType = GetToolCallsType<StateType>;\n\n  const orchestrator = new CustomStreamOrchestrator<StateType, Bag>(options);\n\n  const version = signal(0);\n  const subagentVersion = signal(0);\n  const isLoading = signal(orchestrator.isLoading);\n  const reactiveSubagents = createReactiveSubagentAccessors(\n    {\n      getSubagent: (toolCallId) => orchestrator.getSubagent(toolCallId),\n      getSubagentsByType: (type) => orchestrator.getSubagentsByType(type),\n      getSubagentsByMessage: (messageId) =>\n        orchestrator.getSubagentsByMessage(messageId),\n    },\n    subagentVersion\n  );\n\n  effect((onCleanup) => {\n    const unsubscribe = orchestrator.subscribe(() => {\n      version.update((v) => v + 1);\n      subagentVersion.update((v) => v + 1);\n      isLoading.set(orchestrator.isLoading);\n    });\n    onCleanup(() => unsubscribe());\n  });\n\n  effect(() => {\n    void version();\n    const loading = orchestrator.isLoading;\n    const hvMessages = orchestrator.messages;\n    if (options.filterSubagentMessages && !loading && hvMessages.length > 0) {\n      orchestrator.reconstructSubagentsIfNeeded();\n    }\n  });\n\n  const values = computed(() => {\n    void version();\n    return orchestrator.values;\n  });\n\n  const branch = signal<string>(\"\");\n\n  return {\n    values,\n    error: computed(() => {\n      void version();\n      return orchestrator.error;\n    }),\n    isLoading,\n\n    stop: () => orchestrator.stop(),\n\n    async submit(\n      values: UpdateType | null | undefined,\n      submitOptions?: CustomSubmitOptions<StateType, ConfigurableType>\n    ) {\n      await orchestrator.submit(values, submitOptions);\n    },\n\n    switchThread(newThreadId: string | null) {\n      orchestrator.switchThread(newThreadId);\n    },\n\n    branch,\n    setBranch(value: string) {\n      branch.set(value);\n      orchestrator.setBranch(value);\n    },\n\n    getMessagesMetadata(\n      message: Message<ToolCallType>,\n      index?: number\n    ): MessageMetadata<StateType> | undefined {\n      return orchestrator.getMessagesMetadata(message, index);\n    },\n\n    queue: {\n      entries: signal([]),\n      size: signal(0),\n      async cancel() {\n        return false;\n      },\n      async clear() {},\n    },\n\n    interrupts: computed((): Interrupt<InterruptType>[] => {\n      void version();\n      return orchestrator.interrupts as Interrupt<InterruptType>[];\n    }),\n\n    interrupt: computed((): Interrupt<InterruptType> | undefined => {\n      void version();\n      return orchestrator.interrupt as Interrupt<InterruptType> | undefined;\n    }),\n\n    messages: computed(() => {\n      void version();\n      return ensureMessageInstances(orchestrator.messages);\n    }),\n\n    toolCalls: computed(() => {\n      void version();\n      return orchestrator.toolCalls;\n    }),\n\n    getToolCalls(message: Message<ToolCallType>) {\n      return orchestrator.getToolCalls(message);\n    },\n\n    subagents: computed(() => {\n      void subagentVersion();\n      return reactiveSubagents.mapSubagents(\n        orchestrator.subagents\n      ) as ReadonlyMap<\n        string,\n        typeof orchestrator.subagents extends Map<string, infer V> ? V : never\n      >;\n    }),\n\n    activeSubagents: computed(() => {\n      void subagentVersion();\n      return reactiveSubagents.mapActiveSubagents(\n        orchestrator.activeSubagents\n      ) as readonly (typeof orchestrator.activeSubagents extends (infer V)[]\n        ? V\n        : never)[];\n    }),\n\n    getSubagent(toolCallId: string) {\n      return reactiveSubagents.getSubagent(toolCallId);\n    },\n    getSubagentsByType(type: string) {\n      return reactiveSubagents.getSubagentsByType(type);\n    },\n    getSubagentsByMessage(messageId: string) {\n      return reactiveSubagents.getSubagentsByMessage(messageId);\n    },\n  };\n}\n\n/**\n * @deprecated Use `injectStreamCustom` instead. `useStreamCustom` will be\n * removed in a future major version. `injectStreamCustom` follows Angular's\n * `inject*` naming convention for injection-based patterns.\n */\nexport const useStreamCustom = injectStreamCustom;\n"],"mappings":";;;;AAeA,SAAgB,mBAGd,SAAiD;CAMjD,MAAM,eAAe,IAAI,yBAAyC,QAAQ;CAE1E,MAAM,UAAU,OAAO,EAAE;CACzB,MAAM,kBAAkB,OAAO,EAAE;CACjC,MAAM,YAAY,OAAO,aAAa,UAAU;CAChD,MAAM,oBAAoB,gCACxB;EACE,cAAc,eAAe,aAAa,YAAY,WAAW;EACjE,qBAAqB,SAAS,aAAa,mBAAmB,KAAK;EACnE,wBAAwB,cACtB,aAAa,sBAAsB,UAAU;EAChD,EACD,gBACD;AAED,SAAQ,cAAc;EACpB,MAAM,cAAc,aAAa,gBAAgB;AAC/C,WAAQ,QAAQ,MAAM,IAAI,EAAE;AAC5B,mBAAgB,QAAQ,MAAM,IAAI,EAAE;AACpC,aAAU,IAAI,aAAa,UAAU;IACrC;AACF,kBAAgB,aAAa,CAAC;GAC9B;AAEF,cAAa;AACN,WAAS;EACd,MAAM,UAAU,aAAa;EAC7B,MAAM,aAAa,aAAa;AAChC,MAAI,QAAQ,0BAA0B,CAAC,WAAW,WAAW,SAAS,EACpE,cAAa,8BAA8B;GAE7C;CAEF,MAAM,SAAS,eAAe;AACvB,WAAS;AACd,SAAO,aAAa;GACpB;CAEF,MAAM,SAAS,OAAe,GAAG;AAEjC,QAAO;EACL;EACA,OAAO,eAAe;AACf,YAAS;AACd,UAAO,aAAa;IACpB;EACF;EAEA,YAAY,aAAa,MAAM;EAE/B,MAAM,OACJ,QACA,eACA;AACA,SAAM,aAAa,OAAO,QAAQ,cAAc;;EAGlD,aAAa,aAA4B;AACvC,gBAAa,aAAa,YAAY;;EAGxC;EACA,UAAU,OAAe;AACvB,UAAO,IAAI,MAAM;AACjB,gBAAa,UAAU,MAAM;;EAG/B,oBACE,SACA,OACwC;AACxC,UAAO,aAAa,oBAAoB,SAAS,MAAM;;EAGzD,OAAO;GACL,SAAS,OAAO,EAAE,CAAC;GACnB,MAAM,OAAO,EAAE;GACf,MAAM,SAAS;AACb,WAAO;;GAET,MAAM,QAAQ;GACf;EAED,YAAY,eAA2C;AAChD,YAAS;AACd,UAAO,aAAa;IACpB;EAEF,WAAW,eAAqD;AACzD,YAAS;AACd,UAAO,aAAa;IACpB;EAEF,UAAU,eAAe;AAClB,YAAS;AACd,UAAO,uBAAuB,aAAa,SAAS;IACpD;EAEF,WAAW,eAAe;AACnB,YAAS;AACd,UAAO,aAAa;IACpB;EAEF,aAAa,SAAgC;AAC3C,UAAO,aAAa,aAAa,QAAQ;;EAG3C,WAAW,eAAe;AACnB,oBAAiB;AACtB,UAAO,kBAAkB,aACvB,aAAa,UACd;IAID;EAEF,iBAAiB,eAAe;AACzB,oBAAiB;AACtB,UAAO,kBAAkB,mBACvB,aAAa,gBACd;IAGD;EAEF,YAAY,YAAoB;AAC9B,UAAO,kBAAkB,YAAY,WAAW;;EAElD,mBAAmB,MAAc;AAC/B,UAAO,kBAAkB,mBAAmB,KAAK;;EAEnD,sBAAsB,WAAmB;AACvC,UAAO,kBAAkB,sBAAsB,UAAU;;EAE5D;;;;;;;AAQH,MAAa,kBAAkB"}

package/dist/stream.lgp.cjs

@@ -1,3 +1,4 @@
+const require_subagents = require("./subagents.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");
@@ -12,6 +13,11 @@ function useStreamLGP(options) {
 	orchestrator.initThreadId(options.threadId ?? void 0);
 	const version = (0, _angular_core.signal)(0);
 	const subagentVersion = (0, _angular_core.signal)(0);
+	const reactiveSubagents = require_subagents.createReactiveSubagentAccessors({
+		getSubagent: (toolCallId) => orchestrator.getSubagent(toolCallId),
+		getSubagentsByType: (type) => orchestrator.getSubagentsByType(type),
+		getSubagentsByMessage: (messageId) => orchestrator.getSubagentsByMessage(messageId)
+	}, subagentVersion);
 	(0, _angular_core.effect)((onCleanup) => {
 		const unsubscribe = orchestrator.subscribe(() => {
 			version.update((v) => v + 1);
@@ -103,11 +109,11 @@ function useStreamLGP(options) {
 	});
 	const subagents = (0, _angular_core.computed)(() => {
 		subagentVersion();
-		return orchestrator.subagents;
+		return reactiveSubagents.mapSubagents(orchestrator.subagents);
 	});
 	const activeSubagents = (0, _angular_core.computed)(() => {
 		subagentVersion();
-		return orchestrator.activeSubagents;
+		return reactiveSubagents.mapActiveSubagents(orchestrator.activeSubagents);
 	});
 	return {
 		assistantId: options.assistantId,

package/dist/stream.lgp.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"stream.lgp.cjs","names":["Client","StreamOrchestrator"],"sources":["../src/stream.lgp.ts"],"sourcesContent":["import { signal, computed, effect } from \"@angular/core\";\nimport {\n  StreamOrchestrator,\n  ensureMessageInstances,\n  type MessageMetadata,\n  type AnyStreamOptions,\n  type SubmitOptions,\n  type GetConfigurableType,\n  type GetInterruptType,\n} from \"@langchain/langgraph-sdk/ui\";\nimport {\n  Client,\n  type Message,\n  type Interrupt,\n  type BagTemplate,\n} from \"@langchain/langgraph-sdk\";\n\nexport function useStreamLGP<\n  StateType extends Record<string, unknown> = Record<string, unknown>,\n  Bag extends {\n    ConfigurableType?: Record<string, unknown>;\n    InterruptType?: unknown;\n    CustomEventType?: unknown;\n    UpdateType?: unknown;\n  } = BagTemplate,\n>(options: AnyStreamOptions<StateType, Bag>) {\n  type ConfigurableType = GetConfigurableType<Bag>;\n  type InterruptType = GetInterruptType<Bag>;\n\n  const client = options.client ?? new Client({ apiUrl: options.apiUrl });\n\n  const orchestrator = new StreamOrchestrator<StateType, Bag>(options, {\n    getClient: () => client,\n    getAssistantId: () => options.assistantId,\n    getMessagesKey: () => options.messagesKey ?? \"messages\",\n  });\n\n  orchestrator.initThreadId(options.threadId ?? undefined);\n\n  const version = signal(0);\n  const subagentVersion = signal(0);\n\n  effect((onCleanup) => {\n    const unsubscribe = orchestrator.subscribe(() => {\n      version.update((v) => v + 1);\n      subagentVersion.update((v) => v + 1);\n    });\n    onCleanup(() => unsubscribe());\n  });\n\n  // Subagent reconstruction\n  effect((onCleanup) => {\n    void version();\n    const hvMessages = orchestrator.messages;\n    const should =\n      options.filterSubagentMessages &&\n      !orchestrator.isLoading &&\n      !orchestrator.historyData.isLoading &&\n      hvMessages.length > 0;\n    if (should) {\n      const controller = orchestrator.reconstructSubagentsIfNeeded();\n      if (controller) {\n        onCleanup(() => controller.abort());\n      }\n    }\n  });\n\n  // Queue draining - track isLoading changes specifically so the drain\n  // fires exactly when stream transitions from loading → idle\n  const isLoadingForDrain = computed(() => {\n    void version();\n    return orchestrator.isLoading;\n  });\n  effect(() => {\n    void isLoadingForDrain();\n    orchestrator.drainQueue();\n  });\n\n  // Auto-reconnect\n  const { shouldReconnect } = orchestrator;\n  let hasReconnected = false;\n\n  effect(() => {\n    void version();\n    const tid = orchestrator.threadId;\n    if (!hasReconnected && shouldReconnect && tid && !orchestrator.isLoading) {\n      const reconnected = orchestrator.tryReconnect();\n      if (reconnected) hasReconnected = true;\n    }\n  });\n\n  const values = computed(() => {\n    void version();\n    orchestrator.trackStreamMode(\"values\");\n    return orchestrator.values;\n  });\n\n  const error = computed(() => {\n    void version();\n    return orchestrator.error;\n  });\n\n  const isLoading = signal(orchestrator.isLoading);\n  effect(() => {\n    void version();\n    isLoading.set(orchestrator.isLoading);\n  });\n\n  const branch = signal<string>(\"\");\n  effect(() => {\n    void version();\n    const b = orchestrator.branch;\n    if (branch() !== b) branch.set(b);\n  });\n\n  const messages = computed(() => {\n    void version();\n    orchestrator.trackStreamMode(\"messages-tuple\", \"values\");\n    return ensureMessageInstances(orchestrator.messages);\n  });\n\n  const toolCalls = computed(() => {\n    void version();\n    orchestrator.trackStreamMode(\"messages-tuple\", \"values\");\n    return orchestrator.toolCalls;\n  });\n\n  const interrupt = computed(() => {\n    void version();\n    return orchestrator.interrupt;\n  });\n\n  const interrupts = computed((): Interrupt<InterruptType>[] => {\n    void version();\n    return orchestrator.interrupts as Interrupt<InterruptType>[];\n  });\n\n  const historyList = computed(() => {\n    void version();\n    return orchestrator.flatHistory;\n  });\n\n  const isThreadLoading = computed(() => {\n    void version();\n    return orchestrator.isThreadLoading;\n  });\n\n  const experimentalBranchTree = computed(() => {\n    void version();\n    return orchestrator.experimental_branchTree;\n  });\n\n  const queueEntries = signal(orchestrator.queueEntries);\n  const queueSize = signal(orchestrator.queueSize);\n  effect(() => {\n    void version();\n    queueEntries.set(orchestrator.queueEntries);\n    queueSize.set(orchestrator.queueSize);\n  });\n\n  const subagents = computed(() => {\n    void subagentVersion();\n    return orchestrator.subagents as ReadonlyMap<\n      string,\n      typeof orchestrator.subagents extends Map<string, infer V> ? V : never\n    >;\n  });\n\n  const activeSubagents = computed(() => {\n    void subagentVersion();\n    return orchestrator.activeSubagents as readonly (typeof orchestrator.activeSubagents extends (infer V)[]\n      ? V\n      : never)[];\n  });\n\n  return {\n    assistantId: options.assistantId,\n    client,\n\n    values,\n    error,\n    isLoading,\n\n    branch,\n    setBranch(value: string) {\n      orchestrator.setBranch(value);\n    },\n\n    messages,\n    toolCalls,\n    getToolCalls(message: Message) {\n      return orchestrator.getToolCalls(message);\n    },\n\n    interrupt,\n    interrupts,\n\n    history: historyList,\n    isThreadLoading,\n    experimental_branchTree: experimentalBranchTree,\n\n    getMessagesMetadata(\n      message: Message,\n      index?: number\n    ): MessageMetadata<StateType> | undefined {\n      return orchestrator.getMessagesMetadata(message, index);\n    },\n\n    submit: (\n      values: StateType,\n      submitOptions?: SubmitOptions<StateType, ConfigurableType>\n    ) => orchestrator.submit(values, submitOptions),\n    stop: () => orchestrator.stop(),\n    joinStream: (...args: Parameters<typeof orchestrator.joinStream>) =>\n      orchestrator.joinStream(...args),\n\n    queue: {\n      entries: queueEntries,\n      size: queueSize,\n      cancel: (id: string) => orchestrator.cancelQueueItem(id),\n      clear: () => orchestrator.clearQueue(),\n    },\n\n    switchThread(newThreadId: string | null) {\n      orchestrator.switchThread(newThreadId);\n    },\n\n    subagents,\n    activeSubagents,\n    getSubagent(toolCallId: string) {\n      return orchestrator.getSubagent(toolCallId);\n    },\n    getSubagentsByType(type: string) {\n      return orchestrator.getSubagentsByType(type);\n    },\n    getSubagentsByMessage(messageId: string) {\n      return orchestrator.getSubagentsByMessage(messageId);\n    },\n  };\n}\n"],"mappings":"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"}
+{"version":3,"file":"stream.lgp.cjs","names":["Client","StreamOrchestrator","createReactiveSubagentAccessors"],"sources":["../src/stream.lgp.ts"],"sourcesContent":["import { signal, computed, effect } from \"@angular/core\";\nimport {\n  StreamOrchestrator,\n  ensureMessageInstances,\n  type MessageMetadata,\n  type AnyStreamOptions,\n  type SubmitOptions,\n  type GetConfigurableType,\n  type GetInterruptType,\n} from \"@langchain/langgraph-sdk/ui\";\nimport {\n  Client,\n  type Message,\n  type Interrupt,\n  type BagTemplate,\n} from \"@langchain/langgraph-sdk\";\nimport { createReactiveSubagentAccessors } from \"./subagents.js\";\n\nexport function useStreamLGP<\n  StateType extends Record<string, unknown> = Record<string, unknown>,\n  Bag extends {\n    ConfigurableType?: Record<string, unknown>;\n    InterruptType?: unknown;\n    CustomEventType?: unknown;\n    UpdateType?: unknown;\n  } = BagTemplate,\n>(options: AnyStreamOptions<StateType, Bag>) {\n  type ConfigurableType = GetConfigurableType<Bag>;\n  type InterruptType = GetInterruptType<Bag>;\n\n  const client = options.client ?? new Client({ apiUrl: options.apiUrl });\n\n  const orchestrator = new StreamOrchestrator<StateType, Bag>(options, {\n    getClient: () => client,\n    getAssistantId: () => options.assistantId,\n    getMessagesKey: () => options.messagesKey ?? \"messages\",\n  });\n\n  orchestrator.initThreadId(options.threadId ?? undefined);\n\n  const version = signal(0);\n  const subagentVersion = signal(0);\n  const reactiveSubagents = createReactiveSubagentAccessors(\n    {\n      getSubagent: (toolCallId) => orchestrator.getSubagent(toolCallId),\n      getSubagentsByType: (type) => orchestrator.getSubagentsByType(type),\n      getSubagentsByMessage: (messageId) =>\n        orchestrator.getSubagentsByMessage(messageId),\n    },\n    subagentVersion\n  );\n\n  effect((onCleanup) => {\n    const unsubscribe = orchestrator.subscribe(() => {\n      version.update((v) => v + 1);\n      subagentVersion.update((v) => v + 1);\n    });\n    onCleanup(() => unsubscribe());\n  });\n\n  // Subagent reconstruction\n  effect((onCleanup) => {\n    void version();\n    const hvMessages = orchestrator.messages;\n    const should =\n      options.filterSubagentMessages &&\n      !orchestrator.isLoading &&\n      !orchestrator.historyData.isLoading &&\n      hvMessages.length > 0;\n    if (should) {\n      const controller = orchestrator.reconstructSubagentsIfNeeded();\n      if (controller) {\n        onCleanup(() => controller.abort());\n      }\n    }\n  });\n\n  // Queue draining - track isLoading changes specifically so the drain\n  // fires exactly when stream transitions from loading → idle\n  const isLoadingForDrain = computed(() => {\n    void version();\n    return orchestrator.isLoading;\n  });\n  effect(() => {\n    void isLoadingForDrain();\n    orchestrator.drainQueue();\n  });\n\n  // Auto-reconnect\n  const { shouldReconnect } = orchestrator;\n  let hasReconnected = false;\n\n  effect(() => {\n    void version();\n    const tid = orchestrator.threadId;\n    if (!hasReconnected && shouldReconnect && tid && !orchestrator.isLoading) {\n      const reconnected = orchestrator.tryReconnect();\n      if (reconnected) hasReconnected = true;\n    }\n  });\n\n  const values = computed(() => {\n    void version();\n    orchestrator.trackStreamMode(\"values\");\n    return orchestrator.values;\n  });\n\n  const error = computed(() => {\n    void version();\n    return orchestrator.error;\n  });\n\n  const isLoading = signal(orchestrator.isLoading);\n  effect(() => {\n    void version();\n    isLoading.set(orchestrator.isLoading);\n  });\n\n  const branch = signal<string>(\"\");\n  effect(() => {\n    void version();\n    const b = orchestrator.branch;\n    if (branch() !== b) branch.set(b);\n  });\n\n  const messages = computed(() => {\n    void version();\n    orchestrator.trackStreamMode(\"messages-tuple\", \"values\");\n    return ensureMessageInstances(orchestrator.messages);\n  });\n\n  const toolCalls = computed(() => {\n    void version();\n    orchestrator.trackStreamMode(\"messages-tuple\", \"values\");\n    return orchestrator.toolCalls;\n  });\n\n  const interrupt = computed(() => {\n    void version();\n    return orchestrator.interrupt;\n  });\n\n  const interrupts = computed((): Interrupt<InterruptType>[] => {\n    void version();\n    return orchestrator.interrupts as Interrupt<InterruptType>[];\n  });\n\n  const historyList = computed(() => {\n    void version();\n    return orchestrator.flatHistory;\n  });\n\n  const isThreadLoading = computed(() => {\n    void version();\n    return orchestrator.isThreadLoading;\n  });\n\n  const experimentalBranchTree = computed(() => {\n    void version();\n    return orchestrator.experimental_branchTree;\n  });\n\n  const queueEntries = signal(orchestrator.queueEntries);\n  const queueSize = signal(orchestrator.queueSize);\n  effect(() => {\n    void version();\n    queueEntries.set(orchestrator.queueEntries);\n    queueSize.set(orchestrator.queueSize);\n  });\n\n  const subagents = computed(() => {\n    void subagentVersion();\n    return reactiveSubagents.mapSubagents(\n      orchestrator.subagents as ReadonlyMap<\n        string,\n        typeof orchestrator.subagents extends Map<string, infer V> ? V : never\n      >\n    );\n  });\n\n  const activeSubagents = computed(() => {\n    void subagentVersion();\n    return reactiveSubagents.mapActiveSubagents(\n      orchestrator.activeSubagents as readonly (typeof orchestrator.activeSubagents extends (infer V)[]\n        ? V\n        : never)[]\n    );\n  });\n\n  return {\n    assistantId: options.assistantId,\n    client,\n\n    values,\n    error,\n    isLoading,\n\n    branch,\n    setBranch(value: string) {\n      orchestrator.setBranch(value);\n    },\n\n    messages,\n    toolCalls,\n    getToolCalls(message: Message) {\n      return orchestrator.getToolCalls(message);\n    },\n\n    interrupt,\n    interrupts,\n\n    history: historyList,\n    isThreadLoading,\n    experimental_branchTree: experimentalBranchTree,\n\n    getMessagesMetadata(\n      message: Message,\n      index?: number\n    ): MessageMetadata<StateType> | undefined {\n      return orchestrator.getMessagesMetadata(message, index);\n    },\n\n    submit: (\n      values: StateType,\n      submitOptions?: SubmitOptions<StateType, ConfigurableType>\n    ) => orchestrator.submit(values, submitOptions),\n    stop: () => orchestrator.stop(),\n    joinStream: (...args: Parameters<typeof orchestrator.joinStream>) =>\n      orchestrator.joinStream(...args),\n\n    queue: {\n      entries: queueEntries,\n      size: queueSize,\n      cancel: (id: string) => orchestrator.cancelQueueItem(id),\n      clear: () => orchestrator.clearQueue(),\n    },\n\n    switchThread(newThreadId: string | null) {\n      orchestrator.switchThread(newThreadId);\n    },\n\n    subagents,\n    activeSubagents,\n    getSubagent(toolCallId: string) {\n      return orchestrator.getSubagent(toolCallId);\n    },\n    getSubagentsByType(type: string) {\n      return orchestrator.getSubagentsByType(type);\n    },\n    getSubagentsByMessage(messageId: string) {\n      return orchestrator.getSubagentsByMessage(messageId);\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/stream.lgp.d.cts

@@ -46,8 +46,8 @@ declare function useStreamLGP<StateType extends Record<string, unknown> = Record
     clear: () => Promise<void>;
   };
   switchThread(newThreadId: string | null): void;
-  subagents: _angular_core0.Signal<ReadonlyMap<string, _langchain_langgraph_sdk_ui0.SubagentStreamInterface<Record<string, unknown>, _langchain_langgraph_sdk0.DefaultToolCall, string>>>;
-  activeSubagents: _angular_core0.Signal<readonly _langchain_langgraph_sdk_ui0.SubagentStreamInterface<Record<string, unknown>, _langchain_langgraph_sdk0.DefaultToolCall, string>[]>;
+  subagents: _angular_core0.Signal<Map<string, _langchain_langgraph_sdk_ui0.SubagentStreamInterface<Record<string, unknown>, _langchain_langgraph_sdk0.DefaultToolCall, string>>>;
+  activeSubagents: _angular_core0.Signal<_langchain_langgraph_sdk_ui0.SubagentStreamInterface<Record<string, unknown>, _langchain_langgraph_sdk0.DefaultToolCall, string>[]>;
   getSubagent(toolCallId: string): _langchain_langgraph_sdk_ui0.SubagentStreamInterface<Record<string, unknown>, _langchain_langgraph_sdk0.DefaultToolCall, string> | undefined;
   getSubagentsByType(type: string): _langchain_langgraph_sdk_ui0.SubagentStreamInterface<Record<string, unknown>, _langchain_langgraph_sdk0.DefaultToolCall, string>[];
   getSubagentsByMessage(messageId: string): _langchain_langgraph_sdk_ui0.SubagentStreamInterface<Record<string, unknown>, _langchain_langgraph_sdk0.DefaultToolCall, string>[];

package/dist/stream.lgp.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"stream.lgp.d.cts","names":[],"sources":["../src/stream.lgp.ts"],"mappings":";;;;;;;;;iBAiBgB,YAAA,mBACI,MAAA,oBAA0B,MAAA;EAE1C,gBAAA,GAAmB,MAAA;EACnB,aAAA;EACA,eAAA;EACA,UAAA;AAAA,IACE,WAAA,CAAA,CACJ,OAAA,EAAS,gBAAA,CAAiB,SAAA,EAAW,GAAA;;iBAAZ,yBAAA,CAAA,aAAA"}
+{"version":3,"file":"stream.lgp.d.cts","names":[],"sources":["../src/stream.lgp.ts"],"mappings":";;;;;;;;;iBAkBgB,YAAA,mBACI,MAAA,oBAA0B,MAAA;EAE1C,gBAAA,GAAmB,MAAA;EACnB,aAAA;EACA,eAAA;EACA,UAAA;AAAA,IACE,WAAA,CAAA,CACJ,OAAA,EAAS,gBAAA,CAAiB,SAAA,EAAW,GAAA;;iBAAZ,yBAAA,CAAA,aAAA"}

package/dist/stream.lgp.d.ts

@@ -46,8 +46,8 @@ declare function useStreamLGP<StateType extends Record<string, unknown> = Record
     clear: () => Promise<void>;
   };
   switchThread(newThreadId: string | null): void;
-  subagents: _angular_core0.Signal<ReadonlyMap<string, _langchain_langgraph_sdk_ui0.SubagentStreamInterface<Record<string, unknown>, _langchain_langgraph_sdk0.DefaultToolCall, string>>>;
-  activeSubagents: _angular_core0.Signal<readonly _langchain_langgraph_sdk_ui0.SubagentStreamInterface<Record<string, unknown>, _langchain_langgraph_sdk0.DefaultToolCall, string>[]>;
+  subagents: _angular_core0.Signal<Map<string, _langchain_langgraph_sdk_ui0.SubagentStreamInterface<Record<string, unknown>, _langchain_langgraph_sdk0.DefaultToolCall, string>>>;
+  activeSubagents: _angular_core0.Signal<_langchain_langgraph_sdk_ui0.SubagentStreamInterface<Record<string, unknown>, _langchain_langgraph_sdk0.DefaultToolCall, string>[]>;
   getSubagent(toolCallId: string): _langchain_langgraph_sdk_ui0.SubagentStreamInterface<Record<string, unknown>, _langchain_langgraph_sdk0.DefaultToolCall, string> | undefined;
   getSubagentsByType(type: string): _langchain_langgraph_sdk_ui0.SubagentStreamInterface<Record<string, unknown>, _langchain_langgraph_sdk0.DefaultToolCall, string>[];
   getSubagentsByMessage(messageId: string): _langchain_langgraph_sdk_ui0.SubagentStreamInterface<Record<string, unknown>, _langchain_langgraph_sdk0.DefaultToolCall, string>[];

package/dist/stream.lgp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stream.lgp.d.ts","names":[],"sources":["../src/stream.lgp.ts"],"mappings":";;;;;;;;;iBAiBgB,YAAA,mBACI,MAAA,oBAA0B,MAAA;EAE1C,gBAAA,GAAmB,MAAA;EACnB,aAAA;EACA,eAAA;EACA,UAAA;AAAA,IACE,WAAA,CAAA,CACJ,OAAA,EAAS,gBAAA,CAAiB,SAAA,EAAW,GAAA;;iBAAZ,yBAAA,CAAA,aAAA"}
+{"version":3,"file":"stream.lgp.d.ts","names":[],"sources":["../src/stream.lgp.ts"],"mappings":";;;;;;;;;iBAkBgB,YAAA,mBACI,MAAA,oBAA0B,MAAA;EAE1C,gBAAA,GAAmB,MAAA;EACnB,aAAA;EACA,eAAA;EACA,UAAA;AAAA,IACE,WAAA,CAAA,CACJ,OAAA,EAAS,gBAAA,CAAiB,SAAA,EAAW,GAAA;;iBAAZ,yBAAA,CAAA,aAAA"}

package/dist/stream.lgp.js

@@ -1,3 +1,4 @@
+import { createReactiveSubagentAccessors } from "./subagents.js";
 import { computed, effect, signal } from "@angular/core";
 import { StreamOrchestrator, ensureMessageInstances } from "@langchain/langgraph-sdk/ui";
 import { Client } from "@langchain/langgraph-sdk";
@@ -12,6 +13,11 @@ function useStreamLGP(options) {
 	orchestrator.initThreadId(options.threadId ?? void 0);
 	const version = signal(0);
 	const subagentVersion = signal(0);
+	const reactiveSubagents = createReactiveSubagentAccessors({
+		getSubagent: (toolCallId) => orchestrator.getSubagent(toolCallId),
+		getSubagentsByType: (type) => orchestrator.getSubagentsByType(type),
+		getSubagentsByMessage: (messageId) => orchestrator.getSubagentsByMessage(messageId)
+	}, subagentVersion);
 	effect((onCleanup) => {
 		const unsubscribe = orchestrator.subscribe(() => {
 			version.update((v) => v + 1);
@@ -103,11 +109,11 @@ function useStreamLGP(options) {
 	});
 	const subagents = computed(() => {
 		subagentVersion();
-		return orchestrator.subagents;
+		return reactiveSubagents.mapSubagents(orchestrator.subagents);
 	});
 	const activeSubagents = computed(() => {
 		subagentVersion();
-		return orchestrator.activeSubagents;
+		return reactiveSubagents.mapActiveSubagents(orchestrator.activeSubagents);
 	});
 	return {
 		assistantId: options.assistantId,

package/dist/stream.lgp.js.map

@@ -1 +1 @@
-{"version":3,"file":"stream.lgp.js","names":[],"sources":["../src/stream.lgp.ts"],"sourcesContent":["import { signal, computed, effect } from \"@angular/core\";\nimport {\n  StreamOrchestrator,\n  ensureMessageInstances,\n  type MessageMetadata,\n  type AnyStreamOptions,\n  type SubmitOptions,\n  type GetConfigurableType,\n  type GetInterruptType,\n} from \"@langchain/langgraph-sdk/ui\";\nimport {\n  Client,\n  type Message,\n  type Interrupt,\n  type BagTemplate,\n} from \"@langchain/langgraph-sdk\";\n\nexport function useStreamLGP<\n  StateType extends Record<string, unknown> = Record<string, unknown>,\n  Bag extends {\n    ConfigurableType?: Record<string, unknown>;\n    InterruptType?: unknown;\n    CustomEventType?: unknown;\n    UpdateType?: unknown;\n  } = BagTemplate,\n>(options: AnyStreamOptions<StateType, Bag>) {\n  type ConfigurableType = GetConfigurableType<Bag>;\n  type InterruptType = GetInterruptType<Bag>;\n\n  const client = options.client ?? new Client({ apiUrl: options.apiUrl });\n\n  const orchestrator = new StreamOrchestrator<StateType, Bag>(options, {\n    getClient: () => client,\n    getAssistantId: () => options.assistantId,\n    getMessagesKey: () => options.messagesKey ?? \"messages\",\n  });\n\n  orchestrator.initThreadId(options.threadId ?? undefined);\n\n  const version = signal(0);\n  const subagentVersion = signal(0);\n\n  effect((onCleanup) => {\n    const unsubscribe = orchestrator.subscribe(() => {\n      version.update((v) => v + 1);\n      subagentVersion.update((v) => v + 1);\n    });\n    onCleanup(() => unsubscribe());\n  });\n\n  // Subagent reconstruction\n  effect((onCleanup) => {\n    void version();\n    const hvMessages = orchestrator.messages;\n    const should =\n      options.filterSubagentMessages &&\n      !orchestrator.isLoading &&\n      !orchestrator.historyData.isLoading &&\n      hvMessages.length > 0;\n    if (should) {\n      const controller = orchestrator.reconstructSubagentsIfNeeded();\n      if (controller) {\n        onCleanup(() => controller.abort());\n      }\n    }\n  });\n\n  // Queue draining - track isLoading changes specifically so the drain\n  // fires exactly when stream transitions from loading → idle\n  const isLoadingForDrain = computed(() => {\n    void version();\n    return orchestrator.isLoading;\n  });\n  effect(() => {\n    void isLoadingForDrain();\n    orchestrator.drainQueue();\n  });\n\n  // Auto-reconnect\n  const { shouldReconnect } = orchestrator;\n  let hasReconnected = false;\n\n  effect(() => {\n    void version();\n    const tid = orchestrator.threadId;\n    if (!hasReconnected && shouldReconnect && tid && !orchestrator.isLoading) {\n      const reconnected = orchestrator.tryReconnect();\n      if (reconnected) hasReconnected = true;\n    }\n  });\n\n  const values = computed(() => {\n    void version();\n    orchestrator.trackStreamMode(\"values\");\n    return orchestrator.values;\n  });\n\n  const error = computed(() => {\n    void version();\n    return orchestrator.error;\n  });\n\n  const isLoading = signal(orchestrator.isLoading);\n  effect(() => {\n    void version();\n    isLoading.set(orchestrator.isLoading);\n  });\n\n  const branch = signal<string>(\"\");\n  effect(() => {\n    void version();\n    const b = orchestrator.branch;\n    if (branch() !== b) branch.set(b);\n  });\n\n  const messages = computed(() => {\n    void version();\n    orchestrator.trackStreamMode(\"messages-tuple\", \"values\");\n    return ensureMessageInstances(orchestrator.messages);\n  });\n\n  const toolCalls = computed(() => {\n    void version();\n    orchestrator.trackStreamMode(\"messages-tuple\", \"values\");\n    return orchestrator.toolCalls;\n  });\n\n  const interrupt = computed(() => {\n    void version();\n    return orchestrator.interrupt;\n  });\n\n  const interrupts = computed((): Interrupt<InterruptType>[] => {\n    void version();\n    return orchestrator.interrupts as Interrupt<InterruptType>[];\n  });\n\n  const historyList = computed(() => {\n    void version();\n    return orchestrator.flatHistory;\n  });\n\n  const isThreadLoading = computed(() => {\n    void version();\n    return orchestrator.isThreadLoading;\n  });\n\n  const experimentalBranchTree = computed(() => {\n    void version();\n    return orchestrator.experimental_branchTree;\n  });\n\n  const queueEntries = signal(orchestrator.queueEntries);\n  const queueSize = signal(orchestrator.queueSize);\n  effect(() => {\n    void version();\n    queueEntries.set(orchestrator.queueEntries);\n    queueSize.set(orchestrator.queueSize);\n  });\n\n  const subagents = computed(() => {\n    void subagentVersion();\n    return orchestrator.subagents as ReadonlyMap<\n      string,\n      typeof orchestrator.subagents extends Map<string, infer V> ? V : never\n    >;\n  });\n\n  const activeSubagents = computed(() => {\n    void subagentVersion();\n    return orchestrator.activeSubagents as readonly (typeof orchestrator.activeSubagents extends (infer V)[]\n      ? V\n      : never)[];\n  });\n\n  return {\n    assistantId: options.assistantId,\n    client,\n\n    values,\n    error,\n    isLoading,\n\n    branch,\n    setBranch(value: string) {\n      orchestrator.setBranch(value);\n    },\n\n    messages,\n    toolCalls,\n    getToolCalls(message: Message) {\n      return orchestrator.getToolCalls(message);\n    },\n\n    interrupt,\n    interrupts,\n\n    history: historyList,\n    isThreadLoading,\n    experimental_branchTree: experimentalBranchTree,\n\n    getMessagesMetadata(\n      message: Message,\n      index?: number\n    ): MessageMetadata<StateType> | undefined {\n      return orchestrator.getMessagesMetadata(message, index);\n    },\n\n    submit: (\n      values: StateType,\n      submitOptions?: SubmitOptions<StateType, ConfigurableType>\n    ) => orchestrator.submit(values, submitOptions),\n    stop: () => orchestrator.stop(),\n    joinStream: (...args: Parameters<typeof orchestrator.joinStream>) =>\n      orchestrator.joinStream(...args),\n\n    queue: {\n      entries: queueEntries,\n      size: queueSize,\n      cancel: (id: string) => orchestrator.cancelQueueItem(id),\n      clear: () => orchestrator.clearQueue(),\n    },\n\n    switchThread(newThreadId: string | null) {\n      orchestrator.switchThread(newThreadId);\n    },\n\n    subagents,\n    activeSubagents,\n    getSubagent(toolCallId: string) {\n      return orchestrator.getSubagent(toolCallId);\n    },\n    getSubagentsByType(type: string) {\n      return orchestrator.getSubagentsByType(type);\n    },\n    getSubagentsByMessage(messageId: string) {\n      return orchestrator.getSubagentsByMessage(messageId);\n    },\n  };\n}\n"],"mappings":"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"}
+{"version":3,"file":"stream.lgp.js","names":[],"sources":["../src/stream.lgp.ts"],"sourcesContent":["import { signal, computed, effect } from \"@angular/core\";\nimport {\n  StreamOrchestrator,\n  ensureMessageInstances,\n  type MessageMetadata,\n  type AnyStreamOptions,\n  type SubmitOptions,\n  type GetConfigurableType,\n  type GetInterruptType,\n} from \"@langchain/langgraph-sdk/ui\";\nimport {\n  Client,\n  type Message,\n  type Interrupt,\n  type BagTemplate,\n} from \"@langchain/langgraph-sdk\";\nimport { createReactiveSubagentAccessors } from \"./subagents.js\";\n\nexport function useStreamLGP<\n  StateType extends Record<string, unknown> = Record<string, unknown>,\n  Bag extends {\n    ConfigurableType?: Record<string, unknown>;\n    InterruptType?: unknown;\n    CustomEventType?: unknown;\n    UpdateType?: unknown;\n  } = BagTemplate,\n>(options: AnyStreamOptions<StateType, Bag>) {\n  type ConfigurableType = GetConfigurableType<Bag>;\n  type InterruptType = GetInterruptType<Bag>;\n\n  const client = options.client ?? new Client({ apiUrl: options.apiUrl });\n\n  const orchestrator = new StreamOrchestrator<StateType, Bag>(options, {\n    getClient: () => client,\n    getAssistantId: () => options.assistantId,\n    getMessagesKey: () => options.messagesKey ?? \"messages\",\n  });\n\n  orchestrator.initThreadId(options.threadId ?? undefined);\n\n  const version = signal(0);\n  const subagentVersion = signal(0);\n  const reactiveSubagents = createReactiveSubagentAccessors(\n    {\n      getSubagent: (toolCallId) => orchestrator.getSubagent(toolCallId),\n      getSubagentsByType: (type) => orchestrator.getSubagentsByType(type),\n      getSubagentsByMessage: (messageId) =>\n        orchestrator.getSubagentsByMessage(messageId),\n    },\n    subagentVersion\n  );\n\n  effect((onCleanup) => {\n    const unsubscribe = orchestrator.subscribe(() => {\n      version.update((v) => v + 1);\n      subagentVersion.update((v) => v + 1);\n    });\n    onCleanup(() => unsubscribe());\n  });\n\n  // Subagent reconstruction\n  effect((onCleanup) => {\n    void version();\n    const hvMessages = orchestrator.messages;\n    const should =\n      options.filterSubagentMessages &&\n      !orchestrator.isLoading &&\n      !orchestrator.historyData.isLoading &&\n      hvMessages.length > 0;\n    if (should) {\n      const controller = orchestrator.reconstructSubagentsIfNeeded();\n      if (controller) {\n        onCleanup(() => controller.abort());\n      }\n    }\n  });\n\n  // Queue draining - track isLoading changes specifically so the drain\n  // fires exactly when stream transitions from loading → idle\n  const isLoadingForDrain = computed(() => {\n    void version();\n    return orchestrator.isLoading;\n  });\n  effect(() => {\n    void isLoadingForDrain();\n    orchestrator.drainQueue();\n  });\n\n  // Auto-reconnect\n  const { shouldReconnect } = orchestrator;\n  let hasReconnected = false;\n\n  effect(() => {\n    void version();\n    const tid = orchestrator.threadId;\n    if (!hasReconnected && shouldReconnect && tid && !orchestrator.isLoading) {\n      const reconnected = orchestrator.tryReconnect();\n      if (reconnected) hasReconnected = true;\n    }\n  });\n\n  const values = computed(() => {\n    void version();\n    orchestrator.trackStreamMode(\"values\");\n    return orchestrator.values;\n  });\n\n  const error = computed(() => {\n    void version();\n    return orchestrator.error;\n  });\n\n  const isLoading = signal(orchestrator.isLoading);\n  effect(() => {\n    void version();\n    isLoading.set(orchestrator.isLoading);\n  });\n\n  const branch = signal<string>(\"\");\n  effect(() => {\n    void version();\n    const b = orchestrator.branch;\n    if (branch() !== b) branch.set(b);\n  });\n\n  const messages = computed(() => {\n    void version();\n    orchestrator.trackStreamMode(\"messages-tuple\", \"values\");\n    return ensureMessageInstances(orchestrator.messages);\n  });\n\n  const toolCalls = computed(() => {\n    void version();\n    orchestrator.trackStreamMode(\"messages-tuple\", \"values\");\n    return orchestrator.toolCalls;\n  });\n\n  const interrupt = computed(() => {\n    void version();\n    return orchestrator.interrupt;\n  });\n\n  const interrupts = computed((): Interrupt<InterruptType>[] => {\n    void version();\n    return orchestrator.interrupts as Interrupt<InterruptType>[];\n  });\n\n  const historyList = computed(() => {\n    void version();\n    return orchestrator.flatHistory;\n  });\n\n  const isThreadLoading = computed(() => {\n    void version();\n    return orchestrator.isThreadLoading;\n  });\n\n  const experimentalBranchTree = computed(() => {\n    void version();\n    return orchestrator.experimental_branchTree;\n  });\n\n  const queueEntries = signal(orchestrator.queueEntries);\n  const queueSize = signal(orchestrator.queueSize);\n  effect(() => {\n    void version();\n    queueEntries.set(orchestrator.queueEntries);\n    queueSize.set(orchestrator.queueSize);\n  });\n\n  const subagents = computed(() => {\n    void subagentVersion();\n    return reactiveSubagents.mapSubagents(\n      orchestrator.subagents as ReadonlyMap<\n        string,\n        typeof orchestrator.subagents extends Map<string, infer V> ? V : never\n      >\n    );\n  });\n\n  const activeSubagents = computed(() => {\n    void subagentVersion();\n    return reactiveSubagents.mapActiveSubagents(\n      orchestrator.activeSubagents as readonly (typeof orchestrator.activeSubagents extends (infer V)[]\n        ? V\n        : never)[]\n    );\n  });\n\n  return {\n    assistantId: options.assistantId,\n    client,\n\n    values,\n    error,\n    isLoading,\n\n    branch,\n    setBranch(value: string) {\n      orchestrator.setBranch(value);\n    },\n\n    messages,\n    toolCalls,\n    getToolCalls(message: Message) {\n      return orchestrator.getToolCalls(message);\n    },\n\n    interrupt,\n    interrupts,\n\n    history: historyList,\n    isThreadLoading,\n    experimental_branchTree: experimentalBranchTree,\n\n    getMessagesMetadata(\n      message: Message,\n      index?: number\n    ): MessageMetadata<StateType> | undefined {\n      return orchestrator.getMessagesMetadata(message, index);\n    },\n\n    submit: (\n      values: StateType,\n      submitOptions?: SubmitOptions<StateType, ConfigurableType>\n    ) => orchestrator.submit(values, submitOptions),\n    stop: () => orchestrator.stop(),\n    joinStream: (...args: Parameters<typeof orchestrator.joinStream>) =>\n      orchestrator.joinStream(...args),\n\n    queue: {\n      entries: queueEntries,\n      size: queueSize,\n      cancel: (id: string) => orchestrator.cancelQueueItem(id),\n      clear: () => orchestrator.clearQueue(),\n    },\n\n    switchThread(newThreadId: string | null) {\n      orchestrator.switchThread(newThreadId);\n    },\n\n    subagents,\n    activeSubagents,\n    getSubagent(toolCallId: string) {\n      return orchestrator.getSubagent(toolCallId);\n    },\n    getSubagentsByType(type: string) {\n      return orchestrator.getSubagentsByType(type);\n    },\n    getSubagentsByMessage(messageId: string) {\n      return orchestrator.getSubagentsByMessage(messageId);\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/subagents.cjs

@@ -0,0 +1,76 @@
+//#region src/subagents.ts
+/**
+* Create stable proxy objects for subagents so retained references always read
+* from the latest orchestrator snapshot while remaining invalidated by the
+* Angular signal that tracks subagent updates.
+*/
+function createReactiveSubagentAccessors(accessors, version) {
+	const subagentCache = /* @__PURE__ */ new Map();
+	const getCachedSubagent = (toolCallId) => {
+		if (!accessors.getSubagent(toolCallId)) {
+			subagentCache.delete(toolCallId);
+			return;
+		}
+		let cached = subagentCache.get(toolCallId);
+		if (!cached) {
+			cached = new Proxy({ id: toolCallId }, {
+				get(_target, prop, receiver) {
+					version();
+					const latest = accessors.getSubagent(toolCallId);
+					if (!latest) return void 0;
+					const value = Reflect.get(latest, prop, receiver);
+					return typeof value === "function" ? value.bind(latest) : value;
+				},
+				has(_target, prop) {
+					const latest = accessors.getSubagent(toolCallId);
+					return latest ? prop in latest : false;
+				},
+				ownKeys() {
+					version();
+					const latest = accessors.getSubagent(toolCallId);
+					return latest ? Reflect.ownKeys(latest) : [];
+				},
+				getOwnPropertyDescriptor(_target, prop) {
+					return {
+						configurable: true,
+						enumerable: true,
+						get() {
+							version();
+							const latest = accessors.getSubagent(toolCallId);
+							if (!latest) return void 0;
+							return Reflect.get(latest, prop);
+						}
+					};
+				}
+			});
+			subagentCache.set(toolCallId, cached);
+		}
+		return cached;
+	};
+	const mapSubagents = (subagents) => {
+		const nextIds = new Set(subagents.keys());
+		for (const toolCallId of subagentCache.keys()) if (!nextIds.has(toolCallId)) subagentCache.delete(toolCallId);
+		return new Map([...subagents.keys()].map((toolCallId) => {
+			const cached = getCachedSubagent(toolCallId);
+			return cached ? [toolCallId, cached] : void 0;
+		}).filter((entry) => entry != null));
+	};
+	const mapActiveSubagents = (subagents) => subagents.map((subagent) => getCachedSubagent(subagent.id)).filter((subagent) => subagent != null);
+	return {
+		mapSubagents,
+		mapActiveSubagents,
+		getSubagent: getCachedSubagent,
+		getSubagentsByType(type) {
+			version();
+			return accessors.getSubagentsByType(type).map((subagent) => getCachedSubagent(subagent.id)).filter((subagent) => subagent != null);
+		},
+		getSubagentsByMessage(messageId) {
+			version();
+			return accessors.getSubagentsByMessage(messageId).map((subagent) => getCachedSubagent(subagent.id)).filter((subagent) => subagent != null);
+		}
+	};
+}
+//#endregion
+exports.createReactiveSubagentAccessors = createReactiveSubagentAccessors;
+
+//# sourceMappingURL=subagents.cjs.map

package/dist/subagents.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"subagents.cjs","names":[],"sources":["../src/subagents.ts"],"sourcesContent":["import type { Signal, WritableSignal } from \"@angular/core\";\n\ntype SubagentLike = {\n  id: string;\n};\n\ntype SubagentAccessors<TSubagent extends SubagentLike> = {\n  getSubagent: (toolCallId: string) => TSubagent | undefined;\n  getSubagentsByType: (type: string) => TSubagent[];\n  getSubagentsByMessage: (messageId: string) => TSubagent[];\n};\n\n/**\n * Create stable proxy objects for subagents so retained references always read\n * from the latest orchestrator snapshot while remaining invalidated by the\n * Angular signal that tracks subagent updates.\n */\nexport function createReactiveSubagentAccessors<TSubagent extends SubagentLike>(\n  accessors: SubagentAccessors<TSubagent>,\n  version: Signal<number> | WritableSignal<number>\n) {\n  const subagentCache = new Map<string, TSubagent>();\n\n  const getCachedSubagent = (toolCallId: string): TSubagent | undefined => {\n    const current = accessors.getSubagent(toolCallId);\n    if (!current) {\n      subagentCache.delete(toolCallId);\n      return undefined;\n    }\n\n    let cached = subagentCache.get(toolCallId);\n    if (!cached) {\n      cached = new Proxy({ id: toolCallId } as TSubagent, {\n        get(_target, prop, receiver) {\n          void version();\n          const latest = accessors.getSubagent(toolCallId);\n          if (!latest) return undefined;\n\n          const value = Reflect.get(latest as object, prop, receiver);\n          return typeof value === \"function\" ? value.bind(latest) : value;\n        },\n        has(_target, prop) {\n          const latest = accessors.getSubagent(toolCallId);\n          return latest ? prop in (latest as object) : false;\n        },\n        ownKeys() {\n          void version();\n          const latest = accessors.getSubagent(toolCallId);\n          return latest ? Reflect.ownKeys(latest as object) : [];\n        },\n        getOwnPropertyDescriptor(_target, prop) {\n          return {\n            configurable: true,\n            enumerable: true,\n            get() {\n              void version();\n              const latest = accessors.getSubagent(toolCallId);\n              if (!latest) return undefined;\n              return Reflect.get(latest as object, prop);\n            },\n          };\n        },\n      });\n      subagentCache.set(toolCallId, cached);\n    }\n\n    return cached;\n  };\n\n  const mapSubagents = (subagents: ReadonlyMap<string, TSubagent>) => {\n    const nextIds = new Set(subagents.keys());\n    for (const toolCallId of subagentCache.keys()) {\n      if (!nextIds.has(toolCallId)) {\n        subagentCache.delete(toolCallId);\n      }\n    }\n\n    return new Map(\n      [...subagents.keys()]\n        .map((toolCallId) => {\n          const cached = getCachedSubagent(toolCallId);\n          return cached ? ([toolCallId, cached] as const) : undefined;\n        })\n        .filter((entry): entry is readonly [string, TSubagent] => entry != null)\n    );\n  };\n\n  const mapActiveSubagents = (subagents: readonly TSubagent[]) =>\n    subagents\n      .map((subagent) => getCachedSubagent(subagent.id))\n      .filter((subagent): subagent is TSubagent => subagent != null);\n\n  return {\n    mapSubagents,\n    mapActiveSubagents,\n    getSubagent: getCachedSubagent,\n    getSubagentsByType(type: string): TSubagent[] {\n      void version();\n      return accessors\n        .getSubagentsByType(type)\n        .map((subagent) => getCachedSubagent(subagent.id))\n        .filter((subagent): subagent is TSubagent => subagent != null);\n    },\n    getSubagentsByMessage(messageId: string): TSubagent[] {\n      void version();\n      return accessors\n        .getSubagentsByMessage(messageId)\n        .map((subagent) => getCachedSubagent(subagent.id))\n        .filter((subagent): subagent is TSubagent => subagent != null);\n    },\n  };\n}\n"],"mappings":";;;;;;AAiBA,SAAgB,gCACd,WACA,SACA;CACA,MAAM,gCAAgB,IAAI,KAAwB;CAElD,MAAM,qBAAqB,eAA8C;AAEvE,MAAI,CADY,UAAU,YAAY,WAAW,EACnC;AACZ,iBAAc,OAAO,WAAW;AAChC;;EAGF,IAAI,SAAS,cAAc,IAAI,WAAW;AAC1C,MAAI,CAAC,QAAQ;AACX,YAAS,IAAI,MAAM,EAAE,IAAI,YAAY,EAAe;IAClD,IAAI,SAAS,MAAM,UAAU;AACtB,cAAS;KACd,MAAM,SAAS,UAAU,YAAY,WAAW;AAChD,SAAI,CAAC,OAAQ,QAAO,KAAA;KAEpB,MAAM,QAAQ,QAAQ,IAAI,QAAkB,MAAM,SAAS;AAC3D,YAAO,OAAO,UAAU,aAAa,MAAM,KAAK,OAAO,GAAG;;IAE5D,IAAI,SAAS,MAAM;KACjB,MAAM,SAAS,UAAU,YAAY,WAAW;AAChD,YAAO,SAAS,QAAS,SAAoB;;IAE/C,UAAU;AACH,cAAS;KACd,MAAM,SAAS,UAAU,YAAY,WAAW;AAChD,YAAO,SAAS,QAAQ,QAAQ,OAAiB,GAAG,EAAE;;IAExD,yBAAyB,SAAS,MAAM;AACtC,YAAO;MACL,cAAc;MACd,YAAY;MACZ,MAAM;AACC,gBAAS;OACd,MAAM,SAAS,UAAU,YAAY,WAAW;AAChD,WAAI,CAAC,OAAQ,QAAO,KAAA;AACpB,cAAO,QAAQ,IAAI,QAAkB,KAAK;;MAE7C;;IAEJ,CAAC;AACF,iBAAc,IAAI,YAAY,OAAO;;AAGvC,SAAO;;CAGT,MAAM,gBAAgB,cAA8C;EAClE,MAAM,UAAU,IAAI,IAAI,UAAU,MAAM,CAAC;AACzC,OAAK,MAAM,cAAc,cAAc,MAAM,CAC3C,KAAI,CAAC,QAAQ,IAAI,WAAW,CAC1B,eAAc,OAAO,WAAW;AAIpC,SAAO,IAAI,IACT,CAAC,GAAG,UAAU,MAAM,CAAC,CAClB,KAAK,eAAe;GACnB,MAAM,SAAS,kBAAkB,WAAW;AAC5C,UAAO,SAAU,CAAC,YAAY,OAAO,GAAa,KAAA;IAClD,CACD,QAAQ,UAAiD,SAAS,KAAK,CAC3E;;CAGH,MAAM,sBAAsB,cAC1B,UACG,KAAK,aAAa,kBAAkB,SAAS,GAAG,CAAC,CACjD,QAAQ,aAAoC,YAAY,KAAK;AAElE,QAAO;EACL;EACA;EACA,aAAa;EACb,mBAAmB,MAA2B;AACvC,YAAS;AACd,UAAO,UACJ,mBAAmB,KAAK,CACxB,KAAK,aAAa,kBAAkB,SAAS,GAAG,CAAC,CACjD,QAAQ,aAAoC,YAAY,KAAK;;EAElE,sBAAsB,WAAgC;AAC/C,YAAS;AACd,UAAO,UACJ,sBAAsB,UAAU,CAChC,KAAK,aAAa,kBAAkB,SAAS,GAAG,CAAC,CACjD,QAAQ,aAAoC,YAAY,KAAK;;EAEnE"}

package/dist/subagents.js

@@ -0,0 +1,76 @@
+//#region src/subagents.ts
+/**
+* Create stable proxy objects for subagents so retained references always read
+* from the latest orchestrator snapshot while remaining invalidated by the
+* Angular signal that tracks subagent updates.
+*/
+function createReactiveSubagentAccessors(accessors, version) {
+	const subagentCache = /* @__PURE__ */ new Map();
+	const getCachedSubagent = (toolCallId) => {
+		if (!accessors.getSubagent(toolCallId)) {
+			subagentCache.delete(toolCallId);
+			return;
+		}
+		let cached = subagentCache.get(toolCallId);
+		if (!cached) {
+			cached = new Proxy({ id: toolCallId }, {
+				get(_target, prop, receiver) {
+					version();
+					const latest = accessors.getSubagent(toolCallId);
+					if (!latest) return void 0;
+					const value = Reflect.get(latest, prop, receiver);
+					return typeof value === "function" ? value.bind(latest) : value;
+				},
+				has(_target, prop) {
+					const latest = accessors.getSubagent(toolCallId);
+					return latest ? prop in latest : false;
+				},
+				ownKeys() {
+					version();
+					const latest = accessors.getSubagent(toolCallId);
+					return latest ? Reflect.ownKeys(latest) : [];
+				},
+				getOwnPropertyDescriptor(_target, prop) {
+					return {
+						configurable: true,
+						enumerable: true,
+						get() {
+							version();
+							const latest = accessors.getSubagent(toolCallId);
+							if (!latest) return void 0;
+							return Reflect.get(latest, prop);
+						}
+					};
+				}
+			});
+			subagentCache.set(toolCallId, cached);
+		}
+		return cached;
+	};
+	const mapSubagents = (subagents) => {
+		const nextIds = new Set(subagents.keys());
+		for (const toolCallId of subagentCache.keys()) if (!nextIds.has(toolCallId)) subagentCache.delete(toolCallId);
+		return new Map([...subagents.keys()].map((toolCallId) => {
+			const cached = getCachedSubagent(toolCallId);
+			return cached ? [toolCallId, cached] : void 0;
+		}).filter((entry) => entry != null));
+	};
+	const mapActiveSubagents = (subagents) => subagents.map((subagent) => getCachedSubagent(subagent.id)).filter((subagent) => subagent != null);
+	return {
+		mapSubagents,
+		mapActiveSubagents,
+		getSubagent: getCachedSubagent,
+		getSubagentsByType(type) {
+			version();
+			return accessors.getSubagentsByType(type).map((subagent) => getCachedSubagent(subagent.id)).filter((subagent) => subagent != null);
+		},
+		getSubagentsByMessage(messageId) {
+			version();
+			return accessors.getSubagentsByMessage(messageId).map((subagent) => getCachedSubagent(subagent.id)).filter((subagent) => subagent != null);
+		}
+	};
+}
+//#endregion
+export { createReactiveSubagentAccessors };
+
+//# sourceMappingURL=subagents.js.map

package/dist/subagents.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subagents.js","names":[],"sources":["../src/subagents.ts"],"sourcesContent":["import type { Signal, WritableSignal } from \"@angular/core\";\n\ntype SubagentLike = {\n  id: string;\n};\n\ntype SubagentAccessors<TSubagent extends SubagentLike> = {\n  getSubagent: (toolCallId: string) => TSubagent | undefined;\n  getSubagentsByType: (type: string) => TSubagent[];\n  getSubagentsByMessage: (messageId: string) => TSubagent[];\n};\n\n/**\n * Create stable proxy objects for subagents so retained references always read\n * from the latest orchestrator snapshot while remaining invalidated by the\n * Angular signal that tracks subagent updates.\n */\nexport function createReactiveSubagentAccessors<TSubagent extends SubagentLike>(\n  accessors: SubagentAccessors<TSubagent>,\n  version: Signal<number> | WritableSignal<number>\n) {\n  const subagentCache = new Map<string, TSubagent>();\n\n  const getCachedSubagent = (toolCallId: string): TSubagent | undefined => {\n    const current = accessors.getSubagent(toolCallId);\n    if (!current) {\n      subagentCache.delete(toolCallId);\n      return undefined;\n    }\n\n    let cached = subagentCache.get(toolCallId);\n    if (!cached) {\n      cached = new Proxy({ id: toolCallId } as TSubagent, {\n        get(_target, prop, receiver) {\n          void version();\n          const latest = accessors.getSubagent(toolCallId);\n          if (!latest) return undefined;\n\n          const value = Reflect.get(latest as object, prop, receiver);\n          return typeof value === \"function\" ? value.bind(latest) : value;\n        },\n        has(_target, prop) {\n          const latest = accessors.getSubagent(toolCallId);\n          return latest ? prop in (latest as object) : false;\n        },\n        ownKeys() {\n          void version();\n          const latest = accessors.getSubagent(toolCallId);\n          return latest ? Reflect.ownKeys(latest as object) : [];\n        },\n        getOwnPropertyDescriptor(_target, prop) {\n          return {\n            configurable: true,\n            enumerable: true,\n            get() {\n              void version();\n              const latest = accessors.getSubagent(toolCallId);\n              if (!latest) return undefined;\n              return Reflect.get(latest as object, prop);\n            },\n          };\n        },\n      });\n      subagentCache.set(toolCallId, cached);\n    }\n\n    return cached;\n  };\n\n  const mapSubagents = (subagents: ReadonlyMap<string, TSubagent>) => {\n    const nextIds = new Set(subagents.keys());\n    for (const toolCallId of subagentCache.keys()) {\n      if (!nextIds.has(toolCallId)) {\n        subagentCache.delete(toolCallId);\n      }\n    }\n\n    return new Map(\n      [...subagents.keys()]\n        .map((toolCallId) => {\n          const cached = getCachedSubagent(toolCallId);\n          return cached ? ([toolCallId, cached] as const) : undefined;\n        })\n        .filter((entry): entry is readonly [string, TSubagent] => entry != null)\n    );\n  };\n\n  const mapActiveSubagents = (subagents: readonly TSubagent[]) =>\n    subagents\n      .map((subagent) => getCachedSubagent(subagent.id))\n      .filter((subagent): subagent is TSubagent => subagent != null);\n\n  return {\n    mapSubagents,\n    mapActiveSubagents,\n    getSubagent: getCachedSubagent,\n    getSubagentsByType(type: string): TSubagent[] {\n      void version();\n      return accessors\n        .getSubagentsByType(type)\n        .map((subagent) => getCachedSubagent(subagent.id))\n        .filter((subagent): subagent is TSubagent => subagent != null);\n    },\n    getSubagentsByMessage(messageId: string): TSubagent[] {\n      void version();\n      return accessors\n        .getSubagentsByMessage(messageId)\n        .map((subagent) => getCachedSubagent(subagent.id))\n        .filter((subagent): subagent is TSubagent => subagent != null);\n    },\n  };\n}\n"],"mappings":";;;;;;AAiBA,SAAgB,gCACd,WACA,SACA;CACA,MAAM,gCAAgB,IAAI,KAAwB;CAElD,MAAM,qBAAqB,eAA8C;AAEvE,MAAI,CADY,UAAU,YAAY,WAAW,EACnC;AACZ,iBAAc,OAAO,WAAW;AAChC;;EAGF,IAAI,SAAS,cAAc,IAAI,WAAW;AAC1C,MAAI,CAAC,QAAQ;AACX,YAAS,IAAI,MAAM,EAAE,IAAI,YAAY,EAAe;IAClD,IAAI,SAAS,MAAM,UAAU;AACtB,cAAS;KACd,MAAM,SAAS,UAAU,YAAY,WAAW;AAChD,SAAI,CAAC,OAAQ,QAAO,KAAA;KAEpB,MAAM,QAAQ,QAAQ,IAAI,QAAkB,MAAM,SAAS;AAC3D,YAAO,OAAO,UAAU,aAAa,MAAM,KAAK,OAAO,GAAG;;IAE5D,IAAI,SAAS,MAAM;KACjB,MAAM,SAAS,UAAU,YAAY,WAAW;AAChD,YAAO,SAAS,QAAS,SAAoB;;IAE/C,UAAU;AACH,cAAS;KACd,MAAM,SAAS,UAAU,YAAY,WAAW;AAChD,YAAO,SAAS,QAAQ,QAAQ,OAAiB,GAAG,EAAE;;IAExD,yBAAyB,SAAS,MAAM;AACtC,YAAO;MACL,cAAc;MACd,YAAY;MACZ,MAAM;AACC,gBAAS;OACd,MAAM,SAAS,UAAU,YAAY,WAAW;AAChD,WAAI,CAAC,OAAQ,QAAO,KAAA;AACpB,cAAO,QAAQ,IAAI,QAAkB,KAAK;;MAE7C;;IAEJ,CAAC;AACF,iBAAc,IAAI,YAAY,OAAO;;AAGvC,SAAO;;CAGT,MAAM,gBAAgB,cAA8C;EAClE,MAAM,UAAU,IAAI,IAAI,UAAU,MAAM,CAAC;AACzC,OAAK,MAAM,cAAc,cAAc,MAAM,CAC3C,KAAI,CAAC,QAAQ,IAAI,WAAW,CAC1B,eAAc,OAAO,WAAW;AAIpC,SAAO,IAAI,IACT,CAAC,GAAG,UAAU,MAAM,CAAC,CAClB,KAAK,eAAe;GACnB,MAAM,SAAS,kBAAkB,WAAW;AAC5C,UAAO,SAAU,CAAC,YAAY,OAAO,GAAa,KAAA;IAClD,CACD,QAAQ,UAAiD,SAAS,KAAK,CAC3E;;CAGH,MAAM,sBAAsB,cAC1B,UACG,KAAK,aAAa,kBAAkB,SAAS,GAAG,CAAC,CACjD,QAAQ,aAAoC,YAAY,KAAK;AAElE,QAAO;EACL;EACA;EACA,aAAa;EACb,mBAAmB,MAA2B;AACvC,YAAS;AACd,UAAO,UACJ,mBAAmB,KAAK,CACxB,KAAK,aAAa,kBAAkB,SAAS,GAAG,CAAC,CACjD,QAAQ,aAAoC,YAAY,KAAK;;EAElE,sBAAsB,WAAgC;AAC/C,YAAS;AACd,UAAO,UACJ,sBAAsB,UAAU,CAChC,KAAK,aAAa,kBAAkB,SAAS,GAAG,CAAC,CACjD,QAAQ,aAAoC,YAAY,KAAK;;EAEnE"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/angular",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "description": "Angular integration for LangGraph & LangChain",
   "type": "module",
   "license": "MIT",
@@ -10,7 +10,7 @@
     "directory": "libs/sdk-angular"
   },
   "dependencies": {
-    "@langchain/langgraph-sdk": "^1.8.6"
+    "@langchain/langgraph-sdk": "^1.8.7"
   },
   "devDependencies": {
     "@analogjs/vite-plugin-angular": "^2.4.0",