@langchain/svelte 0.4.7 → 1.0.1

package/dist/context.d.ts

@@ -0,0 +1,72 @@
+import { AgentServerOptions as AgentServerOptions$1, CustomAdapterOptions as CustomAdapterOptions$1, UseStreamReturn } from "./use-stream.svelte.js";
+import { InferStateType } from "@langchain/langgraph-sdk/stream";
+
+//#region src/context.d.ts
+/**
+ * Context key used for the shared stream handle exposed via
+ * {@link provideStream}. Exported so advanced callers can drive
+ * Svelte's context API directly (e.g. a shared context in a
+ * microfrontend shell).
+ */
+declare const STREAM_CONTEXT_KEY: unique symbol;
+/**
+ * Props for {@link provideStream} when talking to the default
+ * LangGraph-Platform agent server.
+ */
+type ProvideStreamProps<T = Record<string, unknown>> = AgentServerOptions$1<InferStateType<T>>;
+/**
+ * Props for {@link provideStream} when wiring a custom
+ * {@link AgentServerAdapter}.
+ */
+type ProvideStreamCustomProps<T = Record<string, unknown>> = CustomAdapterOptions$1<InferStateType<T>>;
+/**
+ * Creates a shared {@link useStream} handle and publishes it via
+ * Svelte's `setContext`. Descendant components read it via
+ * {@link getStream}.
+ *
+ * Must be called during component initialisation (the top level of a
+ * `<script>` block or `<script module>` that runs at mount), same
+ * lifecycle constraint as `setContext`.
+ *
+ * @example
+ * ```svelte
+ * <!-- ChatContainer.svelte -->
+ * <script lang="ts">
+ *   import { provideStream } from "@langchain/svelte";
+ *
+ *   provideStream({
+ *     assistantId: "agent",
+ *     apiUrl: "http://localhost:2024",
+ *   });
+ * </script>
+ *
+ * <ChatHeader />
+ * <MessageList />
+ * <MessageInput />
+ * ```
+ */
+declare function provideStream<T = Record<string, unknown>, InterruptType = unknown, ConfigurableType extends object = Record<string, unknown>>(options: ProvideStreamProps<T> | ProvideStreamCustomProps<T>): UseStreamReturn<T, InterruptType, ConfigurableType>;
+/**
+ * Reads the shared stream handle exposed by the nearest ancestor
+ * {@link provideStream} call. Throws when no ancestor has provided
+ * one.
+ *
+ * @example
+ * ```svelte
+ * <!-- MessageList.svelte -->
+ * <script lang="ts">
+ *   import { getStream } from "@langchain/svelte";
+ *   import type { agent } from "./agent";
+ *
+ *   const stream = getStream<typeof agent>();
+ * </script>
+ *
+ * {#each stream.messages as msg (msg.id)}
+ *   <div>{msg.content}</div>
+ * {/each}
+ * ```
+ */
+declare function getStream<T = Record<string, unknown>, InterruptType = unknown, ConfigurableType extends object = Record<string, unknown>>(): UseStreamReturn<T, InterruptType, ConfigurableType>;
+//#endregion
+export { ProvideStreamCustomProps, ProvideStreamProps, STREAM_CONTEXT_KEY, getStream, provideStream };
+//# sourceMappingURL=context.d.ts.map

package/dist/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","names":[],"sources":["../src/context.ts"],"mappings":";;;;;;AAgBA;;;;cAAa,kBAAA;AAQb;;;;AAAA,KAAY,kBAAA,KAAuB,MAAA,qBACjC,oBAAA,CAAmB,cAAA,CAAe,CAAA;;;;;KAMxB,wBAAA,KAA6B,MAAA,qBACvC,sBAAA,CAAqB,cAAA,CAAe,CAAA;;;;;;;AADtC;;;;;;;;;;;;;;;;AA6BA;;;;iBAAgB,aAAA,KACV,MAAA,8EAE8B,MAAA,kBAAA,CAElC,OAAA,EAAS,kBAAA,CAAmB,CAAA,IAAK,wBAAA,CAAyB,CAAA,IACzD,eAAA,CAAgB,CAAA,EAAG,aAAA,EAAe,gBAAA;;;;;;;;;;;;;;;;;;;;;iBA4BrB,SAAA,KACV,MAAA,8EAE8B,MAAA,kBAAA,CAAA,GAC/B,eAAA,CAAgB,CAAA,EAAG,aAAA,EAAe,gBAAA"}

