@langchain/svelte 1.0.4 → 1.0.5

package/dist/index.d.cts

@@ -1,11 +1,11 @@
-import { AgentServerOptions, AnyStream, CustomAdapterOptions, STREAM_CONTROLLER, StateOf, ThreadStream, UseStreamOptions, UseStreamResult, UseStreamReturn, useStream } from "./use-stream.svelte.cjs";
+import { AgentServerOptions, AnyStream, CustomAdapterOptions, STREAM_CONTROLLER, ThreadStream, UseStreamOptions, UseStreamResult, UseStreamReturn, useStream } from "./use-stream.svelte.cjs";
 import { useProjection } from "./use-projection.svelte.cjs";
 import { SelectorTarget, SubmissionQueueEntry, SubmissionQueueSnapshot, UseSubmissionQueueReturn, useAudio, useChannel, useExtension, useFiles, useImages, useMessageMetadata, useMessages, useSubmissionQueue, useToolCalls, useValues, useVideo } from "./selectors.svelte.cjs";
 import { useMediaURL } from "./use-media-url.svelte.cjs";
 import { AudioPlayerHandle, PlayerStatus, UseAudioPlayerOptions, useAudioPlayer } from "./use-audio-player.svelte.cjs";
 import { UseVideoPlayerOptions, VideoPlayerHandle, useVideoPlayer } from "./use-video-player.svelte.cjs";
 import { ProvideStreamCustomProps, ProvideStreamProps, STREAM_CONTEXT_KEY, getStream, provideStream } from "./context.cjs";
-import { AnyHeadlessToolImplementation, DefaultToolCall, FlushPendingHeadlessToolInterruptsOptions, HeadlessToolImplementation, HeadlessToolInterrupt, HttpAgentServerAdapter, HttpAgentServerAdapterOptions, OnToolCallback, ToolCallFromTool, ToolCallState, ToolCallsFromTools, ToolEvent, executeHeadlessTool, filterOutHeadlessToolInterrupts, findHeadlessTool, flushPendingHeadlessToolInterrupts, handleHeadlessToolInterrupt, headlessToolResumeCommand, isHeadlessToolInterrupt, parseHeadlessToolInterruptPayload } from "@langchain/langgraph-sdk";
-import { AgentServerAdapter, AnyMediaHandle, AssembledToolCall, AudioMedia, Channel, Event, FileMedia, ImageMedia, InferStateType, InferSubagentStates, InferToolCalls, MediaAssemblyError, MediaAssemblyErrorKind, MediaBase, MediaBlockType, MessageMetadata, MessageMetadataMap, StreamSubmitOptions, SubagentDiscoverySnapshot, SubgraphDiscoverySnapshot, ToolCallStatus, VideoMedia, WidenUpdateMessages } from "@langchain/langgraph-sdk/stream";
+import { AnyHeadlessToolImplementation, DefaultToolCall, FlushPendingHeadlessToolInterruptsOptions, HeadlessToolImplementation, HeadlessToolInterrupt, HttpAgentServerAdapter, HttpAgentServerAdapterOptions, OnToolCallback, ToolCallState, 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, InferToolOutput, MediaAssemblyError, MediaAssemblyErrorKind, MediaBase, MediaBlockType, MessageMetadata, MessageMetadataMap, StreamSubmitOptions, SubagentDiscoverySnapshot, SubgraphDiscoverySnapshot, ToolCallStatus, VideoMedia, WidenUpdateMessages } from "@langchain/langgraph-sdk/stream";
 import { AcceptBaseMessages, GetToolCallsType, ResolveStreamInterface, ResolveStreamOptions, UseAgentStream, UseAgentStreamOptions, UseDeepAgentStream, UseDeepAgentStreamOptions } from "@langchain/langgraph-sdk/ui";
-export { type AcceptBaseMessages, 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 GetToolCallsType, type HeadlessToolImplementation, type HeadlessToolInterrupt, HttpAgentServerAdapter, type HttpAgentServerAdapterOptions, type ImageMedia, type InferStateType, type InferSubagentStates, type InferToolCalls, MediaAssemblyError, type MediaAssemblyErrorKind, type MediaBase, type MediaBlockType, type MessageMetadata, type MessageMetadataMap, type OnToolCallback, type PlayerStatus, type ProvideStreamCustomProps, type ProvideStreamProps, type ResolveStreamInterface, type ResolveStreamOptions, STREAM_CONTEXT_KEY, 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 ToolCallsFromTools, type ToolEvent, type UseAgentStream, type UseAgentStreamOptions, type UseAudioPlayerOptions, type UseDeepAgentStream, type UseDeepAgentStreamOptions, type UseStreamOptions, type UseStreamResult, type UseStreamReturn, type UseSubmissionQueueReturn, type UseVideoPlayerOptions, type VideoMedia, type VideoPlayerHandle, type WidenUpdateMessages, executeHeadlessTool, filterOutHeadlessToolInterrupts, findHeadlessTool, flushPendingHeadlessToolInterrupts, getStream, handleHeadlessToolInterrupt, headlessToolResumeCommand, isHeadlessToolInterrupt, parseHeadlessToolInterruptPayload, provideStream, useAudio, useAudioPlayer, useChannel, useExtension, useFiles, useImages, useMediaURL, useMessageMetadata, useMessages, useProjection, useStream, useSubmissionQueue, useToolCalls, useValues, useVideo, useVideoPlayer };
+export { type AcceptBaseMessages, 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 GetToolCallsType, type HeadlessToolImplementation, type HeadlessToolInterrupt, HttpAgentServerAdapter, type HttpAgentServerAdapterOptions, type ImageMedia, type InferStateType, type InferSubagentStates, type InferToolCalls, type InferToolOutput, MediaAssemblyError, type MediaAssemblyErrorKind, type MediaBase, type MediaBlockType, type MessageMetadata, type MessageMetadataMap, type OnToolCallback, type PlayerStatus, type ProvideStreamCustomProps, type ProvideStreamProps, type ResolveStreamInterface, type ResolveStreamOptions, STREAM_CONTEXT_KEY, STREAM_CONTROLLER, type SelectorTarget, type StreamSubmitOptions, type SubagentDiscoverySnapshot, type SubgraphDiscoverySnapshot, type SubmissionQueueEntry, type SubmissionQueueSnapshot, type ThreadStream, type ToolCallFromTool, type ToolCallState, type ToolCallStatus, type ToolCallsFromTools, type ToolEvent, type UseAgentStream, type UseAgentStreamOptions, type UseAudioPlayerOptions, type UseDeepAgentStream, type UseDeepAgentStreamOptions, type UseStreamOptions, type UseStreamResult, type UseStreamReturn, type UseSubmissionQueueReturn, type UseVideoPlayerOptions, type VideoMedia, type VideoPlayerHandle, type WidenUpdateMessages, executeHeadlessTool, filterOutHeadlessToolInterrupts, findHeadlessTool, flushPendingHeadlessToolInterrupts, getStream, handleHeadlessToolInterrupt, headlessToolResumeCommand, isHeadlessToolInterrupt, parseHeadlessToolInterruptPayload, provideStream, useAudio, useAudioPlayer, useChannel, useExtension, useFiles, useImages, useMediaURL, useMessageMetadata, useMessages, useProjection, useStream, useSubmissionQueue, useToolCalls, useValues, useVideo, useVideoPlayer };

package/dist/index.d.ts

@@ -1,11 +1,11 @@
-import { AgentServerOptions, AnyStream, CustomAdapterOptions, STREAM_CONTROLLER, StateOf, ThreadStream, UseStreamOptions, UseStreamResult, UseStreamReturn, useStream } from "./use-stream.svelte.js";
+import { AgentServerOptions, AnyStream, CustomAdapterOptions, STREAM_CONTROLLER, ThreadStream, UseStreamOptions, UseStreamResult, UseStreamReturn, useStream } from "./use-stream.svelte.js";
 import { useProjection } from "./use-projection.svelte.js";
 import { SelectorTarget, SubmissionQueueEntry, SubmissionQueueSnapshot, UseSubmissionQueueReturn, useAudio, useChannel, useExtension, useFiles, useImages, useMessageMetadata, useMessages, useSubmissionQueue, useToolCalls, useValues, useVideo } from "./selectors.svelte.js";
 import { useMediaURL } from "./use-media-url.svelte.js";
 import { AudioPlayerHandle, PlayerStatus, UseAudioPlayerOptions, useAudioPlayer } from "./use-audio-player.svelte.js";
 import { UseVideoPlayerOptions, VideoPlayerHandle, useVideoPlayer } from "./use-video-player.svelte.js";
 import { ProvideStreamCustomProps, ProvideStreamProps, STREAM_CONTEXT_KEY, getStream, provideStream } from "./context.js";
-import { AnyHeadlessToolImplementation, DefaultToolCall, FlushPendingHeadlessToolInterruptsOptions, HeadlessToolImplementation, HeadlessToolInterrupt, HttpAgentServerAdapter, HttpAgentServerAdapterOptions, OnToolCallback, ToolCallFromTool, ToolCallState, ToolCallsFromTools, ToolEvent, executeHeadlessTool, filterOutHeadlessToolInterrupts, findHeadlessTool, flushPendingHeadlessToolInterrupts, handleHeadlessToolInterrupt, headlessToolResumeCommand, isHeadlessToolInterrupt, parseHeadlessToolInterruptPayload } from "@langchain/langgraph-sdk";
-import { AgentServerAdapter, AnyMediaHandle, AssembledToolCall, AudioMedia, Channel, Event, FileMedia, ImageMedia, InferStateType, InferSubagentStates, InferToolCalls, MediaAssemblyError, MediaAssemblyErrorKind, MediaBase, MediaBlockType, MessageMetadata, MessageMetadataMap, StreamSubmitOptions, SubagentDiscoverySnapshot, SubgraphDiscoverySnapshot, ToolCallStatus, VideoMedia, WidenUpdateMessages } from "@langchain/langgraph-sdk/stream";
+import { AnyHeadlessToolImplementation, DefaultToolCall, FlushPendingHeadlessToolInterruptsOptions, HeadlessToolImplementation, HeadlessToolInterrupt, HttpAgentServerAdapter, HttpAgentServerAdapterOptions, OnToolCallback, ToolCallState, 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, InferToolOutput, MediaAssemblyError, MediaAssemblyErrorKind, MediaBase, MediaBlockType, MessageMetadata, MessageMetadataMap, StreamSubmitOptions, SubagentDiscoverySnapshot, SubgraphDiscoverySnapshot, ToolCallStatus, VideoMedia, WidenUpdateMessages } from "@langchain/langgraph-sdk/stream";
 import { AcceptBaseMessages, GetToolCallsType, ResolveStreamInterface, ResolveStreamOptions, UseAgentStream, UseAgentStreamOptions, UseDeepAgentStream, UseDeepAgentStreamOptions } from "@langchain/langgraph-sdk/ui";
-export { type AcceptBaseMessages, 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 GetToolCallsType, type HeadlessToolImplementation, type HeadlessToolInterrupt, HttpAgentServerAdapter, type HttpAgentServerAdapterOptions, type ImageMedia, type InferStateType, type InferSubagentStates, type InferToolCalls, MediaAssemblyError, type MediaAssemblyErrorKind, type MediaBase, type MediaBlockType, type MessageMetadata, type MessageMetadataMap, type OnToolCallback, type PlayerStatus, type ProvideStreamCustomProps, type ProvideStreamProps, type ResolveStreamInterface, type ResolveStreamOptions, STREAM_CONTEXT_KEY, 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 ToolCallsFromTools, type ToolEvent, type UseAgentStream, type UseAgentStreamOptions, type UseAudioPlayerOptions, type UseDeepAgentStream, type UseDeepAgentStreamOptions, type UseStreamOptions, type UseStreamResult, type UseStreamReturn, type UseSubmissionQueueReturn, type UseVideoPlayerOptions, type VideoMedia, type VideoPlayerHandle, type WidenUpdateMessages, executeHeadlessTool, filterOutHeadlessToolInterrupts, findHeadlessTool, flushPendingHeadlessToolInterrupts, getStream, handleHeadlessToolInterrupt, headlessToolResumeCommand, isHeadlessToolInterrupt, parseHeadlessToolInterruptPayload, provideStream, useAudio, useAudioPlayer, useChannel, useExtension, useFiles, useImages, useMediaURL, useMessageMetadata, useMessages, useProjection, useStream, useSubmissionQueue, useToolCalls, useValues, useVideo, useVideoPlayer };
+export { type AcceptBaseMessages, 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 GetToolCallsType, type HeadlessToolImplementation, type HeadlessToolInterrupt, HttpAgentServerAdapter, type HttpAgentServerAdapterOptions, type ImageMedia, type InferStateType, type InferSubagentStates, type InferToolCalls, type InferToolOutput, MediaAssemblyError, type MediaAssemblyErrorKind, type MediaBase, type MediaBlockType, type MessageMetadata, type MessageMetadataMap, type OnToolCallback, type PlayerStatus, type ProvideStreamCustomProps, type ProvideStreamProps, type ResolveStreamInterface, type ResolveStreamOptions, STREAM_CONTEXT_KEY, STREAM_CONTROLLER, type SelectorTarget, type StreamSubmitOptions, type SubagentDiscoverySnapshot, type SubgraphDiscoverySnapshot, type SubmissionQueueEntry, type SubmissionQueueSnapshot, type ThreadStream, type ToolCallFromTool, type ToolCallState, type ToolCallStatus, type ToolCallsFromTools, type ToolEvent, type UseAgentStream, type UseAgentStreamOptions, type UseAudioPlayerOptions, type UseDeepAgentStream, type UseDeepAgentStreamOptions, type UseStreamOptions, type UseStreamResult, type UseStreamReturn, type UseSubmissionQueueReturn, type UseVideoPlayerOptions, type VideoMedia, type VideoPlayerHandle, type WidenUpdateMessages, executeHeadlessTool, filterOutHeadlessToolInterrupts, findHeadlessTool, flushPendingHeadlessToolInterrupts, getStream, handleHeadlessToolInterrupt, headlessToolResumeCommand, isHeadlessToolInterrupt, parseHeadlessToolInterruptPayload, provideStream, useAudio, useAudioPlayer, useChannel, useExtension, useFiles, useImages, useMediaURL, useMessageMetadata, useMessages, useProjection, useStream, useSubmissionQueue, useToolCalls, useValues, useVideo, useVideoPlayer };

package/dist/selectors.svelte.cjs

@@ -70,11 +70,6 @@ function useMessages(stream, target) {
 	}
 	return selectFromTarget(stream, target, EMPTY_MESSAGES, (ns) => (0, _langchain_langgraph_sdk_stream.messagesProjection)(ns), "messages");
 }
