@langchain/svelte 0.4.6 → 1.0.0

package/dist/index.d.ts

@@ -1,97 +1,11 @@
-import { AgentTypeConfigLike, BaseStream, BaseSubagentState, ClassSubagentStreamInterface, CompiledSubAgentLike, DeepAgentTypeConfigLike, DefaultSubagentStates, ExtractAgentConfig, ExtractDeepAgentConfig, ExtractSubAgentMiddleware, FetchStreamTransport, GetToolCallsType, InferAgentToolCalls, InferBag, InferBag as InferBag$1, InferDeepAgentSubagents, InferNodeNames, InferStateType, InferStateType as InferStateType$1, InferSubagentByName, InferSubagentNames, InferSubagentState, InferSubagentStates, InferToolCalls, IsAgentLike, IsDeepAgentLike, MessageMetadata, QueueEntry, QueueInterface, ResolveStreamInterface, ResolveStreamInterface as ResolveStreamInterface$1, ResolveStreamOptions, ResolveStreamOptions as ResolveStreamOptions$1, SubAgentLike, SubagentApi, SubagentManager, SubagentStateMap, SubagentStatus, SubagentStream, SubagentStreamInterface, SubagentToolCall, UseAgentStream, UseAgentStreamOptions, UseDeepAgentStream, UseDeepAgentStreamOptions, UseStreamCustomOptions, UseStreamCustomOptions as UseStreamCustomOptions$1, UseStreamOptions, UseStreamThread, UseStreamTransport, WithClassMessages, calculateDepthFromNamespace, extractParentIdFromNamespace, extractToolCallIdFromNamespace, isSubagentNamespace } from "@langchain/langgraph-sdk/ui";
-import { AnyHeadlessToolImplementation, BagTemplate, DefaultToolCall, DefaultToolCall as DefaultToolCall$1, FlushPendingHeadlessToolInterruptsOptions, HeadlessToolImplementation, HeadlessToolInterrupt, OnToolCallback, ToolCallFromTool, ToolCallState, ToolCallWithResult as ToolCallWithResult$1, ToolCallsFromTools, ToolEvent, executeHeadlessTool, filterOutHeadlessToolInterrupts, findHeadlessTool, flushPendingHeadlessToolInterrupts, handleHeadlessToolInterrupt, headlessToolResumeCommand, isHeadlessToolInterrupt, parseHeadlessToolInterruptPayload } from "@langchain/langgraph-sdk";
-import { AIMessage, ToolMessage } from "@langchain/core/messages";
-
-//#region src/index.d.ts
-/**
- * Provides a `useStream` return value to all descendant components via
- * Svelte's context API. Must be called during component initialisation
- * (i.e. at the top level of a `<script>` block).
- *
- * @example
- * ```svelte
- * <script lang="ts">
- *   import { useStream, setStreamContext } from "@langchain/svelte";
- *
- *   const stream = useStream({ assistantId: "agent", apiUrl: "..." });
- *   setStreamContext(stream);
- * </script>
- *
- * <ChildComponent />
- * ```
- */
-declare function setStreamContext<T extends ReturnType<typeof useStream>>(stream: T): T;
-/**
- * Retrieves the `useStream` instance previously provided by a parent
- * component via {@link setStreamContext} or {@link provideStream}.
- * Must be called during component initialisation.
- *
- * @throws If no stream context has been set by an ancestor component.
- *
- * @example
- * ```svelte
- * <script lang="ts">
- *   import { getStreamContext } from "@langchain/svelte";
- *
- *   const stream = getStreamContext();
- * </script>
- * ```
- */
-declare function getStreamContext<T = Record<string, unknown>, Bag extends BagTemplate = BagTemplate>(): WithClassMessages<ResolveStreamInterface$1<T, InferBag$1<T, Bag>>>;
-/**
- * Creates a shared `useStream` instance and makes it available to all
- * descendant components via Svelte's `setContext`/`getContext`.
- *
- * Call this in a parent component's `<script>` block. Children access
- * the shared stream via {@link getStream}.
- *
- * Uses the same context key as {@link setStreamContext}/{@link getStreamContext},
- * so both retrieval functions work interchangeably.
- *
- * @example
- * ```svelte
- * <!-- ChatContainer.svelte -->
- * <script lang="ts">
- *   import { provideStream } from "@langchain/svelte";
- *
- *   provideStream({
- *     assistantId: "agent",
- *     apiUrl: "http://localhost:2024",
- *   });
- * </script>
- *
- * <ChatHeader />
- * <MessageList />
- * <MessageInput />
- * ```
- *
- * @returns The stream instance (same as calling `useStream` directly).
- */
-declare function provideStream<T = Record<string, unknown>, Bag extends BagTemplate = BagTemplate>(options: ResolveStreamOptions$1<T, InferBag$1<T, Bag>> | UseStreamCustomOptions$1<InferStateType$1<T>, InferBag$1<T, Bag>>): ReturnType<typeof useStream<T, Bag>>;
-/**
- * Retrieves the shared stream instance from the nearest ancestor that
- * called {@link provideStream} or {@link setStreamContext}.
- *
- * Throws if no ancestor has provided a stream.
- *
- * @example
- * ```svelte
- * <!-- MessageList.svelte -->
- * <script lang="ts">
- *   import { getStream } from "@langchain/svelte";
- *
- *   const stream = getStream();
- * </script>
- *
- * {#each stream.messages as msg (msg.id)}
- *   <div>{msg.content}</div>
- * {/each}
- * ```
- */
-declare function getStream<T = Record<string, unknown>, Bag extends BagTemplate = BagTemplate>(): ReturnType<typeof useStream<T, Bag>>;
-declare function useStream<T = Record<string, unknown>, Bag extends BagTemplate = BagTemplate>(options: ResolveStreamOptions$1<T, InferBag$1<T, Bag>>): WithClassMessages<ResolveStreamInterface$1<T, InferBag$1<T, Bag>>>;
-declare function useStream<T = Record<string, unknown>, Bag extends BagTemplate = BagTemplate>(options: UseStreamCustomOptions$1<InferStateType$1<T>, InferBag$1<T, Bag>>): WithClassMessages<ResolveStreamInterface$1<T, InferBag$1<T, Bag>>>;
-type ToolCallWithResult<ToolCall = DefaultToolCall$1> = ToolCallWithResult$1<ToolCall, ToolMessage, AIMessage>;
-//#endregion
-export { type AgentTypeConfigLike, type AnyHeadlessToolImplementation, type BaseStream, type BaseSubagentState, type ClassSubagentStreamInterface, type CompiledSubAgentLike, type DeepAgentTypeConfigLike, type DefaultSubagentStates, type DefaultToolCall, type ExtractAgentConfig, type ExtractDeepAgentConfig, type ExtractSubAgentMiddleware, FetchStreamTransport, type FlushPendingHeadlessToolInterruptsOptions, type GetToolCallsType, type HeadlessToolImplementation, type HeadlessToolInterrupt, type InferAgentToolCalls, type InferBag, type InferDeepAgentSubagents, type InferNodeNames, type InferStateType, type InferSubagentByName, type InferSubagentNames, type InferSubagentState, type InferSubagentStates, type InferToolCalls, type IsAgentLike, type IsDeepAgentLike, type MessageMetadata, type OnToolCallback, type QueueEntry, type QueueInterface, type ResolveStreamInterface, type ResolveStreamOptions, type SubAgentLike, type SubagentApi, SubagentManager, type SubagentStateMap, type SubagentStatus, type SubagentStream, type SubagentStreamInterface, type SubagentToolCall, type ToolCallFromTool, type ToolCallState, ToolCallWithResult, type ToolCallsFromTools, type ToolEvent, type UseAgentStream, type UseAgentStreamOptions, type UseDeepAgentStream, type UseDeepAgentStreamOptions, type UseStreamCustomOptions, type UseStreamOptions, type UseStreamThread, type UseStreamTransport, calculateDepthFromNamespace, executeHeadlessTool, extractParentIdFromNamespace, extractToolCallIdFromNamespace, filterOutHeadlessToolInterrupts, findHeadlessTool, flushPendingHeadlessToolInterrupts, getStream, getStreamContext, handleHeadlessToolInterrupt, headlessToolResumeCommand, isHeadlessToolInterrupt, isSubagentNamespace, parseHeadlessToolInterruptPayload, provideStream, setStreamContext, useStream };
-//# sourceMappingURL=index.d.ts.map
+import { AgentServerOptions, AnyStream, CustomAdapterOptions, STREAM_CONTROLLER, StateOf, 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 { 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 };

package/dist/index.js

@@ -1,290 +1,10 @@
-import { createReactiveSubagentAccessors } from "./subagents.js";
-import { useStreamCustom } from "./stream.custom.js";
-import { derived, fromStore, writable } from "svelte/store";
-import { getContext, onDestroy, onMount, setContext } from "svelte";
-import { FetchStreamTransport, StreamOrchestrator, SubagentManager, calculateDepthFromNamespace, ensureMessageInstances, extractParentIdFromNamespace, extractToolCallIdFromNamespace, isSubagentNamespace } from "@langchain/langgraph-sdk/ui";
-import { Client, executeHeadlessTool, filterOutHeadlessToolInterrupts, findHeadlessTool, flushPendingHeadlessToolInterrupts, handleHeadlessToolInterrupt, headlessToolResumeCommand, isHeadlessToolInterrupt, parseHeadlessToolInterruptPayload } from "@langchain/langgraph-sdk";
-//#region src/index.ts
-const STREAM_CONTEXT_KEY = Symbol.for("langchain:stream-context");
-/**
-* Provides a `useStream` return value to all descendant components via
-* Svelte's context API. Must be called during component initialisation
-* (i.e. at the top level of a `<script>` block).
-*
-* @example
-* ```svelte
-* <script lang="ts">
-*   import { useStream, setStreamContext } from "@langchain/svelte";
-*
-*   const stream = useStream({ assistantId: "agent", apiUrl: "..." });
-*   setStreamContext(stream);
-* <\/script>
-*
-* <ChildComponent />
-* ```
-*/
-function setStreamContext(stream) {
-	setContext(STREAM_CONTEXT_KEY, stream);
-	return stream;
-}
-/**
-* Retrieves the `useStream` instance previously provided by a parent
-* component via {@link setStreamContext} or {@link provideStream}.
-* Must be called during component initialisation.
-*
-* @throws If no stream context has been set by an ancestor component.
-*
-* @example
-* ```svelte
-* <script lang="ts">
-*   import { getStreamContext } from "@langchain/svelte";
-*
-*   const stream = getStreamContext();
-* <\/script>
-* ```
-*/
-function getStreamContext() {
-	const ctx = getContext(STREAM_CONTEXT_KEY);
-	if (!ctx) throw new Error("getStreamContext must be used within a component that has called setStreamContext");
-	return ctx;
-}
-/**
-* Creates a shared `useStream` instance and makes it available to all
-* descendant components via Svelte's `setContext`/`getContext`.
-*
-* Call this in a parent component's `<script>` block. Children access
-* the shared stream via {@link getStream}.
-*
-* Uses the same context key as {@link setStreamContext}/{@link getStreamContext},
-* so both retrieval functions work interchangeably.
-*
-* @example
-* ```svelte
-* <!-- ChatContainer.svelte -->
-* <script lang="ts">
-*   import { provideStream } from "@langchain/svelte";
-*
-*   provideStream({
-*     assistantId: "agent",
-*     apiUrl: "http://localhost:2024",
-*   });
-* <\/script>
-*
-* <ChatHeader />
-* <MessageList />
-* <MessageInput />
-* ```
-*
-* @returns The stream instance (same as calling `useStream` directly).
-*/
-function provideStream(options) {
-	const stream = useStream(options);
-	setContext(STREAM_CONTEXT_KEY, stream);
-	return stream;
-}
-/**
-* Retrieves the shared stream instance from the nearest ancestor that
-* called {@link provideStream} or {@link setStreamContext}.
-*
-* Throws if no ancestor has provided a stream.
-*
-* @example
-* ```svelte
-* <!-- MessageList.svelte -->
-* <script lang="ts">
-*   import { getStream } from "@langchain/svelte";
-*
-*   const stream = getStream();
-* <\/script>
-*
-* {#each stream.messages as msg (msg.id)}
-*   <div>{msg.content}</div>
-* {/each}
-* ```
-*/
-function getStream() {
-	const context = getContext(STREAM_CONTEXT_KEY);
-	if (context == null) throw new Error("getStream() requires a parent component to call provideStream(). Add provideStream({ assistantId: '...' }) in an ancestor component.");
-	return context;
-}
-function useStream(options) {
-	if ("transport" in options) return useStreamCustom(options);
-	return useStreamLGP(options);
-}
-function useStreamLGP(options) {
-	const client = options.client ?? new Client({ apiUrl: options.apiUrl });
-	const orchestrator = new StreamOrchestrator(options, {
-		getClient: () => client,
-		getAssistantId: () => options.assistantId,
-		getMessagesKey: () => options.messagesKey ?? "messages"
-	});
-	orchestrator.initThreadId(options.threadId ?? void 0);
-	const version = writable(0);
-	const reactiveSubagents = createReactiveSubagentAccessors({
-		getSubagent: (toolCallId) => orchestrator.getSubagent(toolCallId),
-		getSubagentsByType: (type) => orchestrator.getSubagentsByType(type),
-		getSubagentsByMessage: (messageId) => orchestrator.getSubagentsByMessage(messageId)
-	}, version);
-	const unsubscribe = orchestrator.subscribe(() => {
-		version.update((v) => v + 1);
-	});
-	let fetchController = null;
-	const unsubReconstruct = derived(version, () => {
-		const hvMessages = orchestrator.messages;
-		if (!options.filterSubagentMessages) return false;
-		if (orchestrator.isLoading || orchestrator.historyData.isLoading) return false;
-		return hvMessages.length > 0;
-	}).subscribe(($should) => {
-		if ($should) {
-			fetchController?.abort();
-			fetchController = orchestrator.reconstructSubagentsIfNeeded();
-		}
-	});
-	const unsubDrain = derived(version, () => orchestrator.isLoading).subscribe(() => {
-		orchestrator.drainQueue();
-	});
-	let { shouldReconnect } = orchestrator;
-	onMount(() => {
-		if (shouldReconnect) {
-			if (orchestrator.tryReconnect()) shouldReconnect = false;
-		}
-	});
-	onDestroy(() => {
-		fetchController?.abort();
-		unsubscribe();
-		unsubReconstruct();
-		unsubDrain();
-		orchestrator.dispose();
-	});
-	const valuesStore = derived(version, () => {
-		orchestrator.trackStreamMode("values");
-		return orchestrator.values;
-	});
-	const errorStore = derived(version, () => orchestrator.error);
-	const isLoadingStore = derived(version, () => orchestrator.isLoading);
-	const branchStore = derived(version, () => orchestrator.branch);
-	const messagesStore = derived(version, () => {
-		orchestrator.trackStreamMode("messages-tuple", "values");
-		return ensureMessageInstances(orchestrator.messages);
-	});
-	const toolCallsStore = derived(version, () => {
-		orchestrator.trackStreamMode("messages-tuple", "values");
-		return orchestrator.toolCalls;
-	});
-	const interruptStore = derived(version, () => orchestrator.interrupt);
-	const interruptsStore = derived(version, () => orchestrator.interrupts);
-	const historyListStore = derived(version, () => orchestrator.flatHistory);
-	const isThreadLoadingStore = derived(version, () => orchestrator.isThreadLoading);
-	const experimentalBranchTreeStore = derived(version, () => orchestrator.experimental_branchTree);
-	const subagentsStore = derived(version, () => {
-		orchestrator.trackStreamMode("updates", "messages-tuple");
-		return reactiveSubagents.mapSubagents(orchestrator.subagents);
-	});
-	const activeSubagentsStore = derived(version, () => {
-		orchestrator.trackStreamMode("updates", "messages-tuple");
-		return reactiveSubagents.mapActiveSubagents(orchestrator.activeSubagents);
-	});
-	const queueEntriesStore = derived(version, () => orchestrator.queueEntries);
-	const queueSizeStore = derived(version, () => orchestrator.queueSize);
-	const valuesRef = fromStore(valuesStore);
-	const errorRef = fromStore(errorStore);
-	const isLoadingRef = fromStore(isLoadingStore);
-	const branchRef = fromStore(branchStore);
-	const messagesRef = fromStore(messagesStore);
-	const toolCallsRef = fromStore(toolCallsStore);
-	const interruptRef = fromStore(interruptStore);
-	const interruptsRef = fromStore(interruptsStore);
-	const historyListRef = fromStore(historyListStore);
-	const isThreadLoadingRef = fromStore(isThreadLoadingStore);
-	const experimentalBranchTreeRef = fromStore(experimentalBranchTreeStore);
-	const subagentsRef = fromStore(subagentsStore);
-	const activeSubagentsRef = fromStore(activeSubagentsStore);
-	const queueEntriesRef = fromStore(queueEntriesStore);
-	const queueSizeRef = fromStore(queueSizeStore);
-	return {
-		assistantId: options.assistantId,
-		client,
-		get values() {
-			return valuesRef.current;
-		},
-		get error() {
-			return errorRef.current;
-		},
-		get isLoading() {
-			return isLoadingRef.current;
-		},
-		get isThreadLoading() {
-			return isThreadLoadingRef.current;
-		},
-		get branch() {
-			return branchRef.current;
-		},
-		setBranch(value) {
-			orchestrator.setBranch(value);
-		},
-		get messages() {
-			return messagesRef.current;
-		},
-		get toolCalls() {
-			return toolCallsRef.current;
-		},
-		getToolCalls(message) {
-			return orchestrator.getToolCalls(message);
-		},
-		get interrupt() {
-			return interruptRef.current;
-		},
-		get interrupts() {
-			return interruptsRef.current;
-		},
-		get history() {
-			return historyListRef.current;
-		},
-		get experimental_branchTree() {
-			return experimentalBranchTreeRef.current;
-		},
-		getMessagesMetadata(message, index) {
-			return orchestrator.getMessagesMetadata(message, index);
-		},
-		submit: (...args) => orchestrator.submit(...args),
-		stop: () => orchestrator.stop(),
-		joinStream: (...args) => orchestrator.joinStream(...args),
-		queue: {
-			get entries() {
-				return queueEntriesRef.current;
-			},
-			get size() {
-				return queueSizeRef.current;
-			},
-			cancel: (id) => orchestrator.cancelQueueItem(id),
-			clear: () => orchestrator.clearQueue()
-		},
-		switchThread(newThreadId) {
-			orchestrator.switchThread(newThreadId);
-		},
-		get subagents() {
-			orchestrator.trackStreamMode("updates", "messages-tuple");
-			return subagentsRef.current;
-		},
-		get activeSubagents() {
-			orchestrator.trackStreamMode("updates", "messages-tuple");
-			return activeSubagentsRef.current;
-		},
-		getSubagent(toolCallId) {
-			orchestrator.trackStreamMode("updates", "messages-tuple");
-			return reactiveSubagents.getSubagent(toolCallId);
-		},
-		getSubagentsByType(type) {
-			orchestrator.trackStreamMode("updates", "messages-tuple");
-			return reactiveSubagents.getSubagentsByType(type);
-		},
-		getSubagentsByMessage(messageId) {
-			orchestrator.trackStreamMode("updates", "messages-tuple");
-			return reactiveSubagents.getSubagentsByMessage(messageId);
-		}
-	};
-}
-//#endregion
-export { FetchStreamTransport, SubagentManager, calculateDepthFromNamespace, executeHeadlessTool, extractParentIdFromNamespace, extractToolCallIdFromNamespace, filterOutHeadlessToolInterrupts, findHeadlessTool, flushPendingHeadlessToolInterrupts, getStream, getStreamContext, handleHeadlessToolInterrupt, headlessToolResumeCommand, isHeadlessToolInterrupt, isSubagentNamespace, parseHeadlessToolInterruptPayload, provideStream, setStreamContext, useStream };
-
-//# sourceMappingURL=index.js.map
+import { STREAM_CONTROLLER, useStream } from "./use-stream.svelte.js";
+import { useProjection } from "./use-projection.svelte.js";
+import { useAudio, useChannel, useExtension, useFiles, useImages, useMessageMetadata, useMessages, useSubmissionQueue, useToolCalls, useValues, useVideo } from "./selectors.svelte.js";
+import { useMediaURL } from "./use-media-url.svelte.js";
+import { useAudioPlayer } from "./use-audio-player.svelte.js";
+import { useVideoPlayer } from "./use-video-player.svelte.js";
+import { STREAM_CONTEXT_KEY, getStream, provideStream } from "./context.js";
+import { HttpAgentServerAdapter, executeHeadlessTool, filterOutHeadlessToolInterrupts, findHeadlessTool, flushPendingHeadlessToolInterrupts, handleHeadlessToolInterrupt, headlessToolResumeCommand, isHeadlessToolInterrupt, parseHeadlessToolInterruptPayload } from "@langchain/langgraph-sdk";
+import { MediaAssemblyError } from "@langchain/langgraph-sdk/stream";
+export { HttpAgentServerAdapter, MediaAssemblyError, STREAM_CONTEXT_KEY, STREAM_CONTROLLER, 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

@@ -0,0 +1,214 @@
+const require_use_stream_svelte = require("./use-stream.svelte.cjs");
+const require_use_projection_svelte = require("./use-projection.svelte.cjs");
+let _langchain_langgraph_sdk_stream = require("@langchain/langgraph-sdk/stream");
+//#region src/selectors.svelte.ts
+const EMPTY_NAMESPACE = [];
+function resolveNamespace(target) {
+	if (target == null) return EMPTY_NAMESPACE;
+	if (Array.isArray(target)) return target;
+	return target.namespace ?? EMPTY_NAMESPACE;
+}
+function isRoot(namespace) {
+	return namespace.length === 0;
+}
+function namespaceKey(namespace) {
+	return namespace.join(_langchain_langgraph_sdk_stream.NAMESPACE_SEPARATOR);
+}
+function isGetter(input) {
+	return typeof input === "function";
+}
+/**
+* Internal helper that wires a reactive-or-static target into
+* {@link useProjection}. Encapsulates the bookkeeping every selector
+* otherwise repeats.
+*/
+function selectFromTarget(stream, target, initialValue, makeSpec, keyPrefix) {
+	if (isGetter(target)) {
+		const getTarget = target;
+		return require_use_projection_svelte.useProjection(() => {
+			return isRoot(resolveNamespace(getTarget())) ? null : require_use_stream_svelte.getRegistry(stream);
+		}, () => makeSpec(resolveNamespace(getTarget())), () => `${keyPrefix}|${namespaceKey(resolveNamespace(getTarget()))}`, initialValue);
+	}
+	const ns = resolveNamespace(target);
+	const key = `${keyPrefix}|${namespaceKey(ns)}`;
+	return require_use_projection_svelte.useProjection(isRoot(ns) ? null : require_use_stream_svelte.getRegistry(stream), () => makeSpec(ns), key, initialValue);
+}
+const EMPTY_MESSAGES = [];
+const EMPTY_TOOLCALLS = [];
+const EMPTY_EVENTS = [];
+const EMPTY_AUDIO = [];
+const EMPTY_IMAGES = [];
+const EMPTY_VIDEO = [];
+const EMPTY_FILES = [];
+/**
+* Subscribe to a scoped `messages` stream.
+*
+* Contract:
+*  - At the root (no `target`, or a static target that resolves to
+*    the root namespace) returns a handle whose `.current` delegates
+*    to `stream.messages` — the always-on root projection. No extra
+*    subscription is opened.
+*  - For any non-root namespace, mount triggers a ref-counted
+*    `messages` subscription scoped to that namespace. The
+*    subscription is released automatically when the owning
+*    component teardown fires (and the registry closes the
+*    underlying server subscription when the last consumer leaves).
+*  - A reactive `target` (getter form) re-binds the subscription on
+*    change. A getter that flips between root and scoped is
+*    supported: the root case short-circuits to the initial value
+*    because dynamic root delegation isn't meaningful — pass a
+*    static undefined/null target for root handles.
+*
+* Messages are always `BaseMessage` class instances from
+* `@langchain/core/messages`.
+*/
+function useMessages(stream, target) {
+	if (!isGetter(target)) {
+		if (isRoot(resolveNamespace(target))) return { get current() {
+			return stream.messages;
+		} };
+	}
+	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() {
+			return stream.toolCalls;
+		} };
+	}
+	return selectFromTarget(stream, target, EMPTY_TOOLCALLS, (ns) => (0, _langchain_langgraph_sdk_stream.toolCallsProjection)(ns), "toolCalls");
+}
+function useValues(stream, target, options) {
+	if (!isGetter(target)) {
+		if (isRoot(resolveNamespace(target))) return { get current() {
+			return stream.values;
+		} };
+	}
+	const messagesKey = options?.messagesKey ?? "messages";
+	return selectFromTarget(stream, target, void 0, (ns) => (0, _langchain_langgraph_sdk_stream.valuesProjection)(ns, messagesKey), `values|${messagesKey}`);
+}
+/**
+* Subscribe to a `custom:<name>` stream extension — most-recent
+* payload emitted by the transformer, scoped to the target namespace.
+*
+* `name` accepts either a plain string or a getter so component
+* state can drive the extension name at runtime.
+*/
+function useExtension(stream, name, target) {
+	const getName = () => isGetter(name) ? name() : name;
+	if (isGetter(target)) {
+		const getTarget = target;
+		return require_use_projection_svelte.useProjection(() => require_use_stream_svelte.getRegistry(stream), () => (0, _langchain_langgraph_sdk_stream.extensionProjection)(getName(), resolveNamespace(getTarget())), () => `extension|${getName()}|${namespaceKey(resolveNamespace(getTarget()))}`, void 0);
+	}
+	const ns = resolveNamespace(target);
+	return require_use_projection_svelte.useProjection(require_use_stream_svelte.getRegistry(stream), () => (0, _langchain_langgraph_sdk_stream.extensionProjection)(getName(), ns), () => `extension|${getName()}|${namespaceKey(ns)}`, void 0);
+}
+function useChannel(stream, channels, target, options) {
+	const getChannels = () => isGetter(channels) ? channels() : channels;
+	const getTarget = () => isGetter(target) ? target() : target;
+	const bufferSize = options?.bufferSize ?? "default";
+	const replayMode = options?.replay ?? true ? "replay" : "live";
+	return require_use_projection_svelte.useProjection(() => require_use_stream_svelte.getRegistry(stream), () => (0, _langchain_langgraph_sdk_stream.channelProjection)(getChannels(), resolveNamespace(getTarget()), options), () => {
+		return `channel|${bufferSize}|${replayMode}|${[...getChannels()].sort().join(",")}|${namespaceKey(resolveNamespace(getTarget()))}`;
+	}, EMPTY_EVENTS);
+}
+/**
+* Subscribe to a scoped audio-media stream. Each handle is yielded
+* on its first matching `content-block-start`, exposes
+* `.partialBytes` for live access, settles `.blob` / `.objectURL` /
+* `.transcript` on `message-finish`, and surfaces errors via
+* `.error`.
+*/
+function useAudio(stream, target) {
+	return selectFromTarget(stream, target, EMPTY_AUDIO, (ns) => (0, _langchain_langgraph_sdk_stream.audioProjection)(ns), "audio");
+}
+/**
+* Subscribe to a scoped image-media stream. Pair with `useMediaURL`
+* for `<img src>`.
+*/
+function useImages(stream, target) {
+	return selectFromTarget(stream, target, EMPTY_IMAGES, (ns) => (0, _langchain_langgraph_sdk_stream.imagesProjection)(ns), "images");
+}
+/**
+* Subscribe to a scoped video-media stream. Pair with `useMediaURL`
+* for `<video src>`.
+*/
+function useVideo(stream, target) {
+	return selectFromTarget(stream, target, EMPTY_VIDEO, (ns) => (0, _langchain_langgraph_sdk_stream.videoProjection)(ns), "video");
+}
+/**
+* Subscribe to a scoped file-media stream. Pair with `useMediaURL`
+* for an `<a download href>` target.
+*/
+function useFiles(stream, target) {
+	return selectFromTarget(stream, target, EMPTY_FILES, (ns) => (0, _langchain_langgraph_sdk_stream.filesProjection)(ns), "files");
+}
+/**
+* Read metadata recorded for a specific message id — today exposes
+* `parentCheckpointId`, the checkpoint the message was first seen
+* on. Designed for fork / edit flows:
+*
+* ```svelte
+* <script lang="ts">
+*   const meta = useMessageMetadata(stream, () => selected?.id);
+* <\/script>
+* Parent: {meta.current?.parentCheckpointId ?? "root"}
+* ```
+*
+* `messageId` accepts a plain string or a getter — the binding
+* re-evaluates whenever the id changes.
+*/
+function useMessageMetadata(stream, messageId) {
+	const store = stream[require_use_stream_svelte.STREAM_CONTROLLER].messageMetadataStore;
+	let map = $state(store.getSnapshot());
+	$effect(() => {
+		return store.subscribe(() => {
+			map = store.getSnapshot();
+		});
+	});
+	const getId = () => isGetter(messageId) ? messageId() : messageId;
+	return { get current() {
+		const key = getId();
+		if (key == null) return void 0;
+		return map.get(key);
+	} };
+}
+function useSubmissionQueue(stream) {
+	const controller = stream[require_use_stream_svelte.STREAM_CONTROLLER];
+	const store = controller.queueStore;
+	let entries = $state(store.getSnapshot());
+	$effect(() => {
+		return store.subscribe(() => {
+			entries = store.getSnapshot();
+		});
+	});
+	return {
+		get entries() {
+			return entries;
+		},
+		get size() {
+			return entries.length;
+		},
+		cancel: (id) => controller.cancelQueued(id),
+		clear: () => controller.clearQueue()
+	};
+}
+//#endregion
+exports.useAudio = useAudio;
+exports.useChannel = useChannel;
+exports.useExtension = useExtension;
+exports.useFiles = useFiles;
+exports.useImages = useImages;
+exports.useMessageMetadata = useMessageMetadata;
+exports.useMessages = useMessages;
+exports.useSubmissionQueue = useSubmissionQueue;
+exports.useToolCalls = useToolCalls;
+exports.useValues = useValues;
+exports.useVideo = useVideo;
+
+//# sourceMappingURL=selectors.svelte.cjs.map