@langchain/vue 1.0.4 → 1.0.6

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-import { AgentServerOptions, AnyStream, CustomAdapterOptions, STREAM_CONTROLLER, StateOf, ThreadStream, UseStreamOptions, UseStreamResult, UseStreamReturn, useStream } from "./use-stream.cjs";
+import { AgentServerOptions, AnyStream, CustomAdapterOptions, STREAM_CONTROLLER, ThreadStream, UseStreamOptions, UseStreamResult, UseStreamReturn, useStream } from "./use-stream.cjs";
 import { useProjection } from "./use-projection.cjs";
 import { SelectorTarget, SubmissionQueueEntry, SubmissionQueueSnapshot, UseSubmissionQueueReturn, useAudio, useChannel, useExtension, useFiles, useImages, useMessageMetadata, useMessages, useSubmissionQueue, useToolCalls, useValues, useVideo } from "./selectors.cjs";
 import { useMediaURL } from "./use-media-url.cjs";
@@ -6,6 +6,6 @@ import { AudioPlayerHandle, PlayerStatus, UseAudioPlayerOptions, useAudioPlayer
 import { UseVideoPlayerOptions, VideoPlayerHandle, useVideoPlayer } from "./use-video-player.cjs";
 import { LANGCHAIN_OPTIONS, LangChainPlugin, LangChainPluginOptions, provideStream, useStreamContext } from "./context.cjs";
 import { VueReactiveOptions } from "./types.cjs";
-import { AnyHeadlessToolImplementation, DefaultToolCall, FlushPendingHeadlessToolInterruptsOptions, HeadlessToolImplementation, HeadlessToolInterrupt, HttpAgentServerAdapter, HttpAgentServerAdapterOptions, OnToolCallback, ToolCallFromTool, ToolCallState, ToolCallWithResult, 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, MessageMetadata, MessageMetadataMap, 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 AudioPlayerHandle, 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, LANGCHAIN_OPTIONS, LangChainPlugin, type LangChainPluginOptions, MediaAssemblyError, type MediaAssemblyErrorKind, type MediaBase, type MediaBlockType, type MessageMetadata, type MessageMetadataMap, type OnToolCallback, type PlayerStatus, STREAM_CONTROLLER, type SelectorTarget, type StateOf, type StreamSubmitOptions, type SubagentDiscoverySnapshot, type SubgraphDiscoverySnapshot, type SubmissionQueueEntry, type SubmissionQueueSnapshot, type ThreadStream, type ToolCallFromTool, type ToolCallState, type ToolCallStatus, type ToolCallWithResult, type ToolCallsFromTools, type ToolEvent, type UseAudioPlayerOptions, type UseStreamOptions, type UseStreamResult, type UseStreamReturn, type UseSubmissionQueueReturn, type UseVideoPlayerOptions, type VideoMedia, type VideoPlayerHandle, type VueReactiveOptions, type WidenUpdateMessages, executeHeadlessTool, filterOutHeadlessToolInterrupts, findHeadlessTool, flushPendingHeadlessToolInterrupts, handleHeadlessToolInterrupt, headlessToolResumeCommand, isHeadlessToolInterrupt, parseHeadlessToolInterruptPayload, provideStream, useAudio, useAudioPlayer, useChannel, useExtension, useFiles, useImages, useMediaURL, useMessageMetadata, useMessages, useProjection, useStream, useStreamContext, useSubmissionQueue, useToolCalls, useValues, useVideo, useVideoPlayer };
+import { AnyHeadlessToolImplementation, DefaultToolCall, FlushPendingHeadlessToolInterruptsOptions, HeadlessToolImplementation, HeadlessToolInterrupt, HttpAgentServerAdapter, HttpAgentServerAdapterOptions, OnToolCallback, ToolCallState, ToolCallWithResult, ToolCallsFromTools, ToolEvent, executeHeadlessTool, filterOutHeadlessToolInterrupts, findHeadlessTool, flushPendingHeadlessToolInterrupts, handleHeadlessToolInterrupt, headlessToolResumeCommand, isHeadlessToolInterrupt, parseHeadlessToolInterruptPayload } from "@langchain/langgraph-sdk";
+import { AgentServerAdapter, AnyMediaHandle, AssembledToolCall, AssembledToolCallFromTool as ToolCallFromTool, AudioMedia, Channel, Event, FileMedia, ImageMedia, InferStateType, InferSubagentStates, InferToolCalls, MediaAssemblyError, MediaAssemblyErrorKind, MediaBase, MediaBlockType, MessageMetadata, MessageMetadataMap, 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 AudioPlayerHandle, 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, LANGCHAIN_OPTIONS, LangChainPlugin, type LangChainPluginOptions, MediaAssemblyError, type MediaAssemblyErrorKind, type MediaBase, type MediaBlockType, type MessageMetadata, type MessageMetadataMap, type OnToolCallback, type PlayerStatus, STREAM_CONTROLLER, type SelectorTarget, type StreamSubmitOptions, type SubagentDiscoverySnapshot, type SubgraphDiscoverySnapshot, type SubmissionQueueEntry, type SubmissionQueueSnapshot, type ThreadStream, type ToolCallFromTool, type ToolCallState, type ToolCallStatus, type ToolCallWithResult, type ToolCallsFromTools, type ToolEvent, type UseAudioPlayerOptions, type UseStreamOptions, type UseStreamResult, type UseStreamReturn, type UseSubmissionQueueReturn, type UseVideoPlayerOptions, type VideoMedia, type VideoPlayerHandle, type VueReactiveOptions, type WidenUpdateMessages, executeHeadlessTool, filterOutHeadlessToolInterrupts, findHeadlessTool, flushPendingHeadlessToolInterrupts, handleHeadlessToolInterrupt, headlessToolResumeCommand, isHeadlessToolInterrupt, parseHeadlessToolInterruptPayload, provideStream, useAudio, useAudioPlayer, useChannel, useExtension, useFiles, useImages, useMediaURL, useMessageMetadata, useMessages, useProjection, useStream, useStreamContext, useSubmissionQueue, useToolCalls, useValues, useVideo, useVideoPlayer };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { AgentServerOptions, AnyStream, CustomAdapterOptions, STREAM_CONTROLLER, StateOf, ThreadStream, UseStreamOptions, UseStreamResult, UseStreamReturn, useStream } from "./use-stream.js";
+import { AgentServerOptions, AnyStream, CustomAdapterOptions, STREAM_CONTROLLER, ThreadStream, UseStreamOptions, UseStreamResult, UseStreamReturn, useStream } from "./use-stream.js";
 import { useProjection } from "./use-projection.js";
 import { SelectorTarget, SubmissionQueueEntry, SubmissionQueueSnapshot, UseSubmissionQueueReturn, useAudio, useChannel, useExtension, useFiles, useImages, useMessageMetadata, useMessages, useSubmissionQueue, useToolCalls, useValues, useVideo } from "./selectors.js";
 import { useMediaURL } from "./use-media-url.js";
@@ -6,6 +6,6 @@ import { AudioPlayerHandle, PlayerStatus, UseAudioPlayerOptions, useAudioPlayer
 import { UseVideoPlayerOptions, VideoPlayerHandle, useVideoPlayer } from "./use-video-player.js";
 import { LANGCHAIN_OPTIONS, LangChainPlugin, LangChainPluginOptions, provideStream, useStreamContext } from "./context.js";
 import { VueReactiveOptions } from "./types.js";
-import { AnyHeadlessToolImplementation, DefaultToolCall, FlushPendingHeadlessToolInterruptsOptions, HeadlessToolImplementation, HeadlessToolInterrupt, HttpAgentServerAdapter, HttpAgentServerAdapterOptions, OnToolCallback, ToolCallFromTool, ToolCallState, ToolCallWithResult, 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, MessageMetadata, MessageMetadataMap, 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 AudioPlayerHandle, 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, LANGCHAIN_OPTIONS, LangChainPlugin, type LangChainPluginOptions, MediaAssemblyError, type MediaAssemblyErrorKind, type MediaBase, type MediaBlockType, type MessageMetadata, type MessageMetadataMap, type OnToolCallback, type PlayerStatus, STREAM_CONTROLLER, type SelectorTarget, type StateOf, type StreamSubmitOptions, type SubagentDiscoverySnapshot, type SubgraphDiscoverySnapshot, type SubmissionQueueEntry, type SubmissionQueueSnapshot, type ThreadStream, type ToolCallFromTool, type ToolCallState, type ToolCallStatus, type ToolCallWithResult, type ToolCallsFromTools, type ToolEvent, type UseAudioPlayerOptions, type UseStreamOptions, type UseStreamResult, type UseStreamReturn, type UseSubmissionQueueReturn, type UseVideoPlayerOptions, type VideoMedia, type VideoPlayerHandle, type VueReactiveOptions, type WidenUpdateMessages, executeHeadlessTool, filterOutHeadlessToolInterrupts, findHeadlessTool, flushPendingHeadlessToolInterrupts, handleHeadlessToolInterrupt, headlessToolResumeCommand, isHeadlessToolInterrupt, parseHeadlessToolInterruptPayload, provideStream, useAudio, useAudioPlayer, useChannel, useExtension, useFiles, useImages, useMediaURL, useMessageMetadata, useMessages, useProjection, useStream, useStreamContext, useSubmissionQueue, useToolCalls, useValues, useVideo, useVideoPlayer };
+import { AnyHeadlessToolImplementation, DefaultToolCall, FlushPendingHeadlessToolInterruptsOptions, HeadlessToolImplementation, HeadlessToolInterrupt, HttpAgentServerAdapter, HttpAgentServerAdapterOptions, OnToolCallback, ToolCallState, ToolCallWithResult, ToolCallsFromTools, ToolEvent, executeHeadlessTool, filterOutHeadlessToolInterrupts, findHeadlessTool, flushPendingHeadlessToolInterrupts, handleHeadlessToolInterrupt, headlessToolResumeCommand, isHeadlessToolInterrupt, parseHeadlessToolInterruptPayload } from "@langchain/langgraph-sdk";
+import { AgentServerAdapter, AnyMediaHandle, AssembledToolCall, AssembledToolCallFromTool as ToolCallFromTool, AudioMedia, Channel, Event, FileMedia, ImageMedia, InferStateType, InferSubagentStates, InferToolCalls, MediaAssemblyError, MediaAssemblyErrorKind, MediaBase, MediaBlockType, MessageMetadata, MessageMetadataMap, 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 AudioPlayerHandle, 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, LANGCHAIN_OPTIONS, LangChainPlugin, type LangChainPluginOptions, MediaAssemblyError, type MediaAssemblyErrorKind, type MediaBase, type MediaBlockType, type MessageMetadata, type MessageMetadataMap, type OnToolCallback, type PlayerStatus, STREAM_CONTROLLER, type SelectorTarget, type StreamSubmitOptions, type SubagentDiscoverySnapshot, type SubgraphDiscoverySnapshot, type SubmissionQueueEntry, type SubmissionQueueSnapshot, type ThreadStream, type ToolCallFromTool, type ToolCallState, type ToolCallStatus, type ToolCallWithResult, type ToolCallsFromTools, type ToolEvent, type UseAudioPlayerOptions, type UseStreamOptions, type UseStreamResult, type UseStreamReturn, type UseSubmissionQueueReturn, type UseVideoPlayerOptions, type VideoMedia, type VideoPlayerHandle, type VueReactiveOptions, type WidenUpdateMessages, executeHeadlessTool, filterOutHeadlessToolInterrupts, findHeadlessTool, flushPendingHeadlessToolInterrupts, handleHeadlessToolInterrupt, headlessToolResumeCommand, isHeadlessToolInterrupt, parseHeadlessToolInterruptPayload, provideStream, useAudio, useAudioPlayer, useChannel, useExtension, useFiles, useImages, useMediaURL, useMessageMetadata, useMessages, useProjection, useStream, useStreamContext, useSubmissionQueue, useToolCalls, useValues, useVideo, useVideoPlayer };

package/dist/selectors.cjs

@@ -37,11 +37,6 @@ function useMessages(stream, target) {
 	return require_use_projection.useProjection(require_use_stream.getRegistry(stream), () => (0, _langchain_langgraph_sdk_stream.messagesProjection)(namespace.value), key, EMPTY_MESSAGES);
 }
 const EMPTY_MESSAGES = [];
-/**
-* Subscribe to a scoped `tools` (tool-call) stream. Same target and
-* lifecycle rules as {@link useMessages}; at the root this returns
-* `stream.toolCalls` directly.
-*/
 function useToolCalls(stream, target) {
 	const namespace = (0, vue.computed)(() => resolveNamespace((0, vue.toValue)(target)));
 	if (isRoot(namespace.value)) return stream.toolCalls;

package/dist/selectors.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"selectors.cjs","names":["NAMESPACE_SEPARATOR","useProjection","getRegistry","STREAM_CONTROLLER"],"sources":["../src/selectors.ts"],"sourcesContent":["import {\n  computed,\n  onScopeDispose,\n  readonly,\n  shallowRef,\n  toValue,\n  type ComputedRef,\n  type MaybeRefOrGetter,\n  type ShallowRef,\n} from \"vue\";\nimport type { BaseMessage } from \"@langchain/core/messages\";\nimport {\n  NAMESPACE_SEPARATOR,\n  audioProjection,\n  channelProjection,\n  extensionProjection,\n  filesProjection,\n  imagesProjection,\n  messagesProjection,\n  toolCallsProjection,\n  valuesProjection,\n  videoProjection,\n  type AssembledToolCall,\n  type AudioMedia,\n  type Channel,\n  type ChannelProjectionOptions,\n  type Event,\n  type FileMedia,\n  type ImageMedia,\n  type InferStateType,\n  type MessageMetadata,\n  type MessageMetadataMap,\n  type SubagentDiscoverySnapshot,\n  type SubgraphDiscoverySnapshot,\n  type SubmissionQueueEntry,\n  type SubmissionQueueSnapshot,\n  type VideoMedia,\n} from \"@langchain/langgraph-sdk/stream\";\nimport {\n  getRegistry,\n  STREAM_CONTROLLER,\n  type AnyStream,\n  type UseStreamReturn,\n} from \"./use-stream.js\";\nimport { useProjection } from \"./use-projection.js\";\n\n/**\n * Selector composables don't need to carry `InterruptType` /\n * `ConfigurableType`. Parameterising on `StateType` alone lets\n * callers with a full `useStream<S, I, C>()` handle pass it in without\n * redeclaring those generics at every call site.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype StreamHandle<StateType extends object> = UseStreamReturn<\n  StateType,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  any,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  any\n>;\n\n/**\n * What a selector composable can be targeted at. Callers can pass:\n *  - `undefined` / `null` — root namespace (served by the always-on\n *    root store — no extra subscription);\n *  - a {@link SubagentDiscoverySnapshot} (`stream.subagents.value.get(...)`);\n *  - a {@link SubgraphDiscoverySnapshot} (`stream.subgraphs.value.get(...)`);\n *  - an explicit `{ namespace: string[] }`;\n *  - a raw `string[]` escape hatch.\n */\nexport type SelectorTarget =\n  | undefined\n  | null\n  | readonly string[]\n  | { namespace: readonly string[] }\n  | SubagentDiscoverySnapshot\n  | SubgraphDiscoverySnapshot;\n\nconst EMPTY_NAMESPACE: readonly string[] = [];\n\nfunction resolveNamespace(target: SelectorTarget): readonly string[] {\n  if (target == null) return EMPTY_NAMESPACE;\n  if (Array.isArray(target)) return target as readonly string[];\n  const obj = target as { namespace?: readonly string[] };\n  return obj.namespace ?? EMPTY_NAMESPACE;\n}\n\nfunction isRoot(namespace: readonly string[]): boolean {\n  return namespace.length === 0;\n}\n\nfunction namespaceKey(namespace: readonly string[]): string {\n  return namespace.join(NAMESPACE_SEPARATOR);\n}\n\n/**\n * Subscribe to a scoped `messages` stream.\n *\n * Contract:\n *  - At the root (no `target`) this returns `stream.messages` — the\n *    always-on root projection; no extra subscription is opened.\n *  - For any non-root namespace, mount triggers a ref-counted\n *    `messages` subscription scoped to that namespace. The\n *    subscription is released automatically when the calling scope\n *    disappears (and the registry closes the underlying server\n *    subscription when the last consumer leaves).\n *\n * Messages are always `BaseMessage` class instances from\n * `@langchain/core/messages`.\n */\nexport function useMessages(\n  stream: AnyStream,\n  target?: MaybeRefOrGetter<SelectorTarget>\n): Readonly<ShallowRef<BaseMessage[]>> {\n  const namespace = computed(() => resolveNamespace(toValue(target)));\n  if (isRoot(namespace.value)) return stream.messages;\n  const key = computed(() => `messages|${namespaceKey(namespace.value)}`);\n  return useProjection<BaseMessage[]>(\n    getRegistry(stream),\n    () => messagesProjection(namespace.value),\n    key,\n    EMPTY_MESSAGES\n  );\n}\n\nconst EMPTY_MESSAGES: BaseMessage[] = [];\n\n/**\n * Subscribe to a scoped `tools` (tool-call) stream. Same target and\n * lifecycle rules as {@link useMessages}; at the root this returns\n * `stream.toolCalls` directly.\n */\nexport function useToolCalls(\n  stream: AnyStream,\n  target?: MaybeRefOrGetter<SelectorTarget>\n): Readonly<ShallowRef<AssembledToolCall[]>> {\n  const namespace = computed(() => resolveNamespace(toValue(target)));\n  if (isRoot(namespace.value)) return stream.toolCalls;\n  const key = computed(() => `toolCalls|${namespaceKey(namespace.value)}`);\n  return useProjection<AssembledToolCall[]>(\n    getRegistry(stream),\n    () => toolCallsProjection(namespace.value),\n    key,\n    EMPTY_TOOLCALLS\n  );\n}\n\nconst EMPTY_TOOLCALLS: AssembledToolCall[] = [];\n\n/**\n * Subscribe to a scoped `values` stream — the most recent state\n * payload for a namespace. At the root returns `stream.values`.\n *\n * Typing:\n *  - **Root** (`useValues(stream)`): returns the `StateType` declared\n *    on `useStream<State>()` — non-nullable (the root snapshot always\n *    has values, falling back to `initialValues ?? {}`).\n *  - **Scoped** (`useValues(stream, target)`): scoped payloads can\n *    differ from the root state; callers should annotate the\n *    expected shape explicitly (`useValues<SubagentState>(stream,\n *    sub)`). Defaults to `unknown` when not annotated.\n */\nexport function useValues<StateType extends object>(\n  stream: StreamHandle<StateType>\n): Readonly<ShallowRef<StateType>>;\nexport function useValues<T>(\n  stream: AnyStream\n): Readonly<ShallowRef<InferStateType<T>>>;\nexport function useValues<T = unknown>(\n  stream: AnyStream,\n  target: SelectorTarget,\n  options?: { messagesKey?: string }\n): Readonly<ShallowRef<T | undefined>>;\nexport function useValues(\n  stream: AnyStream,\n  target?: SelectorTarget,\n  options?: { messagesKey?: string }\n): Readonly<ShallowRef<unknown>> {\n  const namespace = resolveNamespace(target);\n  if (isRoot(namespace)) return stream.values as Readonly<ShallowRef<unknown>>;\n  const messagesKey = options?.messagesKey ?? \"messages\";\n  const key = `values|${messagesKey}|${namespaceKey(namespace)}`;\n  return useProjection<unknown>(\n    getRegistry(stream),\n    () => valuesProjection<unknown>(namespace, messagesKey),\n    key,\n    undefined\n  );\n}\n\n/**\n * Subscribe to a `custom:<name>` stream extension — most-recent\n * payload emitted by the transformer, scoped to the target namespace.\n */\nexport function useExtension<T = unknown>(\n  stream: AnyStream,\n  name: string,\n  target?: SelectorTarget\n): Readonly<ShallowRef<T | undefined>> {\n  const namespace = resolveNamespace(target);\n  const key = `extension|${name}|${namespaceKey(namespace)}`;\n  return useProjection<T | undefined>(\n    getRegistry(stream),\n    () => extensionProjection<T>(name, namespace),\n    key,\n    undefined\n  );\n}\n\n/**\n * Raw-events escape hatch. Subscribes to one or more channels at a\n * namespace and returns a bounded buffer of raw protocol events.\n * Prefer {@link useMessages} / {@link useToolCalls} / {@link useValues}\n * for the common cases.\n */\nexport type UseChannelOptions = ChannelProjectionOptions;\n\nexport function useChannel(\n  stream: AnyStream,\n  channels: readonly Channel[],\n  target?: SelectorTarget,\n  options?: UseChannelOptions\n): Readonly<ShallowRef<Event[]>> {\n  const namespace = resolveNamespace(target);\n  const sortedChannels = [...channels].sort().join(\",\");\n  const key = `channel|${options?.bufferSize ?? \"default\"}|${(options?.replay ?? true) ? \"replay\" : \"live\"}|${sortedChannels}|${namespaceKey(namespace)}`;\n  return useProjection<Event[]>(\n    getRegistry(stream),\n    () => channelProjection(channels, namespace, options),\n    key,\n    EMPTY_EVENTS\n  );\n}\n\nconst EMPTY_EVENTS: Event[] = [];\n\n/**\n * Subscribe to a scoped audio-media stream. Each handle is yielded\n * on its first matching `content-block-start`, exposes\n * `.partialBytes` for live access, settles `.blob` / `.objectURL` /\n * `.transcript` on `message-finish`, and surfaces errors via\n * `.error`.\n */\nexport function useAudio(\n  stream: AnyStream,\n  target?: SelectorTarget\n): Readonly<ShallowRef<AudioMedia[]>> {\n  const namespace = resolveNamespace(target);\n  const key = `audio|${namespaceKey(namespace)}`;\n  return useProjection<AudioMedia[]>(\n    getRegistry(stream),\n    () => audioProjection(namespace),\n    key,\n    EMPTY_AUDIO\n  );\n}\n\nconst EMPTY_AUDIO: AudioMedia[] = [];\n\n/**\n * Subscribe to a scoped image-media stream. Pair with\n * {@link useMediaURL} for `<img src>`.\n */\nexport function useImages(\n  stream: AnyStream,\n  target?: SelectorTarget\n): Readonly<ShallowRef<ImageMedia[]>> {\n  const namespace = resolveNamespace(target);\n  const key = `images|${namespaceKey(namespace)}`;\n  return useProjection<ImageMedia[]>(\n    getRegistry(stream),\n    () => imagesProjection(namespace),\n    key,\n    EMPTY_IMAGES\n  );\n}\n\nconst EMPTY_IMAGES: ImageMedia[] = [];\n\n/**\n * Subscribe to a scoped video-media stream. Pair with\n * {@link useMediaURL} for `<video src>`.\n */\nexport function useVideo(\n  stream: AnyStream,\n  target?: SelectorTarget\n): Readonly<ShallowRef<VideoMedia[]>> {\n  const namespace = resolveNamespace(target);\n  const key = `video|${namespaceKey(namespace)}`;\n  return useProjection<VideoMedia[]>(\n    getRegistry(stream),\n    () => videoProjection(namespace),\n    key,\n    EMPTY_VIDEO\n  );\n}\n\nconst EMPTY_VIDEO: VideoMedia[] = [];\n\n/**\n * Subscribe to a scoped file-media stream. Pair with\n * {@link useMediaURL} for an `<a download href>` target.\n */\nexport function useFiles(\n  stream: AnyStream,\n  target?: SelectorTarget\n): Readonly<ShallowRef<FileMedia[]>> {\n  const namespace = resolveNamespace(target);\n  const key = `files|${namespaceKey(namespace)}`;\n  return useProjection<FileMedia[]>(\n    getRegistry(stream),\n    () => filesProjection(namespace),\n    key,\n    EMPTY_FILES\n  );\n}\n\nconst EMPTY_FILES: FileMedia[] = [];\n\n/**\n * Read metadata recorded for a specific message id — today exposes\n * `parentCheckpointId`, the checkpoint the message was first seen on.\n * Designed for fork / edit flows:\n *\n * ```ts\n * const meta = useMessageMetadata(stream, () => msg.id);\n * // meta.value?.parentCheckpointId\n * ```\n *\n * `messageId` accepts a raw string, a `Ref<string | undefined>`, or\n * a getter — the binding re-evaluates whenever the id changes.\n */\nexport function useMessageMetadata(\n  stream: AnyStream,\n  messageId: MaybeRefOrGetter<string | undefined>\n): ComputedRef<MessageMetadata | undefined> {\n  const store = stream[STREAM_CONTROLLER].messageMetadataStore;\n  const mapRef = shallowRef<MessageMetadataMap>(store.getSnapshot());\n  const unsubscribe = store.subscribe(() => {\n    mapRef.value = store.getSnapshot();\n  });\n  onScopeDispose(unsubscribe);\n\n  return computed<MessageMetadata | undefined>(() => {\n    const key = toValue(messageId);\n    if (key == null) return undefined;\n    return mapRef.value.get(key);\n  });\n}\n\n/**\n * Reactive handle on the server-side submission queue.\n *\n * Populated when `submit()` is invoked with\n * `multitaskStrategy: \"enqueue\"` while another run is in flight. The\n * returned refs are shared per call — safe to pass into `v-for`.\n */\nexport interface UseSubmissionQueueReturn<\n  StateType extends object = Record<string, unknown>,\n> {\n  readonly entries: Readonly<ShallowRef<SubmissionQueueSnapshot<StateType>>>;\n  readonly size: ComputedRef<number>;\n  cancel(id: string): Promise<boolean>;\n  clear(): Promise<void>;\n}\n\nexport function useSubmissionQueue<StateType extends object>(\n  stream: StreamHandle<StateType>\n): UseSubmissionQueueReturn<StateType>;\nexport function useSubmissionQueue(stream: AnyStream): UseSubmissionQueueReturn;\nexport function useSubmissionQueue(\n  stream: AnyStream\n): UseSubmissionQueueReturn {\n  const controller = stream[STREAM_CONTROLLER];\n  const store = controller.queueStore;\n  const entries = shallowRef<SubmissionQueueSnapshot>(store.getSnapshot());\n  const unsubscribe = store.subscribe(() => {\n    entries.value = store.getSnapshot();\n  });\n  onScopeDispose(unsubscribe);\n\n  return {\n    entries: readonly(entries) as Readonly<ShallowRef<SubmissionQueueSnapshot>>,\n    size: computed(() => entries.value.length),\n    cancel: (id) => controller.cancelQueued(id),\n    clear: () => controller.clearQueue(),\n  };\n}\n\nexport type { SubmissionQueueEntry, SubmissionQueueSnapshot };\n"],"mappings":"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"}
+{"version":3,"file":"selectors.cjs","names":["NAMESPACE_SEPARATOR","useProjection","getRegistry","STREAM_CONTROLLER"],"sources":["../src/selectors.ts"],"sourcesContent":["import {\n  computed,\n  onScopeDispose,\n  readonly,\n  shallowRef,\n  toValue,\n  type ComputedRef,\n  type MaybeRefOrGetter,\n  type ShallowRef,\n} from \"vue\";\nimport type { BaseMessage } from \"@langchain/core/messages\";\nimport {\n  NAMESPACE_SEPARATOR,\n  audioProjection,\n  channelProjection,\n  extensionProjection,\n  filesProjection,\n  imagesProjection,\n  messagesProjection,\n  toolCallsProjection,\n  valuesProjection,\n  videoProjection,\n  type AssembledToolCall,\n  type AudioMedia,\n  type Channel,\n  type ChannelProjectionOptions,\n  type Event,\n  type FileMedia,\n  type ImageMedia,\n  type InferToolCalls,\n  type InferStateType,\n  type MessageMetadata,\n  type MessageMetadataMap,\n  type SubagentDiscoverySnapshot,\n  type SubgraphDiscoverySnapshot,\n  type SubmissionQueueEntry,\n  type SubmissionQueueSnapshot,\n  type VideoMedia,\n} from \"@langchain/langgraph-sdk/stream\";\nimport {\n  getRegistry,\n  STREAM_CONTROLLER,\n  type AnyStream,\n  type UseStreamReturn,\n} from \"./use-stream.js\";\nimport { useProjection } from \"./use-projection.js\";\n\n/**\n * Selector composables don't need to carry `InterruptType` /\n * `ConfigurableType`. Parameterising on `StateType` alone lets\n * callers with a full `useStream<S, I, C>()` handle pass it in without\n * redeclaring those generics at every call site.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype StreamHandle<StateType extends object> = UseStreamReturn<\n  StateType,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  any,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  any\n>;\n\n/**\n * What a selector composable can be targeted at. Callers can pass:\n *  - `undefined` / `null` — root namespace (served by the always-on\n *    root store — no extra subscription);\n *  - a {@link SubagentDiscoverySnapshot} (`stream.subagents.value.get(...)`);\n *  - a {@link SubgraphDiscoverySnapshot} (`stream.subgraphs.value.get(...)`);\n *  - an explicit `{ namespace: string[] }`;\n *  - a raw `string[]` escape hatch.\n */\nexport type SelectorTarget =\n  | undefined\n  | null\n  | readonly string[]\n  | { namespace: readonly string[] }\n  | SubagentDiscoverySnapshot\n  | SubgraphDiscoverySnapshot;\n\nconst EMPTY_NAMESPACE: readonly string[] = [];\n\nfunction resolveNamespace(target: SelectorTarget): readonly string[] {\n  if (target == null) return EMPTY_NAMESPACE;\n  if (Array.isArray(target)) return target as readonly string[];\n  const obj = target as { namespace?: readonly string[] };\n  return obj.namespace ?? EMPTY_NAMESPACE;\n}\n\nfunction isRoot(namespace: readonly string[]): boolean {\n  return namespace.length === 0;\n}\n\nfunction namespaceKey(namespace: readonly string[]): string {\n  return namespace.join(NAMESPACE_SEPARATOR);\n}\n\n/**\n * Subscribe to a scoped `messages` stream.\n *\n * Contract:\n *  - At the root (no `target`) this returns `stream.messages` — the\n *    always-on root projection; no extra subscription is opened.\n *  - For any non-root namespace, mount triggers a ref-counted\n *    `messages` subscription scoped to that namespace. The\n *    subscription is released automatically when the calling scope\n *    disappears (and the registry closes the underlying server\n *    subscription when the last consumer leaves).\n *\n * Messages are always `BaseMessage` class instances from\n * `@langchain/core/messages`.\n */\nexport function useMessages(\n  stream: AnyStream,\n  target?: MaybeRefOrGetter<SelectorTarget>\n): Readonly<ShallowRef<BaseMessage[]>> {\n  const namespace = computed(() => resolveNamespace(toValue(target)));\n  if (isRoot(namespace.value)) return stream.messages;\n  const key = computed(() => `messages|${namespaceKey(namespace.value)}`);\n  return useProjection<BaseMessage[]>(\n    getRegistry(stream),\n    () => messagesProjection(namespace.value),\n    key,\n    EMPTY_MESSAGES\n  );\n}\n\nconst EMPTY_MESSAGES: BaseMessage[] = [];\n\n/**\n * Subscribe to a scoped `tools` (tool-call) stream. Same target and\n * lifecycle rules as {@link useMessages}; at the root this returns\n * `stream.toolCalls` directly.\n */\nexport function useToolCalls(\n  stream: AnyStream,\n  target?: MaybeRefOrGetter<SelectorTarget>\n): Readonly<ShallowRef<AssembledToolCall[]>>;\nexport function useToolCalls<T>(\n  stream: AnyStream,\n  target?: MaybeRefOrGetter<SelectorTarget>\n): Readonly<ShallowRef<InferToolCalls<T>[]>>;\nexport function useToolCalls(\n  stream: AnyStream,\n  target?: MaybeRefOrGetter<SelectorTarget>\n): Readonly<ShallowRef<AssembledToolCall[]>> {\n  const namespace = computed(() => resolveNamespace(toValue(target)));\n  if (isRoot(namespace.value)) return stream.toolCalls;\n  const key = computed(() => `toolCalls|${namespaceKey(namespace.value)}`);\n  return useProjection<AssembledToolCall[]>(\n    getRegistry(stream),\n    () => toolCallsProjection(namespace.value),\n    key,\n    EMPTY_TOOLCALLS\n  );\n}\n\nconst EMPTY_TOOLCALLS: AssembledToolCall[] = [];\n\n/**\n * Subscribe to a scoped `values` stream — the most recent state\n * payload for a namespace. At the root returns `stream.values`.\n *\n * Typing:\n *  - **Root** (`useValues(stream)`): returns the `StateType` declared\n *    on `useStream<State>()` — non-nullable (the root snapshot always\n *    has values, falling back to `initialValues ?? {}`).\n *  - **Scoped** (`useValues(stream, target)`): scoped payloads can\n *    differ from the root state; callers should annotate the\n *    expected shape explicitly (`useValues<SubagentState>(stream,\n *    sub)`). Defaults to `unknown` when not annotated.\n */\nexport function useValues<StateType extends object>(\n  stream: StreamHandle<StateType>\n): Readonly<ShallowRef<StateType>>;\nexport function useValues<T>(\n  stream: AnyStream\n): Readonly<ShallowRef<InferStateType<T>>>;\nexport function useValues<T = unknown>(\n  stream: AnyStream,\n  target: SelectorTarget,\n  options?: { messagesKey?: string }\n): Readonly<ShallowRef<T | undefined>>;\nexport function useValues(\n  stream: AnyStream,\n  target?: SelectorTarget,\n  options?: { messagesKey?: string }\n): Readonly<ShallowRef<unknown>> {\n  const namespace = resolveNamespace(target);\n  if (isRoot(namespace)) return stream.values as Readonly<ShallowRef<unknown>>;\n  const messagesKey = options?.messagesKey ?? \"messages\";\n  const key = `values|${messagesKey}|${namespaceKey(namespace)}`;\n  return useProjection<unknown>(\n    getRegistry(stream),\n    () => valuesProjection<unknown>(namespace, messagesKey),\n    key,\n    undefined\n  );\n}\n\n/**\n * Subscribe to a `custom:<name>` stream extension — most-recent\n * payload emitted by the transformer, scoped to the target namespace.\n */\nexport function useExtension<T = unknown>(\n  stream: AnyStream,\n  name: string,\n  target?: SelectorTarget\n): Readonly<ShallowRef<T | undefined>> {\n  const namespace = resolveNamespace(target);\n  const key = `extension|${name}|${namespaceKey(namespace)}`;\n  return useProjection<T | undefined>(\n    getRegistry(stream),\n    () => extensionProjection<T>(name, namespace),\n    key,\n    undefined\n  );\n}\n\n/**\n * Raw-events escape hatch. Subscribes to one or more channels at a\n * namespace and returns a bounded buffer of raw protocol events.\n * Prefer {@link useMessages} / {@link useToolCalls} / {@link useValues}\n * for the common cases.\n */\nexport type UseChannelOptions = ChannelProjectionOptions;\n\nexport function useChannel(\n  stream: AnyStream,\n  channels: readonly Channel[],\n  target?: SelectorTarget,\n  options?: UseChannelOptions\n): Readonly<ShallowRef<Event[]>> {\n  const namespace = resolveNamespace(target);\n  const sortedChannels = [...channels].sort().join(\",\");\n  const key = `channel|${options?.bufferSize ?? \"default\"}|${(options?.replay ?? true) ? \"replay\" : \"live\"}|${sortedChannels}|${namespaceKey(namespace)}`;\n  return useProjection<Event[]>(\n    getRegistry(stream),\n    () => channelProjection(channels, namespace, options),\n    key,\n    EMPTY_EVENTS\n  );\n}\n\nconst EMPTY_EVENTS: Event[] = [];\n\n/**\n * Subscribe to a scoped audio-media stream. Each handle is yielded\n * on its first matching `content-block-start`, exposes\n * `.partialBytes` for live access, settles `.blob` / `.objectURL` /\n * `.transcript` on `message-finish`, and surfaces errors via\n * `.error`.\n */\nexport function useAudio(\n  stream: AnyStream,\n  target?: SelectorTarget\n): Readonly<ShallowRef<AudioMedia[]>> {\n  const namespace = resolveNamespace(target);\n  const key = `audio|${namespaceKey(namespace)}`;\n  return useProjection<AudioMedia[]>(\n    getRegistry(stream),\n    () => audioProjection(namespace),\n    key,\n    EMPTY_AUDIO\n  );\n}\n\nconst EMPTY_AUDIO: AudioMedia[] = [];\n\n/**\n * Subscribe to a scoped image-media stream. Pair with\n * {@link useMediaURL} for `<img src>`.\n */\nexport function useImages(\n  stream: AnyStream,\n  target?: SelectorTarget\n): Readonly<ShallowRef<ImageMedia[]>> {\n  const namespace = resolveNamespace(target);\n  const key = `images|${namespaceKey(namespace)}`;\n  return useProjection<ImageMedia[]>(\n    getRegistry(stream),\n    () => imagesProjection(namespace),\n    key,\n    EMPTY_IMAGES\n  );\n}\n\nconst EMPTY_IMAGES: ImageMedia[] = [];\n\n/**\n * Subscribe to a scoped video-media stream. Pair with\n * {@link useMediaURL} for `<video src>`.\n */\nexport function useVideo(\n  stream: AnyStream,\n  target?: SelectorTarget\n): Readonly<ShallowRef<VideoMedia[]>> {\n  const namespace = resolveNamespace(target);\n  const key = `video|${namespaceKey(namespace)}`;\n  return useProjection<VideoMedia[]>(\n    getRegistry(stream),\n    () => videoProjection(namespace),\n    key,\n    EMPTY_VIDEO\n  );\n}\n\nconst EMPTY_VIDEO: VideoMedia[] = [];\n\n/**\n * Subscribe to a scoped file-media stream. Pair with\n * {@link useMediaURL} for an `<a download href>` target.\n */\nexport function useFiles(\n  stream: AnyStream,\n  target?: SelectorTarget\n): Readonly<ShallowRef<FileMedia[]>> {\n  const namespace = resolveNamespace(target);\n  const key = `files|${namespaceKey(namespace)}`;\n  return useProjection<FileMedia[]>(\n    getRegistry(stream),\n    () => filesProjection(namespace),\n    key,\n    EMPTY_FILES\n  );\n}\n\nconst EMPTY_FILES: FileMedia[] = [];\n\n/**\n * Read metadata recorded for a specific message id — today exposes\n * `parentCheckpointId`, the checkpoint the message was first seen on.\n * Designed for fork / edit flows:\n *\n * ```ts\n * const meta = useMessageMetadata(stream, () => msg.id);\n * // meta.value?.parentCheckpointId\n * ```\n *\n * `messageId` accepts a raw string, a `Ref<string | undefined>`, or\n * a getter — the binding re-evaluates whenever the id changes.\n */\nexport function useMessageMetadata(\n  stream: AnyStream,\n  messageId: MaybeRefOrGetter<string | undefined>\n): ComputedRef<MessageMetadata | undefined> {\n  const store = stream[STREAM_CONTROLLER].messageMetadataStore;\n  const mapRef = shallowRef<MessageMetadataMap>(store.getSnapshot());\n  const unsubscribe = store.subscribe(() => {\n    mapRef.value = store.getSnapshot();\n  });\n  onScopeDispose(unsubscribe);\n\n  return computed<MessageMetadata | undefined>(() => {\n    const key = toValue(messageId);\n    if (key == null) return undefined;\n    return mapRef.value.get(key);\n  });\n}\n\n/**\n * Reactive handle on the server-side submission queue.\n *\n * Populated when `submit()` is invoked with\n * `multitaskStrategy: \"enqueue\"` while another run is in flight. The\n * returned refs are shared per call — safe to pass into `v-for`.\n */\nexport interface UseSubmissionQueueReturn<\n  StateType extends object = Record<string, unknown>,\n> {\n  readonly entries: Readonly<ShallowRef<SubmissionQueueSnapshot<StateType>>>;\n  readonly size: ComputedRef<number>;\n  cancel(id: string): Promise<boolean>;\n  clear(): Promise<void>;\n}\n\nexport function useSubmissionQueue<StateType extends object>(\n  stream: StreamHandle<StateType>\n): UseSubmissionQueueReturn<StateType>;\nexport function useSubmissionQueue(stream: AnyStream): UseSubmissionQueueReturn;\nexport function useSubmissionQueue(\n  stream: AnyStream\n): UseSubmissionQueueReturn {\n  const controller = stream[STREAM_CONTROLLER];\n  const store = controller.queueStore;\n  const entries = shallowRef<SubmissionQueueSnapshot>(store.getSnapshot());\n  const unsubscribe = store.subscribe(() => {\n    entries.value = store.getSnapshot();\n  });\n  onScopeDispose(unsubscribe);\n\n  return {\n    entries: readonly(entries) as Readonly<ShallowRef<SubmissionQueueSnapshot>>,\n    size: computed(() => entries.value.length),\n    cancel: (id) => controller.cancelQueued(id),\n    clear: () => controller.clearQueue(),\n  };\n}\n\nexport type { SubmissionQueueEntry, SubmissionQueueSnapshot };\n"],"mappings":"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"}

package/dist/selectors.d.cts

@@ -1,7 +1,7 @@
 import { AnyStream, UseStreamReturn } from "./use-stream.cjs";
 import { ComputedRef, MaybeRefOrGetter, ShallowRef } from "vue";
 import { BaseMessage } from "@langchain/core/messages";
-import { AssembledToolCall, AudioMedia, Channel, ChannelProjectionOptions, Event, FileMedia, ImageMedia, InferStateType, MessageMetadata, SubagentDiscoverySnapshot, SubgraphDiscoverySnapshot, SubmissionQueueEntry, SubmissionQueueSnapshot, VideoMedia } from "@langchain/langgraph-sdk/stream";
+import { AssembledToolCall, AudioMedia, Channel, ChannelProjectionOptions, Event, FileMedia, ImageMedia, InferStateType, InferToolCalls, MessageMetadata, SubagentDiscoverySnapshot, SubgraphDiscoverySnapshot, SubmissionQueueEntry, SubmissionQueueSnapshot, VideoMedia } from "@langchain/langgraph-sdk/stream";
 
 //#region src/selectors.d.ts
 /**
@@ -45,6 +45,7 @@ declare function useMessages(stream: AnyStream, target?: MaybeRefOrGetter<Select
  * `stream.toolCalls` directly.
  */
 declare function useToolCalls(stream: AnyStream, target?: MaybeRefOrGetter<SelectorTarget>): Readonly<ShallowRef<AssembledToolCall[]>>;
+declare function useToolCalls<T>(stream: AnyStream, target?: MaybeRefOrGetter<SelectorTarget>): Readonly<ShallowRef<InferToolCalls<T>[]>>;
 /**
  * Subscribe to a scoped `values` stream — the most recent state
  * payload for a namespace. At the root returns `stream.values`.

package/dist/selectors.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"selectors.d.cts","names":[],"sources":["../src/selectors.ts"],"mappings":";;;;;;;;AA2CyB;;;;KAUpB,YAAA,6BAAyC,eAAA,CAC5C,SAAA;;;;;AAgBF;;;;;KAAY,cAAA;EAIN,SAAA;AAAA,IACF,yBAAA,GACA,yBAAA;;AAkCJ;;;;;;;;;;;;;;iBAAgB,WAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,gBAAA,CAAiB,cAAA,IACzB,QAAA,CAAS,UAAA,CAAW,WAAA;;;;;;iBAmBP,YAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,gBAAA,CAAiB,cAAA,IACzB,QAAA,CAAS,UAAA,CAAW,iBAAA;AAHvB;;;;;;;;;;;;;AAAA,iBA8BgB,SAAA,0BAAA,CACd,MAAA,EAAQ,YAAA,CAAa,SAAA,IACpB,QAAA,CAAS,UAAA,CAAW,SAAA;AAAA,iBACP,SAAA,GAAA,CACd,MAAA,EAAQ,SAAA,GACP,QAAA,CAAS,UAAA,CAAW,cAAA,CAAe,CAAA;AAAA,iBACtB,SAAA,aAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,EAAQ,cAAA,EACR,OAAA;EAAY,WAAA;AAAA,IACX,QAAA,CAAS,UAAA,CAAW,CAAA;;;;AAVvB;iBAgCgB,YAAA,aAAA,CACd,MAAA,EAAQ,SAAA,EACR,IAAA,UACA,MAAA,GAAS,cAAA,GACR,QAAA,CAAS,UAAA,CAAW,CAAA;;;;;;;KAiBX,iBAAA,GAAoB,wBAAA;AAAA,iBAEhB,UAAA,CACd,MAAA,EAAQ,SAAA,EACR,QAAA,WAAmB,OAAA,IACnB,MAAA,GAAS,cAAA,EACT,OAAA,GAAU,iBAAA,GACT,QAAA,CAAS,UAAA,CAAW,KAAA;;;;;;;;iBAqBP,QAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,cAAA,GACR,QAAA,CAAS,UAAA,CAAW,UAAA;;AAjFvB;;;iBAkGgB,SAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,cAAA,GACR,QAAA,CAAS,UAAA,CAAW,UAAA;;;;;iBAiBP,QAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,cAAA,GACR,QAAA,CAAS,UAAA,CAAW,UAAA;;;;;iBAiBP,QAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,cAAA,GACR,QAAA,CAAS,UAAA,CAAW,SAAA;;;;;;AA1IvB;;;;;;;;iBAoKgB,kBAAA,CACd,MAAA,EAAQ,SAAA,EACR,SAAA,EAAW,gBAAA,uBACV,WAAA,CAAY,eAAA;;;;;;;;UAsBE,wBAAA,4BACY,MAAA;EAAA,SAElB,OAAA,EAAS,QAAA,CAAS,UAAA,CAAW,uBAAA,CAAwB,SAAA;EAAA,SACrD,IAAA,EAAM,WAAA;EACf,MAAA,CAAO,EAAA,WAAa,OAAA;EACpB,KAAA,IAAS,OAAA;AAAA;AAAA,iBAGK,kBAAA,0BAAA,CACd,MAAA,EAAQ,YAAA,CAAa,SAAA,IACpB,wBAAA,CAAyB,SAAA;AAAA,iBACZ,kBAAA,CAAmB,MAAA,EAAQ,SAAA,GAAY,wBAAA"}
+{"version":3,"file":"selectors.d.cts","names":[],"sources":["../src/selectors.ts"],"mappings":";;;;;;;;AA4CyB;;;;KAUpB,YAAA,6BAAyC,eAAA,CAC5C,SAAA;;;;;AAgBF;;;;;KAAY,cAAA;EAIN,SAAA;AAAA,IACF,yBAAA,GACA,yBAAA;;AAkCJ;;;;;;;;;;;;;;iBAAgB,WAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,gBAAA,CAAiB,cAAA,IACzB,QAAA,CAAS,UAAA,CAAW,WAAA;;;;;;iBAmBP,YAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,gBAAA,CAAiB,cAAA,IACzB,QAAA,CAAS,UAAA,CAAW,iBAAA;AAAA,iBACP,YAAA,GAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,gBAAA,CAAiB,cAAA,IACzB,QAAA,CAAS,UAAA,CAAW,cAAA,CAAe,CAAA;;;;;;;;;;;;;;iBA+BtB,SAAA,0BAAA,CACd,MAAA,EAAQ,YAAA,CAAa,SAAA,IACpB,QAAA,CAAS,UAAA,CAAW,SAAA;AAAA,iBACP,SAAA,GAAA,CACd,MAAA,EAAQ,SAAA,GACP,QAAA,CAAS,UAAA,CAAW,cAAA,CAAe,CAAA;AAAA,iBACtB,SAAA,aAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,EAAQ,cAAA,EACR,OAAA;EAAY,WAAA;AAAA,IACX,QAAA,CAAS,UAAA,CAAW,CAAA;;;AA5CvB;;iBAkEgB,YAAA,aAAA,CACd,MAAA,EAAQ,SAAA,EACR,IAAA,UACA,MAAA,GAAS,cAAA,GACR,QAAA,CAAS,UAAA,CAAW,CAAA;;;;;;;KAiBX,iBAAA,GAAoB,wBAAA;AAAA,iBAEhB,UAAA,CACd,MAAA,EAAQ,SAAA,EACR,QAAA,WAAmB,OAAA,IACnB,MAAA,GAAS,cAAA,EACT,OAAA,GAAU,iBAAA,GACT,QAAA,CAAS,UAAA,CAAW,KAAA;;;;;;;;iBAqBP,QAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,cAAA,GACR,QAAA,CAAS,UAAA,CAAW,UAAA;;;;;iBAiBP,SAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,cAAA,GACR,QAAA,CAAS,UAAA,CAAW,UAAA;AAxGvB;;;;AAAA,iBAyHgB,QAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,cAAA,GACR,QAAA,CAAS,UAAA,CAAW,UAAA;;;;;iBAiBP,QAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,cAAA,GACR,QAAA,CAAS,UAAA,CAAW,SAAA;;;;;;;;;;AA7IvB;;;;iBAuKgB,kBAAA,CACd,MAAA,EAAQ,SAAA,EACR,SAAA,EAAW,gBAAA,uBACV,WAAA,CAAY,eAAA;;;;;;;;UAsBE,wBAAA,4BACY,MAAA;EAAA,SAElB,OAAA,EAAS,QAAA,CAAS,UAAA,CAAW,uBAAA,CAAwB,SAAA;EAAA,SACrD,IAAA,EAAM,WAAA;EACf,MAAA,CAAO,EAAA,WAAa,OAAA;EACpB,KAAA,IAAS,OAAA;AAAA;AAAA,iBAGK,kBAAA,0BAAA,CACd,MAAA,EAAQ,YAAA,CAAa,SAAA,IACpB,wBAAA,CAAyB,SAAA;AAAA,iBACZ,kBAAA,CAAmB,MAAA,EAAQ,SAAA,GAAY,wBAAA"}

package/dist/selectors.d.ts

@@ -1,6 +1,6 @@
 import { AnyStream, UseStreamReturn } from "./use-stream.js";
 import { ComputedRef, MaybeRefOrGetter, ShallowRef } from "vue";
-import { AssembledToolCall, AudioMedia, Channel, ChannelProjectionOptions, Event, FileMedia, ImageMedia, InferStateType, MessageMetadata, SubagentDiscoverySnapshot, SubgraphDiscoverySnapshot, SubmissionQueueEntry, SubmissionQueueSnapshot, VideoMedia } from "@langchain/langgraph-sdk/stream";
+import { AssembledToolCall, AudioMedia, Channel, ChannelProjectionOptions, Event, FileMedia, ImageMedia, InferStateType, InferToolCalls, MessageMetadata, SubagentDiscoverySnapshot, SubgraphDiscoverySnapshot, SubmissionQueueEntry, SubmissionQueueSnapshot, VideoMedia } from "@langchain/langgraph-sdk/stream";
 import { BaseMessage } from "@langchain/core/messages";
 
 //#region src/selectors.d.ts
@@ -45,6 +45,7 @@ declare function useMessages(stream: AnyStream, target?: MaybeRefOrGetter<Select
  * `stream.toolCalls` directly.
  */
 declare function useToolCalls(stream: AnyStream, target?: MaybeRefOrGetter<SelectorTarget>): Readonly<ShallowRef<AssembledToolCall[]>>;
+declare function useToolCalls<T>(stream: AnyStream, target?: MaybeRefOrGetter<SelectorTarget>): Readonly<ShallowRef<InferToolCalls<T>[]>>;
 /**
  * Subscribe to a scoped `values` stream — the most recent state
  * payload for a namespace. At the root returns `stream.values`.

package/dist/selectors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"selectors.d.ts","names":[],"sources":["../src/selectors.ts"],"mappings":";;;;;;;;AA2CyB;;;;KAUpB,YAAA,6BAAyC,eAAA,CAC5C,SAAA;;;;;AAgBF;;;;;KAAY,cAAA;EAIN,SAAA;AAAA,IACF,yBAAA,GACA,yBAAA;;AAkCJ;;;;;;;;;;;;;;iBAAgB,WAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,gBAAA,CAAiB,cAAA,IACzB,QAAA,CAAS,UAAA,CAAW,WAAA;;;;;;iBAmBP,YAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,gBAAA,CAAiB,cAAA,IACzB,QAAA,CAAS,UAAA,CAAW,iBAAA;AAHvB;;;;;;;;;;;;;AAAA,iBA8BgB,SAAA,0BAAA,CACd,MAAA,EAAQ,YAAA,CAAa,SAAA,IACpB,QAAA,CAAS,UAAA,CAAW,SAAA;AAAA,iBACP,SAAA,GAAA,CACd,MAAA,EAAQ,SAAA,GACP,QAAA,CAAS,UAAA,CAAW,cAAA,CAAe,CAAA;AAAA,iBACtB,SAAA,aAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,EAAQ,cAAA,EACR,OAAA;EAAY,WAAA;AAAA,IACX,QAAA,CAAS,UAAA,CAAW,CAAA;;;;AAVvB;iBAgCgB,YAAA,aAAA,CACd,MAAA,EAAQ,SAAA,EACR,IAAA,UACA,MAAA,GAAS,cAAA,GACR,QAAA,CAAS,UAAA,CAAW,CAAA;;;;;;;KAiBX,iBAAA,GAAoB,wBAAA;AAAA,iBAEhB,UAAA,CACd,MAAA,EAAQ,SAAA,EACR,QAAA,WAAmB,OAAA,IACnB,MAAA,GAAS,cAAA,EACT,OAAA,GAAU,iBAAA,GACT,QAAA,CAAS,UAAA,CAAW,KAAA;;;;;;;;iBAqBP,QAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,cAAA,GACR,QAAA,CAAS,UAAA,CAAW,UAAA;;AAjFvB;;;iBAkGgB,SAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,cAAA,GACR,QAAA,CAAS,UAAA,CAAW,UAAA;;;;;iBAiBP,QAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,cAAA,GACR,QAAA,CAAS,UAAA,CAAW,UAAA;;;;;iBAiBP,QAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,cAAA,GACR,QAAA,CAAS,UAAA,CAAW,SAAA;;;;;;AA1IvB;;;;;;;;iBAoKgB,kBAAA,CACd,MAAA,EAAQ,SAAA,EACR,SAAA,EAAW,gBAAA,uBACV,WAAA,CAAY,eAAA;;;;;;;;UAsBE,wBAAA,4BACY,MAAA;EAAA,SAElB,OAAA,EAAS,QAAA,CAAS,UAAA,CAAW,uBAAA,CAAwB,SAAA;EAAA,SACrD,IAAA,EAAM,WAAA;EACf,MAAA,CAAO,EAAA,WAAa,OAAA;EACpB,KAAA,IAAS,OAAA;AAAA;AAAA,iBAGK,kBAAA,0BAAA,CACd,MAAA,EAAQ,YAAA,CAAa,SAAA,IACpB,wBAAA,CAAyB,SAAA;AAAA,iBACZ,kBAAA,CAAmB,MAAA,EAAQ,SAAA,GAAY,wBAAA"}
+{"version":3,"file":"selectors.d.ts","names":[],"sources":["../src/selectors.ts"],"mappings":";;;;;;;;AA4CyB;;;;KAUpB,YAAA,6BAAyC,eAAA,CAC5C,SAAA;;;;;AAgBF;;;;;KAAY,cAAA;EAIN,SAAA;AAAA,IACF,yBAAA,GACA,yBAAA;;AAkCJ;;;;;;;;;;;;;;iBAAgB,WAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,gBAAA,CAAiB,cAAA,IACzB,QAAA,CAAS,UAAA,CAAW,WAAA;;;;;;iBAmBP,YAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,gBAAA,CAAiB,cAAA,IACzB,QAAA,CAAS,UAAA,CAAW,iBAAA;AAAA,iBACP,YAAA,GAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,gBAAA,CAAiB,cAAA,IACzB,QAAA,CAAS,UAAA,CAAW,cAAA,CAAe,CAAA;;;;;;;;;;;;;;iBA+BtB,SAAA,0BAAA,CACd,MAAA,EAAQ,YAAA,CAAa,SAAA,IACpB,QAAA,CAAS,UAAA,CAAW,SAAA;AAAA,iBACP,SAAA,GAAA,CACd,MAAA,EAAQ,SAAA,GACP,QAAA,CAAS,UAAA,CAAW,cAAA,CAAe,CAAA;AAAA,iBACtB,SAAA,aAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,EAAQ,cAAA,EACR,OAAA;EAAY,WAAA;AAAA,IACX,QAAA,CAAS,UAAA,CAAW,CAAA;;;AA5CvB;;iBAkEgB,YAAA,aAAA,CACd,MAAA,EAAQ,SAAA,EACR,IAAA,UACA,MAAA,GAAS,cAAA,GACR,QAAA,CAAS,UAAA,CAAW,CAAA;;;;;;;KAiBX,iBAAA,GAAoB,wBAAA;AAAA,iBAEhB,UAAA,CACd,MAAA,EAAQ,SAAA,EACR,QAAA,WAAmB,OAAA,IACnB,MAAA,GAAS,cAAA,EACT,OAAA,GAAU,iBAAA,GACT,QAAA,CAAS,UAAA,CAAW,KAAA;;;;;;;;iBAqBP,QAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,cAAA,GACR,QAAA,CAAS,UAAA,CAAW,UAAA;;;;;iBAiBP,SAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,cAAA,GACR,QAAA,CAAS,UAAA,CAAW,UAAA;AAxGvB;;;;AAAA,iBAyHgB,QAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,cAAA,GACR,QAAA,CAAS,UAAA,CAAW,UAAA;;;;;iBAiBP,QAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,cAAA,GACR,QAAA,CAAS,UAAA,CAAW,SAAA;;;;;;;;;;AA7IvB;;;;iBAuKgB,kBAAA,CACd,MAAA,EAAQ,SAAA,EACR,SAAA,EAAW,gBAAA,uBACV,WAAA,CAAY,eAAA;;;;;;;;UAsBE,wBAAA,4BACY,MAAA;EAAA,SAElB,OAAA,EAAS,QAAA,CAAS,UAAA,CAAW,uBAAA,CAAwB,SAAA;EAAA,SACrD,IAAA,EAAM,WAAA;EACf,MAAA,CAAO,EAAA,WAAa,OAAA;EACpB,KAAA,IAAS,OAAA;AAAA;AAAA,iBAGK,kBAAA,0BAAA,CACd,MAAA,EAAQ,YAAA,CAAa,SAAA,IACpB,wBAAA,CAAyB,SAAA;AAAA,iBACZ,kBAAA,CAAmB,MAAA,EAAQ,SAAA,GAAY,wBAAA"}

package/dist/selectors.js

@@ -37,11 +37,6 @@ function useMessages(stream, target) {
 	return useProjection(getRegistry(stream), () => messagesProjection(namespace.value), key, EMPTY_MESSAGES);
 }
 const EMPTY_MESSAGES = [];
-/**
-* Subscribe to a scoped `tools` (tool-call) stream. Same target and
-* lifecycle rules as {@link useMessages}; at the root this returns
-* `stream.toolCalls` directly.
-*/
 function useToolCalls(stream, target) {
 	const namespace = computed(() => resolveNamespace(toValue(target)));
 	if (isRoot(namespace.value)) return stream.toolCalls;

package/dist/selectors.js.map

@@ -1 +1 @@
-{"version":3,"file":"selectors.js","names":[],"sources":["../src/selectors.ts"],"sourcesContent":["import {\n  computed,\n  onScopeDispose,\n  readonly,\n  shallowRef,\n  toValue,\n  type ComputedRef,\n  type MaybeRefOrGetter,\n  type ShallowRef,\n} from \"vue\";\nimport type { BaseMessage } from \"@langchain/core/messages\";\nimport {\n  NAMESPACE_SEPARATOR,\n  audioProjection,\n  channelProjection,\n  extensionProjection,\n  filesProjection,\n  imagesProjection,\n  messagesProjection,\n  toolCallsProjection,\n  valuesProjection,\n  videoProjection,\n  type AssembledToolCall,\n  type AudioMedia,\n  type Channel,\n  type ChannelProjectionOptions,\n  type Event,\n  type FileMedia,\n  type ImageMedia,\n  type InferStateType,\n  type MessageMetadata,\n  type MessageMetadataMap,\n  type SubagentDiscoverySnapshot,\n  type SubgraphDiscoverySnapshot,\n  type SubmissionQueueEntry,\n  type SubmissionQueueSnapshot,\n  type VideoMedia,\n} from \"@langchain/langgraph-sdk/stream\";\nimport {\n  getRegistry,\n  STREAM_CONTROLLER,\n  type AnyStream,\n  type UseStreamReturn,\n} from \"./use-stream.js\";\nimport { useProjection } from \"./use-projection.js\";\n\n/**\n * Selector composables don't need to carry `InterruptType` /\n * `ConfigurableType`. Parameterising on `StateType` alone lets\n * callers with a full `useStream<S, I, C>()` handle pass it in without\n * redeclaring those generics at every call site.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype StreamHandle<StateType extends object> = UseStreamReturn<\n  StateType,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  any,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  any\n>;\n\n/**\n * What a selector composable can be targeted at. Callers can pass:\n *  - `undefined` / `null` — root namespace (served by the always-on\n *    root store — no extra subscription);\n *  - a {@link SubagentDiscoverySnapshot} (`stream.subagents.value.get(...)`);\n *  - a {@link SubgraphDiscoverySnapshot} (`stream.subgraphs.value.get(...)`);\n *  - an explicit `{ namespace: string[] }`;\n *  - a raw `string[]` escape hatch.\n */\nexport type SelectorTarget =\n  | undefined\n  | null\n  | readonly string[]\n  | { namespace: readonly string[] }\n  | SubagentDiscoverySnapshot\n  | SubgraphDiscoverySnapshot;\n\nconst EMPTY_NAMESPACE: readonly string[] = [];\n\nfunction resolveNamespace(target: SelectorTarget): readonly string[] {\n  if (target == null) return EMPTY_NAMESPACE;\n  if (Array.isArray(target)) return target as readonly string[];\n  const obj = target as { namespace?: readonly string[] };\n  return obj.namespace ?? EMPTY_NAMESPACE;\n}\n\nfunction isRoot(namespace: readonly string[]): boolean {\n  return namespace.length === 0;\n}\n\nfunction namespaceKey(namespace: readonly string[]): string {\n  return namespace.join(NAMESPACE_SEPARATOR);\n}\n\n/**\n * Subscribe to a scoped `messages` stream.\n *\n * Contract:\n *  - At the root (no `target`) this returns `stream.messages` — the\n *    always-on root projection; no extra subscription is opened.\n *  - For any non-root namespace, mount triggers a ref-counted\n *    `messages` subscription scoped to that namespace. The\n *    subscription is released automatically when the calling scope\n *    disappears (and the registry closes the underlying server\n *    subscription when the last consumer leaves).\n *\n * Messages are always `BaseMessage` class instances from\n * `@langchain/core/messages`.\n */\nexport function useMessages(\n  stream: AnyStream,\n  target?: MaybeRefOrGetter<SelectorTarget>\n): Readonly<ShallowRef<BaseMessage[]>> {\n  const namespace = computed(() => resolveNamespace(toValue(target)));\n  if (isRoot(namespace.value)) return stream.messages;\n  const key = computed(() => `messages|${namespaceKey(namespace.value)}`);\n  return useProjection<BaseMessage[]>(\n    getRegistry(stream),\n    () => messagesProjection(namespace.value),\n    key,\n    EMPTY_MESSAGES\n  );\n}\n\nconst EMPTY_MESSAGES: BaseMessage[] = [];\n\n/**\n * Subscribe to a scoped `tools` (tool-call) stream. Same target and\n * lifecycle rules as {@link useMessages}; at the root this returns\n * `stream.toolCalls` directly.\n */\nexport function useToolCalls(\n  stream: AnyStream,\n  target?: MaybeRefOrGetter<SelectorTarget>\n): Readonly<ShallowRef<AssembledToolCall[]>> {\n  const namespace = computed(() => resolveNamespace(toValue(target)));\n  if (isRoot(namespace.value)) return stream.toolCalls;\n  const key = computed(() => `toolCalls|${namespaceKey(namespace.value)}`);\n  return useProjection<AssembledToolCall[]>(\n    getRegistry(stream),\n    () => toolCallsProjection(namespace.value),\n    key,\n    EMPTY_TOOLCALLS\n  );\n}\n\nconst EMPTY_TOOLCALLS: AssembledToolCall[] = [];\n\n/**\n * Subscribe to a scoped `values` stream — the most recent state\n * payload for a namespace. At the root returns `stream.values`.\n *\n * Typing:\n *  - **Root** (`useValues(stream)`): returns the `StateType` declared\n *    on `useStream<State>()` — non-nullable (the root snapshot always\n *    has values, falling back to `initialValues ?? {}`).\n *  - **Scoped** (`useValues(stream, target)`): scoped payloads can\n *    differ from the root state; callers should annotate the\n *    expected shape explicitly (`useValues<SubagentState>(stream,\n *    sub)`). Defaults to `unknown` when not annotated.\n */\nexport function useValues<StateType extends object>(\n  stream: StreamHandle<StateType>\n): Readonly<ShallowRef<StateType>>;\nexport function useValues<T>(\n  stream: AnyStream\n): Readonly<ShallowRef<InferStateType<T>>>;\nexport function useValues<T = unknown>(\n  stream: AnyStream,\n  target: SelectorTarget,\n  options?: { messagesKey?: string }\n): Readonly<ShallowRef<T | undefined>>;\nexport function useValues(\n  stream: AnyStream,\n  target?: SelectorTarget,\n  options?: { messagesKey?: string }\n): Readonly<ShallowRef<unknown>> {\n  const namespace = resolveNamespace(target);\n  if (isRoot(namespace)) return stream.values as Readonly<ShallowRef<unknown>>;\n  const messagesKey = options?.messagesKey ?? \"messages\";\n  const key = `values|${messagesKey}|${namespaceKey(namespace)}`;\n  return useProjection<unknown>(\n    getRegistry(stream),\n    () => valuesProjection<unknown>(namespace, messagesKey),\n    key,\n    undefined\n  );\n}\n\n/**\n * Subscribe to a `custom:<name>` stream extension — most-recent\n * payload emitted by the transformer, scoped to the target namespace.\n */\nexport function useExtension<T = unknown>(\n  stream: AnyStream,\n  name: string,\n  target?: SelectorTarget\n): Readonly<ShallowRef<T | undefined>> {\n  const namespace = resolveNamespace(target);\n  const key = `extension|${name}|${namespaceKey(namespace)}`;\n  return useProjection<T | undefined>(\n    getRegistry(stream),\n    () => extensionProjection<T>(name, namespace),\n    key,\n    undefined\n  );\n}\n\n/**\n * Raw-events escape hatch. Subscribes to one or more channels at a\n * namespace and returns a bounded buffer of raw protocol events.\n * Prefer {@link useMessages} / {@link useToolCalls} / {@link useValues}\n * for the common cases.\n */\nexport type UseChannelOptions = ChannelProjectionOptions;\n\nexport function useChannel(\n  stream: AnyStream,\n  channels: readonly Channel[],\n  target?: SelectorTarget,\n  options?: UseChannelOptions\n): Readonly<ShallowRef<Event[]>> {\n  const namespace = resolveNamespace(target);\n  const sortedChannels = [...channels].sort().join(\",\");\n  const key = `channel|${options?.bufferSize ?? \"default\"}|${(options?.replay ?? true) ? \"replay\" : \"live\"}|${sortedChannels}|${namespaceKey(namespace)}`;\n  return useProjection<Event[]>(\n    getRegistry(stream),\n    () => channelProjection(channels, namespace, options),\n    key,\n    EMPTY_EVENTS\n  );\n}\n\nconst EMPTY_EVENTS: Event[] = [];\n\n/**\n * Subscribe to a scoped audio-media stream. Each handle is yielded\n * on its first matching `content-block-start`, exposes\n * `.partialBytes` for live access, settles `.blob` / `.objectURL` /\n * `.transcript` on `message-finish`, and surfaces errors via\n * `.error`.\n */\nexport function useAudio(\n  stream: AnyStream,\n  target?: SelectorTarget\n): Readonly<ShallowRef<AudioMedia[]>> {\n  const namespace = resolveNamespace(target);\n  const key = `audio|${namespaceKey(namespace)}`;\n  return useProjection<AudioMedia[]>(\n    getRegistry(stream),\n    () => audioProjection(namespace),\n    key,\n    EMPTY_AUDIO\n  );\n}\n\nconst EMPTY_AUDIO: AudioMedia[] = [];\n\n/**\n * Subscribe to a scoped image-media stream. Pair with\n * {@link useMediaURL} for `<img src>`.\n */\nexport function useImages(\n  stream: AnyStream,\n  target?: SelectorTarget\n): Readonly<ShallowRef<ImageMedia[]>> {\n  const namespace = resolveNamespace(target);\n  const key = `images|${namespaceKey(namespace)}`;\n  return useProjection<ImageMedia[]>(\n    getRegistry(stream),\n    () => imagesProjection(namespace),\n    key,\n    EMPTY_IMAGES\n  );\n}\n\nconst EMPTY_IMAGES: ImageMedia[] = [];\n\n/**\n * Subscribe to a scoped video-media stream. Pair with\n * {@link useMediaURL} for `<video src>`.\n */\nexport function useVideo(\n  stream: AnyStream,\n  target?: SelectorTarget\n): Readonly<ShallowRef<VideoMedia[]>> {\n  const namespace = resolveNamespace(target);\n  const key = `video|${namespaceKey(namespace)}`;\n  return useProjection<VideoMedia[]>(\n    getRegistry(stream),\n    () => videoProjection(namespace),\n    key,\n    EMPTY_VIDEO\n  );\n}\n\nconst EMPTY_VIDEO: VideoMedia[] = [];\n\n/**\n * Subscribe to a scoped file-media stream. Pair with\n * {@link useMediaURL} for an `<a download href>` target.\n */\nexport function useFiles(\n  stream: AnyStream,\n  target?: SelectorTarget\n): Readonly<ShallowRef<FileMedia[]>> {\n  const namespace = resolveNamespace(target);\n  const key = `files|${namespaceKey(namespace)}`;\n  return useProjection<FileMedia[]>(\n    getRegistry(stream),\n    () => filesProjection(namespace),\n    key,\n    EMPTY_FILES\n  );\n}\n\nconst EMPTY_FILES: FileMedia[] = [];\n\n/**\n * Read metadata recorded for a specific message id — today exposes\n * `parentCheckpointId`, the checkpoint the message was first seen on.\n * Designed for fork / edit flows:\n *\n * ```ts\n * const meta = useMessageMetadata(stream, () => msg.id);\n * // meta.value?.parentCheckpointId\n * ```\n *\n * `messageId` accepts a raw string, a `Ref<string | undefined>`, or\n * a getter — the binding re-evaluates whenever the id changes.\n */\nexport function useMessageMetadata(\n  stream: AnyStream,\n  messageId: MaybeRefOrGetter<string | undefined>\n): ComputedRef<MessageMetadata | undefined> {\n  const store = stream[STREAM_CONTROLLER].messageMetadataStore;\n  const mapRef = shallowRef<MessageMetadataMap>(store.getSnapshot());\n  const unsubscribe = store.subscribe(() => {\n    mapRef.value = store.getSnapshot();\n  });\n  onScopeDispose(unsubscribe);\n\n  return computed<MessageMetadata | undefined>(() => {\n    const key = toValue(messageId);\n    if (key == null) return undefined;\n    return mapRef.value.get(key);\n  });\n}\n\n/**\n * Reactive handle on the server-side submission queue.\n *\n * Populated when `submit()` is invoked with\n * `multitaskStrategy: \"enqueue\"` while another run is in flight. The\n * returned refs are shared per call — safe to pass into `v-for`.\n */\nexport interface UseSubmissionQueueReturn<\n  StateType extends object = Record<string, unknown>,\n> {\n  readonly entries: Readonly<ShallowRef<SubmissionQueueSnapshot<StateType>>>;\n  readonly size: ComputedRef<number>;\n  cancel(id: string): Promise<boolean>;\n  clear(): Promise<void>;\n}\n\nexport function useSubmissionQueue<StateType extends object>(\n  stream: StreamHandle<StateType>\n): UseSubmissionQueueReturn<StateType>;\nexport function useSubmissionQueue(stream: AnyStream): UseSubmissionQueueReturn;\nexport function useSubmissionQueue(\n  stream: AnyStream\n): UseSubmissionQueueReturn {\n  const controller = stream[STREAM_CONTROLLER];\n  const store = controller.queueStore;\n  const entries = shallowRef<SubmissionQueueSnapshot>(store.getSnapshot());\n  const unsubscribe = store.subscribe(() => {\n    entries.value = store.getSnapshot();\n  });\n  onScopeDispose(unsubscribe);\n\n  return {\n    entries: readonly(entries) as Readonly<ShallowRef<SubmissionQueueSnapshot>>,\n    size: computed(() => entries.value.length),\n    cancel: (id) => controller.cancelQueued(id),\n    clear: () => controller.clearQueue(),\n  };\n}\n\nexport type { SubmissionQueueEntry, SubmissionQueueSnapshot };\n"],"mappings":"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"}
+{"version":3,"file":"selectors.js","names":[],"sources":["../src/selectors.ts"],"sourcesContent":["import {\n  computed,\n  onScopeDispose,\n  readonly,\n  shallowRef,\n  toValue,\n  type ComputedRef,\n  type MaybeRefOrGetter,\n  type ShallowRef,\n} from \"vue\";\nimport type { BaseMessage } from \"@langchain/core/messages\";\nimport {\n  NAMESPACE_SEPARATOR,\n  audioProjection,\n  channelProjection,\n  extensionProjection,\n  filesProjection,\n  imagesProjection,\n  messagesProjection,\n  toolCallsProjection,\n  valuesProjection,\n  videoProjection,\n  type AssembledToolCall,\n  type AudioMedia,\n  type Channel,\n  type ChannelProjectionOptions,\n  type Event,\n  type FileMedia,\n  type ImageMedia,\n  type InferToolCalls,\n  type InferStateType,\n  type MessageMetadata,\n  type MessageMetadataMap,\n  type SubagentDiscoverySnapshot,\n  type SubgraphDiscoverySnapshot,\n  type SubmissionQueueEntry,\n  type SubmissionQueueSnapshot,\n  type VideoMedia,\n} from \"@langchain/langgraph-sdk/stream\";\nimport {\n  getRegistry,\n  STREAM_CONTROLLER,\n  type AnyStream,\n  type UseStreamReturn,\n} from \"./use-stream.js\";\nimport { useProjection } from \"./use-projection.js\";\n\n/**\n * Selector composables don't need to carry `InterruptType` /\n * `ConfigurableType`. Parameterising on `StateType` alone lets\n * callers with a full `useStream<S, I, C>()` handle pass it in without\n * redeclaring those generics at every call site.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype StreamHandle<StateType extends object> = UseStreamReturn<\n  StateType,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  any,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  any\n>;\n\n/**\n * What a selector composable can be targeted at. Callers can pass:\n *  - `undefined` / `null` — root namespace (served by the always-on\n *    root store — no extra subscription);\n *  - a {@link SubagentDiscoverySnapshot} (`stream.subagents.value.get(...)`);\n *  - a {@link SubgraphDiscoverySnapshot} (`stream.subgraphs.value.get(...)`);\n *  - an explicit `{ namespace: string[] }`;\n *  - a raw `string[]` escape hatch.\n */\nexport type SelectorTarget =\n  | undefined\n  | null\n  | readonly string[]\n  | { namespace: readonly string[] }\n  | SubagentDiscoverySnapshot\n  | SubgraphDiscoverySnapshot;\n\nconst EMPTY_NAMESPACE: readonly string[] = [];\n\nfunction resolveNamespace(target: SelectorTarget): readonly string[] {\n  if (target == null) return EMPTY_NAMESPACE;\n  if (Array.isArray(target)) return target as readonly string[];\n  const obj = target as { namespace?: readonly string[] };\n  return obj.namespace ?? EMPTY_NAMESPACE;\n}\n\nfunction isRoot(namespace: readonly string[]): boolean {\n  return namespace.length === 0;\n}\n\nfunction namespaceKey(namespace: readonly string[]): string {\n  return namespace.join(NAMESPACE_SEPARATOR);\n}\n\n/**\n * Subscribe to a scoped `messages` stream.\n *\n * Contract:\n *  - At the root (no `target`) this returns `stream.messages` — the\n *    always-on root projection; no extra subscription is opened.\n *  - For any non-root namespace, mount triggers a ref-counted\n *    `messages` subscription scoped to that namespace. The\n *    subscription is released automatically when the calling scope\n *    disappears (and the registry closes the underlying server\n *    subscription when the last consumer leaves).\n *\n * Messages are always `BaseMessage` class instances from\n * `@langchain/core/messages`.\n */\nexport function useMessages(\n  stream: AnyStream,\n  target?: MaybeRefOrGetter<SelectorTarget>\n): Readonly<ShallowRef<BaseMessage[]>> {\n  const namespace = computed(() => resolveNamespace(toValue(target)));\n  if (isRoot(namespace.value)) return stream.messages;\n  const key = computed(() => `messages|${namespaceKey(namespace.value)}`);\n  return useProjection<BaseMessage[]>(\n    getRegistry(stream),\n    () => messagesProjection(namespace.value),\n    key,\n    EMPTY_MESSAGES\n  );\n}\n\nconst EMPTY_MESSAGES: BaseMessage[] = [];\n\n/**\n * Subscribe to a scoped `tools` (tool-call) stream. Same target and\n * lifecycle rules as {@link useMessages}; at the root this returns\n * `stream.toolCalls` directly.\n */\nexport function useToolCalls(\n  stream: AnyStream,\n  target?: MaybeRefOrGetter<SelectorTarget>\n): Readonly<ShallowRef<AssembledToolCall[]>>;\nexport function useToolCalls<T>(\n  stream: AnyStream,\n  target?: MaybeRefOrGetter<SelectorTarget>\n): Readonly<ShallowRef<InferToolCalls<T>[]>>;\nexport function useToolCalls(\n  stream: AnyStream,\n  target?: MaybeRefOrGetter<SelectorTarget>\n): Readonly<ShallowRef<AssembledToolCall[]>> {\n  const namespace = computed(() => resolveNamespace(toValue(target)));\n  if (isRoot(namespace.value)) return stream.toolCalls;\n  const key = computed(() => `toolCalls|${namespaceKey(namespace.value)}`);\n  return useProjection<AssembledToolCall[]>(\n    getRegistry(stream),\n    () => toolCallsProjection(namespace.value),\n    key,\n    EMPTY_TOOLCALLS\n  );\n}\n\nconst EMPTY_TOOLCALLS: AssembledToolCall[] = [];\n\n/**\n * Subscribe to a scoped `values` stream — the most recent state\n * payload for a namespace. At the root returns `stream.values`.\n *\n * Typing:\n *  - **Root** (`useValues(stream)`): returns the `StateType` declared\n *    on `useStream<State>()` — non-nullable (the root snapshot always\n *    has values, falling back to `initialValues ?? {}`).\n *  - **Scoped** (`useValues(stream, target)`): scoped payloads can\n *    differ from the root state; callers should annotate the\n *    expected shape explicitly (`useValues<SubagentState>(stream,\n *    sub)`). Defaults to `unknown` when not annotated.\n */\nexport function useValues<StateType extends object>(\n  stream: StreamHandle<StateType>\n): Readonly<ShallowRef<StateType>>;\nexport function useValues<T>(\n  stream: AnyStream\n): Readonly<ShallowRef<InferStateType<T>>>;\nexport function useValues<T = unknown>(\n  stream: AnyStream,\n  target: SelectorTarget,\n  options?: { messagesKey?: string }\n): Readonly<ShallowRef<T | undefined>>;\nexport function useValues(\n  stream: AnyStream,\n  target?: SelectorTarget,\n  options?: { messagesKey?: string }\n): Readonly<ShallowRef<unknown>> {\n  const namespace = resolveNamespace(target);\n  if (isRoot(namespace)) return stream.values as Readonly<ShallowRef<unknown>>;\n  const messagesKey = options?.messagesKey ?? \"messages\";\n  const key = `values|${messagesKey}|${namespaceKey(namespace)}`;\n  return useProjection<unknown>(\n    getRegistry(stream),\n    () => valuesProjection<unknown>(namespace, messagesKey),\n    key,\n    undefined\n  );\n}\n\n/**\n * Subscribe to a `custom:<name>` stream extension — most-recent\n * payload emitted by the transformer, scoped to the target namespace.\n */\nexport function useExtension<T = unknown>(\n  stream: AnyStream,\n  name: string,\n  target?: SelectorTarget\n): Readonly<ShallowRef<T | undefined>> {\n  const namespace = resolveNamespace(target);\n  const key = `extension|${name}|${namespaceKey(namespace)}`;\n  return useProjection<T | undefined>(\n    getRegistry(stream),\n    () => extensionProjection<T>(name, namespace),\n    key,\n    undefined\n  );\n}\n\n/**\n * Raw-events escape hatch. Subscribes to one or more channels at a\n * namespace and returns a bounded buffer of raw protocol events.\n * Prefer {@link useMessages} / {@link useToolCalls} / {@link useValues}\n * for the common cases.\n */\nexport type UseChannelOptions = ChannelProjectionOptions;\n\nexport function useChannel(\n  stream: AnyStream,\n  channels: readonly Channel[],\n  target?: SelectorTarget,\n  options?: UseChannelOptions\n): Readonly<ShallowRef<Event[]>> {\n  const namespace = resolveNamespace(target);\n  const sortedChannels = [...channels].sort().join(\",\");\n  const key = `channel|${options?.bufferSize ?? \"default\"}|${(options?.replay ?? true) ? \"replay\" : \"live\"}|${sortedChannels}|${namespaceKey(namespace)}`;\n  return useProjection<Event[]>(\n    getRegistry(stream),\n    () => channelProjection(channels, namespace, options),\n    key,\n    EMPTY_EVENTS\n  );\n}\n\nconst EMPTY_EVENTS: Event[] = [];\n\n/**\n * Subscribe to a scoped audio-media stream. Each handle is yielded\n * on its first matching `content-block-start`, exposes\n * `.partialBytes` for live access, settles `.blob` / `.objectURL` /\n * `.transcript` on `message-finish`, and surfaces errors via\n * `.error`.\n */\nexport function useAudio(\n  stream: AnyStream,\n  target?: SelectorTarget\n): Readonly<ShallowRef<AudioMedia[]>> {\n  const namespace = resolveNamespace(target);\n  const key = `audio|${namespaceKey(namespace)}`;\n  return useProjection<AudioMedia[]>(\n    getRegistry(stream),\n    () => audioProjection(namespace),\n    key,\n    EMPTY_AUDIO\n  );\n}\n\nconst EMPTY_AUDIO: AudioMedia[] = [];\n\n/**\n * Subscribe to a scoped image-media stream. Pair with\n * {@link useMediaURL} for `<img src>`.\n */\nexport function useImages(\n  stream: AnyStream,\n  target?: SelectorTarget\n): Readonly<ShallowRef<ImageMedia[]>> {\n  const namespace = resolveNamespace(target);\n  const key = `images|${namespaceKey(namespace)}`;\n  return useProjection<ImageMedia[]>(\n    getRegistry(stream),\n    () => imagesProjection(namespace),\n    key,\n    EMPTY_IMAGES\n  );\n}\n\nconst EMPTY_IMAGES: ImageMedia[] = [];\n\n/**\n * Subscribe to a scoped video-media stream. Pair with\n * {@link useMediaURL} for `<video src>`.\n */\nexport function useVideo(\n  stream: AnyStream,\n  target?: SelectorTarget\n): Readonly<ShallowRef<VideoMedia[]>> {\n  const namespace = resolveNamespace(target);\n  const key = `video|${namespaceKey(namespace)}`;\n  return useProjection<VideoMedia[]>(\n    getRegistry(stream),\n    () => videoProjection(namespace),\n    key,\n    EMPTY_VIDEO\n  );\n}\n\nconst EMPTY_VIDEO: VideoMedia[] = [];\n\n/**\n * Subscribe to a scoped file-media stream. Pair with\n * {@link useMediaURL} for an `<a download href>` target.\n */\nexport function useFiles(\n  stream: AnyStream,\n  target?: SelectorTarget\n): Readonly<ShallowRef<FileMedia[]>> {\n  const namespace = resolveNamespace(target);\n  const key = `files|${namespaceKey(namespace)}`;\n  return useProjection<FileMedia[]>(\n    getRegistry(stream),\n    () => filesProjection(namespace),\n    key,\n    EMPTY_FILES\n  );\n}\n\nconst EMPTY_FILES: FileMedia[] = [];\n\n/**\n * Read metadata recorded for a specific message id — today exposes\n * `parentCheckpointId`, the checkpoint the message was first seen on.\n * Designed for fork / edit flows:\n *\n * ```ts\n * const meta = useMessageMetadata(stream, () => msg.id);\n * // meta.value?.parentCheckpointId\n * ```\n *\n * `messageId` accepts a raw string, a `Ref<string | undefined>`, or\n * a getter — the binding re-evaluates whenever the id changes.\n */\nexport function useMessageMetadata(\n  stream: AnyStream,\n  messageId: MaybeRefOrGetter<string | undefined>\n): ComputedRef<MessageMetadata | undefined> {\n  const store = stream[STREAM_CONTROLLER].messageMetadataStore;\n  const mapRef = shallowRef<MessageMetadataMap>(store.getSnapshot());\n  const unsubscribe = store.subscribe(() => {\n    mapRef.value = store.getSnapshot();\n  });\n  onScopeDispose(unsubscribe);\n\n  return computed<MessageMetadata | undefined>(() => {\n    const key = toValue(messageId);\n    if (key == null) return undefined;\n    return mapRef.value.get(key);\n  });\n}\n\n/**\n * Reactive handle on the server-side submission queue.\n *\n * Populated when `submit()` is invoked with\n * `multitaskStrategy: \"enqueue\"` while another run is in flight. The\n * returned refs are shared per call — safe to pass into `v-for`.\n */\nexport interface UseSubmissionQueueReturn<\n  StateType extends object = Record<string, unknown>,\n> {\n  readonly entries: Readonly<ShallowRef<SubmissionQueueSnapshot<StateType>>>;\n  readonly size: ComputedRef<number>;\n  cancel(id: string): Promise<boolean>;\n  clear(): Promise<void>;\n}\n\nexport function useSubmissionQueue<StateType extends object>(\n  stream: StreamHandle<StateType>\n): UseSubmissionQueueReturn<StateType>;\nexport function useSubmissionQueue(stream: AnyStream): UseSubmissionQueueReturn;\nexport function useSubmissionQueue(\n  stream: AnyStream\n): UseSubmissionQueueReturn {\n  const controller = stream[STREAM_CONTROLLER];\n  const store = controller.queueStore;\n  const entries = shallowRef<SubmissionQueueSnapshot>(store.getSnapshot());\n  const unsubscribe = store.subscribe(() => {\n    entries.value = store.getSnapshot();\n  });\n  onScopeDispose(unsubscribe);\n\n  return {\n    entries: readonly(entries) as Readonly<ShallowRef<SubmissionQueueSnapshot>>,\n    size: computed(() => entries.value.length),\n    cancel: (id) => controller.cancelQueued(id),\n    clear: () => controller.clearQueue(),\n  };\n}\n\nexport type { SubmissionQueueEntry, SubmissionQueueSnapshot };\n"],"mappings":"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"}

package/dist/use-stream.cjs

@@ -72,6 +72,7 @@ function useStream(options) {
 		webSocketFactory: hasCustomAdapter ? void 0 : asBag.webSocketFactory,
 		onThreadId: options.onThreadId,
 		onCreated: options.onCreated,
+		onCompleted: options.onCompleted,
 		initialValues: options.initialValues,
 		messagesKey: options.messagesKey
 	});
@@ -110,24 +111,27 @@ function useStream(options) {
 	(0, vue.watch)(() => (0, vue.toValue)(asBag.threadId) ?? null, () => handledTools.clear());
 	const tools = options.tools;
 	const onTool = options.onTool;
-	if (tools?.length) (0, vue.watch)(() => [rootRef.value.values, rootRef.value.interrupts], ([rootValues, rootInterrupts]) => {
-		const bag = rootValues;
-		const combined = [...Array.isArray(bag?.__interrupt__) ? bag.__interrupt__ : [], ...rootInterrupts];
-		if (combined.length === 0) return;
-		(0, _langchain_langgraph_sdk.flushPendingHeadlessToolInterrupts)({
-			...bag,
-			__interrupt__: combined
-		}, tools, handledTools, {
-			onTool,
-			defer: (run) => {
-				Promise.resolve().then(run);
-			},
-			resumeSubmit: (command) => controller.submit(null, { command })
+	if (tools?.length) (0, vue.watch)(() => [rootRef.value.values, rootRef.value.interrupts], () => {
+		(0, _langchain_langgraph_sdk.scheduleCoalescedHeadlessToolFlush)(handledTools, () => {
+			const rootValues = rootRef.value.values;
+			const rootInterrupts = rootRef.value.interrupts;
+			const bag = rootValues;
+			const protocolInterrupts = rootInterrupts;
+			const valuesInterrupts = Array.isArray(bag?.__interrupt__) ? bag.__interrupt__ : [];
+			const headlessInterrupts = protocolInterrupts.length > 0 ? protocolInterrupts : valuesInterrupts;
+			if (headlessInterrupts.length === 0) return;
+			(0, _langchain_langgraph_sdk.flushPendingHeadlessToolInterrupts)({
+				...bag,
+				__interrupt__: headlessInterrupts
+			}, tools, handledTools, {
+				onTool,
+				defer: (run) => {
+					Promise.resolve().then(run);
+				},
+				resumeSubmit: (command) => controller.submit(null, { command })
+			});
 		});
-	}, {
-		immediate: true,
-		flush: "sync"
-	});
+	}, { immediate: true });
 	return {
 		values: asShallow(values),
 		messages: asShallow(messages),

package/dist/use-stream.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"use-stream.cjs","names":["LANGCHAIN_OPTIONS","ClientCtor","StreamController"],"sources":["../src/use-stream.ts"],"sourcesContent":["import {\n  computed,\n  onScopeDispose,\n  readonly,\n  shallowRef,\n  toValue,\n  watch,\n  type ComputedRef,\n  type MaybeRefOrGetter,\n  type ShallowRef,\n} from \"vue\";\nimport type { BaseMessage } from \"@langchain/core/messages\";\nimport type { Client, Interrupt } from \"@langchain/langgraph-sdk\";\nimport {\n  filterOutHeadlessToolInterrupts,\n  flushPendingHeadlessToolInterrupts,\n  type AnyHeadlessToolImplementation,\n  type OnToolCallback,\n} from \"@langchain/langgraph-sdk\";\nimport {\n  Client as ClientCtor,\n  type ClientConfig,\n  type ThreadStream,\n} from \"@langchain/langgraph-sdk/client\";\nimport {\n  StreamController,\n  type AgentServerAdapter,\n  type AgentServerOptions as StreamAgentServerOptions,\n  type AssembledToolCall,\n  type ChannelRegistry,\n  type CustomAdapterOptions as StreamCustomAdapterOptions,\n  type InferStateType,\n  type InferSubagentStates,\n  type RootSnapshot,\n  type StateOf as StreamStateOf,\n  type StreamSubmitOptions,\n  type SubagentDiscoverySnapshot,\n  type SubagentMap,\n  type SubgraphByNodeMap,\n  type SubgraphDiscoverySnapshot,\n  type SubgraphMap,\n  type UseStreamOptions as StreamUseStreamOptions,\n  type WidenUpdateMessages,\n} from \"@langchain/langgraph-sdk/stream\";\nimport { inject } from \"vue\";\nimport { LANGCHAIN_OPTIONS } from \"./context.js\";\n\n/** @deprecated Prefer {@link InferStateType}. */\nexport type StateOf<T> = StreamStateOf<T>;\n\ntype VueThreadId = MaybeRefOrGetter<string | null | undefined>;\ntype VueApiString = MaybeRefOrGetter<string | undefined>;\n\nexport type AgentServerOptions<StateType extends object> =\n  StreamAgentServerOptions<StateType, VueThreadId, VueApiString, VueApiString>;\n\nexport type CustomAdapterOptions<StateType extends object> =\n  StreamCustomAdapterOptions<StateType, VueThreadId, string>;\n\nexport type UseStreamOptions<\n  StateType extends object = Record<string, unknown>,\n> = StreamUseStreamOptions<\n  StateType,\n  VueThreadId,\n  VueApiString,\n  VueApiString,\n  string\n>;\n\n/**\n * Private field on the handle that carries the {@link StreamController}\n * reference. Selector composables read this to reach the shared\n * {@link ChannelRegistry}. Use the selector composables (`useMessages`,\n * `useToolCalls`, `useValues`, …) instead of reading this directly.\n */\nexport const STREAM_CONTROLLER: unique symbol = Symbol.for(\n  \"@langchain/vue/controller\"\n);\n\n/**\n * Vue binding return type for {@link useStream}.\n *\n * Reactive primitives follow Vue conventions:\n *\n *  - Data projections are `Readonly<ShallowRef<T>>` / `ComputedRef<T>`\n *    so templates auto-unwrap via `msg.value` in `<script setup>`\n *    and directly in templates. They are snapshots — never mutate.\n *  - Imperative methods (`submit` / `stop` / `respond`) are plain\n *    functions — no refs involved.\n *  - Identity values captured at setup time (`client` / `assistantId`)\n *    are exposed as plain values; if you need to swap the bound agent\n *    or client, remount the composable.\n */\nexport interface UseStreamReturn<\n  T = Record<string, unknown>,\n  InterruptType = unknown,\n  ConfigurableType extends object = Record<string, unknown>,\n  StateType extends object = InferStateType<T>,\n  SubagentStates = InferSubagentStates<T>,\n> {\n  readonly values: Readonly<ShallowRef<StateType>>;\n  readonly messages: Readonly<ShallowRef<BaseMessage[]>>;\n  readonly toolCalls: Readonly<ShallowRef<AssembledToolCall[]>>;\n  readonly interrupts: Readonly<ShallowRef<Interrupt<InterruptType>[]>>;\n  readonly interrupt: ComputedRef<Interrupt<InterruptType> | undefined>;\n  readonly isLoading: ComputedRef<boolean>;\n  readonly isThreadLoading: ComputedRef<boolean>;\n  readonly error: ComputedRef<unknown>;\n  readonly threadId: ComputedRef<string | null>;\n\n  /**\n   * Promise that settles when the active thread's initial hydration\n   * completes. Exposed so `async setup()` sites can\n   * `await stream.hydrationPromise` to implement a Suspense-like\n   * boundary.\n   */\n  readonly hydrationPromise: ComputedRef<Promise<void>>;\n\n  readonly subagents: Readonly<\n    ShallowRef<\n      ReadonlyMap<\n        keyof SubagentStates & string extends never\n          ? string\n          : keyof SubagentStates & string,\n        SubagentDiscoverySnapshot\n      >\n    >\n  >;\n  readonly subgraphs: Readonly<\n    ShallowRef<ReadonlyMap<string, SubgraphDiscoverySnapshot>>\n  >;\n  readonly subgraphsByNode: Readonly<\n    ShallowRef<ReadonlyMap<string, readonly SubgraphDiscoverySnapshot[]>>\n  >;\n\n  submit(\n    input: WidenUpdateMessages<Partial<StateType>> | null | undefined,\n    options?: StreamSubmitOptions<StateType, ConfigurableType>\n  ): Promise<void>;\n  stop(): Promise<void>;\n  respond(\n    response: unknown,\n    target?: { interruptId: string; namespace?: string[] }\n  ): Promise<void>;\n\n  readonly client: Client;\n  readonly assistantId: string;\n\n  /** v2 escape hatch — returns the bound {@link ThreadStream}. */\n  getThread(): ThreadStream | undefined;\n\n  /** @internal Used by selector composables. */\n  readonly [STREAM_CONTROLLER]: StreamController<\n    StateType,\n    InterruptType,\n    ConfigurableType\n  >;\n}\n\n/**\n * Erased handle useful as a parameter type for helpers and wrapper\n * components that pass a `stream` through to selector composables\n * without reading `values` directly. Mirrors the React\n * `AnyStream` alias.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type AnyStream = UseStreamReturn<any, any, any>;\n\n/** Convenience alias for the fully-resolved stream handle type. */\nexport type UseStreamResult<\n  T = Record<string, unknown>,\n  InterruptType = unknown,\n  ConfigurableType extends object = Record<string, unknown>,\n> = UseStreamReturn<T, InterruptType, ConfigurableType>;\n\n/**\n * Vue Composition API binding for the v2-native stream runtime.\n *\n * Returns a handle whose projections are Vue refs so templates\n * auto-unwrap and scripts can feed them into `computed`/`watch`.\n * Scoped views (subagents, subgraphs, any namespaced projection) are\n * surfaced via the companion selector composables (`useMessages`,\n * `useToolCalls`, `useValues`, `useMessageMetadata`,\n * `useSubmissionQueue`, `useExtension`, `useChannel`, plus media\n * composables).\n *\n * @example\n * ```vue\n * <script setup lang=\"ts\">\n * import { useStream } from \"@langchain/vue\";\n *\n * const stream = useStream({\n *   assistantId: \"agent\",\n *   apiUrl: \"http://localhost:2024\",\n * });\n * </script>\n *\n * <template>\n *   <div v-for=\"msg in stream.messages.value\" :key=\"msg.id\">\n *     {{ msg.content }}\n *   </div>\n *   <button @click=\"stream.submit({ messages: [{ type: 'human', content: 'Hi' }] })\">\n *     Send\n *   </button>\n * </template>\n * ```\n *\n * `assistantId`, `client`, and `transport` are captured at setup time.\n * To bind a new assistant/transport, remount the component. Reactive\n * inputs (`threadId`, `apiUrl`, `apiKey`) trigger in-place behaviour\n * changes on the active controller.\n */\nexport function useStream<\n  T = Record<string, unknown>,\n  InterruptType = unknown,\n  ConfigurableType extends object = Record<string, unknown>,\n>(\n  options: UseStreamOptions<InferStateType<T>>\n): UseStreamReturn<T, InterruptType, ConfigurableType> {\n  type StateType = InferStateType<T>;\n\n  interface OptionsBag {\n    assistantId?: string;\n    threadId?: MaybeRefOrGetter<string | null | undefined>;\n    client?: Client;\n    apiUrl?: MaybeRefOrGetter<string | undefined>;\n    apiKey?: MaybeRefOrGetter<string | undefined>;\n    callerOptions?: ClientConfig[\"callerOptions\"];\n    defaultHeaders?: ClientConfig[\"defaultHeaders\"];\n    transport?: \"sse\" | \"websocket\" | AgentServerAdapter;\n    fetch?: typeof fetch;\n    webSocketFactory?: (url: string) => WebSocket;\n    onThreadId?: (threadId: string) => void;\n    onCreated?: (meta: { run_id: string; thread_id: string }) => void;\n    initialValues?: StateType;\n    messagesKey?: string;\n    tools?: AnyHeadlessToolImplementation[];\n    onTool?: OnToolCallback;\n  }\n  const asBag = options as OptionsBag;\n\n  // Inherit missing apiUrl / apiKey / client from any LangChainPlugin\n  // installed on the app. Vue's `inject` returns `undefined` if the\n  // key was never provided; that's fine — we only merge when the\n  // caller didn't set a value.\n  const pluginOptions =\n    inject(LANGCHAIN_OPTIONS, undefined) ?? ({} as Record<string, unknown>);\n\n  const hasCustomAdapter =\n    asBag.transport != null && typeof asBag.transport !== \"string\";\n  const transport = asBag.transport;\n\n  // ─── Client construction ────────────────────────────────────────────\n  //\n  // Identity-stable per setup. Watches apiUrl/apiKey refs so callers\n  // that flip a backend at runtime get a fresh client without a full\n  // remount — the controller is swapped in lock-step below.\n  const resolveApiUrl = () =>\n    toValue(asBag.apiUrl) ?? (pluginOptions as { apiUrl?: string }).apiUrl;\n  const resolveApiKey = () =>\n    toValue(asBag.apiKey) ?? (pluginOptions as { apiKey?: string }).apiKey;\n  const explicitClient =\n    asBag.client ?? (pluginOptions as { client?: Client }).client;\n\n  const clientRef = shallowRef<Client>(\n    explicitClient ??\n      (new ClientCtor({\n        apiUrl: resolveApiUrl(),\n        apiKey: resolveApiKey(),\n        callerOptions: asBag.callerOptions,\n        defaultHeaders: asBag.defaultHeaders,\n      }) as unknown as Client)\n  );\n\n  // Note: we intentionally bind the controller to the *initial* client\n  // instance. A dynamic client swap would require tearing the\n  // controller down (in-flight subscriptions, queue, hydration), so we\n  // keep the rule simple: client is captured at setup. Mirrors React\n  // v1 which bakes `useMemo` on `[client, assistantId, transport]`.\n  const client = clientRef.value;\n\n  // Custom adapters may omit `assistantId`; the controller still\n  // requires one so it has something to forward to `threads.stream`.\n  const sentinel = \"_\";\n  const assistantId =\n    \"assistantId\" in options ? (options.assistantId ?? sentinel) : sentinel;\n\n  const initialThreadId = toValue(asBag.threadId) ?? null;\n\n  // ─── Controller construction ────────────────────────────────────────\n  const controller = new StreamController<\n    StateType,\n    InterruptType,\n    ConfigurableType\n  >({\n    assistantId,\n    client: client as unknown as Client<StateType>,\n    threadId: initialThreadId,\n    transport,\n    fetch: hasCustomAdapter ? undefined : asBag.fetch,\n    webSocketFactory: hasCustomAdapter ? undefined : asBag.webSocketFactory,\n    onThreadId: options.onThreadId,\n    onCreated: options.onCreated,\n    initialValues: options.initialValues,\n    messagesKey: options.messagesKey,\n  });\n\n  // Deferred dispose: on the next microtask after the owning scope\n  // disappears. Mirrors React's StrictMode-safe activate/deactivate\n  // pattern — HMR and other scope-reuse scenarios stay clean because\n  // `activate()` cancels the pending dispose if the scope survives.\n  const deactivate = controller.activate();\n  onScopeDispose(deactivate);\n\n  // ─── Reactivity adapters — StreamStore → shallowRef ─────────────────\n  function bindStore<S>(\n    subscribe: (listener: () => void) => () => void,\n    getSnapshot: () => S\n  ): Readonly<ShallowRef<S>> {\n    const ref = shallowRef<S>(getSnapshot());\n    const unsubscribe = subscribe(() => {\n      ref.value = getSnapshot();\n    });\n    onScopeDispose(unsubscribe);\n    return readonly(ref) as Readonly<ShallowRef<S>>;\n  }\n\n  const rootRef = bindStore<RootSnapshot<StateType, InterruptType>>(\n    controller.rootStore.subscribe,\n    controller.rootStore.getSnapshot\n  );\n  const subagentRef = bindStore<SubagentMap>(\n    controller.subagentStore.subscribe,\n    controller.subagentStore.getSnapshot\n  );\n  const subgraphRef = bindStore<SubgraphMap>(\n    controller.subgraphStore.subscribe,\n    controller.subgraphStore.getSnapshot\n  );\n  const subgraphByNodeRef = bindStore<SubgraphByNodeMap>(\n    controller.subgraphByNodeStore.subscribe,\n    controller.subgraphByNodeStore.getSnapshot\n  );\n\n  // Derived refs for individual root-snapshot fields. Using computed\n  // means templates that read `values.value` only retrigger when the\n  // root snapshot's identity actually changes — we can't split further\n  // because `StreamStore` fans the whole snapshot out on every update.\n  const values = computed(() => rootRef.value.values);\n  const messages = computed(() => rootRef.value.messages);\n  const toolCalls = computed(() => rootRef.value.toolCalls);\n  const interrupts = computed(() =>\n    filterOutHeadlessToolInterrupts(rootRef.value.interrupts)\n  );\n  const interrupt = computed(() => interrupts.value[0]);\n  const isLoading = computed(() => rootRef.value.isLoading);\n  const isThreadLoading = computed(() => rootRef.value.isThreadLoading);\n  const error = computed(() => rootRef.value.error);\n  const threadId = computed(() => rootRef.value.threadId);\n  const hydrationPromise = computed(() => controller.hydrationPromise);\n\n  // Expose the derived refs through a `readonly(shallowRef)` shape to\n  // match the rest of the public surface. `computed` already gives us\n  // read-only semantics but templates type-check more cleanly when the\n  // fully-typed return claims `Readonly<ShallowRef<T>>` everywhere.\n  // The cast is safe — a ComputedRef<T> is structurally a\n  // Readonly<Ref<T>>.\n  const asShallow = <V>(c: ComputedRef<V>): Readonly<ShallowRef<V>> =>\n    c as unknown as Readonly<ShallowRef<V>>;\n\n  // ─── threadId reactivity ────────────────────────────────────────────\n  //\n  // Re-hydrate whenever the caller's threadId input changes post-setup.\n  // The initial hydrate already fired synchronously in the controller\n  // constructor, so we skip that first tick; otherwise we'd double-fetch\n  // `thread.state.get()`.\n  let skipFirstThreadIdWatch = true;\n  watch(\n    () => toValue(asBag.threadId) ?? null,\n    (next) => {\n      if (skipFirstThreadIdWatch) {\n        skipFirstThreadIdWatch = false;\n        return;\n      }\n      void controller.hydrate(next);\n    }\n  );\n\n  // ─── Headless-tool handling ─────────────────────────────────────────\n  //\n  // Watch root values + protocol interrupts for items targeting a\n  // registered tool, invoke the handler, and resume the run with the\n  // handler's return value. Dedup via an id set so StrictMode /\n  // rerenders don't replay a tool call twice.\n  const handledTools = new Set<string>();\n  watch(\n    () => toValue(asBag.threadId) ?? null,\n    () => handledTools.clear()\n  );\n  const tools = options.tools;\n  const onTool = options.onTool;\n  if (tools?.length) {\n    watch(\n      () => [rootRef.value.values, rootRef.value.interrupts] as const,\n      ([rootValues, rootInterrupts]) => {\n        const bag = rootValues as unknown as Record<string, unknown>;\n        const existing = Array.isArray(bag?.__interrupt__)\n          ? (bag.__interrupt__ as Interrupt[])\n          : [];\n        const combined: Interrupt[] = [\n          ...existing,\n          ...(rootInterrupts as unknown as Interrupt[]),\n        ];\n        if (combined.length === 0) return;\n        flushPendingHeadlessToolInterrupts(\n          { ...bag, __interrupt__: combined },\n          tools,\n          handledTools,\n          {\n            onTool,\n            defer: (run) => {\n              void Promise.resolve().then(run);\n            },\n            resumeSubmit: (command) =>\n              controller.submit(null, {\n                command,\n              } as StreamSubmitOptions<StateType, ConfigurableType>),\n          }\n        );\n      },\n      { immediate: true, flush: \"sync\" }\n    );\n  }\n\n  const handle: UseStreamReturn<T, InterruptType, ConfigurableType> = {\n    values: asShallow(values) as UseStreamReturn<\n      T,\n      InterruptType,\n      ConfigurableType\n    >[\"values\"],\n    messages: asShallow(messages),\n    toolCalls: asShallow(toolCalls),\n    interrupts: asShallow(interrupts),\n    interrupt,\n    isLoading,\n    isThreadLoading,\n    error,\n    threadId,\n    hydrationPromise,\n    subagents: subagentRef as UseStreamReturn<\n      T,\n      InterruptType,\n      ConfigurableType\n    >[\"subagents\"],\n    subgraphs: subgraphRef,\n    subgraphsByNode: subgraphByNodeRef,\n    submit: (input, submitOptions) => controller.submit(input, submitOptions),\n    stop: () => controller.stop(),\n    respond: (response, target) => controller.respond(response, target),\n    getThread: () => controller.getThread(),\n    client,\n    assistantId,\n    [STREAM_CONTROLLER]: controller,\n  };\n\n  return handle;\n}\n\n/**\n * Helper used by the selector composables to reach the underlying\n * {@link ChannelRegistry} from a stream handle. Kept internal —\n * application code should call `useMessages`, `useToolCalls`, etc.\n *\n * @internal\n */\nexport function getRegistry(\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  stream: UseStreamReturn<any, any, any>\n): ChannelRegistry {\n  return stream[STREAM_CONTROLLER].registry;\n}\n\nexport type { ThreadStream };\n"],"mappings":"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"}
+{"version":3,"file":"use-stream.cjs","names":["LANGCHAIN_OPTIONS","ClientCtor","StreamController"],"sources":["../src/use-stream.ts"],"sourcesContent":["import {\n  computed,\n  onScopeDispose,\n  readonly,\n  shallowRef,\n  toValue,\n  watch,\n  type ComputedRef,\n  type MaybeRefOrGetter,\n  type ShallowRef,\n} from \"vue\";\nimport type { BaseMessage } from \"@langchain/core/messages\";\nimport type { Client, Interrupt } from \"@langchain/langgraph-sdk\";\nimport {\n  filterOutHeadlessToolInterrupts,\n  flushPendingHeadlessToolInterrupts,\n  scheduleCoalescedHeadlessToolFlush,\n  type AnyHeadlessToolImplementation,\n  type OnToolCallback,\n} from \"@langchain/langgraph-sdk\";\nimport {\n  Client as ClientCtor,\n  type ClientConfig,\n  type ThreadStream,\n} from \"@langchain/langgraph-sdk/client\";\nimport {\n  StreamController,\n  type AgentServerAdapter,\n  type AgentServerOptions as StreamAgentServerOptions,\n  type ChannelRegistry,\n  type CustomAdapterOptions as StreamCustomAdapterOptions,\n  type InferStateType,\n  type InferSubagentStates,\n  type InferToolCalls,\n  type RootSnapshot,\n  type RunCompletedInfo,\n  type RunExecutionInfo,\n  type StreamSubmitOptions,\n  type SubagentDiscoverySnapshot,\n  type SubagentMap,\n  type SubgraphByNodeMap,\n  type SubgraphDiscoverySnapshot,\n  type SubgraphMap,\n  type UseStreamOptions as StreamUseStreamOptions,\n  type WidenUpdateMessages,\n} from \"@langchain/langgraph-sdk/stream\";\nimport { inject } from \"vue\";\nimport { LANGCHAIN_OPTIONS } from \"./context.js\";\n\ntype VueThreadId = MaybeRefOrGetter<string | null | undefined>;\ntype VueApiString = MaybeRefOrGetter<string | undefined>;\n\nexport type AgentServerOptions<StateType extends object> =\n  StreamAgentServerOptions<StateType, VueThreadId, VueApiString, VueApiString>;\n\nexport type CustomAdapterOptions<StateType extends object> =\n  StreamCustomAdapterOptions<StateType, VueThreadId, string>;\n\nexport type UseStreamOptions<\n  StateType extends object = Record<string, unknown>,\n> = StreamUseStreamOptions<\n  StateType,\n  VueThreadId,\n  VueApiString,\n  VueApiString,\n  string\n>;\n\n/**\n * Private field on the handle that carries the {@link StreamController}\n * reference. Selector composables read this to reach the shared\n * {@link ChannelRegistry}. Use the selector composables (`useMessages`,\n * `useToolCalls`, `useValues`, …) instead of reading this directly.\n */\nexport const STREAM_CONTROLLER: unique symbol = Symbol.for(\n  \"@langchain/vue/controller\"\n);\n\n/**\n * Vue binding return type for {@link useStream}.\n *\n * Reactive primitives follow Vue conventions:\n *\n *  - Data projections are `Readonly<ShallowRef<T>>` / `ComputedRef<T>`\n *    so templates auto-unwrap via `msg.value` in `<script setup>`\n *    and directly in templates. They are snapshots — never mutate.\n *  - Imperative methods (`submit` / `stop` / `respond`) are plain\n *    functions — no refs involved.\n *  - Identity values captured at setup time (`client` / `assistantId`)\n *    are exposed as plain values; if you need to swap the bound agent\n *    or client, remount the composable.\n */\nexport interface UseStreamReturn<\n  T = Record<string, unknown>,\n  InterruptType = unknown,\n  ConfigurableType extends object = Record<string, unknown>,\n  StateType extends object = InferStateType<T>,\n  SubagentStates = InferSubagentStates<T>,\n> {\n  // ----- always-on root projections -----\n  /**\n   * The most recent `values`-channel snapshot emitted at the root\n   * namespace — i.e. the thread-level state as the server sees it\n   * after each superstep. Updated on every root `values` event, not\n   * on token-level deltas: if you render `stream.values.value.messages`\n   * directly you'll see full turns appear at once instead of\n   * streaming token-by-token. Use {@link messages} (or\n   * `useMessages`) for the token-streamed view.\n   *\n   * Equivalent to calling `useValues(stream)`.\n   */\n  readonly values: Readonly<ShallowRef<StateType>>;\n  /**\n   * The root message projection. Assembled from two sources and\n   * merged in real time:\n   *\n   *  1. `messages`-channel deltas — token-level streaming events\n   *     (`message-start`, `content-block-delta`, `message-finish`)\n   *     emitted by the runtime. These drive live, token-by-token\n   *     updates.\n   *  2. `values.messages` snapshots — the authoritative ordering\n   *     and any messages the agent produces without token streaming\n   *     (human turns, tool results, echoes from subagents).\n   *\n   * If the backend only emits `values` events (no `messages`\n   * channel), every message will appear fully-formed on each\n   * values update rather than streaming. This is a backend/runtime\n   * concern — the Vue layer faithfully renders whatever the\n   * server sends.\n   *\n   * Equivalent to calling `useMessages(stream)` with no target.\n   */\n  readonly messages: Readonly<ShallowRef<BaseMessage[]>>;\n  /**\n   * Root-namespace tool calls assembled from the `tools` channel.\n   * Each entry is a fully parsed {@link AssembledToolCall} with\n   * name, args, and id — suitable for rendering approval UIs or\n   * forwarding to headless tool handlers.\n   *\n   * When the stream is typed with an agent brand or tool list,\n   * entries are narrowed via {@link InferToolCalls}. Equivalent to\n   * calling `useToolCalls(stream)` with no target.\n   */\n  readonly toolCalls: Readonly<ShallowRef<InferToolCalls<T>[]>>;\n  /**\n   * All unresolved protocol interrupts observed on the root\n   * namespace during the active thread. Populated from lifecycle /\n   * input events and seeded on hydration from `thread.getState()`.\n   * Cleared optimistically when a new run starts or an interrupt is\n   * resolved via {@link respond} / `submit({ command: { resume } })`.\n   */\n  readonly interrupts: Readonly<ShallowRef<Interrupt<InterruptType>[]>>;\n  /**\n   * Convenience alias for {@link interrupts}[0] — the primary\n   * interrupt most UIs should act on when only one is pending.\n   * `undefined` when no interrupt is active.\n   */\n  readonly interrupt: ComputedRef<Interrupt<InterruptType> | undefined>;\n  /**\n   * `true` while a run is active or being started on the current\n   * thread. Driven by root-namespace lifecycle events (`running` →\n   * `true`, terminal phases → `false`). Use this to disable submit\n   * buttons and show in-flight spinners.\n   */\n  readonly isLoading: ComputedRef<boolean>;\n  /**\n   * `true` while the initial `thread.getState()` hydration for the\n   * active thread is in flight. Distinct from {@link isLoading} —\n   * thread loading covers the one-time fetch that seeds\n   * {@link values} / {@link messages} before any user submit.\n   */\n  readonly isThreadLoading: ComputedRef<boolean>;\n  /**\n   * The last error observed on the active run or hydration attempt.\n   * `undefined` when no error has occurred. Cleared optimistically\n   * when a new {@link submit} starts.\n   */\n  readonly error: ComputedRef<unknown>;\n  /**\n   * Id of the thread the controller is bound to. `null` until the\n   * first {@link submit} creates or selects a thread (or until an\n   * explicit `threadId` option is provided and hydrated).\n   */\n  readonly threadId: ComputedRef<string | null>;\n  /**\n   * Promise that settles when the active thread's initial hydration\n   * completes. Exposed so `async setup()` sites can\n   * `await stream.hydrationPromise.value` to implement a\n   * Suspense-like boundary. A fresh promise is installed on every\n   * `threadId` change.\n   */\n  readonly hydrationPromise: ComputedRef<Promise<void>>;\n\n  // ----- always-on discovery -----\n  /**\n   * Subagents discovered on the root run. For DeepAgent-typed\n   * streams the key set is narrowed to the subagent names declared\n   * on the agent brand (`keyof InferSubagentStates<T>`).\n   */\n  readonly subagents: Readonly<\n    ShallowRef<\n      ReadonlyMap<\n        keyof SubagentStates & string extends never\n          ? string\n          : keyof SubagentStates & string,\n        SubagentDiscoverySnapshot\n      >\n    >\n  >;\n  /**\n   * Subgraphs discovered on the root run.\n   *\n   * A namespace is classified as a subgraph iff at least one\n   * strictly-deeper namespace has been observed with it as a prefix.\n   * This is inferred from the lifecycle event stream — plain function\n   * nodes (`orchestrator`, `writer` in the nested-stategraph example)\n   * never appear here even though the server emits namespaced\n   * lifecycle events for them. Promotion is monotonic and retroactive;\n   * an entry appears as soon as the first descendant event lands.\n   */\n  readonly subgraphs: Readonly<\n    ShallowRef<ReadonlyMap<string, SubgraphDiscoverySnapshot>>\n  >;\n  /**\n   * Subgraphs indexed by the graph node that produced them\n   * (`addNode(\"visualizer_0\", …)`). Each value is an array because\n   * parallel fan-outs and loops can spawn multiple invocations of\n   * the same node; arrays preserve insertion order. Updates in\n   * lock-step with {@link subgraphs}.\n   */\n  readonly subgraphsByNode: Readonly<\n    ShallowRef<ReadonlyMap<string, readonly SubgraphDiscoverySnapshot[]>>\n  >;\n\n  // ----- imperatives -----\n  /**\n   * Dispatch a new run on the bound thread.\n   *\n   * `input` is typed as `Partial<StateType>` so IDE autocompletion\n   * surfaces the state keys declared on the root composable. Pass\n   * `null` (or omit fields) when resuming an interrupt via\n   * `options.command.resume` — the server accepts a null payload\n   * in that case.\n   */\n  submit(\n    input: WidenUpdateMessages<Partial<StateType>> | null | undefined,\n    options?: StreamSubmitOptions<StateType, ConfigurableType>\n  ): Promise<void>;\n  /**\n   * Abort the in-flight run on the current thread without clearing\n   * accumulated state. Sets {@link isLoading} to `false` immediately;\n   * {@link values} and {@link messages} are preserved.\n   */\n  stop(): Promise<void>;\n  /**\n   * Resume a pending protocol interrupt by sending a response payload\n   * back to the interrupted namespace.\n   *\n   * When `target` is omitted, responds to the latest unresolved\n   * interrupt in {@link interrupts}. Pass an explicit\n   * `{ interruptId, namespace? }` when multiple interrupts are\n   * pending or the interrupt lives in a subgraph namespace.\n   */\n  respond(\n    response: unknown,\n    target?: { interruptId: string; namespace?: string[] }\n  ): Promise<void>;\n\n  // ----- identity -----\n  /** LangGraph SDK client used to construct thread streams. */\n  readonly client: Client;\n  /** Assistant id the thread is bound to for its lifetime. */\n  readonly assistantId: string;\n\n  /**\n   * Returns the bound {@link ThreadStream}, if one exists (`undefined`\n   * until the thread is hydrated or the first submit completes). Prefer\n   * the projections and selector composables for UI work; use this for\n   * low-level protocol access (raw subscriptions, state commands, etc.).\n   */\n  getThread(): ThreadStream | undefined;\n\n  /** @internal Used by selector composables. */\n  readonly [STREAM_CONTROLLER]: StreamController<\n    StateType,\n    InterruptType,\n    ConfigurableType\n  >;\n}\n\n/**\n * Erased handle useful as a parameter type for helpers and wrapper\n * components that pass a `stream` through to selector composables\n * without reading `values` directly. Mirrors the React\n * `AnyStream` alias.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type AnyStream = UseStreamReturn<any, any, any>;\n\n/** Convenience alias for the fully-resolved stream handle type. */\nexport type UseStreamResult<\n  T = Record<string, unknown>,\n  InterruptType = unknown,\n  ConfigurableType extends object = Record<string, unknown>,\n> = UseStreamReturn<T, InterruptType, ConfigurableType>;\n\n/**\n * Vue Composition API binding for the v2-native stream runtime.\n *\n * Returns a handle whose projections are Vue refs so templates\n * auto-unwrap and scripts can feed them into `computed`/`watch`.\n * Scoped views (subagents, subgraphs, any namespaced projection) are\n * surfaced via the companion selector composables (`useMessages`,\n * `useToolCalls`, `useValues`, `useMessageMetadata`,\n * `useSubmissionQueue`, `useExtension`, `useChannel`, plus media\n * composables).\n *\n * @example\n * ```vue\n * <script setup lang=\"ts\">\n * import { useStream } from \"@langchain/vue\";\n *\n * const stream = useStream({\n *   assistantId: \"agent\",\n *   apiUrl: \"http://localhost:2024\",\n * });\n * </script>\n *\n * <template>\n *   <div v-for=\"msg in stream.messages.value\" :key=\"msg.id\">\n *     {{ msg.content }}\n *   </div>\n *   <button @click=\"stream.submit({ messages: [{ type: 'human', content: 'Hi' }] })\">\n *     Send\n *   </button>\n * </template>\n * ```\n *\n * `assistantId`, `client`, and `transport` are captured at setup time.\n * To bind a new assistant/transport, remount the component. Reactive\n * inputs (`threadId`, `apiUrl`, `apiKey`) trigger in-place behaviour\n * changes on the active controller.\n */\nexport function useStream<\n  T = Record<string, unknown>,\n  InterruptType = unknown,\n  ConfigurableType extends object = Record<string, unknown>,\n>(\n  options: UseStreamOptions<InferStateType<T>>\n): UseStreamReturn<T, InterruptType, ConfigurableType> {\n  type StateType = InferStateType<T>;\n\n  interface OptionsBag {\n    assistantId?: string;\n    threadId?: MaybeRefOrGetter<string | null | undefined>;\n    client?: Client;\n    apiUrl?: MaybeRefOrGetter<string | undefined>;\n    apiKey?: MaybeRefOrGetter<string | undefined>;\n    callerOptions?: ClientConfig[\"callerOptions\"];\n    defaultHeaders?: ClientConfig[\"defaultHeaders\"];\n    transport?: \"sse\" | \"websocket\" | AgentServerAdapter;\n    fetch?: typeof fetch;\n    webSocketFactory?: (url: string) => WebSocket;\n    onThreadId?: (threadId: string) => void;\n    onCreated?: (info: RunExecutionInfo) => void;\n    onCompleted?: (info: RunCompletedInfo) => void;\n    initialValues?: StateType;\n    messagesKey?: string;\n    tools?: AnyHeadlessToolImplementation[];\n    onTool?: OnToolCallback;\n  }\n  const asBag = options as OptionsBag;\n\n  // Inherit missing apiUrl / apiKey / client from any LangChainPlugin\n  // installed on the app. Vue's `inject` returns `undefined` if the\n  // key was never provided; that's fine — we only merge when the\n  // caller didn't set a value.\n  const pluginOptions =\n    inject(LANGCHAIN_OPTIONS, undefined) ?? ({} as Record<string, unknown>);\n\n  const hasCustomAdapter =\n    asBag.transport != null && typeof asBag.transport !== \"string\";\n  const transport = asBag.transport;\n\n  // ─── Client construction ────────────────────────────────────────────\n  //\n  // Identity-stable per setup. Watches apiUrl/apiKey refs so callers\n  // that flip a backend at runtime get a fresh client without a full\n  // remount — the controller is swapped in lock-step below.\n  const resolveApiUrl = () =>\n    toValue(asBag.apiUrl) ?? (pluginOptions as { apiUrl?: string }).apiUrl;\n  const resolveApiKey = () =>\n    toValue(asBag.apiKey) ?? (pluginOptions as { apiKey?: string }).apiKey;\n  const explicitClient =\n    asBag.client ?? (pluginOptions as { client?: Client }).client;\n\n  const clientRef = shallowRef<Client>(\n    explicitClient ??\n      (new ClientCtor({\n        apiUrl: resolveApiUrl(),\n        apiKey: resolveApiKey(),\n        callerOptions: asBag.callerOptions,\n        defaultHeaders: asBag.defaultHeaders,\n      }) as unknown as Client)\n  );\n\n  // Note: we intentionally bind the controller to the *initial* client\n  // instance. A dynamic client swap would require tearing the\n  // controller down (in-flight subscriptions, queue, hydration), so we\n  // keep the rule simple: client is captured at setup. Mirrors React\n  // v1 which bakes `useMemo` on `[client, assistantId, transport]`.\n  const client = clientRef.value;\n\n  // Custom adapters may omit `assistantId`; the controller still\n  // requires one so it has something to forward to `threads.stream`.\n  const sentinel = \"_\";\n  const assistantId =\n    \"assistantId\" in options ? (options.assistantId ?? sentinel) : sentinel;\n\n  const initialThreadId = toValue(asBag.threadId) ?? null;\n\n  // ─── Controller construction ────────────────────────────────────────\n  const controller = new StreamController<\n    StateType,\n    InterruptType,\n    ConfigurableType\n  >({\n    assistantId,\n    client: client as unknown as Client<StateType>,\n    threadId: initialThreadId,\n    transport,\n    fetch: hasCustomAdapter ? undefined : asBag.fetch,\n    webSocketFactory: hasCustomAdapter ? undefined : asBag.webSocketFactory,\n    onThreadId: options.onThreadId,\n    onCreated: options.onCreated,\n    onCompleted: options.onCompleted,\n    initialValues: options.initialValues,\n    messagesKey: options.messagesKey,\n  });\n\n  // Deferred dispose: on the next microtask after the owning scope\n  // disappears. Mirrors React's StrictMode-safe activate/deactivate\n  // pattern — HMR and other scope-reuse scenarios stay clean because\n  // `activate()` cancels the pending dispose if the scope survives.\n  const deactivate = controller.activate();\n  onScopeDispose(deactivate);\n\n  // ─── Reactivity adapters — StreamStore → shallowRef ─────────────────\n  function bindStore<S>(\n    subscribe: (listener: () => void) => () => void,\n    getSnapshot: () => S\n  ): Readonly<ShallowRef<S>> {\n    const ref = shallowRef<S>(getSnapshot());\n    const unsubscribe = subscribe(() => {\n      ref.value = getSnapshot();\n    });\n    onScopeDispose(unsubscribe);\n    return readonly(ref) as Readonly<ShallowRef<S>>;\n  }\n\n  const rootRef = bindStore<RootSnapshot<StateType, InterruptType>>(\n    controller.rootStore.subscribe,\n    controller.rootStore.getSnapshot\n  );\n  const subagentRef = bindStore<SubagentMap>(\n    controller.subagentStore.subscribe,\n    controller.subagentStore.getSnapshot\n  );\n  const subgraphRef = bindStore<SubgraphMap>(\n    controller.subgraphStore.subscribe,\n    controller.subgraphStore.getSnapshot\n  );\n  const subgraphByNodeRef = bindStore<SubgraphByNodeMap>(\n    controller.subgraphByNodeStore.subscribe,\n    controller.subgraphByNodeStore.getSnapshot\n  );\n\n  // Derived refs for individual root-snapshot fields. Using computed\n  // means templates that read `values.value` only retrigger when the\n  // root snapshot's identity actually changes — we can't split further\n  // because `StreamStore` fans the whole snapshot out on every update.\n  const values = computed(() => rootRef.value.values);\n  const messages = computed(() => rootRef.value.messages);\n  const toolCalls = computed(\n    () => rootRef.value.toolCalls as InferToolCalls<T>[]\n  );\n  const interrupts = computed(() =>\n    filterOutHeadlessToolInterrupts(rootRef.value.interrupts)\n  );\n  const interrupt = computed(() => interrupts.value[0]);\n  const isLoading = computed(() => rootRef.value.isLoading);\n  const isThreadLoading = computed(() => rootRef.value.isThreadLoading);\n  const error = computed(() => rootRef.value.error);\n  const threadId = computed(() => rootRef.value.threadId);\n  const hydrationPromise = computed(() => controller.hydrationPromise);\n\n  // Expose the derived refs through a `readonly(shallowRef)` shape to\n  // match the rest of the public surface. `computed` already gives us\n  // read-only semantics but templates type-check more cleanly when the\n  // fully-typed return claims `Readonly<ShallowRef<T>>` everywhere.\n  // The cast is safe — a ComputedRef<T> is structurally a\n  // Readonly<Ref<T>>.\n  const asShallow = <V>(c: ComputedRef<V>): Readonly<ShallowRef<V>> =>\n    c as unknown as Readonly<ShallowRef<V>>;\n\n  // ─── threadId reactivity ────────────────────────────────────────────\n  //\n  // Re-hydrate whenever the caller's threadId input changes post-setup.\n  // The initial hydrate already fired synchronously in the controller\n  // constructor, so we skip that first tick; otherwise we'd double-fetch\n  // `thread.state.get()`.\n  let skipFirstThreadIdWatch = true;\n  watch(\n    () => toValue(asBag.threadId) ?? null,\n    (next) => {\n      if (skipFirstThreadIdWatch) {\n        skipFirstThreadIdWatch = false;\n        return;\n      }\n      void controller.hydrate(next);\n    }\n  );\n\n  // ─── Headless-tool handling ─────────────────────────────────────────\n  //\n  // Watch root values + protocol interrupts for items targeting a\n  // registered tool, invoke the handler, and resume the run with the\n  // handler's return value. Dedup via an id set so StrictMode /\n  // rerenders don't replay a tool call twice.\n  const handledTools = new Set<string>();\n  watch(\n    () => toValue(asBag.threadId) ?? null,\n    () => handledTools.clear()\n  );\n  const tools = options.tools;\n  const onTool = options.onTool;\n  if (tools?.length) {\n    watch(\n      () => [rootRef.value.values, rootRef.value.interrupts] as const,\n      () => {\n        scheduleCoalescedHeadlessToolFlush(handledTools, () => {\n          const rootValues = rootRef.value.values;\n          const rootInterrupts = rootRef.value.interrupts;\n          const bag = rootValues as unknown as Record<string, unknown>;\n          const protocolInterrupts = rootInterrupts as unknown as Interrupt[];\n          const valuesInterrupts = Array.isArray(bag?.__interrupt__)\n            ? (bag.__interrupt__ as Interrupt[])\n            : [];\n          const headlessInterrupts =\n            protocolInterrupts.length > 0\n              ? protocolInterrupts\n              : valuesInterrupts;\n          if (headlessInterrupts.length === 0) return;\n          flushPendingHeadlessToolInterrupts(\n            { ...bag, __interrupt__: headlessInterrupts },\n            tools,\n            handledTools,\n            {\n              onTool,\n              defer: (run) => {\n                void Promise.resolve().then(run);\n              },\n              resumeSubmit: (command) =>\n                controller.submit(null, {\n                  command,\n                } as StreamSubmitOptions<StateType, ConfigurableType>),\n            }\n          );\n        });\n      },\n      { immediate: true }\n    );\n  }\n\n  const handle: UseStreamReturn<T, InterruptType, ConfigurableType> = {\n    values: asShallow(values) as UseStreamReturn<\n      T,\n      InterruptType,\n      ConfigurableType\n    >[\"values\"],\n    messages: asShallow(messages),\n    toolCalls: asShallow(toolCalls),\n    interrupts: asShallow(interrupts),\n    interrupt,\n    isLoading,\n    isThreadLoading,\n    error,\n    threadId,\n    hydrationPromise,\n    subagents: subagentRef as UseStreamReturn<\n      T,\n      InterruptType,\n      ConfigurableType\n    >[\"subagents\"],\n    subgraphs: subgraphRef,\n    subgraphsByNode: subgraphByNodeRef,\n    submit: (input, submitOptions) => controller.submit(input, submitOptions),\n    stop: () => controller.stop(),\n    respond: (response, target) => controller.respond(response, target),\n    getThread: () => controller.getThread(),\n    client,\n    assistantId,\n    [STREAM_CONTROLLER]: controller,\n  };\n\n  return handle;\n}\n\n/**\n * Helper used by the selector composables to reach the underlying\n * {@link ChannelRegistry} from a stream handle. Kept internal —\n * application code should call `useMessages`, `useToolCalls`, etc.\n *\n * @internal\n */\nexport function getRegistry(\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  stream: UseStreamReturn<any, any, any>\n): ChannelRegistry {\n  return stream[STREAM_CONTROLLER].registry;\n}\n\nexport type { ThreadStream };\n"],"mappings":"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"}

package/dist/use-stream.d.cts

@@ -2,11 +2,9 @@ import { ComputedRef, MaybeRefOrGetter, ShallowRef } from "vue";
 import { BaseMessage } from "@langchain/core/messages";
 import { Client, Interrupt } from "@langchain/langgraph-sdk";
 import { ThreadStream } from "@langchain/langgraph-sdk/client";
-import { AgentServerOptions, AssembledToolCall, ChannelRegistry, CustomAdapterOptions, InferStateType, InferSubagentStates, StateOf, StreamController, StreamSubmitOptions, SubagentDiscoverySnapshot, SubgraphDiscoverySnapshot, UseStreamOptions, WidenUpdateMessages } from "@langchain/langgraph-sdk/stream";
+import { AgentServerOptions, ChannelRegistry, CustomAdapterOptions, InferStateType, InferSubagentStates, InferToolCalls, StreamController, StreamSubmitOptions, SubagentDiscoverySnapshot, SubgraphDiscoverySnapshot, UseStreamOptions, WidenUpdateMessages } from "@langchain/langgraph-sdk/stream";
 
 //#region src/use-stream.d.ts
-/** @deprecated Prefer {@link InferStateType}. */
-type StateOf$1<T> = StateOf<T>;
 type VueThreadId = MaybeRefOrGetter<string | null | undefined>;
 type VueApiString = MaybeRefOrGetter<string | undefined>;
 type AgentServerOptions$1<StateType extends object> = AgentServerOptions<StateType, VueThreadId, VueApiString, VueApiString>;
@@ -34,34 +32,163 @@ declare const STREAM_CONTROLLER: unique symbol;
  *    or client, remount the composable.
  */
 interface UseStreamReturn<T = Record<string, unknown>, InterruptType = unknown, ConfigurableType extends object = Record<string, unknown>, StateType extends object = InferStateType<T>, SubagentStates = InferSubagentStates<T>> {
+  /**
+   * The most recent `values`-channel snapshot emitted at the root
+   * namespace — i.e. the thread-level state as the server sees it
+   * after each superstep. Updated on every root `values` event, not
+   * on token-level deltas: if you render `stream.values.value.messages`
+   * directly you'll see full turns appear at once instead of
+   * streaming token-by-token. Use {@link messages} (or
+   * `useMessages`) for the token-streamed view.
+   *
+   * Equivalent to calling `useValues(stream)`.
+   */
   readonly values: Readonly<ShallowRef<StateType>>;
+  /**
+   * The root message projection. Assembled from two sources and
+   * merged in real time:
+   *
+   *  1. `messages`-channel deltas — token-level streaming events
+   *     (`message-start`, `content-block-delta`, `message-finish`)
+   *     emitted by the runtime. These drive live, token-by-token
+   *     updates.
+   *  2. `values.messages` snapshots — the authoritative ordering
+   *     and any messages the agent produces without token streaming
+   *     (human turns, tool results, echoes from subagents).
+   *
+   * If the backend only emits `values` events (no `messages`
+   * channel), every message will appear fully-formed on each
+   * values update rather than streaming. This is a backend/runtime
+   * concern — the Vue layer faithfully renders whatever the
+   * server sends.
+   *
+   * Equivalent to calling `useMessages(stream)` with no target.
+   */
   readonly messages: Readonly<ShallowRef<BaseMessage[]>>;
-  readonly toolCalls: Readonly<ShallowRef<AssembledToolCall[]>>;
+  /**
+   * Root-namespace tool calls assembled from the `tools` channel.
+   * Each entry is a fully parsed {@link AssembledToolCall} with
+   * name, args, and id — suitable for rendering approval UIs or
+   * forwarding to headless tool handlers.
+   *
+   * When the stream is typed with an agent brand or tool list,
+   * entries are narrowed via {@link InferToolCalls}. Equivalent to
+   * calling `useToolCalls(stream)` with no target.
+   */
+  readonly toolCalls: Readonly<ShallowRef<InferToolCalls<T>[]>>;
+  /**
+   * All unresolved protocol interrupts observed on the root
+   * namespace during the active thread. Populated from lifecycle /
+   * input events and seeded on hydration from `thread.getState()`.
+   * Cleared optimistically when a new run starts or an interrupt is
+   * resolved via {@link respond} / `submit({ command: { resume } })`.
+   */
   readonly interrupts: Readonly<ShallowRef<Interrupt<InterruptType>[]>>;
+  /**
+   * Convenience alias for {@link interrupts}[0] — the primary
+   * interrupt most UIs should act on when only one is pending.
+   * `undefined` when no interrupt is active.
+   */
   readonly interrupt: ComputedRef<Interrupt<InterruptType> | undefined>;
+  /**
+   * `true` while a run is active or being started on the current
+   * thread. Driven by root-namespace lifecycle events (`running` →
+   * `true`, terminal phases → `false`). Use this to disable submit
+   * buttons and show in-flight spinners.
+   */
   readonly isLoading: ComputedRef<boolean>;
+  /**
+   * `true` while the initial `thread.getState()` hydration for the
+   * active thread is in flight. Distinct from {@link isLoading} —
+   * thread loading covers the one-time fetch that seeds
+   * {@link values} / {@link messages} before any user submit.
+   */
   readonly isThreadLoading: ComputedRef<boolean>;
+  /**
+   * The last error observed on the active run or hydration attempt.
+   * `undefined` when no error has occurred. Cleared optimistically
+   * when a new {@link submit} starts.
+   */
   readonly error: ComputedRef<unknown>;
+  /**
+   * Id of the thread the controller is bound to. `null` until the
+   * first {@link submit} creates or selects a thread (or until an
+   * explicit `threadId` option is provided and hydrated).
+   */
   readonly threadId: ComputedRef<string | null>;
   /**
    * Promise that settles when the active thread's initial hydration
    * completes. Exposed so `async setup()` sites can
-   * `await stream.hydrationPromise` to implement a Suspense-like
-   * boundary.
+   * `await stream.hydrationPromise.value` to implement a
+   * Suspense-like boundary. A fresh promise is installed on every
+   * `threadId` change.
    */
   readonly hydrationPromise: ComputedRef<Promise<void>>;
+  /**
+   * Subagents discovered on the root run. For DeepAgent-typed
+   * streams the key set is narrowed to the subagent names declared
+   * on the agent brand (`keyof InferSubagentStates<T>`).
+   */
   readonly subagents: Readonly<ShallowRef<ReadonlyMap<keyof SubagentStates & string extends never ? string : keyof SubagentStates & string, SubagentDiscoverySnapshot>>>;
+  /**
+   * Subgraphs discovered on the root run.
+   *
+   * A namespace is classified as a subgraph iff at least one
+   * strictly-deeper namespace has been observed with it as a prefix.
+   * This is inferred from the lifecycle event stream — plain function
+   * nodes (`orchestrator`, `writer` in the nested-stategraph example)
+   * never appear here even though the server emits namespaced
+   * lifecycle events for them. Promotion is monotonic and retroactive;
+   * an entry appears as soon as the first descendant event lands.
+   */
   readonly subgraphs: Readonly<ShallowRef<ReadonlyMap<string, SubgraphDiscoverySnapshot>>>;
+  /**
+   * Subgraphs indexed by the graph node that produced them
+   * (`addNode("visualizer_0", …)`). Each value is an array because
+   * parallel fan-outs and loops can spawn multiple invocations of
+   * the same node; arrays preserve insertion order. Updates in
+   * lock-step with {@link subgraphs}.
+   */
   readonly subgraphsByNode: Readonly<ShallowRef<ReadonlyMap<string, readonly SubgraphDiscoverySnapshot[]>>>;
+  /**
+   * Dispatch a new run on the bound thread.
+   *
+   * `input` is typed as `Partial<StateType>` so IDE autocompletion
+   * surfaces the state keys declared on the root composable. Pass
+   * `null` (or omit fields) when resuming an interrupt via
+   * `options.command.resume` — the server accepts a null payload
+   * in that case.
+   */
   submit(input: WidenUpdateMessages<Partial<StateType>> | null | undefined, options?: StreamSubmitOptions<StateType, ConfigurableType>): Promise<void>;
+  /**
+   * Abort the in-flight run on the current thread without clearing
+   * accumulated state. Sets {@link isLoading} to `false` immediately;
+   * {@link values} and {@link messages} are preserved.
+   */
   stop(): Promise<void>;
+  /**
+   * Resume a pending protocol interrupt by sending a response payload
+   * back to the interrupted namespace.
+   *
+   * When `target` is omitted, responds to the latest unresolved
+   * interrupt in {@link interrupts}. Pass an explicit
+   * `{ interruptId, namespace? }` when multiple interrupts are
+   * pending or the interrupt lives in a subgraph namespace.
+   */
   respond(response: unknown, target?: {
     interruptId: string;
     namespace?: string[];
   }): Promise<void>;
+  /** LangGraph SDK client used to construct thread streams. */
   readonly client: Client;
+  /** Assistant id the thread is bound to for its lifetime. */
   readonly assistantId: string;
-  /** v2 escape hatch — returns the bound {@link ThreadStream}. */
+  /**
+   * Returns the bound {@link ThreadStream}, if one exists (`undefined`
+   * until the thread is hydrated or the first submit completes). Prefer
+   * the projections and selector composables for UI work; use this for
+   * low-level protocol access (raw subscriptions, state commands, etc.).
+   */
   getThread(): ThreadStream | undefined;
   /** @internal Used by selector composables. */
   readonly [STREAM_CONTROLLER]: StreamController<StateType, InterruptType, ConfigurableType>;
@@ -114,5 +241,5 @@ type UseStreamResult<T = Record<string, unknown>, InterruptType = unknown, Confi
  */
 declare function useStream<T = Record<string, unknown>, InterruptType = unknown, ConfigurableType extends object = Record<string, unknown>>(options: UseStreamOptions$1<InferStateType<T>>): UseStreamReturn<T, InterruptType, ConfigurableType>;
 //#endregion
-export { AgentServerOptions$1 as AgentServerOptions, AnyStream, CustomAdapterOptions$1 as CustomAdapterOptions, STREAM_CONTROLLER, StateOf$1 as StateOf, type ThreadStream, UseStreamOptions$1 as UseStreamOptions, UseStreamResult, UseStreamReturn, useStream };
+export { AgentServerOptions$1 as AgentServerOptions, AnyStream, CustomAdapterOptions$1 as CustomAdapterOptions, STREAM_CONTROLLER, type ThreadStream, UseStreamOptions$1 as UseStreamOptions, UseStreamResult, UseStreamReturn, useStream };
 //# sourceMappingURL=use-stream.d.cts.map

package/dist/use-stream.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"use-stream.d.cts","names":[],"sources":["../src/use-stream.ts"],"mappings":";;;;;;;;KAgDY,SAAA,MAAa,OAAA,CAAc,CAAA;AAAA,KAElC,WAAA,GAAc,gBAAA;AAAA,KACd,YAAA,GAAe,gBAAA;AAAA,KAER,oBAAA,6BACV,kBAAA,CAAyB,SAAA,EAAW,WAAA,EAAa,YAAA,EAAc,YAAA;AAAA,KAErD,sBAAA,6BACV,oBAAA,CAA2B,SAAA,EAAW,WAAA;AAAA,KAE5B,kBAAA,4BACiB,MAAA,qBACzB,gBAAA,CACF,SAAA,EACA,WAAA,EACA,YAAA,EACA,YAAA;;;;;AAjBwC;;cA2B7B,iBAAA;;;AAzBsB;;;;;AAGnC;;;;;;;UAwCiB,eAAA,KACX,MAAA,8EAE8B,MAAA,8CACP,cAAA,CAAe,CAAA,oBACzB,mBAAA,CAAoB,CAAA;EAAA,SAE5B,MAAA,EAAQ,QAAA,CAAS,UAAA,CAAW,SAAA;EAAA,SAC5B,QAAA,EAAU,QAAA,CAAS,UAAA,CAAW,WAAA;EAAA,SAC9B,SAAA,EAAW,QAAA,CAAS,UAAA,CAAW,iBAAA;EAAA,SAC/B,UAAA,EAAY,QAAA,CAAS,UAAA,CAAW,SAAA,CAAU,aAAA;EAAA,SAC1C,SAAA,EAAW,WAAA,CAAY,SAAA,CAAU,aAAA;EAAA,SACjC,SAAA,EAAW,WAAA;EAAA,SACX,eAAA,EAAiB,WAAA;EAAA,SACjB,KAAA,EAAO,WAAA;EAAA,SACP,QAAA,EAAU,WAAA;EAtDwD;AAE7E;;;;;EAF6E,SA8DlE,gBAAA,EAAkB,WAAA,CAAY,OAAA;EAAA,SAE9B,SAAA,EAAW,QAAA,CAClB,UAAA,CACE,WAAA,OACQ,cAAA,yCAEI,cAAA,WACV,yBAAA;EAAA,SAIG,SAAA,EAAW,QAAA,CAClB,UAAA,CAAW,WAAA,SAAoB,yBAAA;EAAA,SAExB,eAAA,EAAiB,QAAA,CACxB,UAAA,CAAW,WAAA,kBAA6B,yBAAA;EAG1C,MAAA,CACE,KAAA,EAAO,mBAAA,CAAoB,OAAA,CAAQ,SAAA,uBACnC,OAAA,GAAU,mBAAA,CAAoB,SAAA,EAAW,gBAAA,IACxC,OAAA;EACH,IAAA,IAAQ,OAAA;EACR,OAAA,CACE,QAAA,WACA,MAAA;IAAW,WAAA;IAAqB,SAAA;EAAA,IAC/B,OAAA;EAAA,SAEM,MAAA,EAAQ,MAAA;EAAA,SACR,WAAA;EAtFkB;EAyF3B,SAAA,IAAa,YAAA;EAtFb;EAAA,UAyFU,iBAAA,GAAoB,gBAAA,CAC5B,SAAA,EACA,aAAA,EACA,gBAAA;AAAA;;;;;;;KAWQ,SAAA,GAAY,eAAA;;KAGZ,eAAA,KACN,MAAA,8EAE8B,MAAA,qBAChC,eAAA,CAAgB,CAAA,EAAG,aAAA,EAAe,gBAAA;;;;AAlGtC;;;;;AAkBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuHgB,SAAA,KACV,MAAA,8EAE8B,MAAA,kBAAA,CAElC,OAAA,EAAS,kBAAA,CAAiB,cAAA,CAAe,CAAA,KACxC,eAAA,CAAgB,CAAA,EAAG,aAAA,EAAe,gBAAA"}
+{"version":3,"file":"use-stream.d.cts","names":[],"sources":["../src/use-stream.ts"],"mappings":";;;;;;;KAiDK,WAAA,GAAc,gBAAA;AAAA,KACd,YAAA,GAAe,gBAAA;AAAA,KAER,oBAAA,6BACV,kBAAA,CAAyB,SAAA,EAAW,WAAA,EAAa,YAAA,EAAc,YAAA;AAAA,KAErD,sBAAA,6BACV,oBAAA,CAA2B,SAAA,EAAW,WAAA;AAAA,KAE5B,kBAAA,4BACiB,MAAA,qBACzB,gBAAA,CACF,SAAA,EACA,WAAA,EACA,YAAA,EACA,YAAA;;;AAfiC;;;;cAyBtB,iBAAA;AAtBb;;;;;;;;;;;;;;AAAA,UAwCiB,eAAA,KACX,MAAA,8EAE8B,MAAA,8CACP,cAAA,CAAe,CAAA,oBACzB,mBAAA,CAAoB,CAAA;EA5C0B;;;AAEjE;;;;;;;;EAFiE,SA0DtD,MAAA,EAAQ,QAAA,CAAS,UAAA,CAAW,SAAA;EAvDrC;;;;;AAEF;;;;;;;;;;;;;;;EAFE,SA4ES,QAAA,EAAU,QAAA,CAAS,UAAA,CAAW,WAAA;EArEvC;;;;AAWF;;;;;AAkBA;EA7BE,SAgFS,SAAA,EAAW,QAAA,CAAS,UAAA,CAAW,cAAA,CAAe,CAAA;EAnDzB;;;;;;;EAAA,SA2DrB,UAAA,EAAY,QAAA,CAAS,UAAA,CAAW,SAAA,CAAU,aAAA;EAxCzB;;;;;EAAA,SA8CjB,SAAA,EAAW,WAAA,CAAY,SAAA,CAAU,aAAA;EAdF;;;;;;EAAA,SAqB/B,SAAA,EAAW,WAAA;EAPsB;;;;;;EAAA,SAcjC,eAAA,EAAiB,WAAA;EAoBa;;;;;EAAA,SAd9B,KAAA,EAAO,WAAA;EAuBd;;;;;EAAA,SAjBO,QAAA,EAAU,WAAA;EAgDuB;;;;;;;EAAA,SAxCjC,gBAAA,EAAkB,WAAA,CAAY,OAAA;EAuDI;;;;;EAAA,SA/ClC,SAAA,EAAW,QAAA,CAClB,UAAA,CACE,WAAA,OACQ,cAAA,yCAEI,cAAA,WACV,yBAAA;EA2EO;;;;;;;;;;;EAAA,SA5DJ,SAAA,EAAW,QAAA,CAClB,UAAA,CAAW,WAAA,SAAoB,yBAAA;EA9HC;;;;;;;EAAA,SAuIzB,eAAA,EAAiB,QAAA,CACxB,UAAA,CAAW,WAAA,kBAA6B,yBAAA;EAxHzB;;;;;;;;;EAqIjB,MAAA,CACE,KAAA,EAAO,mBAAA,CAAoB,OAAA,CAAQ,SAAA,uBACnC,OAAA,GAAU,mBAAA,CAAoB,SAAA,EAAW,gBAAA,IACxC,OAAA;EAxGqC;;;;;EA8GxC,IAAA,IAAQ,OAAA;EAtG2C;;;;;;;;;EAgHnD,OAAA,CACE,QAAA,WACA,MAAA;IAAW,WAAA;IAAqB,SAAA;EAAA,IAC/B,OAAA;EA3EM;EAAA,SA+EA,MAAA,EAAQ,MAAA;EA/EsB;EAAA,SAiF9B,WAAA;EAzEW;;;;;;EAiFpB,SAAA,IAAa,YAAA;EA5DO;EAAA,UA+DV,iBAAA,GAAoB,gBAAA,CAC5B,SAAA,EACA,aAAA,EACA,gBAAA;AAAA;;;;;;;KAWQ,SAAA,GAAY,eAAA;;KAGZ,eAAA,KACN,MAAA,8EAE8B,MAAA,qBAChC,eAAA,CAAgB,CAAA,EAAG,aAAA,EAAe,gBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAPtC;;;;;AAGA;;;;;iBA2CgB,SAAA,KACV,MAAA,8EAE8B,MAAA,kBAAA,CAElC,OAAA,EAAS,kBAAA,CAAiB,cAAA,CAAe,CAAA,KACxC,eAAA,CAAgB,CAAA,EAAG,aAAA,EAAe,gBAAA"}

package/dist/use-stream.d.ts

@@ -1,12 +1,10 @@
 import { ComputedRef, MaybeRefOrGetter, ShallowRef } from "vue";
 import { Client, Interrupt } from "@langchain/langgraph-sdk";
 import { ThreadStream } from "@langchain/langgraph-sdk/client";
-import { AgentServerOptions, AssembledToolCall, ChannelRegistry, CustomAdapterOptions, InferStateType, InferSubagentStates, StateOf, StreamController, StreamSubmitOptions, SubagentDiscoverySnapshot, SubgraphDiscoverySnapshot, UseStreamOptions, WidenUpdateMessages } from "@langchain/langgraph-sdk/stream";
+import { AgentServerOptions, ChannelRegistry, CustomAdapterOptions, InferStateType, InferSubagentStates, InferToolCalls, StreamController, StreamSubmitOptions, SubagentDiscoverySnapshot, SubgraphDiscoverySnapshot, UseStreamOptions, WidenUpdateMessages } from "@langchain/langgraph-sdk/stream";
 import { BaseMessage } from "@langchain/core/messages";
 
 //#region src/use-stream.d.ts
-/** @deprecated Prefer {@link InferStateType}. */
-type StateOf$1<T> = StateOf<T>;
 type VueThreadId = MaybeRefOrGetter<string | null | undefined>;
 type VueApiString = MaybeRefOrGetter<string | undefined>;
 type AgentServerOptions$1<StateType extends object> = AgentServerOptions<StateType, VueThreadId, VueApiString, VueApiString>;
@@ -34,34 +32,163 @@ declare const STREAM_CONTROLLER: unique symbol;
  *    or client, remount the composable.
  */
 interface UseStreamReturn<T = Record<string, unknown>, InterruptType = unknown, ConfigurableType extends object = Record<string, unknown>, StateType extends object = InferStateType<T>, SubagentStates = InferSubagentStates<T>> {
+  /**
+   * The most recent `values`-channel snapshot emitted at the root
+   * namespace — i.e. the thread-level state as the server sees it
+   * after each superstep. Updated on every root `values` event, not
+   * on token-level deltas: if you render `stream.values.value.messages`
+   * directly you'll see full turns appear at once instead of
+   * streaming token-by-token. Use {@link messages} (or
+   * `useMessages`) for the token-streamed view.
+   *
+   * Equivalent to calling `useValues(stream)`.
+   */
   readonly values: Readonly<ShallowRef<StateType>>;
+  /**
+   * The root message projection. Assembled from two sources and
+   * merged in real time:
+   *
+   *  1. `messages`-channel deltas — token-level streaming events
+   *     (`message-start`, `content-block-delta`, `message-finish`)
+   *     emitted by the runtime. These drive live, token-by-token
+   *     updates.
+   *  2. `values.messages` snapshots — the authoritative ordering
+   *     and any messages the agent produces without token streaming
+   *     (human turns, tool results, echoes from subagents).
+   *
+   * If the backend only emits `values` events (no `messages`
+   * channel), every message will appear fully-formed on each
+   * values update rather than streaming. This is a backend/runtime
+   * concern — the Vue layer faithfully renders whatever the
+   * server sends.
+   *
+   * Equivalent to calling `useMessages(stream)` with no target.
+   */
   readonly messages: Readonly<ShallowRef<BaseMessage[]>>;
-  readonly toolCalls: Readonly<ShallowRef<AssembledToolCall[]>>;
+  /**
+   * Root-namespace tool calls assembled from the `tools` channel.
+   * Each entry is a fully parsed {@link AssembledToolCall} with
+   * name, args, and id — suitable for rendering approval UIs or
+   * forwarding to headless tool handlers.
+   *
+   * When the stream is typed with an agent brand or tool list,
+   * entries are narrowed via {@link InferToolCalls}. Equivalent to
+   * calling `useToolCalls(stream)` with no target.
+   */
+  readonly toolCalls: Readonly<ShallowRef<InferToolCalls<T>[]>>;
+  /**
+   * All unresolved protocol interrupts observed on the root
+   * namespace during the active thread. Populated from lifecycle /
+   * input events and seeded on hydration from `thread.getState()`.
+   * Cleared optimistically when a new run starts or an interrupt is
+   * resolved via {@link respond} / `submit({ command: { resume } })`.
+   */
   readonly interrupts: Readonly<ShallowRef<Interrupt<InterruptType>[]>>;
+  /**
+   * Convenience alias for {@link interrupts}[0] — the primary
+   * interrupt most UIs should act on when only one is pending.
+   * `undefined` when no interrupt is active.
+   */
   readonly interrupt: ComputedRef<Interrupt<InterruptType> | undefined>;
+  /**
+   * `true` while a run is active or being started on the current
+   * thread. Driven by root-namespace lifecycle events (`running` →
+   * `true`, terminal phases → `false`). Use this to disable submit
+   * buttons and show in-flight spinners.
+   */
   readonly isLoading: ComputedRef<boolean>;
+  /**
+   * `true` while the initial `thread.getState()` hydration for the
+   * active thread is in flight. Distinct from {@link isLoading} —
+   * thread loading covers the one-time fetch that seeds
+   * {@link values} / {@link messages} before any user submit.
+   */
   readonly isThreadLoading: ComputedRef<boolean>;
+  /**
+   * The last error observed on the active run or hydration attempt.
+   * `undefined` when no error has occurred. Cleared optimistically
+   * when a new {@link submit} starts.
+   */
   readonly error: ComputedRef<unknown>;
+  /**
+   * Id of the thread the controller is bound to. `null` until the
+   * first {@link submit} creates or selects a thread (or until an
+   * explicit `threadId` option is provided and hydrated).
+   */
   readonly threadId: ComputedRef<string | null>;
   /**
    * Promise that settles when the active thread's initial hydration
    * completes. Exposed so `async setup()` sites can
-   * `await stream.hydrationPromise` to implement a Suspense-like
-   * boundary.
+   * `await stream.hydrationPromise.value` to implement a
+   * Suspense-like boundary. A fresh promise is installed on every
+   * `threadId` change.
    */
   readonly hydrationPromise: ComputedRef<Promise<void>>;
+  /**
+   * Subagents discovered on the root run. For DeepAgent-typed
+   * streams the key set is narrowed to the subagent names declared
+   * on the agent brand (`keyof InferSubagentStates<T>`).
+   */
   readonly subagents: Readonly<ShallowRef<ReadonlyMap<keyof SubagentStates & string extends never ? string : keyof SubagentStates & string, SubagentDiscoverySnapshot>>>;
+  /**
+   * Subgraphs discovered on the root run.
+   *
+   * A namespace is classified as a subgraph iff at least one
+   * strictly-deeper namespace has been observed with it as a prefix.
+   * This is inferred from the lifecycle event stream — plain function
+   * nodes (`orchestrator`, `writer` in the nested-stategraph example)
+   * never appear here even though the server emits namespaced
+   * lifecycle events for them. Promotion is monotonic and retroactive;
+   * an entry appears as soon as the first descendant event lands.
+   */
   readonly subgraphs: Readonly<ShallowRef<ReadonlyMap<string, SubgraphDiscoverySnapshot>>>;
+  /**
+   * Subgraphs indexed by the graph node that produced them
+   * (`addNode("visualizer_0", …)`). Each value is an array because
+   * parallel fan-outs and loops can spawn multiple invocations of
+   * the same node; arrays preserve insertion order. Updates in
+   * lock-step with {@link subgraphs}.
+   */
   readonly subgraphsByNode: Readonly<ShallowRef<ReadonlyMap<string, readonly SubgraphDiscoverySnapshot[]>>>;
+  /**
+   * Dispatch a new run on the bound thread.
+   *
+   * `input` is typed as `Partial<StateType>` so IDE autocompletion
+   * surfaces the state keys declared on the root composable. Pass
+   * `null` (or omit fields) when resuming an interrupt via
+   * `options.command.resume` — the server accepts a null payload
+   * in that case.
+   */
   submit(input: WidenUpdateMessages<Partial<StateType>> | null | undefined, options?: StreamSubmitOptions<StateType, ConfigurableType>): Promise<void>;
+  /**
+   * Abort the in-flight run on the current thread without clearing
+   * accumulated state. Sets {@link isLoading} to `false` immediately;
+   * {@link values} and {@link messages} are preserved.
+   */
   stop(): Promise<void>;
+  /**
+   * Resume a pending protocol interrupt by sending a response payload
+   * back to the interrupted namespace.
+   *
+   * When `target` is omitted, responds to the latest unresolved
+   * interrupt in {@link interrupts}. Pass an explicit
+   * `{ interruptId, namespace? }` when multiple interrupts are
+   * pending or the interrupt lives in a subgraph namespace.
+   */
   respond(response: unknown, target?: {
     interruptId: string;
     namespace?: string[];
   }): Promise<void>;
+  /** LangGraph SDK client used to construct thread streams. */
   readonly client: Client;
+  /** Assistant id the thread is bound to for its lifetime. */
   readonly assistantId: string;
-  /** v2 escape hatch — returns the bound {@link ThreadStream}. */
+  /**
+   * Returns the bound {@link ThreadStream}, if one exists (`undefined`
+   * until the thread is hydrated or the first submit completes). Prefer
+   * the projections and selector composables for UI work; use this for
+   * low-level protocol access (raw subscriptions, state commands, etc.).
+   */
   getThread(): ThreadStream | undefined;
   /** @internal Used by selector composables. */
   readonly [STREAM_CONTROLLER]: StreamController<StateType, InterruptType, ConfigurableType>;
@@ -114,5 +241,5 @@ type UseStreamResult<T = Record<string, unknown>, InterruptType = unknown, Confi
  */
 declare function useStream<T = Record<string, unknown>, InterruptType = unknown, ConfigurableType extends object = Record<string, unknown>>(options: UseStreamOptions$1<InferStateType<T>>): UseStreamReturn<T, InterruptType, ConfigurableType>;
 //#endregion
-export { AgentServerOptions$1 as AgentServerOptions, AnyStream, CustomAdapterOptions$1 as CustomAdapterOptions, STREAM_CONTROLLER, StateOf$1 as StateOf, type ThreadStream, UseStreamOptions$1 as UseStreamOptions, UseStreamResult, UseStreamReturn, useStream };
+export { AgentServerOptions$1 as AgentServerOptions, AnyStream, CustomAdapterOptions$1 as CustomAdapterOptions, STREAM_CONTROLLER, type ThreadStream, UseStreamOptions$1 as UseStreamOptions, UseStreamResult, UseStreamReturn, useStream };
 //# sourceMappingURL=use-stream.d.ts.map

package/dist/use-stream.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-stream.d.ts","names":[],"sources":["../src/use-stream.ts"],"mappings":";;;;;;;;KAgDY,SAAA,MAAa,OAAA,CAAc,CAAA;AAAA,KAElC,WAAA,GAAc,gBAAA;AAAA,KACd,YAAA,GAAe,gBAAA;AAAA,KAER,oBAAA,6BACV,kBAAA,CAAyB,SAAA,EAAW,WAAA,EAAa,YAAA,EAAc,YAAA;AAAA,KAErD,sBAAA,6BACV,oBAAA,CAA2B,SAAA,EAAW,WAAA;AAAA,KAE5B,kBAAA,4BACiB,MAAA,qBACzB,gBAAA,CACF,SAAA,EACA,WAAA,EACA,YAAA,EACA,YAAA;;;;;AAjBwC;;cA2B7B,iBAAA;;;AAzBsB;;;;;AAGnC;;;;;;;UAwCiB,eAAA,KACX,MAAA,8EAE8B,MAAA,8CACP,cAAA,CAAe,CAAA,oBACzB,mBAAA,CAAoB,CAAA;EAAA,SAE5B,MAAA,EAAQ,QAAA,CAAS,UAAA,CAAW,SAAA;EAAA,SAC5B,QAAA,EAAU,QAAA,CAAS,UAAA,CAAW,WAAA;EAAA,SAC9B,SAAA,EAAW,QAAA,CAAS,UAAA,CAAW,iBAAA;EAAA,SAC/B,UAAA,EAAY,QAAA,CAAS,UAAA,CAAW,SAAA,CAAU,aAAA;EAAA,SAC1C,SAAA,EAAW,WAAA,CAAY,SAAA,CAAU,aAAA;EAAA,SACjC,SAAA,EAAW,WAAA;EAAA,SACX,eAAA,EAAiB,WAAA;EAAA,SACjB,KAAA,EAAO,WAAA;EAAA,SACP,QAAA,EAAU,WAAA;EAtDwD;AAE7E;;;;;EAF6E,SA8DlE,gBAAA,EAAkB,WAAA,CAAY,OAAA;EAAA,SAE9B,SAAA,EAAW,QAAA,CAClB,UAAA,CACE,WAAA,OACQ,cAAA,yCAEI,cAAA,WACV,yBAAA;EAAA,SAIG,SAAA,EAAW,QAAA,CAClB,UAAA,CAAW,WAAA,SAAoB,yBAAA;EAAA,SAExB,eAAA,EAAiB,QAAA,CACxB,UAAA,CAAW,WAAA,kBAA6B,yBAAA;EAG1C,MAAA,CACE,KAAA,EAAO,mBAAA,CAAoB,OAAA,CAAQ,SAAA,uBACnC,OAAA,GAAU,mBAAA,CAAoB,SAAA,EAAW,gBAAA,IACxC,OAAA;EACH,IAAA,IAAQ,OAAA;EACR,OAAA,CACE,QAAA,WACA,MAAA;IAAW,WAAA;IAAqB,SAAA;EAAA,IAC/B,OAAA;EAAA,SAEM,MAAA,EAAQ,MAAA;EAAA,SACR,WAAA;EAtFkB;EAyF3B,SAAA,IAAa,YAAA;EAtFb;EAAA,UAyFU,iBAAA,GAAoB,gBAAA,CAC5B,SAAA,EACA,aAAA,EACA,gBAAA;AAAA;;;;;;;KAWQ,SAAA,GAAY,eAAA;;KAGZ,eAAA,KACN,MAAA,8EAE8B,MAAA,qBAChC,eAAA,CAAgB,CAAA,EAAG,aAAA,EAAe,gBAAA;;;;AAlGtC;;;;;AAkBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuHgB,SAAA,KACV,MAAA,8EAE8B,MAAA,kBAAA,CAElC,OAAA,EAAS,kBAAA,CAAiB,cAAA,CAAe,CAAA,KACxC,eAAA,CAAgB,CAAA,EAAG,aAAA,EAAe,gBAAA"}
+{"version":3,"file":"use-stream.d.ts","names":[],"sources":["../src/use-stream.ts"],"mappings":";;;;;;;KAiDK,WAAA,GAAc,gBAAA;AAAA,KACd,YAAA,GAAe,gBAAA;AAAA,KAER,oBAAA,6BACV,kBAAA,CAAyB,SAAA,EAAW,WAAA,EAAa,YAAA,EAAc,YAAA;AAAA,KAErD,sBAAA,6BACV,oBAAA,CAA2B,SAAA,EAAW,WAAA;AAAA,KAE5B,kBAAA,4BACiB,MAAA,qBACzB,gBAAA,CACF,SAAA,EACA,WAAA,EACA,YAAA,EACA,YAAA;;;AAfiC;;;;cAyBtB,iBAAA;AAtBb;;;;;;;;;;;;;;AAAA,UAwCiB,eAAA,KACX,MAAA,8EAE8B,MAAA,8CACP,cAAA,CAAe,CAAA,oBACzB,mBAAA,CAAoB,CAAA;EA5C0B;;;AAEjE;;;;;;;;EAFiE,SA0DtD,MAAA,EAAQ,QAAA,CAAS,UAAA,CAAW,SAAA;EAvDrC;;;;;AAEF;;;;;;;;;;;;;;;EAFE,SA4ES,QAAA,EAAU,QAAA,CAAS,UAAA,CAAW,WAAA;EArEvC;;;;AAWF;;;;;AAkBA;EA7BE,SAgFS,SAAA,EAAW,QAAA,CAAS,UAAA,CAAW,cAAA,CAAe,CAAA;EAnDzB;;;;;;;EAAA,SA2DrB,UAAA,EAAY,QAAA,CAAS,UAAA,CAAW,SAAA,CAAU,aAAA;EAxCzB;;;;;EAAA,SA8CjB,SAAA,EAAW,WAAA,CAAY,SAAA,CAAU,aAAA;EAdF;;;;;;EAAA,SAqB/B,SAAA,EAAW,WAAA;EAPsB;;;;;;EAAA,SAcjC,eAAA,EAAiB,WAAA;EAoBa;;;;;EAAA,SAd9B,KAAA,EAAO,WAAA;EAuBd;;;;;EAAA,SAjBO,QAAA,EAAU,WAAA;EAgDuB;;;;;;;EAAA,SAxCjC,gBAAA,EAAkB,WAAA,CAAY,OAAA;EAuDI;;;;;EAAA,SA/ClC,SAAA,EAAW,QAAA,CAClB,UAAA,CACE,WAAA,OACQ,cAAA,yCAEI,cAAA,WACV,yBAAA;EA2EO;;;;;;;;;;;EAAA,SA5DJ,SAAA,EAAW,QAAA,CAClB,UAAA,CAAW,WAAA,SAAoB,yBAAA;EA9HC;;;;;;;EAAA,SAuIzB,eAAA,EAAiB,QAAA,CACxB,UAAA,CAAW,WAAA,kBAA6B,yBAAA;EAxHzB;;;;;;;;;EAqIjB,MAAA,CACE,KAAA,EAAO,mBAAA,CAAoB,OAAA,CAAQ,SAAA,uBACnC,OAAA,GAAU,mBAAA,CAAoB,SAAA,EAAW,gBAAA,IACxC,OAAA;EAxGqC;;;;;EA8GxC,IAAA,IAAQ,OAAA;EAtG2C;;;;;;;;;EAgHnD,OAAA,CACE,QAAA,WACA,MAAA;IAAW,WAAA;IAAqB,SAAA;EAAA,IAC/B,OAAA;EA3EM;EAAA,SA+EA,MAAA,EAAQ,MAAA;EA/EsB;EAAA,SAiF9B,WAAA;EAzEW;;;;;;EAiFpB,SAAA,IAAa,YAAA;EA5DO;EAAA,UA+DV,iBAAA,GAAoB,gBAAA,CAC5B,SAAA,EACA,aAAA,EACA,gBAAA;AAAA;;;;;;;KAWQ,SAAA,GAAY,eAAA;;KAGZ,eAAA,KACN,MAAA,8EAE8B,MAAA,qBAChC,eAAA,CAAgB,CAAA,EAAG,aAAA,EAAe,gBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAPtC;;;;;AAGA;;;;;iBA2CgB,SAAA,KACV,MAAA,8EAE8B,MAAA,kBAAA,CAElC,OAAA,EAAS,kBAAA,CAAiB,cAAA,CAAe,CAAA,KACxC,eAAA,CAAgB,CAAA,EAAG,aAAA,EAAe,gBAAA"}

package/dist/use-stream.js

@@ -1,6 +1,6 @@
 import { LANGCHAIN_OPTIONS } from "./context.js";
 import { computed, inject, onScopeDispose, readonly, shallowRef, toValue, watch } from "vue";
-import { filterOutHeadlessToolInterrupts, flushPendingHeadlessToolInterrupts } from "@langchain/langgraph-sdk";
+import { filterOutHeadlessToolInterrupts, flushPendingHeadlessToolInterrupts, scheduleCoalescedHeadlessToolFlush } from "@langchain/langgraph-sdk";
 import { Client as Client$1 } from "@langchain/langgraph-sdk/client";
 import { StreamController } from "@langchain/langgraph-sdk/stream";
 //#region src/use-stream.ts
@@ -72,6 +72,7 @@ function useStream(options) {
 		webSocketFactory: hasCustomAdapter ? void 0 : asBag.webSocketFactory,
 		onThreadId: options.onThreadId,
 		onCreated: options.onCreated,
+		onCompleted: options.onCompleted,
 		initialValues: options.initialValues,
 		messagesKey: options.messagesKey
 	});
@@ -110,24 +111,27 @@ function useStream(options) {
 	watch(() => toValue(asBag.threadId) ?? null, () => handledTools.clear());
 	const tools = options.tools;
 	const onTool = options.onTool;
-	if (tools?.length) watch(() => [rootRef.value.values, rootRef.value.interrupts], ([rootValues, rootInterrupts]) => {
-		const bag = rootValues;
-		const combined = [...Array.isArray(bag?.__interrupt__) ? bag.__interrupt__ : [], ...rootInterrupts];
-		if (combined.length === 0) return;
-		flushPendingHeadlessToolInterrupts({
-			...bag,
-			__interrupt__: combined
-		}, tools, handledTools, {
-			onTool,
-			defer: (run) => {
-				Promise.resolve().then(run);
-			},
-			resumeSubmit: (command) => controller.submit(null, { command })
+	if (tools?.length) watch(() => [rootRef.value.values, rootRef.value.interrupts], () => {
+		scheduleCoalescedHeadlessToolFlush(handledTools, () => {
+			const rootValues = rootRef.value.values;
+			const rootInterrupts = rootRef.value.interrupts;
+			const bag = rootValues;
+			const protocolInterrupts = rootInterrupts;
+			const valuesInterrupts = Array.isArray(bag?.__interrupt__) ? bag.__interrupt__ : [];
+			const headlessInterrupts = protocolInterrupts.length > 0 ? protocolInterrupts : valuesInterrupts;
+			if (headlessInterrupts.length === 0) return;
+			flushPendingHeadlessToolInterrupts({
+				...bag,
+				__interrupt__: headlessInterrupts
+			}, tools, handledTools, {
+				onTool,
+				defer: (run) => {
+					Promise.resolve().then(run);
+				},
+				resumeSubmit: (command) => controller.submit(null, { command })
+			});
 		});
-	}, {
-		immediate: true,
-		flush: "sync"
-	});
+	}, { immediate: true });
 	return {
 		values: asShallow(values),
 		messages: asShallow(messages),

package/dist/use-stream.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-stream.js","names":["ClientCtor"],"sources":["../src/use-stream.ts"],"sourcesContent":["import {\n  computed,\n  onScopeDispose,\n  readonly,\n  shallowRef,\n  toValue,\n  watch,\n  type ComputedRef,\n  type MaybeRefOrGetter,\n  type ShallowRef,\n} from \"vue\";\nimport type { BaseMessage } from \"@langchain/core/messages\";\nimport type { Client, Interrupt } from \"@langchain/langgraph-sdk\";\nimport {\n  filterOutHeadlessToolInterrupts,\n  flushPendingHeadlessToolInterrupts,\n  type AnyHeadlessToolImplementation,\n  type OnToolCallback,\n} from \"@langchain/langgraph-sdk\";\nimport {\n  Client as ClientCtor,\n  type ClientConfig,\n  type ThreadStream,\n} from \"@langchain/langgraph-sdk/client\";\nimport {\n  StreamController,\n  type AgentServerAdapter,\n  type AgentServerOptions as StreamAgentServerOptions,\n  type AssembledToolCall,\n  type ChannelRegistry,\n  type CustomAdapterOptions as StreamCustomAdapterOptions,\n  type InferStateType,\n  type InferSubagentStates,\n  type RootSnapshot,\n  type StateOf as StreamStateOf,\n  type StreamSubmitOptions,\n  type SubagentDiscoverySnapshot,\n  type SubagentMap,\n  type SubgraphByNodeMap,\n  type SubgraphDiscoverySnapshot,\n  type SubgraphMap,\n  type UseStreamOptions as StreamUseStreamOptions,\n  type WidenUpdateMessages,\n} from \"@langchain/langgraph-sdk/stream\";\nimport { inject } from \"vue\";\nimport { LANGCHAIN_OPTIONS } from \"./context.js\";\n\n/** @deprecated Prefer {@link InferStateType}. */\nexport type StateOf<T> = StreamStateOf<T>;\n\ntype VueThreadId = MaybeRefOrGetter<string | null | undefined>;\ntype VueApiString = MaybeRefOrGetter<string | undefined>;\n\nexport type AgentServerOptions<StateType extends object> =\n  StreamAgentServerOptions<StateType, VueThreadId, VueApiString, VueApiString>;\n\nexport type CustomAdapterOptions<StateType extends object> =\n  StreamCustomAdapterOptions<StateType, VueThreadId, string>;\n\nexport type UseStreamOptions<\n  StateType extends object = Record<string, unknown>,\n> = StreamUseStreamOptions<\n  StateType,\n  VueThreadId,\n  VueApiString,\n  VueApiString,\n  string\n>;\n\n/**\n * Private field on the handle that carries the {@link StreamController}\n * reference. Selector composables read this to reach the shared\n * {@link ChannelRegistry}. Use the selector composables (`useMessages`,\n * `useToolCalls`, `useValues`, …) instead of reading this directly.\n */\nexport const STREAM_CONTROLLER: unique symbol = Symbol.for(\n  \"@langchain/vue/controller\"\n);\n\n/**\n * Vue binding return type for {@link useStream}.\n *\n * Reactive primitives follow Vue conventions:\n *\n *  - Data projections are `Readonly<ShallowRef<T>>` / `ComputedRef<T>`\n *    so templates auto-unwrap via `msg.value` in `<script setup>`\n *    and directly in templates. They are snapshots — never mutate.\n *  - Imperative methods (`submit` / `stop` / `respond`) are plain\n *    functions — no refs involved.\n *  - Identity values captured at setup time (`client` / `assistantId`)\n *    are exposed as plain values; if you need to swap the bound agent\n *    or client, remount the composable.\n */\nexport interface UseStreamReturn<\n  T = Record<string, unknown>,\n  InterruptType = unknown,\n  ConfigurableType extends object = Record<string, unknown>,\n  StateType extends object = InferStateType<T>,\n  SubagentStates = InferSubagentStates<T>,\n> {\n  readonly values: Readonly<ShallowRef<StateType>>;\n  readonly messages: Readonly<ShallowRef<BaseMessage[]>>;\n  readonly toolCalls: Readonly<ShallowRef<AssembledToolCall[]>>;\n  readonly interrupts: Readonly<ShallowRef<Interrupt<InterruptType>[]>>;\n  readonly interrupt: ComputedRef<Interrupt<InterruptType> | undefined>;\n  readonly isLoading: ComputedRef<boolean>;\n  readonly isThreadLoading: ComputedRef<boolean>;\n  readonly error: ComputedRef<unknown>;\n  readonly threadId: ComputedRef<string | null>;\n\n  /**\n   * Promise that settles when the active thread's initial hydration\n   * completes. Exposed so `async setup()` sites can\n   * `await stream.hydrationPromise` to implement a Suspense-like\n   * boundary.\n   */\n  readonly hydrationPromise: ComputedRef<Promise<void>>;\n\n  readonly subagents: Readonly<\n    ShallowRef<\n      ReadonlyMap<\n        keyof SubagentStates & string extends never\n          ? string\n          : keyof SubagentStates & string,\n        SubagentDiscoverySnapshot\n      >\n    >\n  >;\n  readonly subgraphs: Readonly<\n    ShallowRef<ReadonlyMap<string, SubgraphDiscoverySnapshot>>\n  >;\n  readonly subgraphsByNode: Readonly<\n    ShallowRef<ReadonlyMap<string, readonly SubgraphDiscoverySnapshot[]>>\n  >;\n\n  submit(\n    input: WidenUpdateMessages<Partial<StateType>> | null | undefined,\n    options?: StreamSubmitOptions<StateType, ConfigurableType>\n  ): Promise<void>;\n  stop(): Promise<void>;\n  respond(\n    response: unknown,\n    target?: { interruptId: string; namespace?: string[] }\n  ): Promise<void>;\n\n  readonly client: Client;\n  readonly assistantId: string;\n\n  /** v2 escape hatch — returns the bound {@link ThreadStream}. */\n  getThread(): ThreadStream | undefined;\n\n  /** @internal Used by selector composables. */\n  readonly [STREAM_CONTROLLER]: StreamController<\n    StateType,\n    InterruptType,\n    ConfigurableType\n  >;\n}\n\n/**\n * Erased handle useful as a parameter type for helpers and wrapper\n * components that pass a `stream` through to selector composables\n * without reading `values` directly. Mirrors the React\n * `AnyStream` alias.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type AnyStream = UseStreamReturn<any, any, any>;\n\n/** Convenience alias for the fully-resolved stream handle type. */\nexport type UseStreamResult<\n  T = Record<string, unknown>,\n  InterruptType = unknown,\n  ConfigurableType extends object = Record<string, unknown>,\n> = UseStreamReturn<T, InterruptType, ConfigurableType>;\n\n/**\n * Vue Composition API binding for the v2-native stream runtime.\n *\n * Returns a handle whose projections are Vue refs so templates\n * auto-unwrap and scripts can feed them into `computed`/`watch`.\n * Scoped views (subagents, subgraphs, any namespaced projection) are\n * surfaced via the companion selector composables (`useMessages`,\n * `useToolCalls`, `useValues`, `useMessageMetadata`,\n * `useSubmissionQueue`, `useExtension`, `useChannel`, plus media\n * composables).\n *\n * @example\n * ```vue\n * <script setup lang=\"ts\">\n * import { useStream } from \"@langchain/vue\";\n *\n * const stream = useStream({\n *   assistantId: \"agent\",\n *   apiUrl: \"http://localhost:2024\",\n * });\n * </script>\n *\n * <template>\n *   <div v-for=\"msg in stream.messages.value\" :key=\"msg.id\">\n *     {{ msg.content }}\n *   </div>\n *   <button @click=\"stream.submit({ messages: [{ type: 'human', content: 'Hi' }] })\">\n *     Send\n *   </button>\n * </template>\n * ```\n *\n * `assistantId`, `client`, and `transport` are captured at setup time.\n * To bind a new assistant/transport, remount the component. Reactive\n * inputs (`threadId`, `apiUrl`, `apiKey`) trigger in-place behaviour\n * changes on the active controller.\n */\nexport function useStream<\n  T = Record<string, unknown>,\n  InterruptType = unknown,\n  ConfigurableType extends object = Record<string, unknown>,\n>(\n  options: UseStreamOptions<InferStateType<T>>\n): UseStreamReturn<T, InterruptType, ConfigurableType> {\n  type StateType = InferStateType<T>;\n\n  interface OptionsBag {\n    assistantId?: string;\n    threadId?: MaybeRefOrGetter<string | null | undefined>;\n    client?: Client;\n    apiUrl?: MaybeRefOrGetter<string | undefined>;\n    apiKey?: MaybeRefOrGetter<string | undefined>;\n    callerOptions?: ClientConfig[\"callerOptions\"];\n    defaultHeaders?: ClientConfig[\"defaultHeaders\"];\n    transport?: \"sse\" | \"websocket\" | AgentServerAdapter;\n    fetch?: typeof fetch;\n    webSocketFactory?: (url: string) => WebSocket;\n    onThreadId?: (threadId: string) => void;\n    onCreated?: (meta: { run_id: string; thread_id: string }) => void;\n    initialValues?: StateType;\n    messagesKey?: string;\n    tools?: AnyHeadlessToolImplementation[];\n    onTool?: OnToolCallback;\n  }\n  const asBag = options as OptionsBag;\n\n  // Inherit missing apiUrl / apiKey / client from any LangChainPlugin\n  // installed on the app. Vue's `inject` returns `undefined` if the\n  // key was never provided; that's fine — we only merge when the\n  // caller didn't set a value.\n  const pluginOptions =\n    inject(LANGCHAIN_OPTIONS, undefined) ?? ({} as Record<string, unknown>);\n\n  const hasCustomAdapter =\n    asBag.transport != null && typeof asBag.transport !== \"string\";\n  const transport = asBag.transport;\n\n  // ─── Client construction ────────────────────────────────────────────\n  //\n  // Identity-stable per setup. Watches apiUrl/apiKey refs so callers\n  // that flip a backend at runtime get a fresh client without a full\n  // remount — the controller is swapped in lock-step below.\n  const resolveApiUrl = () =>\n    toValue(asBag.apiUrl) ?? (pluginOptions as { apiUrl?: string }).apiUrl;\n  const resolveApiKey = () =>\n    toValue(asBag.apiKey) ?? (pluginOptions as { apiKey?: string }).apiKey;\n  const explicitClient =\n    asBag.client ?? (pluginOptions as { client?: Client }).client;\n\n  const clientRef = shallowRef<Client>(\n    explicitClient ??\n      (new ClientCtor({\n        apiUrl: resolveApiUrl(),\n        apiKey: resolveApiKey(),\n        callerOptions: asBag.callerOptions,\n        defaultHeaders: asBag.defaultHeaders,\n      }) as unknown as Client)\n  );\n\n  // Note: we intentionally bind the controller to the *initial* client\n  // instance. A dynamic client swap would require tearing the\n  // controller down (in-flight subscriptions, queue, hydration), so we\n  // keep the rule simple: client is captured at setup. Mirrors React\n  // v1 which bakes `useMemo` on `[client, assistantId, transport]`.\n  const client = clientRef.value;\n\n  // Custom adapters may omit `assistantId`; the controller still\n  // requires one so it has something to forward to `threads.stream`.\n  const sentinel = \"_\";\n  const assistantId =\n    \"assistantId\" in options ? (options.assistantId ?? sentinel) : sentinel;\n\n  const initialThreadId = toValue(asBag.threadId) ?? null;\n\n  // ─── Controller construction ────────────────────────────────────────\n  const controller = new StreamController<\n    StateType,\n    InterruptType,\n    ConfigurableType\n  >({\n    assistantId,\n    client: client as unknown as Client<StateType>,\n    threadId: initialThreadId,\n    transport,\n    fetch: hasCustomAdapter ? undefined : asBag.fetch,\n    webSocketFactory: hasCustomAdapter ? undefined : asBag.webSocketFactory,\n    onThreadId: options.onThreadId,\n    onCreated: options.onCreated,\n    initialValues: options.initialValues,\n    messagesKey: options.messagesKey,\n  });\n\n  // Deferred dispose: on the next microtask after the owning scope\n  // disappears. Mirrors React's StrictMode-safe activate/deactivate\n  // pattern — HMR and other scope-reuse scenarios stay clean because\n  // `activate()` cancels the pending dispose if the scope survives.\n  const deactivate = controller.activate();\n  onScopeDispose(deactivate);\n\n  // ─── Reactivity adapters — StreamStore → shallowRef ─────────────────\n  function bindStore<S>(\n    subscribe: (listener: () => void) => () => void,\n    getSnapshot: () => S\n  ): Readonly<ShallowRef<S>> {\n    const ref = shallowRef<S>(getSnapshot());\n    const unsubscribe = subscribe(() => {\n      ref.value = getSnapshot();\n    });\n    onScopeDispose(unsubscribe);\n    return readonly(ref) as Readonly<ShallowRef<S>>;\n  }\n\n  const rootRef = bindStore<RootSnapshot<StateType, InterruptType>>(\n    controller.rootStore.subscribe,\n    controller.rootStore.getSnapshot\n  );\n  const subagentRef = bindStore<SubagentMap>(\n    controller.subagentStore.subscribe,\n    controller.subagentStore.getSnapshot\n  );\n  const subgraphRef = bindStore<SubgraphMap>(\n    controller.subgraphStore.subscribe,\n    controller.subgraphStore.getSnapshot\n  );\n  const subgraphByNodeRef = bindStore<SubgraphByNodeMap>(\n    controller.subgraphByNodeStore.subscribe,\n    controller.subgraphByNodeStore.getSnapshot\n  );\n\n  // Derived refs for individual root-snapshot fields. Using computed\n  // means templates that read `values.value` only retrigger when the\n  // root snapshot's identity actually changes — we can't split further\n  // because `StreamStore` fans the whole snapshot out on every update.\n  const values = computed(() => rootRef.value.values);\n  const messages = computed(() => rootRef.value.messages);\n  const toolCalls = computed(() => rootRef.value.toolCalls);\n  const interrupts = computed(() =>\n    filterOutHeadlessToolInterrupts(rootRef.value.interrupts)\n  );\n  const interrupt = computed(() => interrupts.value[0]);\n  const isLoading = computed(() => rootRef.value.isLoading);\n  const isThreadLoading = computed(() => rootRef.value.isThreadLoading);\n  const error = computed(() => rootRef.value.error);\n  const threadId = computed(() => rootRef.value.threadId);\n  const hydrationPromise = computed(() => controller.hydrationPromise);\n\n  // Expose the derived refs through a `readonly(shallowRef)` shape to\n  // match the rest of the public surface. `computed` already gives us\n  // read-only semantics but templates type-check more cleanly when the\n  // fully-typed return claims `Readonly<ShallowRef<T>>` everywhere.\n  // The cast is safe — a ComputedRef<T> is structurally a\n  // Readonly<Ref<T>>.\n  const asShallow = <V>(c: ComputedRef<V>): Readonly<ShallowRef<V>> =>\n    c as unknown as Readonly<ShallowRef<V>>;\n\n  // ─── threadId reactivity ────────────────────────────────────────────\n  //\n  // Re-hydrate whenever the caller's threadId input changes post-setup.\n  // The initial hydrate already fired synchronously in the controller\n  // constructor, so we skip that first tick; otherwise we'd double-fetch\n  // `thread.state.get()`.\n  let skipFirstThreadIdWatch = true;\n  watch(\n    () => toValue(asBag.threadId) ?? null,\n    (next) => {\n      if (skipFirstThreadIdWatch) {\n        skipFirstThreadIdWatch = false;\n        return;\n      }\n      void controller.hydrate(next);\n    }\n  );\n\n  // ─── Headless-tool handling ─────────────────────────────────────────\n  //\n  // Watch root values + protocol interrupts for items targeting a\n  // registered tool, invoke the handler, and resume the run with the\n  // handler's return value. Dedup via an id set so StrictMode /\n  // rerenders don't replay a tool call twice.\n  const handledTools = new Set<string>();\n  watch(\n    () => toValue(asBag.threadId) ?? null,\n    () => handledTools.clear()\n  );\n  const tools = options.tools;\n  const onTool = options.onTool;\n  if (tools?.length) {\n    watch(\n      () => [rootRef.value.values, rootRef.value.interrupts] as const,\n      ([rootValues, rootInterrupts]) => {\n        const bag = rootValues as unknown as Record<string, unknown>;\n        const existing = Array.isArray(bag?.__interrupt__)\n          ? (bag.__interrupt__ as Interrupt[])\n          : [];\n        const combined: Interrupt[] = [\n          ...existing,\n          ...(rootInterrupts as unknown as Interrupt[]),\n        ];\n        if (combined.length === 0) return;\n        flushPendingHeadlessToolInterrupts(\n          { ...bag, __interrupt__: combined },\n          tools,\n          handledTools,\n          {\n            onTool,\n            defer: (run) => {\n              void Promise.resolve().then(run);\n            },\n            resumeSubmit: (command) =>\n              controller.submit(null, {\n                command,\n              } as StreamSubmitOptions<StateType, ConfigurableType>),\n          }\n        );\n      },\n      { immediate: true, flush: \"sync\" }\n    );\n  }\n\n  const handle: UseStreamReturn<T, InterruptType, ConfigurableType> = {\n    values: asShallow(values) as UseStreamReturn<\n      T,\n      InterruptType,\n      ConfigurableType\n    >[\"values\"],\n    messages: asShallow(messages),\n    toolCalls: asShallow(toolCalls),\n    interrupts: asShallow(interrupts),\n    interrupt,\n    isLoading,\n    isThreadLoading,\n    error,\n    threadId,\n    hydrationPromise,\n    subagents: subagentRef as UseStreamReturn<\n      T,\n      InterruptType,\n      ConfigurableType\n    >[\"subagents\"],\n    subgraphs: subgraphRef,\n    subgraphsByNode: subgraphByNodeRef,\n    submit: (input, submitOptions) => controller.submit(input, submitOptions),\n    stop: () => controller.stop(),\n    respond: (response, target) => controller.respond(response, target),\n    getThread: () => controller.getThread(),\n    client,\n    assistantId,\n    [STREAM_CONTROLLER]: controller,\n  };\n\n  return handle;\n}\n\n/**\n * Helper used by the selector composables to reach the underlying\n * {@link ChannelRegistry} from a stream handle. Kept internal —\n * application code should call `useMessages`, `useToolCalls`, etc.\n *\n * @internal\n */\nexport function getRegistry(\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  stream: UseStreamReturn<any, any, any>\n): ChannelRegistry {\n  return stream[STREAM_CONTROLLER].registry;\n}\n\nexport type { ThreadStream };\n"],"mappings":"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"}
+{"version":3,"file":"use-stream.js","names":["ClientCtor"],"sources":["../src/use-stream.ts"],"sourcesContent":["import {\n  computed,\n  onScopeDispose,\n  readonly,\n  shallowRef,\n  toValue,\n  watch,\n  type ComputedRef,\n  type MaybeRefOrGetter,\n  type ShallowRef,\n} from \"vue\";\nimport type { BaseMessage } from \"@langchain/core/messages\";\nimport type { Client, Interrupt } from \"@langchain/langgraph-sdk\";\nimport {\n  filterOutHeadlessToolInterrupts,\n  flushPendingHeadlessToolInterrupts,\n  scheduleCoalescedHeadlessToolFlush,\n  type AnyHeadlessToolImplementation,\n  type OnToolCallback,\n} from \"@langchain/langgraph-sdk\";\nimport {\n  Client as ClientCtor,\n  type ClientConfig,\n  type ThreadStream,\n} from \"@langchain/langgraph-sdk/client\";\nimport {\n  StreamController,\n  type AgentServerAdapter,\n  type AgentServerOptions as StreamAgentServerOptions,\n  type ChannelRegistry,\n  type CustomAdapterOptions as StreamCustomAdapterOptions,\n  type InferStateType,\n  type InferSubagentStates,\n  type InferToolCalls,\n  type RootSnapshot,\n  type RunCompletedInfo,\n  type RunExecutionInfo,\n  type StreamSubmitOptions,\n  type SubagentDiscoverySnapshot,\n  type SubagentMap,\n  type SubgraphByNodeMap,\n  type SubgraphDiscoverySnapshot,\n  type SubgraphMap,\n  type UseStreamOptions as StreamUseStreamOptions,\n  type WidenUpdateMessages,\n} from \"@langchain/langgraph-sdk/stream\";\nimport { inject } from \"vue\";\nimport { LANGCHAIN_OPTIONS } from \"./context.js\";\n\ntype VueThreadId = MaybeRefOrGetter<string | null | undefined>;\ntype VueApiString = MaybeRefOrGetter<string | undefined>;\n\nexport type AgentServerOptions<StateType extends object> =\n  StreamAgentServerOptions<StateType, VueThreadId, VueApiString, VueApiString>;\n\nexport type CustomAdapterOptions<StateType extends object> =\n  StreamCustomAdapterOptions<StateType, VueThreadId, string>;\n\nexport type UseStreamOptions<\n  StateType extends object = Record<string, unknown>,\n> = StreamUseStreamOptions<\n  StateType,\n  VueThreadId,\n  VueApiString,\n  VueApiString,\n  string\n>;\n\n/**\n * Private field on the handle that carries the {@link StreamController}\n * reference. Selector composables read this to reach the shared\n * {@link ChannelRegistry}. Use the selector composables (`useMessages`,\n * `useToolCalls`, `useValues`, …) instead of reading this directly.\n */\nexport const STREAM_CONTROLLER: unique symbol = Symbol.for(\n  \"@langchain/vue/controller\"\n);\n\n/**\n * Vue binding return type for {@link useStream}.\n *\n * Reactive primitives follow Vue conventions:\n *\n *  - Data projections are `Readonly<ShallowRef<T>>` / `ComputedRef<T>`\n *    so templates auto-unwrap via `msg.value` in `<script setup>`\n *    and directly in templates. They are snapshots — never mutate.\n *  - Imperative methods (`submit` / `stop` / `respond`) are plain\n *    functions — no refs involved.\n *  - Identity values captured at setup time (`client` / `assistantId`)\n *    are exposed as plain values; if you need to swap the bound agent\n *    or client, remount the composable.\n */\nexport interface UseStreamReturn<\n  T = Record<string, unknown>,\n  InterruptType = unknown,\n  ConfigurableType extends object = Record<string, unknown>,\n  StateType extends object = InferStateType<T>,\n  SubagentStates = InferSubagentStates<T>,\n> {\n  // ----- always-on root projections -----\n  /**\n   * The most recent `values`-channel snapshot emitted at the root\n   * namespace — i.e. the thread-level state as the server sees it\n   * after each superstep. Updated on every root `values` event, not\n   * on token-level deltas: if you render `stream.values.value.messages`\n   * directly you'll see full turns appear at once instead of\n   * streaming token-by-token. Use {@link messages} (or\n   * `useMessages`) for the token-streamed view.\n   *\n   * Equivalent to calling `useValues(stream)`.\n   */\n  readonly values: Readonly<ShallowRef<StateType>>;\n  /**\n   * The root message projection. Assembled from two sources and\n   * merged in real time:\n   *\n   *  1. `messages`-channel deltas — token-level streaming events\n   *     (`message-start`, `content-block-delta`, `message-finish`)\n   *     emitted by the runtime. These drive live, token-by-token\n   *     updates.\n   *  2. `values.messages` snapshots — the authoritative ordering\n   *     and any messages the agent produces without token streaming\n   *     (human turns, tool results, echoes from subagents).\n   *\n   * If the backend only emits `values` events (no `messages`\n   * channel), every message will appear fully-formed on each\n   * values update rather than streaming. This is a backend/runtime\n   * concern — the Vue layer faithfully renders whatever the\n   * server sends.\n   *\n   * Equivalent to calling `useMessages(stream)` with no target.\n   */\n  readonly messages: Readonly<ShallowRef<BaseMessage[]>>;\n  /**\n   * Root-namespace tool calls assembled from the `tools` channel.\n   * Each entry is a fully parsed {@link AssembledToolCall} with\n   * name, args, and id — suitable for rendering approval UIs or\n   * forwarding to headless tool handlers.\n   *\n   * When the stream is typed with an agent brand or tool list,\n   * entries are narrowed via {@link InferToolCalls}. Equivalent to\n   * calling `useToolCalls(stream)` with no target.\n   */\n  readonly toolCalls: Readonly<ShallowRef<InferToolCalls<T>[]>>;\n  /**\n   * All unresolved protocol interrupts observed on the root\n   * namespace during the active thread. Populated from lifecycle /\n   * input events and seeded on hydration from `thread.getState()`.\n   * Cleared optimistically when a new run starts or an interrupt is\n   * resolved via {@link respond} / `submit({ command: { resume } })`.\n   */\n  readonly interrupts: Readonly<ShallowRef<Interrupt<InterruptType>[]>>;\n  /**\n   * Convenience alias for {@link interrupts}[0] — the primary\n   * interrupt most UIs should act on when only one is pending.\n   * `undefined` when no interrupt is active.\n   */\n  readonly interrupt: ComputedRef<Interrupt<InterruptType> | undefined>;\n  /**\n   * `true` while a run is active or being started on the current\n   * thread. Driven by root-namespace lifecycle events (`running` →\n   * `true`, terminal phases → `false`). Use this to disable submit\n   * buttons and show in-flight spinners.\n   */\n  readonly isLoading: ComputedRef<boolean>;\n  /**\n   * `true` while the initial `thread.getState()` hydration for the\n   * active thread is in flight. Distinct from {@link isLoading} —\n   * thread loading covers the one-time fetch that seeds\n   * {@link values} / {@link messages} before any user submit.\n   */\n  readonly isThreadLoading: ComputedRef<boolean>;\n  /**\n   * The last error observed on the active run or hydration attempt.\n   * `undefined` when no error has occurred. Cleared optimistically\n   * when a new {@link submit} starts.\n   */\n  readonly error: ComputedRef<unknown>;\n  /**\n   * Id of the thread the controller is bound to. `null` until the\n   * first {@link submit} creates or selects a thread (or until an\n   * explicit `threadId` option is provided and hydrated).\n   */\n  readonly threadId: ComputedRef<string | null>;\n  /**\n   * Promise that settles when the active thread's initial hydration\n   * completes. Exposed so `async setup()` sites can\n   * `await stream.hydrationPromise.value` to implement a\n   * Suspense-like boundary. A fresh promise is installed on every\n   * `threadId` change.\n   */\n  readonly hydrationPromise: ComputedRef<Promise<void>>;\n\n  // ----- always-on discovery -----\n  /**\n   * Subagents discovered on the root run. For DeepAgent-typed\n   * streams the key set is narrowed to the subagent names declared\n   * on the agent brand (`keyof InferSubagentStates<T>`).\n   */\n  readonly subagents: Readonly<\n    ShallowRef<\n      ReadonlyMap<\n        keyof SubagentStates & string extends never\n          ? string\n          : keyof SubagentStates & string,\n        SubagentDiscoverySnapshot\n      >\n    >\n  >;\n  /**\n   * Subgraphs discovered on the root run.\n   *\n   * A namespace is classified as a subgraph iff at least one\n   * strictly-deeper namespace has been observed with it as a prefix.\n   * This is inferred from the lifecycle event stream — plain function\n   * nodes (`orchestrator`, `writer` in the nested-stategraph example)\n   * never appear here even though the server emits namespaced\n   * lifecycle events for them. Promotion is monotonic and retroactive;\n   * an entry appears as soon as the first descendant event lands.\n   */\n  readonly subgraphs: Readonly<\n    ShallowRef<ReadonlyMap<string, SubgraphDiscoverySnapshot>>\n  >;\n  /**\n   * Subgraphs indexed by the graph node that produced them\n   * (`addNode(\"visualizer_0\", …)`). Each value is an array because\n   * parallel fan-outs and loops can spawn multiple invocations of\n   * the same node; arrays preserve insertion order. Updates in\n   * lock-step with {@link subgraphs}.\n   */\n  readonly subgraphsByNode: Readonly<\n    ShallowRef<ReadonlyMap<string, readonly SubgraphDiscoverySnapshot[]>>\n  >;\n\n  // ----- imperatives -----\n  /**\n   * Dispatch a new run on the bound thread.\n   *\n   * `input` is typed as `Partial<StateType>` so IDE autocompletion\n   * surfaces the state keys declared on the root composable. Pass\n   * `null` (or omit fields) when resuming an interrupt via\n   * `options.command.resume` — the server accepts a null payload\n   * in that case.\n   */\n  submit(\n    input: WidenUpdateMessages<Partial<StateType>> | null | undefined,\n    options?: StreamSubmitOptions<StateType, ConfigurableType>\n  ): Promise<void>;\n  /**\n   * Abort the in-flight run on the current thread without clearing\n   * accumulated state. Sets {@link isLoading} to `false` immediately;\n   * {@link values} and {@link messages} are preserved.\n   */\n  stop(): Promise<void>;\n  /**\n   * Resume a pending protocol interrupt by sending a response payload\n   * back to the interrupted namespace.\n   *\n   * When `target` is omitted, responds to the latest unresolved\n   * interrupt in {@link interrupts}. Pass an explicit\n   * `{ interruptId, namespace? }` when multiple interrupts are\n   * pending or the interrupt lives in a subgraph namespace.\n   */\n  respond(\n    response: unknown,\n    target?: { interruptId: string; namespace?: string[] }\n  ): Promise<void>;\n\n  // ----- identity -----\n  /** LangGraph SDK client used to construct thread streams. */\n  readonly client: Client;\n  /** Assistant id the thread is bound to for its lifetime. */\n  readonly assistantId: string;\n\n  /**\n   * Returns the bound {@link ThreadStream}, if one exists (`undefined`\n   * until the thread is hydrated or the first submit completes). Prefer\n   * the projections and selector composables for UI work; use this for\n   * low-level protocol access (raw subscriptions, state commands, etc.).\n   */\n  getThread(): ThreadStream | undefined;\n\n  /** @internal Used by selector composables. */\n  readonly [STREAM_CONTROLLER]: StreamController<\n    StateType,\n    InterruptType,\n    ConfigurableType\n  >;\n}\n\n/**\n * Erased handle useful as a parameter type for helpers and wrapper\n * components that pass a `stream` through to selector composables\n * without reading `values` directly. Mirrors the React\n * `AnyStream` alias.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type AnyStream = UseStreamReturn<any, any, any>;\n\n/** Convenience alias for the fully-resolved stream handle type. */\nexport type UseStreamResult<\n  T = Record<string, unknown>,\n  InterruptType = unknown,\n  ConfigurableType extends object = Record<string, unknown>,\n> = UseStreamReturn<T, InterruptType, ConfigurableType>;\n\n/**\n * Vue Composition API binding for the v2-native stream runtime.\n *\n * Returns a handle whose projections are Vue refs so templates\n * auto-unwrap and scripts can feed them into `computed`/`watch`.\n * Scoped views (subagents, subgraphs, any namespaced projection) are\n * surfaced via the companion selector composables (`useMessages`,\n * `useToolCalls`, `useValues`, `useMessageMetadata`,\n * `useSubmissionQueue`, `useExtension`, `useChannel`, plus media\n * composables).\n *\n * @example\n * ```vue\n * <script setup lang=\"ts\">\n * import { useStream } from \"@langchain/vue\";\n *\n * const stream = useStream({\n *   assistantId: \"agent\",\n *   apiUrl: \"http://localhost:2024\",\n * });\n * </script>\n *\n * <template>\n *   <div v-for=\"msg in stream.messages.value\" :key=\"msg.id\">\n *     {{ msg.content }}\n *   </div>\n *   <button @click=\"stream.submit({ messages: [{ type: 'human', content: 'Hi' }] })\">\n *     Send\n *   </button>\n * </template>\n * ```\n *\n * `assistantId`, `client`, and `transport` are captured at setup time.\n * To bind a new assistant/transport, remount the component. Reactive\n * inputs (`threadId`, `apiUrl`, `apiKey`) trigger in-place behaviour\n * changes on the active controller.\n */\nexport function useStream<\n  T = Record<string, unknown>,\n  InterruptType = unknown,\n  ConfigurableType extends object = Record<string, unknown>,\n>(\n  options: UseStreamOptions<InferStateType<T>>\n): UseStreamReturn<T, InterruptType, ConfigurableType> {\n  type StateType = InferStateType<T>;\n\n  interface OptionsBag {\n    assistantId?: string;\n    threadId?: MaybeRefOrGetter<string | null | undefined>;\n    client?: Client;\n    apiUrl?: MaybeRefOrGetter<string | undefined>;\n    apiKey?: MaybeRefOrGetter<string | undefined>;\n    callerOptions?: ClientConfig[\"callerOptions\"];\n    defaultHeaders?: ClientConfig[\"defaultHeaders\"];\n    transport?: \"sse\" | \"websocket\" | AgentServerAdapter;\n    fetch?: typeof fetch;\n    webSocketFactory?: (url: string) => WebSocket;\n    onThreadId?: (threadId: string) => void;\n    onCreated?: (info: RunExecutionInfo) => void;\n    onCompleted?: (info: RunCompletedInfo) => void;\n    initialValues?: StateType;\n    messagesKey?: string;\n    tools?: AnyHeadlessToolImplementation[];\n    onTool?: OnToolCallback;\n  }\n  const asBag = options as OptionsBag;\n\n  // Inherit missing apiUrl / apiKey / client from any LangChainPlugin\n  // installed on the app. Vue's `inject` returns `undefined` if the\n  // key was never provided; that's fine — we only merge when the\n  // caller didn't set a value.\n  const pluginOptions =\n    inject(LANGCHAIN_OPTIONS, undefined) ?? ({} as Record<string, unknown>);\n\n  const hasCustomAdapter =\n    asBag.transport != null && typeof asBag.transport !== \"string\";\n  const transport = asBag.transport;\n\n  // ─── Client construction ────────────────────────────────────────────\n  //\n  // Identity-stable per setup. Watches apiUrl/apiKey refs so callers\n  // that flip a backend at runtime get a fresh client without a full\n  // remount — the controller is swapped in lock-step below.\n  const resolveApiUrl = () =>\n    toValue(asBag.apiUrl) ?? (pluginOptions as { apiUrl?: string }).apiUrl;\n  const resolveApiKey = () =>\n    toValue(asBag.apiKey) ?? (pluginOptions as { apiKey?: string }).apiKey;\n  const explicitClient =\n    asBag.client ?? (pluginOptions as { client?: Client }).client;\n\n  const clientRef = shallowRef<Client>(\n    explicitClient ??\n      (new ClientCtor({\n        apiUrl: resolveApiUrl(),\n        apiKey: resolveApiKey(),\n        callerOptions: asBag.callerOptions,\n        defaultHeaders: asBag.defaultHeaders,\n      }) as unknown as Client)\n  );\n\n  // Note: we intentionally bind the controller to the *initial* client\n  // instance. A dynamic client swap would require tearing the\n  // controller down (in-flight subscriptions, queue, hydration), so we\n  // keep the rule simple: client is captured at setup. Mirrors React\n  // v1 which bakes `useMemo` on `[client, assistantId, transport]`.\n  const client = clientRef.value;\n\n  // Custom adapters may omit `assistantId`; the controller still\n  // requires one so it has something to forward to `threads.stream`.\n  const sentinel = \"_\";\n  const assistantId =\n    \"assistantId\" in options ? (options.assistantId ?? sentinel) : sentinel;\n\n  const initialThreadId = toValue(asBag.threadId) ?? null;\n\n  // ─── Controller construction ────────────────────────────────────────\n  const controller = new StreamController<\n    StateType,\n    InterruptType,\n    ConfigurableType\n  >({\n    assistantId,\n    client: client as unknown as Client<StateType>,\n    threadId: initialThreadId,\n    transport,\n    fetch: hasCustomAdapter ? undefined : asBag.fetch,\n    webSocketFactory: hasCustomAdapter ? undefined : asBag.webSocketFactory,\n    onThreadId: options.onThreadId,\n    onCreated: options.onCreated,\n    onCompleted: options.onCompleted,\n    initialValues: options.initialValues,\n    messagesKey: options.messagesKey,\n  });\n\n  // Deferred dispose: on the next microtask after the owning scope\n  // disappears. Mirrors React's StrictMode-safe activate/deactivate\n  // pattern — HMR and other scope-reuse scenarios stay clean because\n  // `activate()` cancels the pending dispose if the scope survives.\n  const deactivate = controller.activate();\n  onScopeDispose(deactivate);\n\n  // ─── Reactivity adapters — StreamStore → shallowRef ─────────────────\n  function bindStore<S>(\n    subscribe: (listener: () => void) => () => void,\n    getSnapshot: () => S\n  ): Readonly<ShallowRef<S>> {\n    const ref = shallowRef<S>(getSnapshot());\n    const unsubscribe = subscribe(() => {\n      ref.value = getSnapshot();\n    });\n    onScopeDispose(unsubscribe);\n    return readonly(ref) as Readonly<ShallowRef<S>>;\n  }\n\n  const rootRef = bindStore<RootSnapshot<StateType, InterruptType>>(\n    controller.rootStore.subscribe,\n    controller.rootStore.getSnapshot\n  );\n  const subagentRef = bindStore<SubagentMap>(\n    controller.subagentStore.subscribe,\n    controller.subagentStore.getSnapshot\n  );\n  const subgraphRef = bindStore<SubgraphMap>(\n    controller.subgraphStore.subscribe,\n    controller.subgraphStore.getSnapshot\n  );\n  const subgraphByNodeRef = bindStore<SubgraphByNodeMap>(\n    controller.subgraphByNodeStore.subscribe,\n    controller.subgraphByNodeStore.getSnapshot\n  );\n\n  // Derived refs for individual root-snapshot fields. Using computed\n  // means templates that read `values.value` only retrigger when the\n  // root snapshot's identity actually changes — we can't split further\n  // because `StreamStore` fans the whole snapshot out on every update.\n  const values = computed(() => rootRef.value.values);\n  const messages = computed(() => rootRef.value.messages);\n  const toolCalls = computed(\n    () => rootRef.value.toolCalls as InferToolCalls<T>[]\n  );\n  const interrupts = computed(() =>\n    filterOutHeadlessToolInterrupts(rootRef.value.interrupts)\n  );\n  const interrupt = computed(() => interrupts.value[0]);\n  const isLoading = computed(() => rootRef.value.isLoading);\n  const isThreadLoading = computed(() => rootRef.value.isThreadLoading);\n  const error = computed(() => rootRef.value.error);\n  const threadId = computed(() => rootRef.value.threadId);\n  const hydrationPromise = computed(() => controller.hydrationPromise);\n\n  // Expose the derived refs through a `readonly(shallowRef)` shape to\n  // match the rest of the public surface. `computed` already gives us\n  // read-only semantics but templates type-check more cleanly when the\n  // fully-typed return claims `Readonly<ShallowRef<T>>` everywhere.\n  // The cast is safe — a ComputedRef<T> is structurally a\n  // Readonly<Ref<T>>.\n  const asShallow = <V>(c: ComputedRef<V>): Readonly<ShallowRef<V>> =>\n    c as unknown as Readonly<ShallowRef<V>>;\n\n  // ─── threadId reactivity ────────────────────────────────────────────\n  //\n  // Re-hydrate whenever the caller's threadId input changes post-setup.\n  // The initial hydrate already fired synchronously in the controller\n  // constructor, so we skip that first tick; otherwise we'd double-fetch\n  // `thread.state.get()`.\n  let skipFirstThreadIdWatch = true;\n  watch(\n    () => toValue(asBag.threadId) ?? null,\n    (next) => {\n      if (skipFirstThreadIdWatch) {\n        skipFirstThreadIdWatch = false;\n        return;\n      }\n      void controller.hydrate(next);\n    }\n  );\n\n  // ─── Headless-tool handling ─────────────────────────────────────────\n  //\n  // Watch root values + protocol interrupts for items targeting a\n  // registered tool, invoke the handler, and resume the run with the\n  // handler's return value. Dedup via an id set so StrictMode /\n  // rerenders don't replay a tool call twice.\n  const handledTools = new Set<string>();\n  watch(\n    () => toValue(asBag.threadId) ?? null,\n    () => handledTools.clear()\n  );\n  const tools = options.tools;\n  const onTool = options.onTool;\n  if (tools?.length) {\n    watch(\n      () => [rootRef.value.values, rootRef.value.interrupts] as const,\n      () => {\n        scheduleCoalescedHeadlessToolFlush(handledTools, () => {\n          const rootValues = rootRef.value.values;\n          const rootInterrupts = rootRef.value.interrupts;\n          const bag = rootValues as unknown as Record<string, unknown>;\n          const protocolInterrupts = rootInterrupts as unknown as Interrupt[];\n          const valuesInterrupts = Array.isArray(bag?.__interrupt__)\n            ? (bag.__interrupt__ as Interrupt[])\n            : [];\n          const headlessInterrupts =\n            protocolInterrupts.length > 0\n              ? protocolInterrupts\n              : valuesInterrupts;\n          if (headlessInterrupts.length === 0) return;\n          flushPendingHeadlessToolInterrupts(\n            { ...bag, __interrupt__: headlessInterrupts },\n            tools,\n            handledTools,\n            {\n              onTool,\n              defer: (run) => {\n                void Promise.resolve().then(run);\n              },\n              resumeSubmit: (command) =>\n                controller.submit(null, {\n                  command,\n                } as StreamSubmitOptions<StateType, ConfigurableType>),\n            }\n          );\n        });\n      },\n      { immediate: true }\n    );\n  }\n\n  const handle: UseStreamReturn<T, InterruptType, ConfigurableType> = {\n    values: asShallow(values) as UseStreamReturn<\n      T,\n      InterruptType,\n      ConfigurableType\n    >[\"values\"],\n    messages: asShallow(messages),\n    toolCalls: asShallow(toolCalls),\n    interrupts: asShallow(interrupts),\n    interrupt,\n    isLoading,\n    isThreadLoading,\n    error,\n    threadId,\n    hydrationPromise,\n    subagents: subagentRef as UseStreamReturn<\n      T,\n      InterruptType,\n      ConfigurableType\n    >[\"subagents\"],\n    subgraphs: subgraphRef,\n    subgraphsByNode: subgraphByNodeRef,\n    submit: (input, submitOptions) => controller.submit(input, submitOptions),\n    stop: () => controller.stop(),\n    respond: (response, target) => controller.respond(response, target),\n    getThread: () => controller.getThread(),\n    client,\n    assistantId,\n    [STREAM_CONTROLLER]: controller,\n  };\n\n  return handle;\n}\n\n/**\n * Helper used by the selector composables to reach the underlying\n * {@link ChannelRegistry} from a stream handle. Kept internal —\n * application code should call `useMessages`, `useToolCalls`, etc.\n *\n * @internal\n */\nexport function getRegistry(\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  stream: UseStreamReturn<any, any, any>\n): ChannelRegistry {\n  return stream[STREAM_CONTROLLER].registry;\n}\n\nexport type { ThreadStream };\n"],"mappings":";;;;;;;;;;;;AA0EA,MAAa,oBAAmC,OAAO,IACrD,4BACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2QD,SAAgB,UAKd,SACqD;CAsBrD,MAAM,QAAQ;CAMd,MAAM,gBACJ,OAAO,mBAAmB,KAAA,EAAU,IAAK,EAAE;CAE7C,MAAM,mBACJ,MAAM,aAAa,QAAQ,OAAO,MAAM,cAAc;CACxD,MAAM,YAAY,MAAM;CAOxB,MAAM,sBACJ,QAAQ,MAAM,OAAO,IAAK,cAAsC;CAClE,MAAM,sBACJ,QAAQ,MAAM,OAAO,IAAK,cAAsC;CAmBlE,MAAM,SAfY,WAFhB,MAAM,UAAW,cAAsC,UAIpD,IAAIA,SAAW;EACd,QAAQ,eAAe;EACvB,QAAQ,eAAe;EACvB,eAAe,MAAM;EACrB,gBAAgB,MAAM;EACvB,CAAC,CACL,CAOwB;CAIzB,MAAM,WAAW;CACjB,MAAM,cACJ,iBAAiB,UAAW,QAAQ,eAAe,WAAY;CAKjE,MAAM,aAAa,IAAI,iBAIrB;EACA;EACQ;EACR,UAVsB,QAAQ,MAAM,SAAS,IAAI;EAWjD;EACA,OAAO,mBAAmB,KAAA,IAAY,MAAM;EAC5C,kBAAkB,mBAAmB,KAAA,IAAY,MAAM;EACvD,YAAY,QAAQ;EACpB,WAAW,QAAQ;EACnB,aAAa,QAAQ;EACrB,eAAe,QAAQ;EACvB,aAAa,QAAQ;EACtB,CAAC;AAOF,gBADmB,WAAW,UAAU,CACd;CAG1B,SAAS,UACP,WACA,aACyB;EACzB,MAAM,MAAM,WAAc,aAAa,CAAC;AAIxC,iBAHoB,gBAAgB;AAClC,OAAI,QAAQ,aAAa;IACzB,CACyB;AAC3B,SAAO,SAAS,IAAI;;CAGtB,MAAM,UAAU,UACd,WAAW,UAAU,WACrB,WAAW,UAAU,YACtB;CACD,MAAM,cAAc,UAClB,WAAW,cAAc,WACzB,WAAW,cAAc,YAC1B;CACD,MAAM,cAAc,UAClB,WAAW,cAAc,WACzB,WAAW,cAAc,YAC1B;CACD,MAAM,oBAAoB,UACxB,WAAW,oBAAoB,WAC/B,WAAW,oBAAoB,YAChC;CAMD,MAAM,SAAS,eAAe,QAAQ,MAAM,OAAO;CACnD,MAAM,WAAW,eAAe,QAAQ,MAAM,SAAS;CACvD,MAAM,YAAY,eACV,QAAQ,MAAM,UACrB;CACD,MAAM,aAAa,eACjB,gCAAgC,QAAQ,MAAM,WAAW,CAC1D;CACD,MAAM,YAAY,eAAe,WAAW,MAAM,GAAG;CACrD,MAAM,YAAY,eAAe,QAAQ,MAAM,UAAU;CACzD,MAAM,kBAAkB,eAAe,QAAQ,MAAM,gBAAgB;CACrE,MAAM,QAAQ,eAAe,QAAQ,MAAM,MAAM;CACjD,MAAM,WAAW,eAAe,QAAQ,MAAM,SAAS;CACvD,MAAM,mBAAmB,eAAe,WAAW,iBAAiB;CAQpE,MAAM,aAAgB,MACpB;CAQF,IAAI,yBAAyB;AAC7B,aACQ,QAAQ,MAAM,SAAS,IAAI,OAChC,SAAS;AACR,MAAI,wBAAwB;AAC1B,4BAAyB;AACzB;;AAEG,aAAW,QAAQ,KAAK;GAEhC;CAQD,MAAM,+BAAe,IAAI,KAAa;AACtC,aACQ,QAAQ,MAAM,SAAS,IAAI,YAC3B,aAAa,OAAO,CAC3B;CACD,MAAM,QAAQ,QAAQ;CACtB,MAAM,SAAS,QAAQ;AACvB,KAAI,OAAO,OACT,aACQ,CAAC,QAAQ,MAAM,QAAQ,QAAQ,MAAM,WAAW,QAChD;AACJ,qCAAmC,oBAAoB;GACrD,MAAM,aAAa,QAAQ,MAAM;GACjC,MAAM,iBAAiB,QAAQ,MAAM;GACrC,MAAM,MAAM;GACZ,MAAM,qBAAqB;GAC3B,MAAM,mBAAmB,MAAM,QAAQ,KAAK,cAAc,GACrD,IAAI,gBACL,EAAE;GACN,MAAM,qBACJ,mBAAmB,SAAS,IACxB,qBACA;AACN,OAAI,mBAAmB,WAAW,EAAG;AACrC,sCACE;IAAE,GAAG;IAAK,eAAe;IAAoB,EAC7C,OACA,cACA;IACE;IACA,QAAQ,QAAQ;AACT,aAAQ,SAAS,CAAC,KAAK,IAAI;;IAElC,eAAe,YACb,WAAW,OAAO,MAAM,EACtB,SACD,CAAqD;IACzD,CACF;IACD;IAEJ,EAAE,WAAW,MAAM,CACpB;AAkCH,QA/BoE;EAClE,QAAQ,UAAU,OAAO;EAKzB,UAAU,UAAU,SAAS;EAC7B,WAAW,UAAU,UAAU;EAC/B,YAAY,UAAU,WAAW;EACjC;EACA;EACA;EACA;EACA;EACA;EACA,WAAW;EAKX,WAAW;EACX,iBAAiB;EACjB,SAAS,OAAO,kBAAkB,WAAW,OAAO,OAAO,cAAc;EACzE,YAAY,WAAW,MAAM;EAC7B,UAAU,UAAU,WAAW,WAAW,QAAQ,UAAU,OAAO;EACnE,iBAAiB,WAAW,WAAW;EACvC;EACA;GACC,oBAAoB;EACtB;;;;;;;;;AAYH,SAAgB,YAEd,QACiB;AACjB,QAAO,OAAO,mBAAmB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/vue",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "Vue integration for LangGraph & LangChain",
   "type": "module",
   "license": "MIT",
@@ -10,7 +10,7 @@
     "directory": "libs/sdk-vue"
   },
   "dependencies": {
-    "@langchain/langgraph-sdk": "1.9.4"
+    "@langchain/langgraph-sdk": "1.9.6"
   },
   "devDependencies": {
     "@hono/node-server": "^1.19.13",