@langchain/angular 0.4.7 → 1.0.1

package/dist/index.d.ts

@@ -1,330 +1,12 @@
-import { injectStreamCustom, useStreamCustom } from "./stream.custom.js";
+import { AgentServerOptions, AnyStream, CustomAdapterOptions, STREAM_CONTROLLER, StateOf, StreamApi, ThreadStream, UseStreamOptions, UseStreamResult, UseStreamReturn, useStream } from "./use-stream.js";
+import { injectStream } from "./inject-stream.js";
+import { injectProjection } from "./inject-projection.js";
+import { SelectorTarget, injectAudio, injectChannel, injectExtension, injectFiles, injectImages, injectMessages, injectToolCalls, injectValues, injectVideo } from "./selectors.js";
+import { InjectSubmissionQueueReturn, SubmissionQueueEntry, SubmissionQueueSnapshot, injectSubmissionQueue } from "./selectors-queue.js";
+import { MessageMetadata, MessageMetadataMap, injectMessageMetadata } from "./selectors-metadata.js";
+import { injectMediaUrl } from "./inject-media-url.js";
 import { STREAM_DEFAULTS, STREAM_INSTANCE, StreamDefaults, provideStream, provideStreamDefaults } from "./context.js";
-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 { 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
-type AngularWritableKeys = "isLoading" | "branch";
-type AngularPlainKeys = "submit" | "stop" | "joinStream" | "switchThread" | "setBranch" | "getMessagesMetadata" | "getToolCalls" | "getSubagent" | "getSubagentsByType" | "getSubagentsByMessage" | "client" | "assistantId";
-type AngularQueueInterface<T> = T extends {
-  entries: infer E;
-  size: infer S;
-  cancel: infer C;
-  clear: infer Cl;
-} ? {
-  entries: WritableSignal<E>;
-  size: WritableSignal<S>;
-  cancel: C;
-  clear: Cl;
-} : T;
-type AngularSignalWrap<T> = { [K in keyof T]: K extends AngularPlainKeys ? T[K] : K extends AngularWritableKeys ? WritableSignal<T[K]> : K extends "queue" ? AngularQueueInterface<T[K]> : Signal<T[K]> };
-/**
- * Injects the shared stream instance from the nearest ancestor that provided
- * one via {@link provideStream}. Throws if no ancestor provides a stream
- * instance.
- *
- * @example
- * ```typescript
- * import { Component } from "@angular/core";
- * import { injectStream } from "@langchain/angular";
- *
- * @Component({
- *   template: `
- *     @for (msg of stream.messages(); track msg.id) {
- *       <div>{{ msg.content }}</div>
- *     }
- *     <button
- *       [disabled]="stream.isLoading()"
- *       (click)="onSubmit()"
- *     >Send</button>
- *   `,
- * })
- * export class ChatComponent {
- *   stream = injectStream();
- *
- *   onSubmit() {
- *     void this.stream.submit({
- *       messages: [{ type: "human", content: "Hello!" }],
- *     });
- *   }
- * }
- * ```
- *
- * @example With type parameters for full type safety:
- * ```typescript
- * import type { agent } from "./agent";
- *
- * export class ChatComponent {
- *   stream = injectStream<typeof agent>();
- *   // stream.messages() returns typed messages
- * }
- * ```
- */
-declare function injectStream<T = Record<string, unknown>, Bag extends BagTemplate = BagTemplate>(): AngularSignalWrap<WithClassMessages<ResolveStreamInterface$1<T, InferBag$1<T, Bag>>>>;
-/**
- * Angular entry point for LangGraph streaming. Call from a component, directive,
- * or service field initializer to get a **Signals-based** stream controller
- * connected to the LangGraph Platform (HTTP + threads API).
- *
- * The returned object mirrors the shared `useStream` API from
- * `@langchain/langgraph-sdk/ui`, but reactive fields are
- * {@link https://angular.dev/guide/signals | Angular `Signal`s}:
- * read state with calls like `stream.messages()`, `stream.values()`, and
- * `stream.isLoading()`, and use `WritableSignal` setters where exposed (for
- * example `stream.branch` for branch selection).
- *
- * ## Typing with `createDeepAgent`
- *
- * Expect `export const agent = createDeepAgent({ ... })` from `deepagents`. In
- * UI code, `import { type agent } from "./agent"` (or `import type { agent }`)
- * is a **type-only** import: it is erased when compiling, so the agent module
- * does not run in the browser. You still pass **`typeof agent`** to
- * `injectStream`, not `agent` alone — `agent` is a value; TypeScript only
- * accepts it in a type position via `typeof` (otherwise: *refers to a value,
- * but is being used as a type*). If you prefer a named type in generics, add
- * `export type Agent = typeof agent` next to the const and use
- * `injectStream<Agent>(...)`.
- *
- * @example
- * ```typescript
- * // agent.ts
- * import { createDeepAgent } from "deepagents";
- * import { tool } from "langchain";
- * import { z } from "zod";
- *
- * const getWeather = tool(
- *   async ({ location }) => `Weather in ${location}`,
- *   { name: "get_weather", schema: z.object({ location: z.string() }) },
- * );
- *
- * export const agent = createDeepAgent({
- *   model: "openai:gpt-4o",
- *   tools: [getWeather],
- * });
- *
- * // chat.component.ts — type-only import; no agent runtime in the frontend
- * import { Component } from "@angular/core";
- * import { injectStream } from "@langchain/angular";
- * import { type agent } from "./agent";
- *
- * @Component({
- *   standalone: true,
- *   template: `
- *     @for (msg of stream.messages(); track msg.id ?? $index) {
- *       <p>{{ msg.content }}</p>
- *     }
- *   `,
- * })
- * export class ChatComponent {
- *   readonly stream = injectStream<typeof agent>({
- *     assistantId: "agent",
- *     apiUrl: "http://localhost:2024",
- *   });
- *   // stream.toolCalls()[0].call.name is typed as "get_weather"
- * }
- * ```
- *
- * ## Typing with `StateGraph` / custom graph state
- *
- * Use your graph state interface as `T` and embed tool call unions in
- * `Message<...>[]` when you need discriminated tool types.
- *
- * @example
- * ```typescript
- * import { Message } from "@langchain/langgraph-sdk";
- * import { Component } from "@angular/core";
- * import { injectStream } from "@langchain/angular";
- *
- * type MyToolCalls =
- *   | { name: "search"; args: { query: string }; id?: string }
- *   | { name: "calculate"; args: { expression: string }; id?: string };
- *
- * interface MyGraphState {
- *   messages: Message<MyToolCalls>[];
- *   context?: string;
- * }
- *
- * @Component({ standalone: true, template: "" })
- * export class ChatComponent {
- *   readonly stream = injectStream<MyGraphState>({
- *     assistantId: "my-graph",
- *     apiUrl: "http://localhost:2024",
- *   });
- *   // stream.values() is typed as MyGraphState | null
- * }
- * ```
- *
- * @example
- * ```typescript
- * // Optional bag for interrupts, configurable, custom events, and updates
- * import { Component } from "@angular/core";
- * import { injectStream } from "@langchain/angular";
- * import type { Message } from "@langchain/langgraph-sdk";
- *
- * interface MyGraphState {
- *   messages: Message[];
- * }
- *
- * @Component({ standalone: true, template: "" })
- * export class ChatComponent {
- *   readonly stream = injectStream<
- *     MyGraphState,
- *     {
- *       InterruptType: { question: string };
- *       ConfigurableType: { userId: string };
- *     }
- *   >({
- *     assistantId: "my-graph",
- *     apiUrl: "http://localhost:2024",
- *   });
- *   // stream.interrupt() is typed as { question: string } | undefined
- * }
- * ```
- *
- * ## Subagent streaming
- *
- * For `createDeepAgent` agents with `subagents`, set `filterSubagentMessages`
- * and use `streamSubgraphs` on `submit` to populate `stream.subagents` and
- * related helpers.
- *
- * @example
- * ```typescript
- * import { Component } from "@angular/core";
- * import { injectStream } from "@langchain/angular";
- * import { type agent } from "./agent";
- *
- * @Component({ standalone: true, template: "" })
- * export class DeepAgentChatComponent {
- *   readonly stream = injectStream<typeof agent>({
- *     assistantId: "deepagent",
- *     apiUrl: "http://localhost:2024",
- *     filterSubagentMessages: true,
- *   });
- *
- *   send(content: string) {
- *     void this.stream.submit(
- *       { messages: [{ content, type: "human" }] },
- *       { streamSubgraphs: true },
- *     );
- *   }
- * }
- * ```
- *
- * @param options - LangGraph Platform client options (`apiUrl` or `client`),
- *   `assistantId`, stream modes, history, reconnect, subagent settings, etc.
- *
- * @returns A stream controller backed by Signals: graph values, messages,
- *   loading and error state, interrupts, tool calls, branching, queue, and
- *   `submit` / `stop` / `switchThread` helpers (writable where the UI layer
- *   requires mutation).
- *
- * @template T Agent type (with `~agentTypes`) from `createDeepAgent` or
- *   `createAgent`, or a state shape extending `Record<string, unknown>`.
- * @template Bag Optional configuration bag:
- *   - `ConfigurableType` — `config.configurable` typing
- *   - `InterruptType` — human-in-the-loop interrupt payloads
- *   - `CustomEventType` — custom stream events
- *   - `UpdateType` — payload typing for `submit`
- *
- * @see {@link https://docs.langchain.com/oss/javascript/langgraph/overview | LangGraph JavaScript overview}
- * @see {@link https://docs.langchain.com/oss/javascript/langchain/overview | LangChain JavaScript overview}
- * @see {@link https://docs.langchain.com/oss/javascript/deepagents/overview | Deep Agents JavaScript overview}
- */
-declare function injectStream<T = Record<string, unknown>, Bag extends BagTemplate = BagTemplate>(options: ResolveStreamOptions$1<T, InferBag$1<T, Bag>>): AngularSignalWrap<WithClassMessages<ResolveStreamInterface$1<T, InferBag$1<T, Bag>>>>;
-/**
- * Overload for a **custom transport** (`options.transport`), for example
- * {@link FetchStreamTransport} or any implementation compatible with
- * {@link injectStreamCustom}. Prefer {@link injectStreamCustom} directly when
- * you only use custom transports and want a narrower import.
- *
- * @param options - Custom transport and stream options (must include
- *   `transport`).
- *
- * @returns The same Signals-based controller shape as the LangGraph Platform
- *   overload.
- *
- * @template T Agent type or state shape, matching the custom transport.
- * @template Bag Same optional bag as the platform overload.
- *
- * @see {@link injectStreamCustom}
- */
-declare function injectStream<T = Record<string, unknown>, Bag extends BagTemplate = BagTemplate>(options: UseStreamCustomOptions$1<InferStateType$1<T>, InferBag$1<T, Bag>>): AngularSignalWrap<WithClassMessages<ResolveStreamInterface$1<T, InferBag$1<T, Bag>>>>;
-/**
- * @deprecated Use `injectStream` instead. `useStream` will be removed in a
- * future major version. `injectStream` follows Angular's `inject*` naming
- * convention for injection-based patterns.
- */
-declare const useStream: typeof injectStream;
-/**
- * Injectable Angular service that wraps {@link injectStream}.
- *
- * Extend this class with your own `@Injectable()` service and call
- * `super(options)` in the constructor:
- *
- * ```ts
- * \@Injectable({ providedIn: 'root' })
- * export class ChatService extends StreamService {
- *   constructor() {
- *     super({ assistantId: 'agent', apiUrl: '...' });
- *   }
- * }
- * ```
- *
- * The service exposes the same signals and methods as `injectStream`
- * (e.g. `values`, `messages`, `isLoading`, `submit`, `stop`).
- *
- * Must be created within an Angular injection context (via DI or
- * `runInInjectionContext`).
- */
-declare class StreamService<T = Record<string, unknown>, Bag extends BagTemplate = BagTemplate> {
-  private readonly _stream;
-  constructor(options: ResolveStreamOptions$1<T, InferBag$1<T, Bag>> | UseStreamCustomOptions$1<InferStateType$1<T>, InferBag$1<T, Bag>>);
-  get values(): Signal<T>;
-  get messages(): Signal<BaseMessage[]>;
-  get isLoading(): WritableSignal<boolean>;
-  get error(): Signal<unknown>;
-  get branch(): WritableSignal<string>;
-  get interrupt(): Signal<Interrupt<GetInterruptType<Bag>> | undefined>;
-  get interrupts(): Signal<Interrupt<GetInterruptType<Bag>>[]>;
-  get toolCalls(): Signal<ToolCallWithResult$1<DefaultToolCall$1>[]>;
-  get queue(): AngularQueueInterface<{
-    entries: readonly {
-      id: string;
-      values: Partial<T> | null | undefined;
-    }[];
-    size: number;
-    cancel: (id: string) => Promise<boolean>;
-    clear: () => Promise<void>;
-  }>;
-  get subagents(): Signal<ReadonlyMap<string, SubagentStreamInterface$1>>;
-  get activeSubagents(): Signal<readonly SubagentStreamInterface$1[]>;
-  get history(): Signal<unknown>;
-  get isThreadLoading(): Signal<boolean>;
-  get experimental_branchTree(): Signal<unknown>;
-  get client(): Client;
-  get assistantId(): string;
-  submit(values: AcceptBaseMessages<Exclude<T, null | undefined>> | null | undefined, options?: SubmitOptions<T extends Record<string, unknown> ? T : Record<string, unknown>, GetConfigurableType<Bag>>): ReturnType<typeof this._stream.submit>;
-  stop(): Promise<void>;
-  setBranch(value: string): void;
-  switchThread(newThreadId: string | null): void;
-  joinStream(runId: string, lastEventId?: string, options?: {
-    streamMode?: StreamMode | StreamMode[];
-    filter?: (event: {
-      id?: string;
-      event: StreamEvent;
-      data: unknown;
-    }) => boolean;
-  }): Promise<void>;
-  getMessagesMetadata(message: BaseMessage, index?: number): MessageMetadata$1<T extends Record<string, unknown> ? T : Record<string, unknown>> | undefined;
-  getToolCalls(message: BaseMessage): ToolCallWithResult$1<DefaultToolCall$1>[];
-  getSubagent(toolCallId: string): SubagentStreamInterface$1 | undefined;
-  getSubagentsByType(type: string): SubagentStreamInterface$1[];
-  getSubagentsByMessage(messageId: string): SubagentStreamInterface$1[];
-}
-type ToolCallWithResult<ToolCall = DefaultToolCall$1> = ToolCallWithResult$1<ToolCall, ToolMessage, AIMessage>;
-//#endregion
-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
+import { StreamService } from "./stream-service.js";
+import { AnyHeadlessToolImplementation, DefaultToolCall, FlushPendingHeadlessToolInterruptsOptions, HeadlessToolImplementation, HeadlessToolInterrupt, HttpAgentServerAdapter, HttpAgentServerAdapterOptions, OnToolCallback, ToolCallFromTool, ToolCallState, ToolCallsFromTools, ToolEvent, executeHeadlessTool, filterOutHeadlessToolInterrupts, findHeadlessTool, flushPendingHeadlessToolInterrupts, handleHeadlessToolInterrupt, headlessToolResumeCommand, isHeadlessToolInterrupt, parseHeadlessToolInterruptPayload } from "@langchain/langgraph-sdk";
+import { AgentServerAdapter, AnyMediaHandle, AssembledToolCall, AudioMedia, Channel, Event, FileMedia, ImageMedia, InferStateType, InferSubagentStates, InferToolCalls, MediaAssemblyError, MediaAssemblyErrorKind, MediaBase, MediaBlockType, StreamSubmitOptions, SubagentDiscoverySnapshot, SubgraphDiscoverySnapshot, ToolCallStatus, VideoMedia, WidenUpdateMessages } from "@langchain/langgraph-sdk/stream";
+export { type AgentServerAdapter, type AgentServerOptions, type AnyHeadlessToolImplementation, type AnyMediaHandle, type AnyStream, type AssembledToolCall, type AudioMedia, type Channel, type CustomAdapterOptions, type DefaultToolCall, type Event, type FileMedia, type FlushPendingHeadlessToolInterruptsOptions, type HeadlessToolImplementation, type HeadlessToolInterrupt, HttpAgentServerAdapter, type HttpAgentServerAdapterOptions, type ImageMedia, type InferStateType, type InferSubagentStates, type InferToolCalls, type InjectSubmissionQueueReturn, MediaAssemblyError, type MediaAssemblyErrorKind, type MediaBase, type MediaBlockType, type MessageMetadata, type MessageMetadataMap, type OnToolCallback, STREAM_CONTROLLER, STREAM_DEFAULTS, STREAM_INSTANCE, type SelectorTarget, type StateOf, type StreamApi, type StreamDefaults, StreamService, type StreamSubmitOptions, type SubagentDiscoverySnapshot, type SubgraphDiscoverySnapshot, type SubmissionQueueEntry, type SubmissionQueueSnapshot, type ThreadStream, type ToolCallFromTool, type ToolCallState, type ToolCallStatus, type ToolCallsFromTools, type ToolEvent, type UseStreamOptions, type UseStreamResult, type UseStreamReturn, type VideoMedia, type WidenUpdateMessages, executeHeadlessTool, filterOutHeadlessToolInterrupts, findHeadlessTool, flushPendingHeadlessToolInterrupts, handleHeadlessToolInterrupt, headlessToolResumeCommand, injectAudio, injectChannel, injectExtension, injectFiles, injectImages, injectMediaUrl, injectMessageMetadata, injectMessages, injectProjection, injectStream, injectSubmissionQueue, injectToolCalls, injectValues, injectVideo, isHeadlessToolInterrupt, parseHeadlessToolInterruptPayload, provideStream, provideStreamDefaults, useStream };

package/dist/index.js

@@ -1,115 +1,12 @@
-import { injectStreamCustom, useStreamCustom } from "./stream.custom.js";
-import { useStreamLGP } from "./stream.lgp.js";
+import { STREAM_CONTROLLER, useStream } from "./use-stream.js";
 import { STREAM_DEFAULTS, STREAM_INSTANCE, provideStream, provideStreamDefaults } from "./context.js";
-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.
-*/
-function injectStream(options) {
-	if (arguments.length === 0) {
-		const instance = inject(STREAM_INSTANCE, { optional: true });
-		if (instance == null) throw new Error("injectStream() requires an ancestor component to provide a stream via provideStream(). Add provideStream({ assistantId: '...' }) to the providers array of a parent component, or use injectStream(options) directly.");
-		return instance;
-	}
-	if ("transport" in options) return injectStreamCustom(options);
-	return useStreamLGP(options);
-}
-/**
-* @deprecated Use `injectStream` instead. `useStream` will be removed in a
-* future major version. `injectStream` follows Angular's `inject*` naming
-* convention for injection-based patterns.
-*/
-const useStream = injectStream;
-let StreamService = class StreamService {
-	_stream;
-	constructor(options) {
-		this._stream = injectStream(options);
-	}
-	get values() {
-		return this._stream.values;
-	}
-	get messages() {
-		return this._stream.messages;
-	}
-	get isLoading() {
-		return this._stream.isLoading;
-	}
-	get error() {
-		return this._stream.error;
-	}
-	get branch() {
-		return this._stream.branch;
-	}
-	get interrupt() {
-		return this._stream.interrupt;
-	}
-	get interrupts() {
-		return this._stream.interrupts;
-	}
-	get toolCalls() {
-		return this._stream.toolCalls;
-	}
-	get queue() {
-		return this._stream.queue;
-	}
-	get subagents() {
-		return this._stream.subagents;
-	}
-	get activeSubagents() {
-		return this._stream.activeSubagents;
-	}
-	get history() {
-		return this._stream.history;
-	}
-	get isThreadLoading() {
-		return this._stream.isThreadLoading;
-	}
-	get experimental_branchTree() {
-		return this._stream.experimental_branchTree;
-	}
-	get client() {
-		return this._stream.client;
-	}
-	get assistantId() {
-		return this._stream.assistantId;
-	}
-	submit(values, options) {
-		return this._stream.submit(values, options);
-	}
-	async stop() {
-		await this._stream.stop();
-	}
-	setBranch(value) {
-		this._stream.setBranch(value);
-	}
-	switchThread(newThreadId) {
-		this._stream.switchThread(newThreadId);
-	}
-	joinStream(runId, lastEventId, options) {
-		return this._stream.joinStream(runId, lastEventId, options);
-	}
-	getMessagesMetadata(message, index) {
-		return this._stream.getMessagesMetadata(message, index);
-	}
-	getToolCalls(message) {
-		return this._stream.getToolCalls(message);
-	}
-	getSubagent(toolCallId) {
-		return this._stream.getSubagent(toolCallId);
-	}
-	getSubagentsByType(type) {
-		return this._stream.getSubagentsByType(type);
-	}
-	getSubagentsByMessage(messageId) {
-		return this._stream.getSubagentsByMessage(messageId);
-	}
-};
-StreamService = __decorate([Injectable()], StreamService);
-//#endregion
-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
+import { injectStream } from "./inject-stream.js";
+import { injectProjection } from "./inject-projection.js";
+import { injectAudio, injectChannel, injectExtension, injectFiles, injectImages, injectMessages, injectToolCalls, injectValues, injectVideo } from "./selectors.js";
+import { injectSubmissionQueue } from "./selectors-queue.js";
+import { injectMessageMetadata } from "./selectors-metadata.js";
+import { injectMediaUrl } from "./inject-media-url.js";
+import { StreamService } from "./stream-service.js";
+import { HttpAgentServerAdapter, executeHeadlessTool, filterOutHeadlessToolInterrupts, findHeadlessTool, flushPendingHeadlessToolInterrupts, handleHeadlessToolInterrupt, headlessToolResumeCommand, isHeadlessToolInterrupt, parseHeadlessToolInterruptPayload } from "@langchain/langgraph-sdk";
+import { MediaAssemblyError } from "@langchain/langgraph-sdk/stream";
+export { HttpAgentServerAdapter, MediaAssemblyError, STREAM_CONTROLLER, STREAM_DEFAULTS, STREAM_INSTANCE, StreamService, executeHeadlessTool, filterOutHeadlessToolInterrupts, findHeadlessTool, flushPendingHeadlessToolInterrupts, handleHeadlessToolInterrupt, headlessToolResumeCommand, injectAudio, injectChannel, injectExtension, injectFiles, injectImages, injectMediaUrl, injectMessageMetadata, injectMessages, injectProjection, injectStream, injectSubmissionQueue, injectToolCalls, injectValues, injectVideo, isHeadlessToolInterrupt, parseHeadlessToolInterruptPayload, provideStream, provideStreamDefaults, useStream };

package/dist/inject-media-url.cjs

@@ -0,0 +1,54 @@
+let _angular_core = require("@angular/core");
+//#region src/inject-media-url.ts
+/**
+* Resolve the lazy {@link MediaBase.objectURL} promise into a string
+* suitable for direct use in `<audio src>` / `<img src>` /
+* `<video src>` / `<a href download>`. Returns `undefined` until the
+* URL is available.
+*
+* Lifecycle:
+*  - On first read (or when `media` changes) the helper awaits
+*    `media.objectURL`, then commits the resolved string to the
+*    returned signal.
+*  - On destroy (or when `media` changes) the helper calls
+*    `media.revoke()` to free the object URL slot. The next consumer
+*    that accesses `media.objectURL` mints a fresh URL from the same
+*    `Blob`, so live re-renders just work.
+*  - If the underlying handle errored before settling, the promise
+*    rejects and `injectMediaUrl` stays at `undefined`. Inspect
+*    `media.error` to surface the failure.
+*
+* Pair with {@link injectAudio} / {@link injectImages} /
+* {@link injectVideo} / {@link injectFiles} to bridge SDK media
+* handles into Angular templates without manual
+* `URL.createObjectURL` bookkeeping.
+*
+* `media` accepts a plain handle or a `Signal<MediaBase | undefined>`
+* so callers can feed a `computed(() => stream.audio()[0])`.
+*/
+function injectMediaUrl(media) {
+	const url = (0, _angular_core.signal)(void 0);
+	const read = (0, _angular_core.isSignal)(media) ? media : () => media;
+	(0, _angular_core.effect)((onCleanup) => {
+		const next = read();
+		(0, _angular_core.untracked)(() => {
+			url.set(void 0);
+			if (next == null) return;
+			let cancelled = false;
+			next.objectURL.then((resolved) => {
+				if (!cancelled) url.set(resolved);
+			}, () => {});
+			onCleanup(() => {
+				cancelled = true;
+				try {
+					next.revoke();
+				} catch {}
+			});
+		});
+	});
+	return url;
+}
+//#endregion
+exports.injectMediaUrl = injectMediaUrl;
+
+//# sourceMappingURL=inject-media-url.cjs.map

package/dist/inject-media-url.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-media-url.cjs","names":[],"sources":["../src/inject-media-url.ts"],"sourcesContent":["import {\n  effect,\n  isSignal,\n  signal,\n  untracked,\n  type Signal,\n} from \"@angular/core\";\nimport type { MediaBase } from \"@langchain/langgraph-sdk/stream\";\n\n/**\n * Resolve the lazy {@link MediaBase.objectURL} promise into a string\n * suitable for direct use in `<audio src>` / `<img src>` /\n * `<video src>` / `<a href download>`. Returns `undefined` until the\n * URL is available.\n *\n * Lifecycle:\n *  - On first read (or when `media` changes) the helper awaits\n *    `media.objectURL`, then commits the resolved string to the\n *    returned signal.\n *  - On destroy (or when `media` changes) the helper calls\n *    `media.revoke()` to free the object URL slot. The next consumer\n *    that accesses `media.objectURL` mints a fresh URL from the same\n *    `Blob`, so live re-renders just work.\n *  - If the underlying handle errored before settling, the promise\n *    rejects and `injectMediaUrl` stays at `undefined`. Inspect\n *    `media.error` to surface the failure.\n *\n * Pair with {@link injectAudio} / {@link injectImages} /\n * {@link injectVideo} / {@link injectFiles} to bridge SDK media\n * handles into Angular templates without manual\n * `URL.createObjectURL` bookkeeping.\n *\n * `media` accepts a plain handle or a `Signal<MediaBase | undefined>`\n * so callers can feed a `computed(() => stream.audio()[0])`.\n */\nexport function injectMediaUrl(\n  media: MediaBase | undefined | Signal<MediaBase | undefined>\n): Signal<string | undefined> {\n  const url = signal<string | undefined>(undefined);\n\n  const read = isSignal(media)\n    ? (media as Signal<MediaBase | undefined>)\n    : () => media as MediaBase | undefined;\n\n  effect((onCleanup) => {\n    const next = (read as () => MediaBase | undefined)();\n\n    untracked(() => {\n      url.set(undefined);\n      if (next == null) return;\n\n      let cancelled = false;\n      next.objectURL.then(\n        (resolved) => {\n          if (!cancelled) url.set(resolved);\n        },\n        () => {\n          // Errors surfaced via `media.error`; keep `url` undefined\n          // so consumers fall through to a no-src render.\n        }\n      );\n\n      onCleanup(() => {\n        cancelled = true;\n        try {\n          next.revoke();\n        } catch {\n          // best-effort\n        }\n      });\n    });\n  });\n\n  return url;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA,SAAgB,eACd,OAC4B;CAC5B,MAAM,OAAA,GAAA,cAAA,QAAiC,KAAA,EAAU;CAEjD,MAAM,QAAA,GAAA,cAAA,UAAgB,MAAM,GACvB,cACK;AAEV,EAAA,GAAA,cAAA,SAAQ,cAAc;EACpB,MAAM,OAAQ,MAAsC;AAEpD,GAAA,GAAA,cAAA,iBAAgB;AACd,OAAI,IAAI,KAAA,EAAU;AAClB,OAAI,QAAQ,KAAM;GAElB,IAAI,YAAY;AAChB,QAAK,UAAU,MACZ,aAAa;AACZ,QAAI,CAAC,UAAW,KAAI,IAAI,SAAS;YAE7B,GAIP;AAED,mBAAgB;AACd,gBAAY;AACZ,QAAI;AACF,UAAK,QAAQ;YACP;KAGR;IACF;GACF;AAEF,QAAO"}