package/dist/context.js

@@ -0,0 +1,70 @@
+import { useStream } from "./use-stream.svelte.js";
+import { getContext, setContext } from "svelte";
+//#region src/context.ts
+/**
+* Context key used for the shared stream handle exposed via
+* {@link provideStream}. Exported so advanced callers can drive
+* Svelte's context API directly (e.g. a shared context in a
+* microfrontend shell).
+*/
+const STREAM_CONTEXT_KEY = Symbol.for("@langchain/svelte/stream-context");
+/**
+* Creates a shared {@link useStream} handle and publishes it via
+* Svelte's `setContext`. Descendant components read it via
+* {@link getStream}.
+*
+* Must be called during component initialisation (the top level of a
+* `<script>` block or `<script module>` that runs at mount), same
+* lifecycle constraint as `setContext`.
+*
+* @example
+* ```svelte
+* <!-- ChatContainer.svelte -->
+* <script lang="ts">
+*   import { provideStream } from "@langchain/svelte";
+*
+*   provideStream({
+*     assistantId: "agent",
+*     apiUrl: "http://localhost:2024",
+*   });
+* <\/script>
+*
+* <ChatHeader />
+* <MessageList />
+* <MessageInput />
+* ```
+*/
+function provideStream(options) {
+	const stream = useStream(options);
+	setContext(STREAM_CONTEXT_KEY, stream);
+	return stream;
+}
+/**
+* Reads the shared stream handle exposed by the nearest ancestor
+* {@link provideStream} call. Throws when no ancestor has provided
+* one.
+*
+* @example
+* ```svelte
+* <!-- MessageList.svelte -->
+* <script lang="ts">
+*   import { getStream } from "@langchain/svelte";
+*   import type { agent } from "./agent";
+*
+*   const stream = getStream<typeof agent>();
+* <\/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;
+}
+//#endregion
+export { STREAM_CONTEXT_KEY, getStream, provideStream };
+
+//# sourceMappingURL=context.js.map

package/dist/context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.js","names":[],"sources":["../src/context.ts"],"sourcesContent":["import { getContext, setContext } from \"svelte\";\nimport type { InferStateType } from \"@langchain/langgraph-sdk/stream\";\nimport {\n  useStream,\n  type AgentServerOptions,\n  type CustomAdapterOptions,\n  type UseStreamOptions,\n  type UseStreamReturn,\n} from \"./use-stream.svelte.js\";\n\n/**\n * Context key used for the shared stream handle exposed via\n * {@link provideStream}. Exported so advanced callers can drive\n * Svelte's context API directly (e.g. a shared context in a\n * microfrontend shell).\n */\nexport const STREAM_CONTEXT_KEY: unique symbol = Symbol.for(\n  \"@langchain/svelte/stream-context\"\n);\n\n/**\n * Props for {@link provideStream} when talking to the default\n * LangGraph-Platform agent server.\n */\nexport type ProvideStreamProps<T = Record<string, unknown>> =\n  AgentServerOptions<InferStateType<T>>;\n\n/**\n * Props for {@link provideStream} when wiring a custom\n * {@link AgentServerAdapter}.\n */\nexport type ProvideStreamCustomProps<T = Record<string, unknown>> =\n  CustomAdapterOptions<InferStateType<T>>;\n\n/**\n * Creates a shared {@link useStream} handle and publishes it via\n * Svelte's `setContext`. Descendant components read it via\n * {@link getStream}.\n *\n * Must be called during component initialisation (the top level of a\n * `<script>` block or `<script module>` that runs at mount), same\n * lifecycle constraint as `setContext`.\n *\n * @example\n * ```svelte\n * <!-- ChatContainer.svelte -->\n * <script lang=\"ts\">\n *   import { provideStream } from \"@langchain/svelte\";\n *\n *   provideStream({\n *     assistantId: \"agent\",\n *     apiUrl: \"http://localhost:2024\",\n *   });\n * </script>\n *\n * <ChatHeader />\n * <MessageList />\n * <MessageInput />\n * ```\n */\nexport function provideStream<\n  T = Record<string, unknown>,\n  InterruptType = unknown,\n  ConfigurableType extends object = Record<string, unknown>,\n>(\n  options: ProvideStreamProps<T> | ProvideStreamCustomProps<T>\n): UseStreamReturn<T, InterruptType, ConfigurableType> {\n  const stream = useStream<T, InterruptType, ConfigurableType>(\n    options as UseStreamOptions<InferStateType<T>>\n  );\n  setContext(STREAM_CONTEXT_KEY, stream);\n  return stream;\n}\n\n/**\n * Reads the shared stream handle exposed by the nearest ancestor\n * {@link provideStream} call. Throws when no ancestor has provided\n * one.\n *\n * @example\n * ```svelte\n * <!-- MessageList.svelte -->\n * <script lang=\"ts\">\n *   import { getStream } from \"@langchain/svelte\";\n *   import type { agent } from \"./agent\";\n *\n *   const stream = getStream<typeof agent>();\n * </script>\n *\n * {#each stream.messages as msg (msg.id)}\n *   <div>{msg.content}</div>\n * {/each}\n * ```\n */\nexport function getStream<\n  T = Record<string, unknown>,\n  InterruptType = unknown,\n  ConfigurableType extends object = Record<string, unknown>,\n>(): UseStreamReturn<T, InterruptType, ConfigurableType> {\n  const context = getContext<\n    UseStreamReturn<T, InterruptType, ConfigurableType> | undefined\n  >(STREAM_CONTEXT_KEY);\n  if (context == null) {\n    throw new Error(\n      \"getStream() requires a parent component to call provideStream(). \" +\n        \"Add provideStream({ assistantId: '...' }) in an ancestor component.\"\n    );\n  }\n  return context;\n}\n"],"mappings":";;;;;;;;;AAgBA,MAAa,qBAAoC,OAAO,IACtD,mCACD;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CD,SAAgB,cAKd,SACqD;CACrD,MAAM,SAAS,UACb,QACD;AACD,YAAW,oBAAoB,OAAO;AACtC,QAAO;;;;;;;;;;;;;;;;;;;;;;AAuBT,SAAgB,YAIyC;CACvD,MAAM,UAAU,WAEd,mBAAmB;AACrB,KAAI,WAAW,KACb,OAAM,IAAI,MACR,uIAED;AAEH,QAAO"}