-/**
-* Subscribe to a scoped `tools` (tool-call) stream. Same target and
-* lifecycle rules as {@link useMessages}; at the root this returns a
-* handle delegating to `stream.toolCalls`.
-*/
 function useToolCalls(stream, target) {
 	if (!isGetter(target)) {
 		if (isRoot(resolveNamespace(target))) return { get current() {

package/dist/selectors.svelte.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"selectors.svelte.cjs","names":["NAMESPACE_SEPARATOR","useProjection","getRegistry","STREAM_CONTROLLER"],"sources":["../src/selectors.svelte.ts"],"sourcesContent":["import 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.svelte.js\";\nimport {\n  useProjection,\n  type ReactiveValue,\n  type ValueOrGetter,\n} from \"./use-projection.svelte.js\";\n\n/**\n * Parameterise selectors on `StateType` alone so callers with a full\n * `useStream<S, I, C>()` handle don't have to redeclare\n * `InterruptType` / `ConfigurableType` at every call site.\n */\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 targets. Callers can pass:\n *  - `undefined` / `null` — root namespace (served by the always-on\n *    root store; no extra subscription opens);\n *  - a {@link SubagentDiscoverySnapshot} (`stream.subagents.get(...)`);\n *  - a {@link SubgraphDiscoverySnapshot}\n *    (`stream.subgraphs.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\nfunction isGetter<T>(input: ValueOrGetter<T> | undefined): input is () => T {\n  return typeof input === \"function\";\n}\n\n/**\n * Internal helper that wires a reactive-or-static target into\n * {@link useProjection}. Encapsulates the bookkeeping every selector\n * otherwise repeats.\n */\nfunction selectFromTarget<T>(\n  stream: AnyStream,\n  target: ValueOrGetter<SelectorTarget> | undefined,\n  initialValue: T,\n  makeSpec: (\n    namespace: readonly string[]\n  ) => import(\"@langchain/langgraph-sdk/stream\").ProjectionSpec<T>,\n  keyPrefix: string\n): ReactiveValue<T> {\n  if (isGetter(target)) {\n    const getTarget = target;\n    return useProjection<T>(\n      () => {\n        const ns = resolveNamespace(getTarget());\n        return isRoot(ns) ? null : getRegistry(stream);\n      },\n      () => makeSpec(resolveNamespace(getTarget())),\n      () => `${keyPrefix}|${namespaceKey(resolveNamespace(getTarget()))}`,\n      initialValue\n    );\n  }\n  const ns = resolveNamespace(target);\n  // Static root: we deliberately don't short-circuit here because\n  // each selector owns the root fallback shape (`stream.messages`\n  // vs `stream.values` vs `stream.toolCalls`). Callers use the\n  // dedicated wrappers below.\n  const key = `${keyPrefix}|${namespaceKey(ns)}`;\n  return useProjection<T>(\n    isRoot(ns) ? null : getRegistry(stream),\n    () => makeSpec(ns),\n    key,\n    initialValue\n  );\n}\n\nconst EMPTY_MESSAGES: BaseMessage[] = [];\nconst EMPTY_TOOLCALLS: AssembledToolCall[] = [];\nconst EMPTY_EVENTS: Event[] = [];\nconst EMPTY_AUDIO: AudioMedia[] = [];\nconst EMPTY_IMAGES: ImageMedia[] = [];\nconst EMPTY_VIDEO: VideoMedia[] = [];\nconst EMPTY_FILES: FileMedia[] = [];\n\n/**\n * Subscribe to a scoped `messages` stream.\n *\n * Contract:\n *  - At the root (no `target`, or a static target that resolves to\n *    the root namespace) returns a handle whose `.current` delegates\n *    to `stream.messages` — the always-on root projection. No extra\n *    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 owning\n *    component teardown fires (and the registry closes the\n *    underlying server subscription when the last consumer leaves).\n *  - A reactive `target` (getter form) re-binds the subscription on\n *    change. A getter that flips between root and scoped is\n *    supported: the root case short-circuits to the initial value\n *    because dynamic root delegation isn't meaningful — pass a\n *    static undefined/null target for root handles.\n *\n * Messages are always `BaseMessage` class instances from\n * `@langchain/core/messages`.\n */\nexport function useMessages(\n  stream: AnyStream,\n  target?: ValueOrGetter<SelectorTarget>\n): ReactiveValue<BaseMessage[]> {\n  if (!isGetter(target)) {\n    const ns = resolveNamespace(target);\n    if (isRoot(ns)) {\n      return {\n        get current() {\n          return stream.messages;\n        },\n      };\n    }\n  }\n  return selectFromTarget<BaseMessage[]>(\n    stream,\n    target,\n    EMPTY_MESSAGES,\n    (ns) => messagesProjection(ns),\n    \"messages\"\n  );\n}\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 a\n * handle delegating to `stream.toolCalls`.\n */\nexport function useToolCalls(\n  stream: AnyStream,\n  target?: ValueOrGetter<SelectorTarget>\n): ReactiveValue<AssembledToolCall[]> {\n  if (!isGetter(target)) {\n    const ns = resolveNamespace(target);\n    if (isRoot(ns)) {\n      return {\n        get current() {\n          return stream.toolCalls;\n        },\n      };\n    }\n  }\n  return selectFromTarget<AssembledToolCall[]>(\n    stream,\n    target,\n    EMPTY_TOOLCALLS,\n    (ns) => toolCallsProjection(ns),\n    \"toolCalls\"\n  );\n}\n\n/**\n * Subscribe to a scoped `values` stream — the most recent state\n * payload for a namespace. At the root returns a handle delegating\n * to `stream.values`.\n *\n * Typing:\n *  - **Root** (`useValues(stream)`): returns the `StateType` declared\n *    on `useStream<State>()` — non-nullable (the root snapshot\n *    always 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): ReactiveValue<StateType>;\nexport function useValues<T>(\n  stream: AnyStream\n): ReactiveValue<InferStateType<T>>;\nexport function useValues<T = unknown>(\n  stream: AnyStream,\n  target: ValueOrGetter<SelectorTarget>,\n  options?: { messagesKey?: string }\n): ReactiveValue<T | undefined>;\nexport function useValues(\n  stream: AnyStream,\n  target?: ValueOrGetter<SelectorTarget>,\n  options?: { messagesKey?: string }\n): ReactiveValue<unknown> {\n  if (!isGetter(target)) {\n    const ns = resolveNamespace(target);\n    if (isRoot(ns)) {\n      return {\n        get current() {\n          return stream.values;\n        },\n      };\n    }\n  }\n  const messagesKey = options?.messagesKey ?? \"messages\";\n  return selectFromTarget<unknown>(\n    stream,\n    target,\n    undefined,\n    (ns) => valuesProjection<unknown>(ns, messagesKey),\n    `values|${messagesKey}`\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 *\n * `name` accepts either a plain string or a getter so component\n * state can drive the extension name at runtime.\n */\nexport function useExtension<T = unknown>(\n  stream: AnyStream,\n  name: ValueOrGetter<string>,\n  target?: ValueOrGetter<SelectorTarget>\n): ReactiveValue<T | undefined> {\n  const getName = () => (isGetter(name) ? (name as () => string)() : name);\n  if (isGetter(target)) {\n    const getTarget = target;\n    return useProjection<T | undefined>(\n      () => getRegistry(stream),\n      () => extensionProjection<T>(getName(), resolveNamespace(getTarget())),\n      () =>\n        `extension|${getName()}|${namespaceKey(resolveNamespace(getTarget()))}`,\n      undefined\n    );\n  }\n  const ns = resolveNamespace(target);\n  return useProjection<T | undefined>(\n    getRegistry(stream),\n    () => extensionProjection<T>(getName(), ns),\n    () => `extension|${getName()}|${namespaceKey(ns)}`,\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: ValueOrGetter<readonly Channel[]>,\n  target?: ValueOrGetter<SelectorTarget>,\n  options?: UseChannelOptions\n): ReactiveValue<Event[]> {\n  const getChannels = () =>\n    isGetter(channels) ? (channels as () => readonly Channel[])() : channels;\n  const getTarget = () => (isGetter(target) ? target() : target);\n  const bufferSize = options?.bufferSize ?? \"default\";\n  const replayMode = (options?.replay ?? true) ? \"replay\" : \"live\";\n  return useProjection<Event[]>(\n    () => getRegistry(stream),\n    () =>\n      channelProjection(\n        getChannels(),\n        resolveNamespace(getTarget()),\n        options\n      ) as unknown as import(\"@langchain/langgraph-sdk/stream\").ProjectionSpec<\n        Event[]\n      >,\n    () => {\n      const sortedChannels = [...getChannels()].sort().join(\",\");\n      return `channel|${bufferSize}|${replayMode}|${sortedChannels}|${namespaceKey(resolveNamespace(getTarget()))}`;\n    },\n    EMPTY_EVENTS\n  );\n}\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?: ValueOrGetter<SelectorTarget>\n): ReactiveValue<AudioMedia[]> {\n  return selectFromTarget<AudioMedia[]>(\n    stream,\n    target,\n    EMPTY_AUDIO,\n    (ns) => audioProjection(ns),\n    \"audio\"\n  );\n}\n\n/**\n * Subscribe to a scoped image-media stream. Pair with `useMediaURL`\n * for `<img src>`.\n */\nexport function useImages(\n  stream: AnyStream,\n  target?: ValueOrGetter<SelectorTarget>\n): ReactiveValue<ImageMedia[]> {\n  return selectFromTarget<ImageMedia[]>(\n    stream,\n    target,\n    EMPTY_IMAGES,\n    (ns) => imagesProjection(ns),\n    \"images\"\n  );\n}\n\n/**\n * Subscribe to a scoped video-media stream. Pair with `useMediaURL`\n * for `<video src>`.\n */\nexport function useVideo(\n  stream: AnyStream,\n  target?: ValueOrGetter<SelectorTarget>\n): ReactiveValue<VideoMedia[]> {\n  return selectFromTarget<VideoMedia[]>(\n    stream,\n    target,\n    EMPTY_VIDEO,\n    (ns) => videoProjection(ns),\n    \"video\"\n  );\n}\n\n/**\n * Subscribe to a scoped file-media stream. Pair with `useMediaURL`\n * for an `<a download href>` target.\n */\nexport function useFiles(\n  stream: AnyStream,\n  target?: ValueOrGetter<SelectorTarget>\n): ReactiveValue<FileMedia[]> {\n  return selectFromTarget<FileMedia[]>(\n    stream,\n    target,\n    EMPTY_FILES,\n    (ns) => filesProjection(ns),\n    \"files\"\n  );\n}\n\n/**\n * Read metadata recorded for a specific message id — today exposes\n * `parentCheckpointId`, the checkpoint the message was first seen\n * on. Designed for fork / edit flows:\n *\n * ```svelte\n * <script lang=\"ts\">\n *   const meta = useMessageMetadata(stream, () => selected?.id);\n * </script>\n * Parent: {meta.current?.parentCheckpointId ?? \"root\"}\n * ```\n *\n * `messageId` accepts a plain string or a getter — the binding\n * re-evaluates whenever the id changes.\n */\nexport function useMessageMetadata(\n  stream: AnyStream,\n  messageId: ValueOrGetter<string | undefined>\n): ReactiveValue<MessageMetadata | undefined> {\n  const store = stream[STREAM_CONTROLLER].messageMetadataStore;\n  let map = $state<MessageMetadataMap>(store.getSnapshot());\n\n  $effect(() => {\n    const unsubscribe = store.subscribe(() => {\n      map = store.getSnapshot();\n    });\n    return unsubscribe;\n  });\n\n  const getId = () =>\n    isGetter(messageId) ? (messageId as () => string | undefined)() : messageId;\n\n  return {\n    get current(): MessageMetadata | undefined {\n      const key = getId();\n      if (key == null) return undefined;\n      return map.get(key);\n    },\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 getters are stable — safe to pass into `{#each}`.\n */\nexport interface UseSubmissionQueueReturn<\n  StateType extends object = Record<string, unknown>,\n> {\n  readonly entries: SubmissionQueueSnapshot<StateType>;\n  readonly size: 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  let entries = $state<SubmissionQueueSnapshot>(store.getSnapshot());\n\n  $effect(() => {\n    const unsubscribe = store.subscribe(() => {\n      entries = store.getSnapshot();\n    });\n    return unsubscribe;\n  });\n\n  return {\n    get entries() {\n      return entries;\n    },\n    get size() {\n      return entries.length;\n    },\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.svelte.cjs","names":["NAMESPACE_SEPARATOR","useProjection","getRegistry","STREAM_CONTROLLER"],"sources":["../src/selectors.svelte.ts"],"sourcesContent":["import 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.svelte.js\";\nimport {\n  useProjection,\n  type ReactiveValue,\n  type ValueOrGetter,\n} from \"./use-projection.svelte.js\";\n\n/**\n * Parameterise selectors on `StateType` alone so callers with a full\n * `useStream<S, I, C>()` handle don't have to redeclare\n * `InterruptType` / `ConfigurableType` at every call site.\n */\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 targets. Callers can pass:\n *  - `undefined` / `null` — root namespace (served by the always-on\n *    root store; no extra subscription opens);\n *  - a {@link SubagentDiscoverySnapshot} (`stream.subagents.get(...)`);\n *  - a {@link SubgraphDiscoverySnapshot}\n *    (`stream.subgraphs.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\nfunction isGetter<T>(input: ValueOrGetter<T> | undefined): input is () => T {\n  return typeof input === \"function\";\n}\n\n/**\n * Internal helper that wires a reactive-or-static target into\n * {@link useProjection}. Encapsulates the bookkeeping every selector\n * otherwise repeats.\n */\nfunction selectFromTarget<T>(\n  stream: AnyStream,\n  target: ValueOrGetter<SelectorTarget> | undefined,\n  initialValue: T,\n  makeSpec: (\n    namespace: readonly string[]\n  ) => import(\"@langchain/langgraph-sdk/stream\").ProjectionSpec<T>,\n  keyPrefix: string\n): ReactiveValue<T> {\n  if (isGetter(target)) {\n    const getTarget = target;\n    return useProjection<T>(\n      () => {\n        const ns = resolveNamespace(getTarget());\n        return isRoot(ns) ? null : getRegistry(stream);\n      },\n      () => makeSpec(resolveNamespace(getTarget())),\n      () => `${keyPrefix}|${namespaceKey(resolveNamespace(getTarget()))}`,\n      initialValue\n    );\n  }\n  const ns = resolveNamespace(target);\n  // Static root: we deliberately don't short-circuit here because\n  // each selector owns the root fallback shape (`stream.messages`\n  // vs `stream.values` vs `stream.toolCalls`). Callers use the\n  // dedicated wrappers below.\n  const key = `${keyPrefix}|${namespaceKey(ns)}`;\n  return useProjection<T>(\n    isRoot(ns) ? null : getRegistry(stream),\n    () => makeSpec(ns),\n    key,\n    initialValue\n  );\n}\n\nconst EMPTY_MESSAGES: BaseMessage[] = [];\nconst EMPTY_TOOLCALLS: AssembledToolCall[] = [];\nconst EMPTY_EVENTS: Event[] = [];\nconst EMPTY_AUDIO: AudioMedia[] = [];\nconst EMPTY_IMAGES: ImageMedia[] = [];\nconst EMPTY_VIDEO: VideoMedia[] = [];\nconst EMPTY_FILES: FileMedia[] = [];\n\n/**\n * Subscribe to a scoped `messages` stream.\n *\n * Contract:\n *  - At the root (no `target`, or a static target that resolves to\n *    the root namespace) returns a handle whose `.current` delegates\n *    to `stream.messages` — the always-on root projection. No extra\n *    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 owning\n *    component teardown fires (and the registry closes the\n *    underlying server subscription when the last consumer leaves).\n *  - A reactive `target` (getter form) re-binds the subscription on\n *    change. A getter that flips between root and scoped is\n *    supported: the root case short-circuits to the initial value\n *    because dynamic root delegation isn't meaningful — pass a\n *    static undefined/null target for root handles.\n *\n * Messages are always `BaseMessage` class instances from\n * `@langchain/core/messages`.\n */\nexport function useMessages(\n  stream: AnyStream,\n  target?: ValueOrGetter<SelectorTarget>\n): ReactiveValue<BaseMessage[]> {\n  if (!isGetter(target)) {\n    const ns = resolveNamespace(target);\n    if (isRoot(ns)) {\n      return {\n        get current() {\n          return stream.messages;\n        },\n      };\n    }\n  }\n  return selectFromTarget<BaseMessage[]>(\n    stream,\n    target,\n    EMPTY_MESSAGES,\n    (ns) => messagesProjection(ns),\n    \"messages\"\n  );\n}\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 a\n * handle delegating to `stream.toolCalls`.\n */\nexport function useToolCalls(\n  stream: AnyStream,\n  target?: ValueOrGetter<SelectorTarget>\n): ReactiveValue<AssembledToolCall[]>;\nexport function useToolCalls<T>(\n  stream: AnyStream,\n  target?: ValueOrGetter<SelectorTarget>\n): ReactiveValue<InferToolCalls<T>[]>;\nexport function useToolCalls(\n  stream: AnyStream,\n  target?: ValueOrGetter<SelectorTarget>\n): ReactiveValue<AssembledToolCall[]> {\n  if (!isGetter(target)) {\n    const ns = resolveNamespace(target);\n    if (isRoot(ns)) {\n      return {\n        get current() {\n          return stream.toolCalls;\n        },\n      };\n    }\n  }\n  return selectFromTarget<AssembledToolCall[]>(\n    stream,\n    target,\n    EMPTY_TOOLCALLS,\n    (ns) => toolCallsProjection(ns),\n    \"toolCalls\"\n  );\n}\n\n/**\n * Subscribe to a scoped `values` stream — the most recent state\n * payload for a namespace. At the root returns a handle delegating\n * to `stream.values`.\n *\n * Typing:\n *  - **Root** (`useValues(stream)`): returns the `StateType` declared\n *    on `useStream<State>()` — non-nullable (the root snapshot\n *    always 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): ReactiveValue<StateType>;\nexport function useValues<T>(\n  stream: AnyStream\n): ReactiveValue<InferStateType<T>>;\nexport function useValues<T = unknown>(\n  stream: AnyStream,\n  target: ValueOrGetter<SelectorTarget>,\n  options?: { messagesKey?: string }\n): ReactiveValue<T | undefined>;\nexport function useValues(\n  stream: AnyStream,\n  target?: ValueOrGetter<SelectorTarget>,\n  options?: { messagesKey?: string }\n): ReactiveValue<unknown> {\n  if (!isGetter(target)) {\n    const ns = resolveNamespace(target);\n    if (isRoot(ns)) {\n      return {\n        get current() {\n          return stream.values;\n        },\n      };\n    }\n  }\n  const messagesKey = options?.messagesKey ?? \"messages\";\n  return selectFromTarget<unknown>(\n    stream,\n    target,\n    undefined,\n    (ns) => valuesProjection<unknown>(ns, messagesKey),\n    `values|${messagesKey}`\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 *\n * `name` accepts either a plain string or a getter so component\n * state can drive the extension name at runtime.\n */\nexport function useExtension<T = unknown>(\n  stream: AnyStream,\n  name: ValueOrGetter<string>,\n  target?: ValueOrGetter<SelectorTarget>\n): ReactiveValue<T | undefined> {\n  const getName = () => (isGetter(name) ? (name as () => string)() : name);\n  if (isGetter(target)) {\n    const getTarget = target;\n    return useProjection<T | undefined>(\n      () => getRegistry(stream),\n      () => extensionProjection<T>(getName(), resolveNamespace(getTarget())),\n      () =>\n        `extension|${getName()}|${namespaceKey(resolveNamespace(getTarget()))}`,\n      undefined\n    );\n  }\n  const ns = resolveNamespace(target);\n  return useProjection<T | undefined>(\n    getRegistry(stream),\n    () => extensionProjection<T>(getName(), ns),\n    () => `extension|${getName()}|${namespaceKey(ns)}`,\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: ValueOrGetter<readonly Channel[]>,\n  target?: ValueOrGetter<SelectorTarget>,\n  options?: UseChannelOptions\n): ReactiveValue<Event[]> {\n  const getChannels = () =>\n    isGetter(channels) ? (channels as () => readonly Channel[])() : channels;\n  const getTarget = () => (isGetter(target) ? target() : target);\n  const bufferSize = options?.bufferSize ?? \"default\";\n  const replayMode = (options?.replay ?? true) ? \"replay\" : \"live\";\n  return useProjection<Event[]>(\n    () => getRegistry(stream),\n    () =>\n      channelProjection(\n        getChannels(),\n        resolveNamespace(getTarget()),\n        options\n      ) as unknown as import(\"@langchain/langgraph-sdk/stream\").ProjectionSpec<\n        Event[]\n      >,\n    () => {\n      const sortedChannels = [...getChannels()].sort().join(\",\");\n      return `channel|${bufferSize}|${replayMode}|${sortedChannels}|${namespaceKey(resolveNamespace(getTarget()))}`;\n    },\n    EMPTY_EVENTS\n  );\n}\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?: ValueOrGetter<SelectorTarget>\n): ReactiveValue<AudioMedia[]> {\n  return selectFromTarget<AudioMedia[]>(\n    stream,\n    target,\n    EMPTY_AUDIO,\n    (ns) => audioProjection(ns),\n    \"audio\"\n  );\n}\n\n/**\n * Subscribe to a scoped image-media stream. Pair with `useMediaURL`\n * for `<img src>`.\n */\nexport function useImages(\n  stream: AnyStream,\n  target?: ValueOrGetter<SelectorTarget>\n): ReactiveValue<ImageMedia[]> {\n  return selectFromTarget<ImageMedia[]>(\n    stream,\n    target,\n    EMPTY_IMAGES,\n    (ns) => imagesProjection(ns),\n    \"images\"\n  );\n}\n\n/**\n * Subscribe to a scoped video-media stream. Pair with `useMediaURL`\n * for `<video src>`.\n */\nexport function useVideo(\n  stream: AnyStream,\n  target?: ValueOrGetter<SelectorTarget>\n): ReactiveValue<VideoMedia[]> {\n  return selectFromTarget<VideoMedia[]>(\n    stream,\n    target,\n    EMPTY_VIDEO,\n    (ns) => videoProjection(ns),\n    \"video\"\n  );\n}\n\n/**\n * Subscribe to a scoped file-media stream. Pair with `useMediaURL`\n * for an `<a download href>` target.\n */\nexport function useFiles(\n  stream: AnyStream,\n  target?: ValueOrGetter<SelectorTarget>\n): ReactiveValue<FileMedia[]> {\n  return selectFromTarget<FileMedia[]>(\n    stream,\n    target,\n    EMPTY_FILES,\n    (ns) => filesProjection(ns),\n    \"files\"\n  );\n}\n\n/**\n * Read metadata recorded for a specific message id — today exposes\n * `parentCheckpointId`, the checkpoint the message was first seen\n * on. Designed for fork / edit flows:\n *\n * ```svelte\n * <script lang=\"ts\">\n *   const meta = useMessageMetadata(stream, () => selected?.id);\n * </script>\n * Parent: {meta.current?.parentCheckpointId ?? \"root\"}\n * ```\n *\n * `messageId` accepts a plain string or a getter — the binding\n * re-evaluates whenever the id changes.\n */\nexport function useMessageMetadata(\n  stream: AnyStream,\n  messageId: ValueOrGetter<string | undefined>\n): ReactiveValue<MessageMetadata | undefined> {\n  const store = stream[STREAM_CONTROLLER].messageMetadataStore;\n  let map = $state<MessageMetadataMap>(store.getSnapshot());\n\n  $effect(() => {\n    const unsubscribe = store.subscribe(() => {\n      map = store.getSnapshot();\n    });\n    return unsubscribe;\n  });\n\n  const getId = () =>\n    isGetter(messageId) ? (messageId as () => string | undefined)() : messageId;\n\n  return {\n    get current(): MessageMetadata | undefined {\n      const key = getId();\n      if (key == null) return undefined;\n      return map.get(key);\n    },\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 getters are stable — safe to pass into `{#each}`.\n */\nexport interface UseSubmissionQueueReturn<\n  StateType extends object = Record<string, unknown>,\n> {\n  readonly entries: SubmissionQueueSnapshot<StateType>;\n  readonly size: 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  let entries = $state<SubmissionQueueSnapshot>(store.getSnapshot());\n\n  $effect(() => {\n    const unsubscribe = store.subscribe(() => {\n      entries = store.getSnapshot();\n    });\n    return unsubscribe;\n  });\n\n  return {\n    get entries() {\n      return entries;\n    },\n    get size() {\n      return entries.length;\n    },\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.svelte.d.cts

@@ -1,7 +1,7 @@
 import { AnyStream, UseStreamReturn } from "./use-stream.svelte.cjs";
 import { ReactiveValue, ValueOrGetter } from "./use-projection.svelte.cjs";
 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.svelte.d.ts
 /**
@@ -52,6 +52,7 @@ declare function useMessages(stream: AnyStream, target?: ValueOrGetter<SelectorT
  * handle delegating to `stream.toolCalls`.
  */
 declare function useToolCalls(stream: AnyStream, target?: ValueOrGetter<SelectorTarget>): ReactiveValue<AssembledToolCall[]>;
+declare function useToolCalls<T>(stream: AnyStream, target?: ValueOrGetter<SelectorTarget>): ReactiveValue<InferToolCalls<T>[]>;
 /**
  * Subscribe to a scoped `values` stream — the most recent state
  * payload for a namespace. At the root returns a handle delegating

package/dist/selectors.svelte.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"selectors.svelte.d.cts","names":[],"sources":["../src/selectors.svelte.ts"],"mappings":";;;;;;;;AAsCoC;;;KAO/B,YAAA,6BAAyC,eAAA,CAC5C,SAAA;;;;;;AAiBF;;;;;KAAY,cAAA;EAIN,SAAA;AAAA,IACF,yBAAA,GACA,yBAAA;;AA6FJ;;;;;;;;;;;;;;;;;;;AA4BA;;iBA5BgB,WAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,aAAA,CAAc,cAAA,IACtB,aAAA,CAAc,WAAA;;;;;;iBAyBD,YAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,aAAA,CAAc,cAAA,IACtB,aAAA,CAAc,iBAAA;;;;;;;;;;;AAkCjB;;;;iBAAgB,SAAA,0BAAA,CACd,MAAA,EAAQ,YAAA,CAAa,SAAA,IACpB,aAAA,CAAc,SAAA;AAAA,iBACD,SAAA,GAAA,CACd,MAAA,EAAQ,SAAA,GACP,aAAA,CAAc,cAAA,CAAe,CAAA;AAAA,iBAChB,SAAA,aAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,EAAQ,aAAA,CAAc,cAAA,GACtB,OAAA;EAAY,WAAA;AAAA,IACX,aAAA,CAAc,CAAA;;;;;;;;iBAiCD,YAAA,aAAA,CACd,MAAA,EAAQ,SAAA,EACR,IAAA,EAAM,aAAA,UACN,MAAA,GAAS,aAAA,CAAc,cAAA,IACtB,aAAA,CAAc,CAAA;AA5CjB;;;;;;AAAA,KAuEY,iBAAA,GAAoB,wBAAA;AAAA,iBAEhB,UAAA,CACd,MAAA,EAAQ,SAAA,EACR,QAAA,EAAU,aAAA,UAAuB,OAAA,KACjC,MAAA,GAAS,aAAA,CAAc,cAAA,GACvB,OAAA,GAAU,iBAAA,GACT,aAAA,CAAc,KAAA;;;;;;;;iBA+BD,QAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,aAAA,CAAc,cAAA,IACtB,aAAA,CAAc,UAAA;;AA7GjB;;;iBA2HgB,SAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,aAAA,CAAc,cAAA,IACtB,aAAA,CAAc,UAAA;;;;;iBAcD,QAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,aAAA,CAAc,cAAA,IACtB,aAAA,CAAc,UAAA;;;;;iBAcD,QAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,aAAA,CAAc,cAAA,IACtB,aAAA,CAAc,SAAA;;;;;;;;;AA3HjB;;;;;;;iBAoJgB,kBAAA,CACd,MAAA,EAAQ,SAAA,EACR,SAAA,EAAW,aAAA,uBACV,aAAA,CAAc,eAAA;;;;;;;;UA8BA,wBAAA,4BACY,MAAA;EAAA,SAElB,OAAA,EAAS,uBAAA,CAAwB,SAAA;EAAA,SACjC,IAAA;EACT,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.svelte.d.cts","names":[],"sources":["../src/selectors.svelte.ts"],"mappings":";;;;;;;;AAuCoC;;;KAO/B,YAAA,6BAAyC,eAAA,CAC5C,SAAA;;;;;;AAiBF;;;;;KAAY,cAAA;EAIN,SAAA;AAAA,IACF,yBAAA,GACA,yBAAA;;AA6FJ;;;;;;;;;;;;;;;;;;;AA4BA;;iBA5BgB,WAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,aAAA,CAAc,cAAA,IACtB,aAAA,CAAc,WAAA;;;;;;iBAyBD,YAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,aAAA,CAAc,cAAA,IACtB,aAAA,CAAc,iBAAA;AAAA,iBACD,YAAA,GAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,aAAA,CAAc,cAAA,IACtB,aAAA,CAAc,cAAA,CAAe,CAAA;;;;;;;;;;AAHhC;;;;;iBAyCgB,SAAA,0BAAA,CACd,MAAA,EAAQ,YAAA,CAAa,SAAA,IACpB,aAAA,CAAc,SAAA;AAAA,iBACD,SAAA,GAAA,CACd,MAAA,EAAQ,SAAA,GACP,aAAA,CAAc,cAAA,CAAe,CAAA;AAAA,iBAChB,SAAA,aAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,EAAQ,aAAA,CAAc,cAAA,GACtB,OAAA;EAAY,WAAA;AAAA,IACX,aAAA,CAAc,CAAA;;;;;;;;iBAiCD,YAAA,aAAA,CACd,MAAA,EAAQ,SAAA,EACR,IAAA,EAAM,aAAA,UACN,MAAA,GAAS,aAAA,CAAc,cAAA,IACtB,aAAA,CAAc,CAAA;;;;;AA/CjB;;KA0EY,iBAAA,GAAoB,wBAAA;AAAA,iBAEhB,UAAA,CACd,MAAA,EAAQ,SAAA,EACR,QAAA,EAAU,aAAA,UAAuB,OAAA,KACjC,MAAA,GAAS,aAAA,CAAc,cAAA,GACvB,OAAA,GAAU,iBAAA,GACT,aAAA,CAAc,KAAA;;;;;;;;iBA+BD,QAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,aAAA,CAAc,cAAA,IACtB,aAAA,CAAc,UAAA;;;;;iBAcD,SAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,aAAA,CAAc,cAAA,IACtB,aAAA,CAAc,UAAA;AAjIjB;;;;AAAA,iBA+IgB,QAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,aAAA,CAAc,cAAA,IACtB,aAAA,CAAc,UAAA;;;;;iBAcD,QAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,aAAA,CAAc,cAAA,IACtB,aAAA,CAAc,SAAA;;;;;;;;AAhKjB;;;;;;;;iBAyLgB,kBAAA,CACd,MAAA,EAAQ,SAAA,EACR,SAAA,EAAW,aAAA,uBACV,aAAA,CAAc,eAAA;;;;;;;;UA8BA,wBAAA,4BACY,MAAA;EAAA,SAElB,OAAA,EAAS,uBAAA,CAAwB,SAAA;EAAA,SACjC,IAAA;EACT,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.svelte.d.ts

@@ -1,6 +1,6 @@
 import { AnyStream, UseStreamReturn } from "./use-stream.svelte.js";
 import { ReactiveValue, ValueOrGetter } from "./use-projection.svelte.js";
-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.svelte.d.ts
@@ -52,6 +52,7 @@ declare function useMessages(stream: AnyStream, target?: ValueOrGetter<SelectorT
  * handle delegating to `stream.toolCalls`.
  */
 declare function useToolCalls(stream: AnyStream, target?: ValueOrGetter<SelectorTarget>): ReactiveValue<AssembledToolCall[]>;
+declare function useToolCalls<T>(stream: AnyStream, target?: ValueOrGetter<SelectorTarget>): ReactiveValue<InferToolCalls<T>[]>;
 /**
  * Subscribe to a scoped `values` stream — the most recent state
  * payload for a namespace. At the root returns a handle delegating

package/dist/selectors.svelte.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"selectors.svelte.d.ts","names":[],"sources":["../src/selectors.svelte.ts"],"mappings":";;;;;;;;AAsCoC;;;KAO/B,YAAA,6BAAyC,eAAA,CAC5C,SAAA;;;;;;AAiBF;;;;;KAAY,cAAA;EAIN,SAAA;AAAA,IACF,yBAAA,GACA,yBAAA;;AA6FJ;;;;;;;;;;;;;;;;;;;AA4BA;;iBA5BgB,WAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,aAAA,CAAc,cAAA,IACtB,aAAA,CAAc,WAAA;;;;;;iBAyBD,YAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,aAAA,CAAc,cAAA,IACtB,aAAA,CAAc,iBAAA;;;;;;;;;;;AAkCjB;;;;iBAAgB,SAAA,0BAAA,CACd,MAAA,EAAQ,YAAA,CAAa,SAAA,IACpB,aAAA,CAAc,SAAA;AAAA,iBACD,SAAA,GAAA,CACd,MAAA,EAAQ,SAAA,GACP,aAAA,CAAc,cAAA,CAAe,CAAA;AAAA,iBAChB,SAAA,aAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,EAAQ,aAAA,CAAc,cAAA,GACtB,OAAA;EAAY,WAAA;AAAA,IACX,aAAA,CAAc,CAAA;;;;;;;;iBAiCD,YAAA,aAAA,CACd,MAAA,EAAQ,SAAA,EACR,IAAA,EAAM,aAAA,UACN,MAAA,GAAS,aAAA,CAAc,cAAA,IACtB,aAAA,CAAc,CAAA;AA5CjB;;;;;;AAAA,KAuEY,iBAAA,GAAoB,wBAAA;AAAA,iBAEhB,UAAA,CACd,MAAA,EAAQ,SAAA,EACR,QAAA,EAAU,aAAA,UAAuB,OAAA,KACjC,MAAA,GAAS,aAAA,CAAc,cAAA,GACvB,OAAA,GAAU,iBAAA,GACT,aAAA,CAAc,KAAA;;;;;;;;iBA+BD,QAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,aAAA,CAAc,cAAA,IACtB,aAAA,CAAc,UAAA;;AA7GjB;;;iBA2HgB,SAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,aAAA,CAAc,cAAA,IACtB,aAAA,CAAc,UAAA;;;;;iBAcD,QAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,aAAA,CAAc,cAAA,IACtB,aAAA,CAAc,UAAA;;;;;iBAcD,QAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,aAAA,CAAc,cAAA,IACtB,aAAA,CAAc,SAAA;;;;;;;;;AA3HjB;;;;;;;iBAoJgB,kBAAA,CACd,MAAA,EAAQ,SAAA,EACR,SAAA,EAAW,aAAA,uBACV,aAAA,CAAc,eAAA;;;;;;;;UA8BA,wBAAA,4BACY,MAAA;EAAA,SAElB,OAAA,EAAS,uBAAA,CAAwB,SAAA;EAAA,SACjC,IAAA;EACT,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.svelte.d.ts","names":[],"sources":["../src/selectors.svelte.ts"],"mappings":";;;;;;;;AAuCoC;;;KAO/B,YAAA,6BAAyC,eAAA,CAC5C,SAAA;;;;;;AAiBF;;;;;KAAY,cAAA;EAIN,SAAA;AAAA,IACF,yBAAA,GACA,yBAAA;;AA6FJ;;;;;;;;;;;;;;;;;;;AA4BA;;iBA5BgB,WAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,aAAA,CAAc,cAAA,IACtB,aAAA,CAAc,WAAA;;;;;;iBAyBD,YAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,aAAA,CAAc,cAAA,IACtB,aAAA,CAAc,iBAAA;AAAA,iBACD,YAAA,GAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,aAAA,CAAc,cAAA,IACtB,aAAA,CAAc,cAAA,CAAe,CAAA;;;;;;;;;;AAHhC;;;;;iBAyCgB,SAAA,0BAAA,CACd,MAAA,EAAQ,YAAA,CAAa,SAAA,IACpB,aAAA,CAAc,SAAA;AAAA,iBACD,SAAA,GAAA,CACd,MAAA,EAAQ,SAAA,GACP,aAAA,CAAc,cAAA,CAAe,CAAA;AAAA,iBAChB,SAAA,aAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,EAAQ,aAAA,CAAc,cAAA,GACtB,OAAA;EAAY,WAAA;AAAA,IACX,aAAA,CAAc,CAAA;;;;;;;;iBAiCD,YAAA,aAAA,CACd,MAAA,EAAQ,SAAA,EACR,IAAA,EAAM,aAAA,UACN,MAAA,GAAS,aAAA,CAAc,cAAA,IACtB,aAAA,CAAc,CAAA;;;;;AA/CjB;;KA0EY,iBAAA,GAAoB,wBAAA;AAAA,iBAEhB,UAAA,CACd,MAAA,EAAQ,SAAA,EACR,QAAA,EAAU,aAAA,UAAuB,OAAA,KACjC,MAAA,GAAS,aAAA,CAAc,cAAA,GACvB,OAAA,GAAU,iBAAA,GACT,aAAA,CAAc,KAAA;;;;;;;;iBA+BD,QAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,aAAA,CAAc,cAAA,IACtB,aAAA,CAAc,UAAA;;;;;iBAcD,SAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,aAAA,CAAc,cAAA,IACtB,aAAA,CAAc,UAAA;AAjIjB;;;;AAAA,iBA+IgB,QAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,aAAA,CAAc,cAAA,IACtB,aAAA,CAAc,UAAA;;;;;iBAcD,QAAA,CACd,MAAA,EAAQ,SAAA,EACR,MAAA,GAAS,aAAA,CAAc,cAAA,IACtB,aAAA,CAAc,SAAA;;;;;;;;AAhKjB;;;;;;;;iBAyLgB,kBAAA,CACd,MAAA,EAAQ,SAAA,EACR,SAAA,EAAW,aAAA,uBACV,aAAA,CAAc,eAAA;;;;;;;;UA8BA,wBAAA,4BACY,MAAA;EAAA,SAElB,OAAA,EAAS,uBAAA,CAAwB,SAAA;EAAA,SACjC,IAAA;EACT,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.svelte.js

@@ -70,11 +70,6 @@ function useMessages(stream, target) {
 	}
 	return selectFromTarget(stream, target, EMPTY_MESSAGES, (ns) => messagesProjection(ns), "messages");
 }
-/**
-* Subscribe to a scoped `tools` (tool-call) stream. Same target and
-* lifecycle rules as {@link useMessages}; at the root this returns a
-* handle delegating to `stream.toolCalls`.
-*/
 function useToolCalls(stream, target) {
 	if (!isGetter(target)) {
 		if (isRoot(resolveNamespace(target))) return { get current() {

package/dist/selectors.svelte.js.map

@@ -1 +1 @@
-{"version":3,"file":"selectors.svelte.js","names":[],"sources":["../src/selectors.svelte.ts"],"sourcesContent":["import 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.svelte.js\";\nimport {\n  useProjection,\n  type ReactiveValue,\n  type ValueOrGetter,\n} from \"./use-projection.svelte.js\";\n\n/**\n * Parameterise selectors on `StateType` alone so callers with a full\n * `useStream<S, I, C>()` handle don't have to redeclare\n * `InterruptType` / `ConfigurableType` at every call site.\n */\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 targets. Callers can pass:\n *  - `undefined` / `null` — root namespace (served by the always-on\n *    root store; no extra subscription opens);\n *  - a {@link SubagentDiscoverySnapshot} (`stream.subagents.get(...)`);\n *  - a {@link SubgraphDiscoverySnapshot}\n *    (`stream.subgraphs.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\nfunction isGetter<T>(input: ValueOrGetter<T> | undefined): input is () => T {\n  return typeof input === \"function\";\n}\n\n/**\n * Internal helper that wires a reactive-or-static target into\n * {@link useProjection}. Encapsulates the bookkeeping every selector\n * otherwise repeats.\n */\nfunction selectFromTarget<T>(\n  stream: AnyStream,\n  target: ValueOrGetter<SelectorTarget> | undefined,\n  initialValue: T,\n  makeSpec: (\n    namespace: readonly string[]\n  ) => import(\"@langchain/langgraph-sdk/stream\").ProjectionSpec<T>,\n  keyPrefix: string\n): ReactiveValue<T> {\n  if (isGetter(target)) {\n    const getTarget = target;\n    return useProjection<T>(\n      () => {\n        const ns = resolveNamespace(getTarget());\n        return isRoot(ns) ? null : getRegistry(stream);\n      },\n      () => makeSpec(resolveNamespace(getTarget())),\n      () => `${keyPrefix}|${namespaceKey(resolveNamespace(getTarget()))}`,\n      initialValue\n    );\n  }\n  const ns = resolveNamespace(target);\n  // Static root: we deliberately don't short-circuit here because\n  // each selector owns the root fallback shape (`stream.messages`\n  // vs `stream.values` vs `stream.toolCalls`). Callers use the\n  // dedicated wrappers below.\n  const key = `${keyPrefix}|${namespaceKey(ns)}`;\n  return useProjection<T>(\n    isRoot(ns) ? null : getRegistry(stream),\n    () => makeSpec(ns),\n    key,\n    initialValue\n  );\n}\n\nconst EMPTY_MESSAGES: BaseMessage[] = [];\nconst EMPTY_TOOLCALLS: AssembledToolCall[] = [];\nconst EMPTY_EVENTS: Event[] = [];\nconst EMPTY_AUDIO: AudioMedia[] = [];\nconst EMPTY_IMAGES: ImageMedia[] = [];\nconst EMPTY_VIDEO: VideoMedia[] = [];\nconst EMPTY_FILES: FileMedia[] = [];\n\n/**\n * Subscribe to a scoped `messages` stream.\n *\n * Contract:\n *  - At the root (no `target`, or a static target that resolves to\n *    the root namespace) returns a handle whose `.current` delegates\n *    to `stream.messages` — the always-on root projection. No extra\n *    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 owning\n *    component teardown fires (and the registry closes the\n *    underlying server subscription when the last consumer leaves).\n *  - A reactive `target` (getter form) re-binds the subscription on\n *    change. A getter that flips between root and scoped is\n *    supported: the root case short-circuits to the initial value\n *    because dynamic root delegation isn't meaningful — pass a\n *    static undefined/null target for root handles.\n *\n * Messages are always `BaseMessage` class instances from\n * `@langchain/core/messages`.\n */\nexport function useMessages(\n  stream: AnyStream,\n  target?: ValueOrGetter<SelectorTarget>\n): ReactiveValue<BaseMessage[]> {\n  if (!isGetter(target)) {\n    const ns = resolveNamespace(target);\n    if (isRoot(ns)) {\n      return {\n        get current() {\n          return stream.messages;\n        },\n      };\n    }\n  }\n  return selectFromTarget<BaseMessage[]>(\n    stream,\n    target,\n    EMPTY_MESSAGES,\n    (ns) => messagesProjection(ns),\n    \"messages\"\n  );\n}\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 a\n * handle delegating to `stream.toolCalls`.\n */\nexport function useToolCalls(\n  stream: AnyStream,\n  target?: ValueOrGetter<SelectorTarget>\n): ReactiveValue<AssembledToolCall[]> {\n  if (!isGetter(target)) {\n    const ns = resolveNamespace(target);\n    if (isRoot(ns)) {\n      return {\n        get current() {\n          return stream.toolCalls;\n        },\n      };\n    }\n  }\n  return selectFromTarget<AssembledToolCall[]>(\n    stream,\n    target,\n    EMPTY_TOOLCALLS,\n    (ns) => toolCallsProjection(ns),\n    \"toolCalls\"\n  );\n}\n\n/**\n * Subscribe to a scoped `values` stream — the most recent state\n * payload for a namespace. At the root returns a handle delegating\n * to `stream.values`.\n *\n * Typing:\n *  - **Root** (`useValues(stream)`): returns the `StateType` declared\n *    on `useStream<State>()` — non-nullable (the root snapshot\n *    always 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): ReactiveValue<StateType>;\nexport function useValues<T>(\n  stream: AnyStream\n): ReactiveValue<InferStateType<T>>;\nexport function useValues<T = unknown>(\n  stream: AnyStream,\n  target: ValueOrGetter<SelectorTarget>,\n  options?: { messagesKey?: string }\n): ReactiveValue<T | undefined>;\nexport function useValues(\n  stream: AnyStream,\n  target?: ValueOrGetter<SelectorTarget>,\n  options?: { messagesKey?: string }\n): ReactiveValue<unknown> {\n  if (!isGetter(target)) {\n    const ns = resolveNamespace(target);\n    if (isRoot(ns)) {\n      return {\n        get current() {\n          return stream.values;\n        },\n      };\n    }\n  }\n  const messagesKey = options?.messagesKey ?? \"messages\";\n  return selectFromTarget<unknown>(\n    stream,\n    target,\n    undefined,\n    (ns) => valuesProjection<unknown>(ns, messagesKey),\n    `values|${messagesKey}`\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 *\n * `name` accepts either a plain string or a getter so component\n * state can drive the extension name at runtime.\n */\nexport function useExtension<T = unknown>(\n  stream: AnyStream,\n  name: ValueOrGetter<string>,\n  target?: ValueOrGetter<SelectorTarget>\n): ReactiveValue<T | undefined> {\n  const getName = () => (isGetter(name) ? (name as () => string)() : name);\n  if (isGetter(target)) {\n    const getTarget = target;\n    return useProjection<T | undefined>(\n      () => getRegistry(stream),\n      () => extensionProjection<T>(getName(), resolveNamespace(getTarget())),\n      () =>\n        `extension|${getName()}|${namespaceKey(resolveNamespace(getTarget()))}`,\n      undefined\n    );\n  }\n  const ns = resolveNamespace(target);\n  return useProjection<T | undefined>(\n    getRegistry(stream),\n    () => extensionProjection<T>(getName(), ns),\n    () => `extension|${getName()}|${namespaceKey(ns)}`,\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: ValueOrGetter<readonly Channel[]>,\n  target?: ValueOrGetter<SelectorTarget>,\n  options?: UseChannelOptions\n): ReactiveValue<Event[]> {\n  const getChannels = () =>\n    isGetter(channels) ? (channels as () => readonly Channel[])() : channels;\n  const getTarget = () => (isGetter(target) ? target() : target);\n  const bufferSize = options?.bufferSize ?? \"default\";\n  const replayMode = (options?.replay ?? true) ? \"replay\" : \"live\";\n  return useProjection<Event[]>(\n    () => getRegistry(stream),\n    () =>\n      channelProjection(\n        getChannels(),\n        resolveNamespace(getTarget()),\n        options\n      ) as unknown as import(\"@langchain/langgraph-sdk/stream\").ProjectionSpec<\n        Event[]\n      >,\n    () => {\n      const sortedChannels = [...getChannels()].sort().join(\",\");\n      return `channel|${bufferSize}|${replayMode}|${sortedChannels}|${namespaceKey(resolveNamespace(getTarget()))}`;\n    },\n    EMPTY_EVENTS\n  );\n}\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?: ValueOrGetter<SelectorTarget>\n): ReactiveValue<AudioMedia[]> {\n  return selectFromTarget<AudioMedia[]>(\n    stream,\n    target,\n    EMPTY_AUDIO,\n    (ns) => audioProjection(ns),\n    \"audio\"\n  );\n}\n\n/**\n * Subscribe to a scoped image-media stream. Pair with `useMediaURL`\n * for `<img src>`.\n */\nexport function useImages(\n  stream: AnyStream,\n  target?: ValueOrGetter<SelectorTarget>\n): ReactiveValue<ImageMedia[]> {\n  return selectFromTarget<ImageMedia[]>(\n    stream,\n    target,\n    EMPTY_IMAGES,\n    (ns) => imagesProjection(ns),\n    \"images\"\n  );\n}\n\n/**\n * Subscribe to a scoped video-media stream. Pair with `useMediaURL`\n * for `<video src>`.\n */\nexport function useVideo(\n  stream: AnyStream,\n  target?: ValueOrGetter<SelectorTarget>\n): ReactiveValue<VideoMedia[]> {\n  return selectFromTarget<VideoMedia[]>(\n    stream,\n    target,\n    EMPTY_VIDEO,\n    (ns) => videoProjection(ns),\n    \"video\"\n  );\n}\n\n/**\n * Subscribe to a scoped file-media stream. Pair with `useMediaURL`\n * for an `<a download href>` target.\n */\nexport function useFiles(\n  stream: AnyStream,\n  target?: ValueOrGetter<SelectorTarget>\n): ReactiveValue<FileMedia[]> {\n  return selectFromTarget<FileMedia[]>(\n    stream,\n    target,\n    EMPTY_FILES,\n    (ns) => filesProjection(ns),\n    \"files\"\n  );\n}\n\n/**\n * Read metadata recorded for a specific message id — today exposes\n * `parentCheckpointId`, the checkpoint the message was first seen\n * on. Designed for fork / edit flows:\n *\n * ```svelte\n * <script lang=\"ts\">\n *   const meta = useMessageMetadata(stream, () => selected?.id);\n * </script>\n * Parent: {meta.current?.parentCheckpointId ?? \"root\"}\n * ```\n *\n * `messageId` accepts a plain string or a getter — the binding\n * re-evaluates whenever the id changes.\n */\nexport function useMessageMetadata(\n  stream: AnyStream,\n  messageId: ValueOrGetter<string | undefined>\n): ReactiveValue<MessageMetadata | undefined> {\n  const store = stream[STREAM_CONTROLLER].messageMetadataStore;\n  let map = $state<MessageMetadataMap>(store.getSnapshot());\n\n  $effect(() => {\n    const unsubscribe = store.subscribe(() => {\n      map = store.getSnapshot();\n    });\n    return unsubscribe;\n  });\n\n  const getId = () =>\n    isGetter(messageId) ? (messageId as () => string | undefined)() : messageId;\n\n  return {\n    get current(): MessageMetadata | undefined {\n      const key = getId();\n      if (key == null) return undefined;\n      return map.get(key);\n    },\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 getters are stable — safe to pass into `{#each}`.\n */\nexport interface UseSubmissionQueueReturn<\n  StateType extends object = Record<string, unknown>,\n> {\n  readonly entries: SubmissionQueueSnapshot<StateType>;\n  readonly size: 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  let entries = $state<SubmissionQueueSnapshot>(store.getSnapshot());\n\n  $effect(() => {\n    const unsubscribe = store.subscribe(() => {\n      entries = store.getSnapshot();\n    });\n    return unsubscribe;\n  });\n\n  return {\n    get entries() {\n      return entries;\n    },\n    get size() {\n      return entries.length;\n    },\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.svelte.js","names":[],"sources":["../src/selectors.svelte.ts"],"sourcesContent":["import 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.svelte.js\";\nimport {\n  useProjection,\n  type ReactiveValue,\n  type ValueOrGetter,\n} from \"./use-projection.svelte.js\";\n\n/**\n * Parameterise selectors on `StateType` alone so callers with a full\n * `useStream<S, I, C>()` handle don't have to redeclare\n * `InterruptType` / `ConfigurableType` at every call site.\n */\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 targets. Callers can pass:\n *  - `undefined` / `null` — root namespace (served by the always-on\n *    root store; no extra subscription opens);\n *  - a {@link SubagentDiscoverySnapshot} (`stream.subagents.get(...)`);\n *  - a {@link SubgraphDiscoverySnapshot}\n *    (`stream.subgraphs.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\nfunction isGetter<T>(input: ValueOrGetter<T> | undefined): input is () => T {\n  return typeof input === \"function\";\n}\n\n/**\n * Internal helper that wires a reactive-or-static target into\n * {@link useProjection}. Encapsulates the bookkeeping every selector\n * otherwise repeats.\n */\nfunction selectFromTarget<T>(\n  stream: AnyStream,\n  target: ValueOrGetter<SelectorTarget> | undefined,\n  initialValue: T,\n  makeSpec: (\n    namespace: readonly string[]\n  ) => import(\"@langchain/langgraph-sdk/stream\").ProjectionSpec<T>,\n  keyPrefix: string\n): ReactiveValue<T> {\n  if (isGetter(target)) {\n    const getTarget = target;\n    return useProjection<T>(\n      () => {\n        const ns = resolveNamespace(getTarget());\n        return isRoot(ns) ? null : getRegistry(stream);\n      },\n      () => makeSpec(resolveNamespace(getTarget())),\n      () => `${keyPrefix}|${namespaceKey(resolveNamespace(getTarget()))}`,\n      initialValue\n    );\n  }\n  const ns = resolveNamespace(target);\n  // Static root: we deliberately don't short-circuit here because\n  // each selector owns the root fallback shape (`stream.messages`\n  // vs `stream.values` vs `stream.toolCalls`). Callers use the\n  // dedicated wrappers below.\n  const key = `${keyPrefix}|${namespaceKey(ns)}`;\n  return useProjection<T>(\n    isRoot(ns) ? null : getRegistry(stream),\n    () => makeSpec(ns),\n    key,\n    initialValue\n  );\n}\n\nconst EMPTY_MESSAGES: BaseMessage[] = [];\nconst EMPTY_TOOLCALLS: AssembledToolCall[] = [];\nconst EMPTY_EVENTS: Event[] = [];\nconst EMPTY_AUDIO: AudioMedia[] = [];\nconst EMPTY_IMAGES: ImageMedia[] = [];\nconst EMPTY_VIDEO: VideoMedia[] = [];\nconst EMPTY_FILES: FileMedia[] = [];\n\n/**\n * Subscribe to a scoped `messages` stream.\n *\n * Contract:\n *  - At the root (no `target`, or a static target that resolves to\n *    the root namespace) returns a handle whose `.current` delegates\n *    to `stream.messages` — the always-on root projection. No extra\n *    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 owning\n *    component teardown fires (and the registry closes the\n *    underlying server subscription when the last consumer leaves).\n *  - A reactive `target` (getter form) re-binds the subscription on\n *    change. A getter that flips between root and scoped is\n *    supported: the root case short-circuits to the initial value\n *    because dynamic root delegation isn't meaningful — pass a\n *    static undefined/null target for root handles.\n *\n * Messages are always `BaseMessage` class instances from\n * `@langchain/core/messages`.\n */\nexport function useMessages(\n  stream: AnyStream,\n  target?: ValueOrGetter<SelectorTarget>\n): ReactiveValue<BaseMessage[]> {\n  if (!isGetter(target)) {\n    const ns = resolveNamespace(target);\n    if (isRoot(ns)) {\n      return {\n        get current() {\n          return stream.messages;\n        },\n      };\n    }\n  }\n  return selectFromTarget<BaseMessage[]>(\n    stream,\n    target,\n    EMPTY_MESSAGES,\n    (ns) => messagesProjection(ns),\n    \"messages\"\n  );\n}\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 a\n * handle delegating to `stream.toolCalls`.\n */\nexport function useToolCalls(\n  stream: AnyStream,\n  target?: ValueOrGetter<SelectorTarget>\n): ReactiveValue<AssembledToolCall[]>;\nexport function useToolCalls<T>(\n  stream: AnyStream,\n  target?: ValueOrGetter<SelectorTarget>\n): ReactiveValue<InferToolCalls<T>[]>;\nexport function useToolCalls(\n  stream: AnyStream,\n  target?: ValueOrGetter<SelectorTarget>\n): ReactiveValue<AssembledToolCall[]> {\n  if (!isGetter(target)) {\n    const ns = resolveNamespace(target);\n    if (isRoot(ns)) {\n      return {\n        get current() {\n          return stream.toolCalls;\n        },\n      };\n    }\n  }\n  return selectFromTarget<AssembledToolCall[]>(\n    stream,\n    target,\n    EMPTY_TOOLCALLS,\n    (ns) => toolCallsProjection(ns),\n    \"toolCalls\"\n  );\n}\n\n/**\n * Subscribe to a scoped `values` stream — the most recent state\n * payload for a namespace. At the root returns a handle delegating\n * to `stream.values`.\n *\n * Typing:\n *  - **Root** (`useValues(stream)`): returns the `StateType` declared\n *    on `useStream<State>()` — non-nullable (the root snapshot\n *    always 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): ReactiveValue<StateType>;\nexport function useValues<T>(\n  stream: AnyStream\n): ReactiveValue<InferStateType<T>>;\nexport function useValues<T = unknown>(\n  stream: AnyStream,\n  target: ValueOrGetter<SelectorTarget>,\n  options?: { messagesKey?: string }\n): ReactiveValue<T | undefined>;\nexport function useValues(\n  stream: AnyStream,\n  target?: ValueOrGetter<SelectorTarget>,\n  options?: { messagesKey?: string }\n): ReactiveValue<unknown> {\n  if (!isGetter(target)) {\n    const ns = resolveNamespace(target);\n    if (isRoot(ns)) {\n      return {\n        get current() {\n          return stream.values;\n        },\n      };\n    }\n  }\n  const messagesKey = options?.messagesKey ?? \"messages\";\n  return selectFromTarget<unknown>(\n    stream,\n    target,\n    undefined,\n    (ns) => valuesProjection<unknown>(ns, messagesKey),\n    `values|${messagesKey}`\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 *\n * `name` accepts either a plain string or a getter so component\n * state can drive the extension name at runtime.\n */\nexport function useExtension<T = unknown>(\n  stream: AnyStream,\n  name: ValueOrGetter<string>,\n  target?: ValueOrGetter<SelectorTarget>\n): ReactiveValue<T | undefined> {\n  const getName = () => (isGetter(name) ? (name as () => string)() : name);\n  if (isGetter(target)) {\n    const getTarget = target;\n    return useProjection<T | undefined>(\n      () => getRegistry(stream),\n      () => extensionProjection<T>(getName(), resolveNamespace(getTarget())),\n      () =>\n        `extension|${getName()}|${namespaceKey(resolveNamespace(getTarget()))}`,\n      undefined\n    );\n  }\n  const ns = resolveNamespace(target);\n  return useProjection<T | undefined>(\n    getRegistry(stream),\n    () => extensionProjection<T>(getName(), ns),\n    () => `extension|${getName()}|${namespaceKey(ns)}`,\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: ValueOrGetter<readonly Channel[]>,\n  target?: ValueOrGetter<SelectorTarget>,\n  options?: UseChannelOptions\n): ReactiveValue<Event[]> {\n  const getChannels = () =>\n    isGetter(channels) ? (channels as () => readonly Channel[])() : channels;\n  const getTarget = () => (isGetter(target) ? target() : target);\n  const bufferSize = options?.bufferSize ?? \"default\";\n  const replayMode = (options?.replay ?? true) ? \"replay\" : \"live\";\n  return useProjection<Event[]>(\n    () => getRegistry(stream),\n    () =>\n      channelProjection(\n        getChannels(),\n        resolveNamespace(getTarget()),\n        options\n      ) as unknown as import(\"@langchain/langgraph-sdk/stream\").ProjectionSpec<\n        Event[]\n      >,\n    () => {\n      const sortedChannels = [...getChannels()].sort().join(\",\");\n      return `channel|${bufferSize}|${replayMode}|${sortedChannels}|${namespaceKey(resolveNamespace(getTarget()))}`;\n    },\n    EMPTY_EVENTS\n  );\n}\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?: ValueOrGetter<SelectorTarget>\n): ReactiveValue<AudioMedia[]> {\n  return selectFromTarget<AudioMedia[]>(\n    stream,\n    target,\n    EMPTY_AUDIO,\n    (ns) => audioProjection(ns),\n    \"audio\"\n  );\n}\n\n/**\n * Subscribe to a scoped image-media stream. Pair with `useMediaURL`\n * for `<img src>`.\n */\nexport function useImages(\n  stream: AnyStream,\n  target?: ValueOrGetter<SelectorTarget>\n): ReactiveValue<ImageMedia[]> {\n  return selectFromTarget<ImageMedia[]>(\n    stream,\n    target,\n    EMPTY_IMAGES,\n    (ns) => imagesProjection(ns),\n    \"images\"\n  );\n}\n\n/**\n * Subscribe to a scoped video-media stream. Pair with `useMediaURL`\n * for `<video src>`.\n */\nexport function useVideo(\n  stream: AnyStream,\n  target?: ValueOrGetter<SelectorTarget>\n): ReactiveValue<VideoMedia[]> {\n  return selectFromTarget<VideoMedia[]>(\n    stream,\n    target,\n    EMPTY_VIDEO,\n    (ns) => videoProjection(ns),\n    \"video\"\n  );\n}\n\n/**\n * Subscribe to a scoped file-media stream. Pair with `useMediaURL`\n * for an `<a download href>` target.\n */\nexport function useFiles(\n  stream: AnyStream,\n  target?: ValueOrGetter<SelectorTarget>\n): ReactiveValue<FileMedia[]> {\n  return selectFromTarget<FileMedia[]>(\n    stream,\n    target,\n    EMPTY_FILES,\n    (ns) => filesProjection(ns),\n    \"files\"\n  );\n}\n\n/**\n * Read metadata recorded for a specific message id — today exposes\n * `parentCheckpointId`, the checkpoint the message was first seen\n * on. Designed for fork / edit flows:\n *\n * ```svelte\n * <script lang=\"ts\">\n *   const meta = useMessageMetadata(stream, () => selected?.id);\n * </script>\n * Parent: {meta.current?.parentCheckpointId ?? \"root\"}\n * ```\n *\n * `messageId` accepts a plain string or a getter — the binding\n * re-evaluates whenever the id changes.\n */\nexport function useMessageMetadata(\n  stream: AnyStream,\n  messageId: ValueOrGetter<string | undefined>\n): ReactiveValue<MessageMetadata | undefined> {\n  const store = stream[STREAM_CONTROLLER].messageMetadataStore;\n  let map = $state<MessageMetadataMap>(store.getSnapshot());\n\n  $effect(() => {\n    const unsubscribe = store.subscribe(() => {\n      map = store.getSnapshot();\n    });\n    return unsubscribe;\n  });\n\n  const getId = () =>\n    isGetter(messageId) ? (messageId as () => string | undefined)() : messageId;\n\n  return {\n    get current(): MessageMetadata | undefined {\n      const key = getId();\n      if (key == null) return undefined;\n      return map.get(key);\n    },\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 getters are stable — safe to pass into `{#each}`.\n */\nexport interface UseSubmissionQueueReturn<\n  StateType extends object = Record<string, unknown>,\n> {\n  readonly entries: SubmissionQueueSnapshot<StateType>;\n  readonly size: 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  let entries = $state<SubmissionQueueSnapshot>(store.getSnapshot());\n\n  $effect(() => {\n    const unsubscribe = store.subscribe(() => {\n      entries = store.getSnapshot();\n    });\n    return unsubscribe;\n  });\n\n  return {\n    get entries() {\n      return entries;\n    },\n    get size() {\n      return entries.length;\n    },\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.svelte.cjs

@@ -70,6 +70,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
 	});

package/dist/use-stream.svelte.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"use-stream.svelte.cjs","names":["ClientCtor","StreamController"],"sources":["../src/use-stream.svelte.ts"],"sourcesContent":["import { onDestroy } from \"svelte\";\nimport type { BaseMessage } from \"@langchain/core/messages\";\nimport type { Client, Interrupt } from \"@langchain/langgraph-sdk\";\nimport {\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\";\n\n/** @deprecated Prefer {@link InferStateType}. */\nexport type StateOf<T> = StreamStateOf<T>;\n\n/**\n * A value that may be either a plain `T` or a getter `() => T`. Used\n * for reactive-capable option inputs (currently `threadId` only). When\n * a getter is passed the composable tracks it via `$effect` and\n * re-hydrates when the returned value changes.\n */\nexport type ValueOrGetter<T> = T | (() => T);\n\nfunction readValueOrGetter<T>(\n  input: ValueOrGetter<T> | undefined\n): T | undefined {\n  if (typeof input === \"function\") return (input as () => T)();\n  return input;\n}\n\ntype SvelteThreadId = ValueOrGetter<string | null | undefined>;\n\nexport type AgentServerOptions<StateType extends object> =\n  StreamAgentServerOptions<StateType, SvelteThreadId>;\n\nexport type CustomAdapterOptions<StateType extends object> =\n  StreamCustomAdapterOptions<StateType, SvelteThreadId, string>;\n\nexport type UseStreamOptions<\n  StateType extends object = Record<string, unknown>,\n> = StreamUseStreamOptions<\n  StateType,\n  SvelteThreadId,\n  string | undefined,\n  string | undefined,\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\n * (`useMessages`, `useToolCalls`, `useValues`, …) instead of reading\n * this directly.\n */\nexport const STREAM_CONTROLLER: unique symbol = Symbol.for(\n  \"@langchain/svelte/controller\"\n);\n\n/**\n * Svelte binding return type for {@link useStream}. Reactive\n * projections are exposed as getters on a stable object so templates\n * can read `stream.messages` directly without a `.value` / `.current`\n * hop and `$derived` wrappers auto-track the getter read.\n *\n * Destructuring (`const { messages } = stream`) breaks reactivity —\n * this is a Svelte 5 constraint and applies to every getter-object\n * pattern. Access fields through the live `stream` handle instead.\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: StateType;\n  readonly messages: BaseMessage[];\n  readonly toolCalls: AssembledToolCall[];\n  readonly interrupts: Interrupt<InterruptType>[];\n  readonly interrupt: Interrupt<InterruptType> | undefined;\n  readonly isLoading: boolean;\n  readonly isThreadLoading: boolean;\n  readonly error: unknown;\n  readonly threadId: string | null;\n  /**\n   * Promise that settles when the current thread's initial hydration\n   * completes. Useful in SvelteKit `load()` handlers (or any\n   * async-init site) to block until the controller has reconciled\n   * with server-held state.\n   */\n  readonly hydrationPromise: Promise<void>;\n\n  readonly subagents: ReadonlyMap<\n    keyof SubagentStates & string extends never\n      ? string\n      : keyof SubagentStates & string,\n    SubagentDiscoverySnapshot\n  >;\n  readonly subgraphs: ReadonlyMap<string, SubgraphDiscoverySnapshot>;\n  readonly subgraphsByNode: ReadonlyMap<\n    string,\n    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/**\n * Svelte 5 binding for the v2-native stream runtime.\n *\n * Returns a handle whose reactive fields are plain getters on a\n * stable object — templates can read `stream.messages` directly and\n * `$derived(stream.isLoading)` auto-tracks the getter.\n *\n * @example\n * ```svelte\n * <script lang=\"ts\">\n *   import { useStream } from \"@langchain/svelte\";\n *\n *   const stream = useStream({\n *     assistantId: \"agent\",\n *     apiUrl: \"http://localhost:2024\",\n *   });\n * </script>\n *\n * {#each stream.messages as msg (msg.id)}\n *   <div>{msg.content}</div>\n * {/each}\n * <button onclick={() =>\n *   stream.submit({ messages: [{ type: \"human\", content: \"Hi\" }] })\n * }>\n *   Send\n * </button>\n * ```\n *\n * `assistantId`, `client`, and `transport` are captured at composable\n * init. To bind a new assistant/transport, remount the component.\n * Only `threadId` is treated as reactive — pass it as a getter\n * (`threadId: () => active`) to drive an in-place thread swap.\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?: ValueOrGetter<string | null | undefined>;\n    client?: Client;\n    apiUrl?: string;\n    apiKey?: string;\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  const hasCustomAdapter =\n    asBag.transport != null && typeof asBag.transport !== \"string\";\n  const transport = asBag.transport;\n\n  // Client construction — captured once at init. Consumers that need\n  // to swap `apiUrl`/`apiKey` at runtime remount the owning component.\n  const client: Client =\n    asBag.client ??\n    (new ClientCtor({\n      apiUrl: asBag.apiUrl,\n      apiKey: asBag.apiKey,\n      callerOptions: asBag.callerOptions,\n      defaultHeaders: asBag.defaultHeaders,\n    }) as unknown as Client);\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 = readValueOrGetter(asBag.threadId) ?? null;\n\n  // Plain `let` binding, not `$state`: the controller holds maps of\n  // listeners, Promises, and the live `ThreadStream`, none of which\n  // survive Svelte's deep `$state` proxy wrapping.\n  const controller = new StreamController<\n    StateType,\n    InterruptType,\n    ConfigurableType\n  >({\n    assistantId,\n    // `Client` is state-shape agnostic at runtime; the controller\n    // advertises `Client<StateType>` on its public type for ergonomics.\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: mirrors React's activate/dispose pattern so HMR\n  // and other scope-reuse scenarios stay clean. `activate()` cancels\n  // a pending dispose if the owning scope survives.\n  const deactivate = controller.activate();\n  onDestroy(deactivate);\n\n  // ─── Reactive state bridges ─────────────────────────────────────────\n  //\n  // Each always-on `StreamStore` is wrapped in a runes `$state` slot\n  // seeded from `getSnapshot()` and kept in sync via `store.subscribe`.\n  // Subscriptions are torn down on component destroy.\n  let rootSnapshot = $state<RootSnapshot<StateType, InterruptType>>(\n    controller.rootStore.getSnapshot()\n  );\n  const unsubscribeRoot = controller.rootStore.subscribe(() => {\n    rootSnapshot = controller.rootStore.getSnapshot();\n  });\n  onDestroy(unsubscribeRoot);\n\n  let subagentSnapshot = $state<SubagentMap>(\n    controller.subagentStore.getSnapshot()\n  );\n  const unsubscribeSubagents = controller.subagentStore.subscribe(() => {\n    subagentSnapshot = controller.subagentStore.getSnapshot();\n  });\n  onDestroy(unsubscribeSubagents);\n\n  let subgraphSnapshot = $state<SubgraphMap>(\n    controller.subgraphStore.getSnapshot()\n  );\n  const unsubscribeSubgraphs = controller.subgraphStore.subscribe(() => {\n    subgraphSnapshot = controller.subgraphStore.getSnapshot();\n  });\n  onDestroy(unsubscribeSubgraphs);\n\n  let subgraphByNodeSnapshot = $state<SubgraphByNodeMap>(\n    controller.subgraphByNodeStore.getSnapshot()\n  );\n  const unsubscribeSubgraphByNode = controller.subgraphByNodeStore.subscribe(\n    () => {\n      subgraphByNodeSnapshot = controller.subgraphByNodeStore.getSnapshot();\n    }\n  );\n  onDestroy(unsubscribeSubgraphByNode);\n\n  // ─── threadId reactivity ────────────────────────────────────────────\n  //\n  // Only matters when the caller passed a getter. The initial hydrate\n  // already fired in the controller constructor, so skip the first\n  // tick to avoid a redundant `thread.state.get()`.\n  if (typeof asBag.threadId === \"function\") {\n    const getThreadId = asBag.threadId;\n    let previousThreadId = initialThreadId;\n    $effect(() => {\n      const next = (getThreadId() ?? null) as string | null;\n      if (next === previousThreadId) return;\n      previousThreadId = next;\n      void controller.hydrate(next);\n    });\n  }\n\n  // ─── Headless-tool handling ─────────────────────────────────────────\n  //\n  // Watch the root `values.__interrupt__` key plus the protocol-\n  // surfaced interrupts for items targeting a registered tool, invoke\n  // the handler, and resume the run with the handler's return value.\n  // Dedup via an id set so rerenders don't replay a tool call twice.\n  const tools = options.tools;\n  const onTool = options.onTool;\n  if (tools?.length) {\n    const handledTools = new Set<string>();\n    let handledForThreadId: string | null = initialThreadId;\n    $effect(() => {\n      // Reset dedup set when the active thread id changes — a fresh\n      // thread may legitimately re-emit a tool-call id we've seen.\n      const currentThreadId = rootSnapshot.threadId;\n      if (currentThreadId !== handledForThreadId) {\n        handledTools.clear();\n        handledForThreadId = currentThreadId;\n      }\n\n      const valuesBag = rootSnapshot.values as unknown as Record<\n        string,\n        unknown\n      >;\n      const existing = Array.isArray(valuesBag?.__interrupt__)\n        ? (valuesBag.__interrupt__ as Interrupt[])\n        : [];\n      const combined: Interrupt[] = [\n        ...existing,\n        ...(rootSnapshot.interrupts as unknown as Interrupt[]),\n      ];\n      if (combined.length === 0) return;\n      flushPendingHeadlessToolInterrupts(\n        { ...valuesBag, __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  }\n\n  // ─── Public handle ──────────────────────────────────────────────────\n  //\n  // Single stable object with getters. Getters read the runes\n  // `$state` slots, which drives template reactivity automatically.\n  const handle: UseStreamReturn<T, InterruptType, ConfigurableType> = {\n    get values() {\n      return rootSnapshot.values;\n    },\n    get messages() {\n      return rootSnapshot.messages;\n    },\n    get toolCalls() {\n      return rootSnapshot.toolCalls;\n    },\n    get interrupts() {\n      return rootSnapshot.interrupts;\n    },\n    get interrupt() {\n      return rootSnapshot.interrupt;\n    },\n    get isLoading() {\n      return rootSnapshot.isLoading;\n    },\n    get isThreadLoading() {\n      return rootSnapshot.isThreadLoading;\n    },\n    get error() {\n      return rootSnapshot.error;\n    },\n    get threadId() {\n      return rootSnapshot.threadId;\n    },\n    get hydrationPromise() {\n      return controller.hydrationPromise;\n    },\n    get subagents() {\n      return subagentSnapshot as UseStreamReturn<\n        T,\n        InterruptType,\n        ConfigurableType\n      >[\"subagents\"];\n    },\n    get subgraphs() {\n      return subgraphSnapshot;\n    },\n    get subgraphsByNode() {\n      return subgraphByNodeSnapshot;\n    },\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/** 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 * 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.svelte.cjs","names":["ClientCtor","StreamController"],"sources":["../src/use-stream.svelte.ts"],"sourcesContent":["import { onDestroy } from \"svelte\";\nimport type { BaseMessage } from \"@langchain/core/messages\";\nimport type { Client, Interrupt } from \"@langchain/langgraph-sdk\";\nimport {\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 ChannelRegistry,\n  type CustomAdapterOptions as StreamCustomAdapterOptions,\n  type InferStateType,\n  type InferToolCalls,\n  type InferSubagentStates,\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\";\n\n/**\n * A value that may be either a plain `T` or a getter `() => T`. Used\n * for reactive-capable option inputs (currently `threadId` only). When\n * a getter is passed the composable tracks it via `$effect` and\n * re-hydrates when the returned value changes.\n */\nexport type ValueOrGetter<T> = T | (() => T);\n\nfunction readValueOrGetter<T>(\n  input: ValueOrGetter<T> | undefined\n): T | undefined {\n  if (typeof input === \"function\") return (input as () => T)();\n  return input;\n}\n\ntype SvelteThreadId = ValueOrGetter<string | null | undefined>;\n\nexport type AgentServerOptions<StateType extends object> =\n  StreamAgentServerOptions<StateType, SvelteThreadId>;\n\nexport type CustomAdapterOptions<StateType extends object> =\n  StreamCustomAdapterOptions<StateType, SvelteThreadId, string>;\n\nexport type UseStreamOptions<\n  StateType extends object = Record<string, unknown>,\n> = StreamUseStreamOptions<\n  StateType,\n  SvelteThreadId,\n  string | undefined,\n  string | undefined,\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\n * (`useMessages`, `useToolCalls`, `useValues`, …) instead of reading\n * this directly.\n */\nexport const STREAM_CONTROLLER: unique symbol = Symbol.for(\n  \"@langchain/svelte/controller\"\n);\n\n/**\n * Svelte binding return type for {@link useStream}. Reactive\n * projections are exposed as getters on a stable object so templates\n * can read `stream.messages` directly without a `.value` / `.current`\n * hop and `$derived` wrappers auto-track the getter read.\n *\n * Destructuring (`const { messages } = stream`) breaks reactivity —\n * this is a Svelte 5 constraint and applies to every getter-object\n * pattern. Access fields through the live `stream` handle instead.\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: StateType;\n  readonly messages: BaseMessage[];\n  readonly toolCalls: InferToolCalls<T>[];\n  readonly interrupts: Interrupt<InterruptType>[];\n  readonly interrupt: Interrupt<InterruptType> | undefined;\n  readonly isLoading: boolean;\n  readonly isThreadLoading: boolean;\n  readonly error: unknown;\n  readonly threadId: string | null;\n  /**\n   * Promise that settles when the current thread's initial hydration\n   * completes. Useful in SvelteKit `load()` handlers (or any\n   * async-init site) to block until the controller has reconciled\n   * with server-held state.\n   */\n  readonly hydrationPromise: Promise<void>;\n\n  readonly subagents: ReadonlyMap<\n    keyof SubagentStates & string extends never\n      ? string\n      : keyof SubagentStates & string,\n    SubagentDiscoverySnapshot\n  >;\n  readonly subgraphs: ReadonlyMap<string, SubgraphDiscoverySnapshot>;\n  readonly subgraphsByNode: ReadonlyMap<\n    string,\n    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/**\n * Svelte 5 binding for the v2-native stream runtime.\n *\n * Returns a handle whose reactive fields are plain getters on a\n * stable object — templates can read `stream.messages` directly and\n * `$derived(stream.isLoading)` auto-tracks the getter.\n *\n * @example\n * ```svelte\n * <script lang=\"ts\">\n *   import { useStream } from \"@langchain/svelte\";\n *\n *   const stream = useStream({\n *     assistantId: \"agent\",\n *     apiUrl: \"http://localhost:2024\",\n *   });\n * </script>\n *\n * {#each stream.messages as msg (msg.id)}\n *   <div>{msg.content}</div>\n * {/each}\n * <button onclick={() =>\n *   stream.submit({ messages: [{ type: \"human\", content: \"Hi\" }] })\n * }>\n *   Send\n * </button>\n * ```\n *\n * `assistantId`, `client`, and `transport` are captured at composable\n * init. To bind a new assistant/transport, remount the component.\n * Only `threadId` is treated as reactive — pass it as a getter\n * (`threadId: () => active`) to drive an in-place thread swap.\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?: ValueOrGetter<string | null | undefined>;\n    client?: Client;\n    apiUrl?: string;\n    apiKey?: string;\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  const hasCustomAdapter =\n    asBag.transport != null && typeof asBag.transport !== \"string\";\n  const transport = asBag.transport;\n\n  // Client construction — captured once at init. Consumers that need\n  // to swap `apiUrl`/`apiKey` at runtime remount the owning component.\n  const client: Client =\n    asBag.client ??\n    (new ClientCtor({\n      apiUrl: asBag.apiUrl,\n      apiKey: asBag.apiKey,\n      callerOptions: asBag.callerOptions,\n      defaultHeaders: asBag.defaultHeaders,\n    }) as unknown as Client);\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 = readValueOrGetter(asBag.threadId) ?? null;\n\n  // Plain `let` binding, not `$state`: the controller holds maps of\n  // listeners, Promises, and the live `ThreadStream`, none of which\n  // survive Svelte's deep `$state` proxy wrapping.\n  const controller = new StreamController<\n    StateType,\n    InterruptType,\n    ConfigurableType\n  >({\n    assistantId,\n    // `Client` is state-shape agnostic at runtime; the controller\n    // advertises `Client<StateType>` on its public type for ergonomics.\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: mirrors React's activate/dispose pattern so HMR\n  // and other scope-reuse scenarios stay clean. `activate()` cancels\n  // a pending dispose if the owning scope survives.\n  const deactivate = controller.activate();\n  onDestroy(deactivate);\n\n  // ─── Reactive state bridges ─────────────────────────────────────────\n  //\n  // Each always-on `StreamStore` is wrapped in a runes `$state` slot\n  // seeded from `getSnapshot()` and kept in sync via `store.subscribe`.\n  // Subscriptions are torn down on component destroy.\n  let rootSnapshot = $state<RootSnapshot<StateType, InterruptType>>(\n    controller.rootStore.getSnapshot()\n  );\n  const unsubscribeRoot = controller.rootStore.subscribe(() => {\n    rootSnapshot = controller.rootStore.getSnapshot();\n  });\n  onDestroy(unsubscribeRoot);\n\n  let subagentSnapshot = $state<SubagentMap>(\n    controller.subagentStore.getSnapshot()\n  );\n  const unsubscribeSubagents = controller.subagentStore.subscribe(() => {\n    subagentSnapshot = controller.subagentStore.getSnapshot();\n  });\n  onDestroy(unsubscribeSubagents);\n\n  let subgraphSnapshot = $state<SubgraphMap>(\n    controller.subgraphStore.getSnapshot()\n  );\n  const unsubscribeSubgraphs = controller.subgraphStore.subscribe(() => {\n    subgraphSnapshot = controller.subgraphStore.getSnapshot();\n  });\n  onDestroy(unsubscribeSubgraphs);\n\n  let subgraphByNodeSnapshot = $state<SubgraphByNodeMap>(\n    controller.subgraphByNodeStore.getSnapshot()\n  );\n  const unsubscribeSubgraphByNode = controller.subgraphByNodeStore.subscribe(\n    () => {\n      subgraphByNodeSnapshot = controller.subgraphByNodeStore.getSnapshot();\n    }\n  );\n  onDestroy(unsubscribeSubgraphByNode);\n\n  // ─── threadId reactivity ────────────────────────────────────────────\n  //\n  // Only matters when the caller passed a getter. The initial hydrate\n  // already fired in the controller constructor, so skip the first\n  // tick to avoid a redundant `thread.state.get()`.\n  if (typeof asBag.threadId === \"function\") {\n    const getThreadId = asBag.threadId;\n    let previousThreadId = initialThreadId;\n    $effect(() => {\n      const next = (getThreadId() ?? null) as string | null;\n      if (next === previousThreadId) return;\n      previousThreadId = next;\n      void controller.hydrate(next);\n    });\n  }\n\n  // ─── Headless-tool handling ─────────────────────────────────────────\n  //\n  // Watch the root `values.__interrupt__` key plus the protocol-\n  // surfaced interrupts for items targeting a registered tool, invoke\n  // the handler, and resume the run with the handler's return value.\n  // Dedup via an id set so rerenders don't replay a tool call twice.\n  const tools = options.tools;\n  const onTool = options.onTool;\n  if (tools?.length) {\n    const handledTools = new Set<string>();\n    let handledForThreadId: string | null = initialThreadId;\n    $effect(() => {\n      // Reset dedup set when the active thread id changes — a fresh\n      // thread may legitimately re-emit a tool-call id we've seen.\n      const currentThreadId = rootSnapshot.threadId;\n      if (currentThreadId !== handledForThreadId) {\n        handledTools.clear();\n        handledForThreadId = currentThreadId;\n      }\n\n      const valuesBag = rootSnapshot.values as unknown as Record<\n        string,\n        unknown\n      >;\n      const existing = Array.isArray(valuesBag?.__interrupt__)\n        ? (valuesBag.__interrupt__ as Interrupt[])\n        : [];\n      const combined: Interrupt[] = [\n        ...existing,\n        ...(rootSnapshot.interrupts as unknown as Interrupt[]),\n      ];\n      if (combined.length === 0) return;\n      flushPendingHeadlessToolInterrupts(\n        { ...valuesBag, __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  }\n\n  // ─── Public handle ──────────────────────────────────────────────────\n  //\n  // Single stable object with getters. Getters read the runes\n  // `$state` slots, which drives template reactivity automatically.\n  const handle: UseStreamReturn<T, InterruptType, ConfigurableType> = {\n    get values() {\n      return rootSnapshot.values;\n    },\n    get messages() {\n      return rootSnapshot.messages;\n    },\n    get toolCalls() {\n      return rootSnapshot.toolCalls as InferToolCalls<T>[];\n    },\n    get interrupts() {\n      return rootSnapshot.interrupts;\n    },\n    get interrupt() {\n      return rootSnapshot.interrupt;\n    },\n    get isLoading() {\n      return rootSnapshot.isLoading;\n    },\n    get isThreadLoading() {\n      return rootSnapshot.isThreadLoading;\n    },\n    get error() {\n      return rootSnapshot.error;\n    },\n    get threadId() {\n      return rootSnapshot.threadId;\n    },\n    get hydrationPromise() {\n      return controller.hydrationPromise;\n    },\n    get subagents() {\n      return subagentSnapshot as UseStreamReturn<\n        T,\n        InterruptType,\n        ConfigurableType\n      >[\"subagents\"];\n    },\n    get subgraphs() {\n      return subgraphSnapshot;\n    },\n    get subgraphsByNode() {\n      return subgraphByNodeSnapshot;\n    },\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/** 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 * 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.svelte.d.cts

@@ -1,11 +1,9 @@
 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.svelte.d.ts
-/** @deprecated Prefer {@link InferStateType}. */
-type StateOf$1<T> = StateOf<T>;
 /**
  * A value that may be either a plain `T` or a getter `() => T`. Used
  * for reactive-capable option inputs (currently `threadId` only). When
@@ -38,7 +36,7 @@ declare const STREAM_CONTROLLER: unique symbol;
 interface UseStreamReturn<T = Record<string, unknown>, InterruptType = unknown, ConfigurableType extends object = Record<string, unknown>, StateType extends object = InferStateType<T>, SubagentStates = InferSubagentStates<T>> {
   readonly values: StateType;
   readonly messages: BaseMessage[];
-  readonly toolCalls: AssembledToolCall[];
+  readonly toolCalls: InferToolCalls<T>[];
   readonly interrupts: Interrupt<InterruptType>[];
   readonly interrupt: Interrupt<InterruptType> | undefined;
   readonly isLoading: boolean;
@@ -112,5 +110,5 @@ declare function useStream<T = Record<string, unknown>, InterruptType = unknown,
 /** Convenience alias for the fully-resolved stream handle type. */
 type UseStreamResult<T = Record<string, unknown>, InterruptType = unknown, ConfigurableType extends object = Record<string, unknown>> = 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.svelte.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"use-stream.svelte.d.cts","names":[],"sources":["../src/use-stream.svelte.ts"],"mappings":";;;;;;;KAmCY,SAAA,MAAa,OAAA,CAAc,CAAA;AAAvC;;;;;;AAAA,KAQY,aAAA,MAAmB,CAAA,UAAW,CAAA;AAAA,KASrC,cAAA,GAAiB,aAAA;AAAA,KAEV,oBAAA,6BACV,kBAAA,CAAyB,SAAA,EAAW,cAAA;AAAA,KAE1B,sBAAA,6BACV,oBAAA,CAA2B,SAAA,EAAW,cAAA;AAAA,KAE5B,kBAAA,4BACiB,MAAA,qBACzB,gBAAA,CACF,SAAA,EACA,cAAA;;;;;;;;cAaW,iBAAA;;;;;AAvBb;;;;;;UAqCiB,eAAA,KACX,MAAA,8EAE8B,MAAA,8CACP,cAAA,CAAe,CAAA,oBACzB,mBAAA,CAAoB,CAAA;EAAA,SAE5B,MAAA,EAAQ,SAAA;EAAA,SACR,QAAA,EAAU,WAAA;EAAA,SACV,SAAA,EAAW,iBAAA;EAAA,SACX,UAAA,EAAY,SAAA,CAAU,aAAA;EAAA,SACtB,SAAA,EAAW,SAAA,CAAU,aAAA;EAAA,SACrB,SAAA;EAAA,SACA,eAAA;EAAA,SACA,KAAA;EAAA,SACA,QAAA;EAjDqB;;;;;;EAAA,SAwDrB,gBAAA,EAAkB,OAAA;EAAA,SAElB,SAAA,EAAW,WAAA,OACZ,cAAA,yCAEI,cAAA,WACV,yBAAA;EAAA,SAEO,SAAA,EAAW,WAAA,SAAoB,yBAAA;EAAA,SAC/B,eAAA,EAAiB,WAAA,kBAEf,yBAAA;EAGX,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;EA5EP;EA+EF,SAAA,IAAa,YAAA;EA/EW;EAAA,UAkFd,iBAAA,GAAoB,gBAAA,CAC5B,SAAA,EACA,aAAA,EACA,gBAAA;AAAA;;;;;;AAtEJ;KAiFY,SAAA,GAAY,eAAA;;;;AAnExB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsGgB,SAAA,KACV,MAAA,8EAE8B,MAAA,kBAAA,CAElC,OAAA,EAAS,kBAAA,CAAiB,cAAA,CAAe,CAAA,KACxC,eAAA,CAAgB,CAAA,EAAG,aAAA,EAAe,gBAAA;;KAgPzB,eAAA,KACN,MAAA,8EAE8B,MAAA,qBAChC,eAAA,CAAgB,CAAA,EAAG,aAAA,EAAe,gBAAA"}
+{"version":3,"file":"use-stream.svelte.d.cts","names":[],"sources":["../src/use-stream.svelte.ts"],"mappings":";;;;;;;;AAyCA;;;;KAAY,aAAA,MAAmB,CAAA,UAAW,CAAA;AAAA,KASrC,cAAA,GAAiB,aAAA;AAAA,KAEV,oBAAA,6BACV,kBAAA,CAAyB,SAAA,EAAW,cAAA;AAAA,KAE1B,sBAAA,6BACV,oBAAA,CAA2B,SAAA,EAAW,cAAA;AAAA,KAE5B,kBAAA,4BACiB,MAAA,qBACzB,gBAAA,CACF,SAAA,EACA,cAAA;AArB2C;;;;;AAW7C;;AAX6C,cAkChC,iBAAA;;;;;;;;;;;UAcI,eAAA,KACX,MAAA,8EAE8B,MAAA,8CACP,cAAA,CAAe,CAAA,oBACzB,mBAAA,CAAoB,CAAA;EAAA,SAE5B,MAAA,EAAQ,SAAA;EAAA,SACR,QAAA,EAAU,WAAA;EAAA,SACV,SAAA,EAAW,cAAA,CAAe,CAAA;EAAA,SAC1B,UAAA,EAAY,SAAA,CAAU,aAAA;EAAA,SACtB,SAAA,EAAW,SAAA,CAAU,aAAA;EAAA,SACrB,SAAA;EAAA,SACA,eAAA;EAAA,SACA,KAAA;EAAA,SACA,QAAA;EAhDT;;;;;AAEF;EAFE,SAuDS,gBAAA,EAAkB,OAAA;EAAA,SAElB,SAAA,EAAW,WAAA,OACZ,cAAA,yCAEI,cAAA,WACV,yBAAA;EAAA,SAEO,SAAA,EAAW,WAAA,SAAoB,yBAAA;EAAA,SAC/B,eAAA,EAAiB,WAAA,kBAEf,yBAAA;EAGX,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;EA1ET;EA6EA,SAAA,IAAa,YAAA;EA7EC;EAAA,UAgFJ,iBAAA,GAAoB,gBAAA,CAC5B,SAAA,EACA,aAAA,EACA,gBAAA;AAAA;;;;AAxDJ;;;KAmEY,SAAA,GAAY,eAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmCR,SAAA,KACV,MAAA,8EAE8B,MAAA,kBAAA,CAElC,OAAA,EAAS,kBAAA,CAAiB,cAAA,CAAe,CAAA,KACxC,eAAA,CAAgB,CAAA,EAAG,aAAA,EAAe,gBAAA;;KAkPzB,eAAA,KACN,MAAA,8EAE8B,MAAA,qBAChC,eAAA,CAAgB,CAAA,EAAG,aAAA,EAAe,gBAAA"}

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

@@ -1,11 +1,9 @@
 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.svelte.d.ts
-/** @deprecated Prefer {@link InferStateType}. */
-type StateOf$1<T> = StateOf<T>;
 /**
  * A value that may be either a plain `T` or a getter `() => T`. Used
  * for reactive-capable option inputs (currently `threadId` only). When
@@ -38,7 +36,7 @@ declare const STREAM_CONTROLLER: unique symbol;
 interface UseStreamReturn<T = Record<string, unknown>, InterruptType = unknown, ConfigurableType extends object = Record<string, unknown>, StateType extends object = InferStateType<T>, SubagentStates = InferSubagentStates<T>> {
   readonly values: StateType;
   readonly messages: BaseMessage[];
-  readonly toolCalls: AssembledToolCall[];
+  readonly toolCalls: InferToolCalls<T>[];
   readonly interrupts: Interrupt<InterruptType>[];
   readonly interrupt: Interrupt<InterruptType> | undefined;
   readonly isLoading: boolean;
@@ -112,5 +110,5 @@ declare function useStream<T = Record<string, unknown>, InterruptType = unknown,
 /** Convenience alias for the fully-resolved stream handle type. */
 type UseStreamResult<T = Record<string, unknown>, InterruptType = unknown, ConfigurableType extends object = Record<string, unknown>> = 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.svelte.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"use-stream.svelte.d.ts","names":[],"sources":["../src/use-stream.svelte.ts"],"mappings":";;;;;;;KAmCY,SAAA,MAAa,OAAA,CAAc,CAAA;AAAvC;;;;;;AAAA,KAQY,aAAA,MAAmB,CAAA,UAAW,CAAA;AAAA,KASrC,cAAA,GAAiB,aAAA;AAAA,KAEV,oBAAA,6BACV,kBAAA,CAAyB,SAAA,EAAW,cAAA;AAAA,KAE1B,sBAAA,6BACV,oBAAA,CAA2B,SAAA,EAAW,cAAA;AAAA,KAE5B,kBAAA,4BACiB,MAAA,qBACzB,gBAAA,CACF,SAAA,EACA,cAAA;;;;;;;;cAaW,iBAAA;;;;;AAvBb;;;;;;UAqCiB,eAAA,KACX,MAAA,8EAE8B,MAAA,8CACP,cAAA,CAAe,CAAA,oBACzB,mBAAA,CAAoB,CAAA;EAAA,SAE5B,MAAA,EAAQ,SAAA;EAAA,SACR,QAAA,EAAU,WAAA;EAAA,SACV,SAAA,EAAW,iBAAA;EAAA,SACX,UAAA,EAAY,SAAA,CAAU,aAAA;EAAA,SACtB,SAAA,EAAW,SAAA,CAAU,aAAA;EAAA,SACrB,SAAA;EAAA,SACA,eAAA;EAAA,SACA,KAAA;EAAA,SACA,QAAA;EAjDqB;;;;;;EAAA,SAwDrB,gBAAA,EAAkB,OAAA;EAAA,SAElB,SAAA,EAAW,WAAA,OACZ,cAAA,yCAEI,cAAA,WACV,yBAAA;EAAA,SAEO,SAAA,EAAW,WAAA,SAAoB,yBAAA;EAAA,SAC/B,eAAA,EAAiB,WAAA,kBAEf,yBAAA;EAGX,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;EA5EP;EA+EF,SAAA,IAAa,YAAA;EA/EW;EAAA,UAkFd,iBAAA,GAAoB,gBAAA,CAC5B,SAAA,EACA,aAAA,EACA,gBAAA;AAAA;;;;;;AAtEJ;KAiFY,SAAA,GAAY,eAAA;;;;AAnExB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsGgB,SAAA,KACV,MAAA,8EAE8B,MAAA,kBAAA,CAElC,OAAA,EAAS,kBAAA,CAAiB,cAAA,CAAe,CAAA,KACxC,eAAA,CAAgB,CAAA,EAAG,aAAA,EAAe,gBAAA;;KAgPzB,eAAA,KACN,MAAA,8EAE8B,MAAA,qBAChC,eAAA,CAAgB,CAAA,EAAG,aAAA,EAAe,gBAAA"}
+{"version":3,"file":"use-stream.svelte.d.ts","names":[],"sources":["../src/use-stream.svelte.ts"],"mappings":";;;;;;;;AAyCA;;;;KAAY,aAAA,MAAmB,CAAA,UAAW,CAAA;AAAA,KASrC,cAAA,GAAiB,aAAA;AAAA,KAEV,oBAAA,6BACV,kBAAA,CAAyB,SAAA,EAAW,cAAA;AAAA,KAE1B,sBAAA,6BACV,oBAAA,CAA2B,SAAA,EAAW,cAAA;AAAA,KAE5B,kBAAA,4BACiB,MAAA,qBACzB,gBAAA,CACF,SAAA,EACA,cAAA;AArB2C;;;;;AAW7C;;AAX6C,cAkChC,iBAAA;;;;;;;;;;;UAcI,eAAA,KACX,MAAA,8EAE8B,MAAA,8CACP,cAAA,CAAe,CAAA,oBACzB,mBAAA,CAAoB,CAAA;EAAA,SAE5B,MAAA,EAAQ,SAAA;EAAA,SACR,QAAA,EAAU,WAAA;EAAA,SACV,SAAA,EAAW,cAAA,CAAe,CAAA;EAAA,SAC1B,UAAA,EAAY,SAAA,CAAU,aAAA;EAAA,SACtB,SAAA,EAAW,SAAA,CAAU,aAAA;EAAA,SACrB,SAAA;EAAA,SACA,eAAA;EAAA,SACA,KAAA;EAAA,SACA,QAAA;EAhDT;;;;;AAEF;EAFE,SAuDS,gBAAA,EAAkB,OAAA;EAAA,SAElB,SAAA,EAAW,WAAA,OACZ,cAAA,yCAEI,cAAA,WACV,yBAAA;EAAA,SAEO,SAAA,EAAW,WAAA,SAAoB,yBAAA;EAAA,SAC/B,eAAA,EAAiB,WAAA,kBAEf,yBAAA;EAGX,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;EA1ET;EA6EA,SAAA,IAAa,YAAA;EA7EC;EAAA,UAgFJ,iBAAA,GAAoB,gBAAA,CAC5B,SAAA,EACA,aAAA,EACA,gBAAA;AAAA;;;;AAxDJ;;;KAmEY,SAAA,GAAY,eAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmCR,SAAA,KACV,MAAA,8EAE8B,MAAA,kBAAA,CAElC,OAAA,EAAS,kBAAA,CAAiB,cAAA,CAAe,CAAA,KACxC,eAAA,CAAgB,CAAA,EAAG,aAAA,EAAe,gBAAA;;KAkPzB,eAAA,KACN,MAAA,8EAE8B,MAAA,qBAChC,eAAA,CAAgB,CAAA,EAAG,aAAA,EAAe,gBAAA"}

package/dist/use-stream.svelte.js

@@ -70,6 +70,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
 	});

package/dist/use-stream.svelte.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-stream.svelte.js","names":["ClientCtor"],"sources":["../src/use-stream.svelte.ts"],"sourcesContent":["import { onDestroy } from \"svelte\";\nimport type { BaseMessage } from \"@langchain/core/messages\";\nimport type { Client, Interrupt } from \"@langchain/langgraph-sdk\";\nimport {\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\";\n\n/** @deprecated Prefer {@link InferStateType}. */\nexport type StateOf<T> = StreamStateOf<T>;\n\n/**\n * A value that may be either a plain `T` or a getter `() => T`. Used\n * for reactive-capable option inputs (currently `threadId` only). When\n * a getter is passed the composable tracks it via `$effect` and\n * re-hydrates when the returned value changes.\n */\nexport type ValueOrGetter<T> = T | (() => T);\n\nfunction readValueOrGetter<T>(\n  input: ValueOrGetter<T> | undefined\n): T | undefined {\n  if (typeof input === \"function\") return (input as () => T)();\n  return input;\n}\n\ntype SvelteThreadId = ValueOrGetter<string | null | undefined>;\n\nexport type AgentServerOptions<StateType extends object> =\n  StreamAgentServerOptions<StateType, SvelteThreadId>;\n\nexport type CustomAdapterOptions<StateType extends object> =\n  StreamCustomAdapterOptions<StateType, SvelteThreadId, string>;\n\nexport type UseStreamOptions<\n  StateType extends object = Record<string, unknown>,\n> = StreamUseStreamOptions<\n  StateType,\n  SvelteThreadId,\n  string | undefined,\n  string | undefined,\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\n * (`useMessages`, `useToolCalls`, `useValues`, …) instead of reading\n * this directly.\n */\nexport const STREAM_CONTROLLER: unique symbol = Symbol.for(\n  \"@langchain/svelte/controller\"\n);\n\n/**\n * Svelte binding return type for {@link useStream}. Reactive\n * projections are exposed as getters on a stable object so templates\n * can read `stream.messages` directly without a `.value` / `.current`\n * hop and `$derived` wrappers auto-track the getter read.\n *\n * Destructuring (`const { messages } = stream`) breaks reactivity —\n * this is a Svelte 5 constraint and applies to every getter-object\n * pattern. Access fields through the live `stream` handle instead.\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: StateType;\n  readonly messages: BaseMessage[];\n  readonly toolCalls: AssembledToolCall[];\n  readonly interrupts: Interrupt<InterruptType>[];\n  readonly interrupt: Interrupt<InterruptType> | undefined;\n  readonly isLoading: boolean;\n  readonly isThreadLoading: boolean;\n  readonly error: unknown;\n  readonly threadId: string | null;\n  /**\n   * Promise that settles when the current thread's initial hydration\n   * completes. Useful in SvelteKit `load()` handlers (or any\n   * async-init site) to block until the controller has reconciled\n   * with server-held state.\n   */\n  readonly hydrationPromise: Promise<void>;\n\n  readonly subagents: ReadonlyMap<\n    keyof SubagentStates & string extends never\n      ? string\n      : keyof SubagentStates & string,\n    SubagentDiscoverySnapshot\n  >;\n  readonly subgraphs: ReadonlyMap<string, SubgraphDiscoverySnapshot>;\n  readonly subgraphsByNode: ReadonlyMap<\n    string,\n    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/**\n * Svelte 5 binding for the v2-native stream runtime.\n *\n * Returns a handle whose reactive fields are plain getters on a\n * stable object — templates can read `stream.messages` directly and\n * `$derived(stream.isLoading)` auto-tracks the getter.\n *\n * @example\n * ```svelte\n * <script lang=\"ts\">\n *   import { useStream } from \"@langchain/svelte\";\n *\n *   const stream = useStream({\n *     assistantId: \"agent\",\n *     apiUrl: \"http://localhost:2024\",\n *   });\n * </script>\n *\n * {#each stream.messages as msg (msg.id)}\n *   <div>{msg.content}</div>\n * {/each}\n * <button onclick={() =>\n *   stream.submit({ messages: [{ type: \"human\", content: \"Hi\" }] })\n * }>\n *   Send\n * </button>\n * ```\n *\n * `assistantId`, `client`, and `transport` are captured at composable\n * init. To bind a new assistant/transport, remount the component.\n * Only `threadId` is treated as reactive — pass it as a getter\n * (`threadId: () => active`) to drive an in-place thread swap.\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?: ValueOrGetter<string | null | undefined>;\n    client?: Client;\n    apiUrl?: string;\n    apiKey?: string;\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  const hasCustomAdapter =\n    asBag.transport != null && typeof asBag.transport !== \"string\";\n  const transport = asBag.transport;\n\n  // Client construction — captured once at init. Consumers that need\n  // to swap `apiUrl`/`apiKey` at runtime remount the owning component.\n  const client: Client =\n    asBag.client ??\n    (new ClientCtor({\n      apiUrl: asBag.apiUrl,\n      apiKey: asBag.apiKey,\n      callerOptions: asBag.callerOptions,\n      defaultHeaders: asBag.defaultHeaders,\n    }) as unknown as Client);\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 = readValueOrGetter(asBag.threadId) ?? null;\n\n  // Plain `let` binding, not `$state`: the controller holds maps of\n  // listeners, Promises, and the live `ThreadStream`, none of which\n  // survive Svelte's deep `$state` proxy wrapping.\n  const controller = new StreamController<\n    StateType,\n    InterruptType,\n    ConfigurableType\n  >({\n    assistantId,\n    // `Client` is state-shape agnostic at runtime; the controller\n    // advertises `Client<StateType>` on its public type for ergonomics.\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: mirrors React's activate/dispose pattern so HMR\n  // and other scope-reuse scenarios stay clean. `activate()` cancels\n  // a pending dispose if the owning scope survives.\n  const deactivate = controller.activate();\n  onDestroy(deactivate);\n\n  // ─── Reactive state bridges ─────────────────────────────────────────\n  //\n  // Each always-on `StreamStore` is wrapped in a runes `$state` slot\n  // seeded from `getSnapshot()` and kept in sync via `store.subscribe`.\n  // Subscriptions are torn down on component destroy.\n  let rootSnapshot = $state<RootSnapshot<StateType, InterruptType>>(\n    controller.rootStore.getSnapshot()\n  );\n  const unsubscribeRoot = controller.rootStore.subscribe(() => {\n    rootSnapshot = controller.rootStore.getSnapshot();\n  });\n  onDestroy(unsubscribeRoot);\n\n  let subagentSnapshot = $state<SubagentMap>(\n    controller.subagentStore.getSnapshot()\n  );\n  const unsubscribeSubagents = controller.subagentStore.subscribe(() => {\n    subagentSnapshot = controller.subagentStore.getSnapshot();\n  });\n  onDestroy(unsubscribeSubagents);\n\n  let subgraphSnapshot = $state<SubgraphMap>(\n    controller.subgraphStore.getSnapshot()\n  );\n  const unsubscribeSubgraphs = controller.subgraphStore.subscribe(() => {\n    subgraphSnapshot = controller.subgraphStore.getSnapshot();\n  });\n  onDestroy(unsubscribeSubgraphs);\n\n  let subgraphByNodeSnapshot = $state<SubgraphByNodeMap>(\n    controller.subgraphByNodeStore.getSnapshot()\n  );\n  const unsubscribeSubgraphByNode = controller.subgraphByNodeStore.subscribe(\n    () => {\n      subgraphByNodeSnapshot = controller.subgraphByNodeStore.getSnapshot();\n    }\n  );\n  onDestroy(unsubscribeSubgraphByNode);\n\n  // ─── threadId reactivity ────────────────────────────────────────────\n  //\n  // Only matters when the caller passed a getter. The initial hydrate\n  // already fired in the controller constructor, so skip the first\n  // tick to avoid a redundant `thread.state.get()`.\n  if (typeof asBag.threadId === \"function\") {\n    const getThreadId = asBag.threadId;\n    let previousThreadId = initialThreadId;\n    $effect(() => {\n      const next = (getThreadId() ?? null) as string | null;\n      if (next === previousThreadId) return;\n      previousThreadId = next;\n      void controller.hydrate(next);\n    });\n  }\n\n  // ─── Headless-tool handling ─────────────────────────────────────────\n  //\n  // Watch the root `values.__interrupt__` key plus the protocol-\n  // surfaced interrupts for items targeting a registered tool, invoke\n  // the handler, and resume the run with the handler's return value.\n  // Dedup via an id set so rerenders don't replay a tool call twice.\n  const tools = options.tools;\n  const onTool = options.onTool;\n  if (tools?.length) {\n    const handledTools = new Set<string>();\n    let handledForThreadId: string | null = initialThreadId;\n    $effect(() => {\n      // Reset dedup set when the active thread id changes — a fresh\n      // thread may legitimately re-emit a tool-call id we've seen.\n      const currentThreadId = rootSnapshot.threadId;\n      if (currentThreadId !== handledForThreadId) {\n        handledTools.clear();\n        handledForThreadId = currentThreadId;\n      }\n\n      const valuesBag = rootSnapshot.values as unknown as Record<\n        string,\n        unknown\n      >;\n      const existing = Array.isArray(valuesBag?.__interrupt__)\n        ? (valuesBag.__interrupt__ as Interrupt[])\n        : [];\n      const combined: Interrupt[] = [\n        ...existing,\n        ...(rootSnapshot.interrupts as unknown as Interrupt[]),\n      ];\n      if (combined.length === 0) return;\n      flushPendingHeadlessToolInterrupts(\n        { ...valuesBag, __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  }\n\n  // ─── Public handle ──────────────────────────────────────────────────\n  //\n  // Single stable object with getters. Getters read the runes\n  // `$state` slots, which drives template reactivity automatically.\n  const handle: UseStreamReturn<T, InterruptType, ConfigurableType> = {\n    get values() {\n      return rootSnapshot.values;\n    },\n    get messages() {\n      return rootSnapshot.messages;\n    },\n    get toolCalls() {\n      return rootSnapshot.toolCalls;\n    },\n    get interrupts() {\n      return rootSnapshot.interrupts;\n    },\n    get interrupt() {\n      return rootSnapshot.interrupt;\n    },\n    get isLoading() {\n      return rootSnapshot.isLoading;\n    },\n    get isThreadLoading() {\n      return rootSnapshot.isThreadLoading;\n    },\n    get error() {\n      return rootSnapshot.error;\n    },\n    get threadId() {\n      return rootSnapshot.threadId;\n    },\n    get hydrationPromise() {\n      return controller.hydrationPromise;\n    },\n    get subagents() {\n      return subagentSnapshot as UseStreamReturn<\n        T,\n        InterruptType,\n        ConfigurableType\n      >[\"subagents\"];\n    },\n    get subgraphs() {\n      return subgraphSnapshot;\n    },\n    get subgraphsByNode() {\n      return subgraphByNodeSnapshot;\n    },\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/** 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 * 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.svelte.js","names":["ClientCtor"],"sources":["../src/use-stream.svelte.ts"],"sourcesContent":["import { onDestroy } from \"svelte\";\nimport type { BaseMessage } from \"@langchain/core/messages\";\nimport type { Client, Interrupt } from \"@langchain/langgraph-sdk\";\nimport {\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 ChannelRegistry,\n  type CustomAdapterOptions as StreamCustomAdapterOptions,\n  type InferStateType,\n  type InferToolCalls,\n  type InferSubagentStates,\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\";\n\n/**\n * A value that may be either a plain `T` or a getter `() => T`. Used\n * for reactive-capable option inputs (currently `threadId` only). When\n * a getter is passed the composable tracks it via `$effect` and\n * re-hydrates when the returned value changes.\n */\nexport type ValueOrGetter<T> = T | (() => T);\n\nfunction readValueOrGetter<T>(\n  input: ValueOrGetter<T> | undefined\n): T | undefined {\n  if (typeof input === \"function\") return (input as () => T)();\n  return input;\n}\n\ntype SvelteThreadId = ValueOrGetter<string | null | undefined>;\n\nexport type AgentServerOptions<StateType extends object> =\n  StreamAgentServerOptions<StateType, SvelteThreadId>;\n\nexport type CustomAdapterOptions<StateType extends object> =\n  StreamCustomAdapterOptions<StateType, SvelteThreadId, string>;\n\nexport type UseStreamOptions<\n  StateType extends object = Record<string, unknown>,\n> = StreamUseStreamOptions<\n  StateType,\n  SvelteThreadId,\n  string | undefined,\n  string | undefined,\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\n * (`useMessages`, `useToolCalls`, `useValues`, …) instead of reading\n * this directly.\n */\nexport const STREAM_CONTROLLER: unique symbol = Symbol.for(\n  \"@langchain/svelte/controller\"\n);\n\n/**\n * Svelte binding return type for {@link useStream}. Reactive\n * projections are exposed as getters on a stable object so templates\n * can read `stream.messages` directly without a `.value` / `.current`\n * hop and `$derived` wrappers auto-track the getter read.\n *\n * Destructuring (`const { messages } = stream`) breaks reactivity —\n * this is a Svelte 5 constraint and applies to every getter-object\n * pattern. Access fields through the live `stream` handle instead.\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: StateType;\n  readonly messages: BaseMessage[];\n  readonly toolCalls: InferToolCalls<T>[];\n  readonly interrupts: Interrupt<InterruptType>[];\n  readonly interrupt: Interrupt<InterruptType> | undefined;\n  readonly isLoading: boolean;\n  readonly isThreadLoading: boolean;\n  readonly error: unknown;\n  readonly threadId: string | null;\n  /**\n   * Promise that settles when the current thread's initial hydration\n   * completes. Useful in SvelteKit `load()` handlers (or any\n   * async-init site) to block until the controller has reconciled\n   * with server-held state.\n   */\n  readonly hydrationPromise: Promise<void>;\n\n  readonly subagents: ReadonlyMap<\n    keyof SubagentStates & string extends never\n      ? string\n      : keyof SubagentStates & string,\n    SubagentDiscoverySnapshot\n  >;\n  readonly subgraphs: ReadonlyMap<string, SubgraphDiscoverySnapshot>;\n  readonly subgraphsByNode: ReadonlyMap<\n    string,\n    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/**\n * Svelte 5 binding for the v2-native stream runtime.\n *\n * Returns a handle whose reactive fields are plain getters on a\n * stable object — templates can read `stream.messages` directly and\n * `$derived(stream.isLoading)` auto-tracks the getter.\n *\n * @example\n * ```svelte\n * <script lang=\"ts\">\n *   import { useStream } from \"@langchain/svelte\";\n *\n *   const stream = useStream({\n *     assistantId: \"agent\",\n *     apiUrl: \"http://localhost:2024\",\n *   });\n * </script>\n *\n * {#each stream.messages as msg (msg.id)}\n *   <div>{msg.content}</div>\n * {/each}\n * <button onclick={() =>\n *   stream.submit({ messages: [{ type: \"human\", content: \"Hi\" }] })\n * }>\n *   Send\n * </button>\n * ```\n *\n * `assistantId`, `client`, and `transport` are captured at composable\n * init. To bind a new assistant/transport, remount the component.\n * Only `threadId` is treated as reactive — pass it as a getter\n * (`threadId: () => active`) to drive an in-place thread swap.\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?: ValueOrGetter<string | null | undefined>;\n    client?: Client;\n    apiUrl?: string;\n    apiKey?: string;\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  const hasCustomAdapter =\n    asBag.transport != null && typeof asBag.transport !== \"string\";\n  const transport = asBag.transport;\n\n  // Client construction — captured once at init. Consumers that need\n  // to swap `apiUrl`/`apiKey` at runtime remount the owning component.\n  const client: Client =\n    asBag.client ??\n    (new ClientCtor({\n      apiUrl: asBag.apiUrl,\n      apiKey: asBag.apiKey,\n      callerOptions: asBag.callerOptions,\n      defaultHeaders: asBag.defaultHeaders,\n    }) as unknown as Client);\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 = readValueOrGetter(asBag.threadId) ?? null;\n\n  // Plain `let` binding, not `$state`: the controller holds maps of\n  // listeners, Promises, and the live `ThreadStream`, none of which\n  // survive Svelte's deep `$state` proxy wrapping.\n  const controller = new StreamController<\n    StateType,\n    InterruptType,\n    ConfigurableType\n  >({\n    assistantId,\n    // `Client` is state-shape agnostic at runtime; the controller\n    // advertises `Client<StateType>` on its public type for ergonomics.\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: mirrors React's activate/dispose pattern so HMR\n  // and other scope-reuse scenarios stay clean. `activate()` cancels\n  // a pending dispose if the owning scope survives.\n  const deactivate = controller.activate();\n  onDestroy(deactivate);\n\n  // ─── Reactive state bridges ─────────────────────────────────────────\n  //\n  // Each always-on `StreamStore` is wrapped in a runes `$state` slot\n  // seeded from `getSnapshot()` and kept in sync via `store.subscribe`.\n  // Subscriptions are torn down on component destroy.\n  let rootSnapshot = $state<RootSnapshot<StateType, InterruptType>>(\n    controller.rootStore.getSnapshot()\n  );\n  const unsubscribeRoot = controller.rootStore.subscribe(() => {\n    rootSnapshot = controller.rootStore.getSnapshot();\n  });\n  onDestroy(unsubscribeRoot);\n\n  let subagentSnapshot = $state<SubagentMap>(\n    controller.subagentStore.getSnapshot()\n  );\n  const unsubscribeSubagents = controller.subagentStore.subscribe(() => {\n    subagentSnapshot = controller.subagentStore.getSnapshot();\n  });\n  onDestroy(unsubscribeSubagents);\n\n  let subgraphSnapshot = $state<SubgraphMap>(\n    controller.subgraphStore.getSnapshot()\n  );\n  const unsubscribeSubgraphs = controller.subgraphStore.subscribe(() => {\n    subgraphSnapshot = controller.subgraphStore.getSnapshot();\n  });\n  onDestroy(unsubscribeSubgraphs);\n\n  let subgraphByNodeSnapshot = $state<SubgraphByNodeMap>(\n    controller.subgraphByNodeStore.getSnapshot()\n  );\n  const unsubscribeSubgraphByNode = controller.subgraphByNodeStore.subscribe(\n    () => {\n      subgraphByNodeSnapshot = controller.subgraphByNodeStore.getSnapshot();\n    }\n  );\n  onDestroy(unsubscribeSubgraphByNode);\n\n  // ─── threadId reactivity ────────────────────────────────────────────\n  //\n  // Only matters when the caller passed a getter. The initial hydrate\n  // already fired in the controller constructor, so skip the first\n  // tick to avoid a redundant `thread.state.get()`.\n  if (typeof asBag.threadId === \"function\") {\n    const getThreadId = asBag.threadId;\n    let previousThreadId = initialThreadId;\n    $effect(() => {\n      const next = (getThreadId() ?? null) as string | null;\n      if (next === previousThreadId) return;\n      previousThreadId = next;\n      void controller.hydrate(next);\n    });\n  }\n\n  // ─── Headless-tool handling ─────────────────────────────────────────\n  //\n  // Watch the root `values.__interrupt__` key plus the protocol-\n  // surfaced interrupts for items targeting a registered tool, invoke\n  // the handler, and resume the run with the handler's return value.\n  // Dedup via an id set so rerenders don't replay a tool call twice.\n  const tools = options.tools;\n  const onTool = options.onTool;\n  if (tools?.length) {\n    const handledTools = new Set<string>();\n    let handledForThreadId: string | null = initialThreadId;\n    $effect(() => {\n      // Reset dedup set when the active thread id changes — a fresh\n      // thread may legitimately re-emit a tool-call id we've seen.\n      const currentThreadId = rootSnapshot.threadId;\n      if (currentThreadId !== handledForThreadId) {\n        handledTools.clear();\n        handledForThreadId = currentThreadId;\n      }\n\n      const valuesBag = rootSnapshot.values as unknown as Record<\n        string,\n        unknown\n      >;\n      const existing = Array.isArray(valuesBag?.__interrupt__)\n        ? (valuesBag.__interrupt__ as Interrupt[])\n        : [];\n      const combined: Interrupt[] = [\n        ...existing,\n        ...(rootSnapshot.interrupts as unknown as Interrupt[]),\n      ];\n      if (combined.length === 0) return;\n      flushPendingHeadlessToolInterrupts(\n        { ...valuesBag, __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  }\n\n  // ─── Public handle ──────────────────────────────────────────────────\n  //\n  // Single stable object with getters. Getters read the runes\n  // `$state` slots, which drives template reactivity automatically.\n  const handle: UseStreamReturn<T, InterruptType, ConfigurableType> = {\n    get values() {\n      return rootSnapshot.values;\n    },\n    get messages() {\n      return rootSnapshot.messages;\n    },\n    get toolCalls() {\n      return rootSnapshot.toolCalls as InferToolCalls<T>[];\n    },\n    get interrupts() {\n      return rootSnapshot.interrupts;\n    },\n    get interrupt() {\n      return rootSnapshot.interrupt;\n    },\n    get isLoading() {\n      return rootSnapshot.isLoading;\n    },\n    get isThreadLoading() {\n      return rootSnapshot.isThreadLoading;\n    },\n    get error() {\n      return rootSnapshot.error;\n    },\n    get threadId() {\n      return rootSnapshot.threadId;\n    },\n    get hydrationPromise() {\n      return controller.hydrationPromise;\n    },\n    get subagents() {\n      return subagentSnapshot as UseStreamReturn<\n        T,\n        InterruptType,\n        ConfigurableType\n      >[\"subagents\"];\n    },\n    get subgraphs() {\n      return subgraphSnapshot;\n    },\n    get subgraphsByNode() {\n      return subgraphByNodeSnapshot;\n    },\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/** 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 * 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/package.json

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