package/dist/inject-media-url.d.cts

@@ -0,0 +1,34 @@
+import { MediaBase } from "@langchain/langgraph-sdk/stream";
+import { Signal } from "@angular/core";
+
+//#region src/inject-media-url.d.ts
+/**
+ * Resolve the lazy {@link MediaBase.objectURL} promise into a string
+ * suitable for direct use in `<audio src>` / `<img src>` /
+ * `<video src>` / `<a href download>`. Returns `undefined` until the
+ * URL is available.
+ *
+ * Lifecycle:
+ *  - On first read (or when `media` changes) the helper awaits
+ *    `media.objectURL`, then commits the resolved string to the
+ *    returned signal.
+ *  - On destroy (or when `media` changes) the helper calls
+ *    `media.revoke()` to free the object URL slot. The next consumer
+ *    that accesses `media.objectURL` mints a fresh URL from the same
+ *    `Blob`, so live re-renders just work.
+ *  - If the underlying handle errored before settling, the promise
+ *    rejects and `injectMediaUrl` stays at `undefined`. Inspect
+ *    `media.error` to surface the failure.
+ *
+ * Pair with {@link injectAudio} / {@link injectImages} /
+ * {@link injectVideo} / {@link injectFiles} to bridge SDK media
+ * handles into Angular templates without manual
+ * `URL.createObjectURL` bookkeeping.
+ *
+ * `media` accepts a plain handle or a `Signal<MediaBase | undefined>`
+ * so callers can feed a `computed(() => stream.audio()[0])`.
+ */
+declare function injectMediaUrl(media: MediaBase | undefined | Signal<MediaBase | undefined>): Signal<string | undefined>;
+//#endregion
+export { injectMediaUrl };
+//# sourceMappingURL=inject-media-url.d.cts.map