package/dist/index.cjs

@@ -1,322 +1,33 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_subagents = require("./subagents.cjs");
-const require_stream_custom = require("./stream.custom.cjs");
-let svelte_store = require("svelte/store");
-let svelte = require("svelte");
-let _langchain_langgraph_sdk_ui = require("@langchain/langgraph-sdk/ui");
+const require_use_stream_svelte = require("./use-stream.svelte.cjs");
+const require_use_projection_svelte = require("./use-projection.svelte.cjs");
+const require_selectors_svelte = require("./selectors.svelte.cjs");
+const require_use_media_url_svelte = require("./use-media-url.svelte.cjs");
+const require_use_audio_player_svelte = require("./use-audio-player.svelte.cjs");
+const require_use_video_player_svelte = require("./use-video-player.svelte.cjs");
+const require_context = require("./context.cjs");
 let _langchain_langgraph_sdk = require("@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) {
-	(0, svelte.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 = (0, svelte.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);
-	(0, svelte.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 = (0, svelte.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 require_stream_custom.useStreamCustom(options);
-	return useStreamLGP(options);
-}
-function useStreamLGP(options) {
-	const client = options.client ?? new _langchain_langgraph_sdk.Client({ apiUrl: options.apiUrl });
-	const orchestrator = new _langchain_langgraph_sdk_ui.StreamOrchestrator(options, {
-		getClient: () => client,
-		getAssistantId: () => options.assistantId,
-		getMessagesKey: () => options.messagesKey ?? "messages"
-	});
-	orchestrator.initThreadId(options.threadId ?? void 0);
-	const version = (0, svelte_store.writable)(0);
-	const reactiveSubagents = require_subagents.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 = (0, svelte_store.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 = (0, svelte_store.derived)(version, () => orchestrator.isLoading).subscribe(() => {
-		orchestrator.drainQueue();
-	});
-	let { shouldReconnect } = orchestrator;
-	(0, svelte.onMount)(() => {
-		if (shouldReconnect) {
-			if (orchestrator.tryReconnect()) shouldReconnect = false;
-		}
-	});
-	(0, svelte.onDestroy)(() => {
-		fetchController?.abort();
-		unsubscribe();
-		unsubReconstruct();
-		unsubDrain();
-		orchestrator.dispose();
-	});
-	const valuesStore = (0, svelte_store.derived)(version, () => {
-		orchestrator.trackStreamMode("values");
-		return orchestrator.values;
-	});
-	const errorStore = (0, svelte_store.derived)(version, () => orchestrator.error);
-	const isLoadingStore = (0, svelte_store.derived)(version, () => orchestrator.isLoading);
-	const branchStore = (0, svelte_store.derived)(version, () => orchestrator.branch);
-	const messagesStore = (0, svelte_store.derived)(version, () => {
-		orchestrator.trackStreamMode("messages-tuple", "values");
-		return (0, _langchain_langgraph_sdk_ui.ensureMessageInstances)(orchestrator.messages);
-	});
-	const toolCallsStore = (0, svelte_store.derived)(version, () => {
-		orchestrator.trackStreamMode("messages-tuple", "values");
-		return orchestrator.toolCalls;
-	});
-	const interruptStore = (0, svelte_store.derived)(version, () => orchestrator.interrupt);
-	const interruptsStore = (0, svelte_store.derived)(version, () => orchestrator.interrupts);
-	const historyListStore = (0, svelte_store.derived)(version, () => orchestrator.flatHistory);
-	const isThreadLoadingStore = (0, svelte_store.derived)(version, () => orchestrator.isThreadLoading);
-	const experimentalBranchTreeStore = (0, svelte_store.derived)(version, () => orchestrator.experimental_branchTree);
-	const subagentsStore = (0, svelte_store.derived)(version, () => {
-		orchestrator.trackStreamMode("updates", "messages-tuple");
-		return reactiveSubagents.mapSubagents(orchestrator.subagents);
-	});
-	const activeSubagentsStore = (0, svelte_store.derived)(version, () => {
-		orchestrator.trackStreamMode("updates", "messages-tuple");
-		return reactiveSubagents.mapActiveSubagents(orchestrator.activeSubagents);
-	});
-	const queueEntriesStore = (0, svelte_store.derived)(version, () => orchestrator.queueEntries);
-	const queueSizeStore = (0, svelte_store.derived)(version, () => orchestrator.queueSize);
-	const valuesRef = (0, svelte_store.fromStore)(valuesStore);
-	const errorRef = (0, svelte_store.fromStore)(errorStore);
-	const isLoadingRef = (0, svelte_store.fromStore)(isLoadingStore);
-	const branchRef = (0, svelte_store.fromStore)(branchStore);
-	const messagesRef = (0, svelte_store.fromStore)(messagesStore);
-	const toolCallsRef = (0, svelte_store.fromStore)(toolCallsStore);
-	const interruptRef = (0, svelte_store.fromStore)(interruptStore);
-	const interruptsRef = (0, svelte_store.fromStore)(interruptsStore);
-	const historyListRef = (0, svelte_store.fromStore)(historyListStore);
-	const isThreadLoadingRef = (0, svelte_store.fromStore)(isThreadLoadingStore);
-	const experimentalBranchTreeRef = (0, svelte_store.fromStore)(experimentalBranchTreeStore);
-	const subagentsRef = (0, svelte_store.fromStore)(subagentsStore);
-	const activeSubagentsRef = (0, svelte_store.fromStore)(activeSubagentsStore);
-	const queueEntriesRef = (0, svelte_store.fromStore)(queueEntriesStore);
-	const queueSizeRef = (0, svelte_store.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
-exports.FetchStreamTransport = _langchain_langgraph_sdk_ui.FetchStreamTransport;
-Object.defineProperty(exports, "SubagentManager", {
+let _langchain_langgraph_sdk_stream = require("@langchain/langgraph-sdk/stream");
+Object.defineProperty(exports, "HttpAgentServerAdapter", {
 	enumerable: true,
 	get: function() {
-		return _langchain_langgraph_sdk_ui.SubagentManager;
+		return _langchain_langgraph_sdk.HttpAgentServerAdapter;
 	}
 });
-Object.defineProperty(exports, "calculateDepthFromNamespace", {
+Object.defineProperty(exports, "MediaAssemblyError", {
 	enumerable: true,
 	get: function() {
-		return _langchain_langgraph_sdk_ui.calculateDepthFromNamespace;
+		return _langchain_langgraph_sdk_stream.MediaAssemblyError;
 	}
 });
+exports.STREAM_CONTEXT_KEY = require_context.STREAM_CONTEXT_KEY;
+exports.STREAM_CONTROLLER = require_use_stream_svelte.STREAM_CONTROLLER;
 Object.defineProperty(exports, "executeHeadlessTool", {
 	enumerable: true,
 	get: function() {
 		return _langchain_langgraph_sdk.executeHeadlessTool;
 	}
 });
-Object.defineProperty(exports, "extractParentIdFromNamespace", {
-	enumerable: true,
-	get: function() {
-		return _langchain_langgraph_sdk_ui.extractParentIdFromNamespace;
-	}
-});
-Object.defineProperty(exports, "extractToolCallIdFromNamespace", {
-	enumerable: true,
-	get: function() {
-		return _langchain_langgraph_sdk_ui.extractToolCallIdFromNamespace;
-	}
-});
 Object.defineProperty(exports, "filterOutHeadlessToolInterrupts", {
 	enumerable: true,
 	get: function() {
@@ -335,8 +46,7 @@ Object.defineProperty(exports, "flushPendingHeadlessToolInterrupts", {
 		return _langchain_langgraph_sdk.flushPendingHeadlessToolInterrupts;
 	}
 });
-exports.getStream = getStream;
-exports.getStreamContext = getStreamContext;
+exports.getStream = require_context.getStream;
 Object.defineProperty(exports, "handleHeadlessToolInterrupt", {
 	enumerable: true,
 	get: function() {
@@ -355,20 +65,26 @@ Object.defineProperty(exports, "isHeadlessToolInterrupt", {
 		return _langchain_langgraph_sdk.isHeadlessToolInterrupt;
 	}
 });
-Object.defineProperty(exports, "isSubagentNamespace", {
-	enumerable: true,
-	get: function() {
-		return _langchain_langgraph_sdk_ui.isSubagentNamespace;
-	}
-});
 Object.defineProperty(exports, "parseHeadlessToolInterruptPayload", {
 	enumerable: true,
 	get: function() {
 		return _langchain_langgraph_sdk.parseHeadlessToolInterruptPayload;
 	}
 });
-exports.provideStream = provideStream;
-exports.setStreamContext = setStreamContext;
-exports.useStream = useStream;
-
-//# sourceMappingURL=index.cjs.map
+exports.provideStream = require_context.provideStream;
+exports.useAudio = require_selectors_svelte.useAudio;
+exports.useAudioPlayer = require_use_audio_player_svelte.useAudioPlayer;
+exports.useChannel = require_selectors_svelte.useChannel;
+exports.useExtension = require_selectors_svelte.useExtension;
+exports.useFiles = require_selectors_svelte.useFiles;
+exports.useImages = require_selectors_svelte.useImages;
+exports.useMediaURL = require_use_media_url_svelte.useMediaURL;
+exports.useMessageMetadata = require_selectors_svelte.useMessageMetadata;
+exports.useMessages = require_selectors_svelte.useMessages;
+exports.useProjection = require_use_projection_svelte.useProjection;
+exports.useStream = require_use_stream_svelte.useStream;
+exports.useSubmissionQueue = require_selectors_svelte.useSubmissionQueue;
+exports.useToolCalls = require_selectors_svelte.useToolCalls;
+exports.useValues = require_selectors_svelte.useValues;
+exports.useVideo = require_selectors_svelte.useVideo;
+exports.useVideoPlayer = require_use_video_player_svelte.useVideoPlayer;

package/dist/index.d.cts

@@ -1,97 +1,11 @@
-import { AIMessage, ToolMessage } from "@langchain/core/messages";
-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";
-
-//#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.cts.map
+import { AgentServerOptions, AnyStream, CustomAdapterOptions, STREAM_CONTROLLER, StateOf, 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 { 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 };