package/dist/inject-media-url.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-media-url.d.cts","names":[],"sources":["../src/inject-media-url.ts"],"mappings":";;;;;;AAmCA;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,cAAA,CACd,KAAA,EAAO,SAAA,eAAwB,MAAA,CAAO,SAAA,gBACrC,MAAA"}

package/dist/inject-media-url.d.ts

@@ -0,0 +1,34 @@
+import { Signal } from "@angular/core";
+import { MediaBase } from "@langchain/langgraph-sdk/stream";
+
+//#region src/inject-media-url.d.ts
+/**
+ * Resolve the lazy {@link MediaBase.objectURL} promise into a string
+ * suitable for direct use in `<audio src>` / `<img src>` /
+ * `<video src>` / `<a href download>`. Returns `undefined` until the
+ * URL is available.
+ *
+ * Lifecycle:
+ *  - On first read (or when `media` changes) the helper awaits
+ *    `media.objectURL`, then commits the resolved string to the
+ *    returned signal.
+ *  - On destroy (or when `media` changes) the helper calls
+ *    `media.revoke()` to free the object URL slot. The next consumer
+ *    that accesses `media.objectURL` mints a fresh URL from the same
+ *    `Blob`, so live re-renders just work.
+ *  - If the underlying handle errored before settling, the promise
+ *    rejects and `injectMediaUrl` stays at `undefined`. Inspect
+ *    `media.error` to surface the failure.
+ *
+ * Pair with {@link injectAudio} / {@link injectImages} /
+ * {@link injectVideo} / {@link injectFiles} to bridge SDK media
+ * handles into Angular templates without manual
+ * `URL.createObjectURL` bookkeeping.
+ *
+ * `media` accepts a plain handle or a `Signal<MediaBase | undefined>`
+ * so callers can feed a `computed(() => stream.audio()[0])`.
+ */
+declare function injectMediaUrl(media: MediaBase | undefined | Signal<MediaBase | undefined>): Signal<string | undefined>;
+//#endregion
+export { injectMediaUrl };
+//# sourceMappingURL=inject-media-url.d.ts.map

package/dist/inject-media-url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-media-url.d.ts","names":[],"sources":["../src/inject-media-url.ts"],"mappings":";;;;;;AAmCA;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,cAAA,CACd,KAAA,EAAO,SAAA,eAAwB,MAAA,CAAO,SAAA,gBACrC,MAAA"}