@langchain/svelte 0.2.0 → 0.3.1

package/dist/index.cjs

@@ -1,11 +1,9 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_stream_custom = require("./stream.custom.cjs");
-const require_context = require("./context.cjs");
 let svelte_store = require("svelte/store");
 let svelte = require("svelte");
 let _langchain_langgraph_sdk_ui = require("@langchain/langgraph-sdk/ui");
 let _langchain_langgraph_sdk = require("@langchain/langgraph-sdk");
-let _langchain_langgraph_sdk_utils = require("@langchain/langgraph-sdk/utils");
 //#region src/index.ts
 const STREAM_CONTEXT_KEY = Symbol.for("langchain:stream-context");
 /**
@@ -31,8 +29,8 @@ function setStreamContext(stream) {
 }
 /**
 * Retrieves the `useStream` instance previously provided by a parent
-* component via {@link setStreamContext}. Must be called during component
-* initialisation.
+* 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.
 *
@@ -50,436 +48,154 @@ function getStreamContext() {
 	if (!ctx) throw new Error("getStreamContext must be used within a component that has called setStreamContext");
 	return ctx;
 }
-function fetchHistory(client, threadId, options) {
-	if (options?.limit === false) return client.threads.getState(threadId).then((state) => {
-		if (state.checkpoint == null) return [];
-		return [state];
-	});
-	const limit = typeof options?.limit === "number" ? options.limit : 10;
-	return client.threads.getHistory(threadId, { limit });
+/**
+* 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 runMetadataStorage = (() => {
-		if (typeof window === "undefined") return null;
-		const storage = options.reconnectOnMount;
-		if (storage === true) return window.sessionStorage;
-		if (typeof storage === "function") return storage();
-		return null;
-	})();
-	const getMessages = (value) => {
-		const messagesKey = options.messagesKey ?? "messages";
-		return Array.isArray(value[messagesKey]) ? value[messagesKey] : [];
-	};
-	const setMessages = (current, messages) => {
-		const messagesKey = options.messagesKey ?? "messages";
-		return {
-			...current,
-			[messagesKey]: messages
-		};
-	};
-	const historyLimit = typeof options.fetchStateHistory === "object" && options.fetchStateHistory != null ? options.fetchStateHistory.limit ?? false : options.fetchStateHistory ?? false;
-	const threadId = (0, svelte_store.writable)(void 0);
-	let threadIdPromise = null;
 	const client = options.client ?? new _langchain_langgraph_sdk.Client({ apiUrl: options.apiUrl });
-	const history = (0, svelte_store.writable)({
-		data: void 0,
-		error: void 0,
-		isLoading: false,
-		mutate: async () => void 0
-	});
-	async function mutate(mutateId) {
-		const tid = mutateId ?? (0, svelte_store.get)(threadId);
-		if (!tid) return void 0;
-		try {
-			const data = await fetchHistory(client, tid, { limit: historyLimit });
-			history.set({
-				data,
-				error: void 0,
-				isLoading: false,
-				mutate
-			});
-			return data;
-		} catch (err) {
-			history.update((prev) => ({
-				...prev,
-				error: err,
-				isLoading: false
-			}));
-			options.onError?.(err, void 0);
-			return;
-		}
-	}
-	history.update((prev) => ({
-		...prev,
-		mutate
-	}));
-	const branch = (0, svelte_store.writable)("");
-	const branchContext = (0, svelte_store.derived)([branch, history], ([$branch, $history]) => (0, _langchain_langgraph_sdk_ui.getBranchContext)($branch, $history.data ?? void 0));
-	const messageManager = new _langchain_langgraph_sdk_ui.MessageTupleManager();
-	const stream = new _langchain_langgraph_sdk_ui.StreamManager(messageManager, {
-		throttle: options.throttle ?? false,
-		subagentToolNames: options.subagentToolNames,
-		filterSubagentMessages: options.filterSubagentMessages,
-		toMessage: _langchain_langgraph_sdk_ui.toMessageClass
-	});
-	const pendingRuns = new _langchain_langgraph_sdk_ui.PendingRunsTracker();
-	const historyValues = (0, svelte_store.derived)([branchContext], ([$branchContext]) => $branchContext.threadHead?.values ?? options.initialValues ?? {});
-	const historyError = (0, svelte_store.derived)([branchContext], ([$branchContext]) => {
-		const error = $branchContext.threadHead?.tasks?.at(-1)?.error;
-		if (error == null) return void 0;
-		try {
-			const parsed = JSON.parse(error);
-			if (_langchain_langgraph_sdk_ui.StreamError.isStructuredError(parsed)) return new _langchain_langgraph_sdk_ui.StreamError(parsed);
-			return parsed;
-		} catch {}
-		return error;
-	});
-	const streamValues = (0, svelte_store.writable)(stream.values);
-	const streamError = (0, svelte_store.writable)(stream.error);
-	const isLoading = (0, svelte_store.writable)(stream.isLoading);
-	const queueEntries = (0, svelte_store.writable)(pendingRuns.entries);
-	const queueSize = (0, svelte_store.writable)(pendingRuns.size);
-	const values = (0, svelte_store.derived)([streamValues, historyValues], ([$streamValues, $historyValues]) => $streamValues ?? $historyValues);
-	const error = (0, svelte_store.derived)([
-		streamError,
-		historyError,
-		history
-	], ([$streamError, $historyError, $history]) => $streamError ?? $historyError ?? $history.error);
-	const messageMetadata = (0, svelte_store.derived)([history, branchContext], ([$history, $branchContext]) => (0, _langchain_langgraph_sdk_ui.getMessagesMetadataMap)({
-		initialValues: options.initialValues,
-		history: $history.data,
-		getMessages,
-		branchContext: $branchContext
-	}));
-	const subagentVersion = (0, svelte_store.writable)(0);
-	const unsubscribe = stream.subscribe(() => {
-		streamValues.set(stream.values);
-		streamError.set(stream.error);
-		isLoading.set(stream.isLoading);
-		subagentVersion.update((v) => v + 1);
-	});
-	const unsubQueue = pendingRuns.subscribe(() => {
-		queueEntries.set(pendingRuns.entries);
-		queueSize.set(pendingRuns.size);
+	const orchestrator = new _langchain_langgraph_sdk_ui.StreamOrchestrator(options, {
+		getClient: () => client,
+		getAssistantId: () => options.assistantId,
+		getMessagesKey: () => options.messagesKey ?? "messages"
 	});
-	const shouldReconstructSubagents = (0, svelte_store.derived)([isLoading, history], ([$isLoading, $history]) => {
-		if (!options.filterSubagentMessages) return false;
-		if ($isLoading || $history.isLoading) return false;
-		return getMessages((0, svelte_store.get)(historyValues)).length > 0;
+	orchestrator.initThreadId(options.threadId ?? void 0);
+	const version = (0, svelte_store.writable)(0);
+	const unsubscribe = orchestrator.subscribe(() => {
+		version.update((v) => v + 1);
 	});
 	let fetchController = null;
-	const unsubReconstruct = shouldReconstructSubagents.subscribe(($should) => {
+	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) {
-			const hvMessages = getMessages((0, svelte_store.get)(historyValues));
-			stream.reconstructSubagents(hvMessages, { skipIfPopulated: true });
 			fetchController?.abort();
-			fetchController = new AbortController();
-			const tid = (0, svelte_store.get)(threadId);
-			if (tid) stream.fetchSubagentHistory(client.threads, tid, {
-				messagesKey: options.messagesKey ?? "messages",
-				signal: fetchController.signal
-			});
+			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();
-		unsubQueue();
-	});
-	function stop() {
-		return stream.stop((0, svelte_store.get)(historyValues), { onStop: (args) => {
-			const tid = (0, svelte_store.get)(threadId);
-			if (runMetadataStorage && tid) {
-				const runId = runMetadataStorage.getItem(`lg:stream:${tid}`);
-				if (runId) client.runs.cancel(tid, runId);
-				runMetadataStorage.removeItem(`lg:stream:${tid}`);
-			}
-			options.onStop?.(args);
-		} });
-	}
-	function setBranch(value) {
-		branch.set(value);
-	}
-	function submitDirect(values, submitOptions) {
-		const currentBranchContext = (0, svelte_store.get)(branchContext);
-		const checkpointId = submitOptions?.checkpoint?.checkpoint_id;
-		branch.set(checkpointId != null ? currentBranchContext.branchByCheckpoint[checkpointId]?.branch ?? "" : "");
-		const includeImplicitBranch = historyLimit === true || typeof historyLimit === "number";
-		const shouldRefetch = options.onFinish != null || includeImplicitBranch;
-		let checkpoint = submitOptions?.checkpoint ?? (includeImplicitBranch ? currentBranchContext.threadHead?.checkpoint : void 0) ?? void 0;
-		if (submitOptions?.checkpoint === null) checkpoint = void 0;
-		if (checkpoint != null) delete checkpoint.thread_id;
-		let callbackMeta;
-		let rejoinKey;
-		let usableThreadId;
-		return stream.start(async (signal) => {
-			usableThreadId = (0, svelte_store.get)(threadId);
-			if (!usableThreadId) {
-				const threadPromise = client.threads.create({
-					threadId: submitOptions?.threadId,
-					metadata: submitOptions?.metadata
-				});
-				threadIdPromise = threadPromise.then((t) => t.thread_id);
-				usableThreadId = (await threadPromise).thread_id;
-				threadId.set(usableThreadId);
-				options.onThreadId?.(usableThreadId);
-			}
-			const streamMode = [
-				"values",
-				"messages-tuple",
-				"updates",
-				...submitOptions?.streamMode ?? []
-			];
-			if (options.onUpdateEvent && !streamMode.includes("updates")) streamMode.push("updates");
-			if (options.onCustomEvent && !streamMode.includes("custom")) streamMode.push("custom");
-			if (options.onCheckpointEvent && !streamMode.includes("checkpoints")) streamMode.push("checkpoints");
-			if (options.onTaskEvent && !streamMode.includes("tasks")) streamMode.push("tasks");
-			if ("onDebugEvent" in options && options.onDebugEvent && !streamMode.includes("debug")) streamMode.push("debug");
-			if ("onLangChainEvent" in options && options.onLangChainEvent && !streamMode.includes("events")) streamMode.push("events");
-			stream.setStreamValues(() => {
-				const prev = {
-					...(0, svelte_store.get)(historyValues),
-					...stream.values
-				};
-				if (submitOptions?.optimisticValues != null) return {
-					...prev,
-					...typeof submitOptions.optimisticValues === "function" ? submitOptions.optimisticValues(prev) : submitOptions.optimisticValues
-				};
-				return { ...prev };
-			});
-			const streamResumable = submitOptions?.streamResumable ?? !!runMetadataStorage;
-			return client.runs.stream(usableThreadId, options.assistantId, {
-				input: values,
-				config: submitOptions?.config,
-				context: submitOptions?.context,
-				command: submitOptions?.command,
-				interruptBefore: submitOptions?.interruptBefore,
-				interruptAfter: submitOptions?.interruptAfter,
-				metadata: submitOptions?.metadata,
-				multitaskStrategy: submitOptions?.multitaskStrategy,
-				onCompletion: submitOptions?.onCompletion,
-				onDisconnect: submitOptions?.onDisconnect ?? (streamResumable ? "continue" : "cancel"),
-				signal,
-				checkpoint,
-				streamMode,
-				streamSubgraphs: submitOptions?.streamSubgraphs,
-				streamResumable,
-				durability: submitOptions?.durability,
-				onRunCreated(params) {
-					callbackMeta = {
-						run_id: params.run_id,
-						thread_id: params.thread_id ?? usableThreadId
-					};
-					if (runMetadataStorage) {
-						rejoinKey = `lg:stream:${usableThreadId}`;
-						runMetadataStorage.setItem(rejoinKey, callbackMeta.run_id);
-					}
-					options.onCreated?.(callbackMeta);
-				}
-			});
-		}, {
-			getMessages,
-			setMessages,
-			initialValues: (0, svelte_store.get)(historyValues),
-			callbacks: options,
-			async onSuccess() {
-				if (rejoinKey) runMetadataStorage?.removeItem(rejoinKey);
-				if (shouldRefetch && usableThreadId) {
-					const lastHead = (await mutate(usableThreadId))?.at(0);
-					if (lastHead) {
-						options.onFinish?.(lastHead, callbackMeta);
-						return null;
-					}
-				}
-			},
-			onError(error) {
-				options.onError?.(error, callbackMeta);
-				submitOptions?.onError?.(error, callbackMeta);
-			},
-			onFinish: () => {}
-		});
-	}
-	let submitting = false;
-	function drainQueue() {
-		if (!(0, svelte_store.get)(isLoading) && !submitting && pendingRuns.size > 0) {
-			const next = pendingRuns.shift();
-			if (next) {
-				submitting = true;
-				joinStream(next.id).finally(() => {
-					submitting = false;
-					drainQueue();
-				});
-			}
-		}
-	}
-	isLoading.subscribe(() => {
-		drainQueue();
+		unsubDrain();
+		orchestrator.dispose();
 	});
-	async function submit(values, submitOptions) {
-		if (stream.isLoading || submitting) {
-			if (submitOptions?.multitaskStrategy === "interrupt" || submitOptions?.multitaskStrategy === "rollback") {
-				submitting = true;
-				try {
-					await submitDirect(values, submitOptions);
-				} finally {
-					submitting = false;
-				}
-				return;
-			}
-			let usableThreadId = (0, svelte_store.get)(threadId);
-			if (!usableThreadId && threadIdPromise) usableThreadId = await threadIdPromise;
-			if (usableThreadId) {
-				try {
-					const run = await client.runs.create(usableThreadId, options.assistantId, {
-						input: values,
-						config: submitOptions?.config,
-						context: submitOptions?.context,
-						command: submitOptions?.command,
-						interruptBefore: submitOptions?.interruptBefore,
-						interruptAfter: submitOptions?.interruptAfter,
-						metadata: submitOptions?.metadata,
-						multitaskStrategy: "enqueue",
-						streamResumable: true,
-						streamSubgraphs: submitOptions?.streamSubgraphs,
-						durability: submitOptions?.durability
-					});
-					pendingRuns.add({
-						id: run.run_id,
-						values,
-						options: submitOptions,
-						createdAt: new Date(run.created_at)
-					});
-				} catch (error) {
-					options.onError?.(error, void 0);
-					submitOptions?.onError?.(error, void 0);
-				}
-				return;
-			}
-		}
-		submitting = true;
-		const result = submitDirect(values, submitOptions);
-		Promise.resolve(result).finally(() => {
-			submitting = false;
-			drainQueue();
-		});
-		return result;
-	}
-	async function joinStream(runId, lastEventId, joinOptions) {
-		lastEventId ??= "-1";
-		const tid = (0, svelte_store.get)(threadId);
-		if (!tid) return;
-		const callbackMeta = {
-			thread_id: tid,
-			run_id: runId
-		};
-		await stream.start(async (signal) => {
-			const rawStream = client.runs.joinStream(tid, runId, {
-				signal,
-				lastEventId,
-				streamMode: joinOptions?.streamMode
-			});
-			return joinOptions?.filter != null ? (0, _langchain_langgraph_sdk_ui.filterStream)(rawStream, joinOptions.filter) : rawStream;
-		}, {
-			getMessages,
-			setMessages,
-			initialValues: (0, svelte_store.get)(historyValues),
-			callbacks: options,
-			async onSuccess() {
-				runMetadataStorage?.removeItem(`lg:stream:${tid}`);
-				const lastHead = (await mutate(tid))?.at(0);
-				if (lastHead) options.onFinish?.(lastHead, callbackMeta);
-			},
-			onError(error) {
-				options.onError?.(error, callbackMeta);
-			},
-			onFinish: () => {}
-		});
-	}
-	let shouldReconnect = !!runMetadataStorage;
-	(0, svelte.onMount)(() => {
-		const tid = (0, svelte_store.get)(threadId);
-		if (shouldReconnect && runMetadataStorage && tid) {
-			const runId = runMetadataStorage.getItem(`lg:stream:${tid}`);
-			if (runId) {
-				shouldReconnect = false;
-				joinStream(runId);
-			}
-		}
+	const valuesStore = (0, svelte_store.derived)(version, () => {
+		orchestrator.trackStreamMode("values");
+		return orchestrator.values;
 	});
-	const messages = (0, svelte_store.derived)([streamValues, historyValues], ([$streamValues, $historyValues]) => (0, _langchain_langgraph_sdk_ui.ensureMessageInstances)(getMessages($streamValues ?? $historyValues)));
-	const interrupt = (0, svelte_store.derived)([
-		streamValues,
-		streamError,
-		branchContext,
-		isLoading
-	], ([$streamValues, $streamError, $branchContext, $isLoading]) => {
-		return (0, _langchain_langgraph_sdk_ui.extractInterrupts)($streamValues, {
-			isLoading: $isLoading,
-			threadState: $branchContext.threadHead,
-			error: $streamError
-		});
+	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 interrupts = (0, svelte_store.derived)([
-		streamValues,
-		streamError,
-		branchContext,
-		isLoading
-	], ([$streamValues, $streamError, $branchContext, $isLoading]) => {
-		const vals = $streamValues ?? (0, svelte_store.get)(historyValues);
-		if (vals != null && "__interrupt__" in vals && Array.isArray(vals.__interrupt__)) {
-			const valueInterrupts = vals.__interrupt__;
-			if (valueInterrupts.length === 0) return [{ when: "breakpoint" }];
-			return valueInterrupts;
-		}
-		if ($isLoading) return [];
-		const allInterrupts = ($branchContext.threadHead?.tasks ?? []).flatMap((t) => t.interrupts ?? []);
-		if (allInterrupts.length > 0) return allInterrupts;
-		if (!($branchContext.threadHead?.next ?? []).length || $streamError != null) return [];
-		return [{ when: "breakpoint" }];
+	const toolCallsStore = (0, svelte_store.derived)(version, () => {
+		orchestrator.trackStreamMode("messages-tuple", "values");
+		return orchestrator.toolCalls;
 	});
-	const toolCalls = (0, svelte_store.derived)([streamValues, historyValues], ([$streamValues, $historyValues]) => (0, _langchain_langgraph_sdk_utils.getToolCallsWithResults)(getMessages($streamValues ?? $historyValues)));
-	function getToolCalls(message) {
-		return (0, _langchain_langgraph_sdk_utils.getToolCallsWithResults)(getMessages((0, svelte_store.get)(streamValues) ?? (0, svelte_store.get)(historyValues))).filter((tc) => tc.aiMessage.id === message.id);
-	}
-	const historyList = (0, svelte_store.derived)([branchContext], ([$branchContext]) => {
-		if (historyLimit === false) throw new Error("`fetchStateHistory` must be set to `true` to use `history`");
-		return (0, _langchain_langgraph_sdk_ui.ensureHistoryMessageInstances)($branchContext.flatHistory, options.messagesKey ?? "messages");
+	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 orchestrator.subagents;
 	});
-	const isThreadLoading = (0, svelte_store.derived)([history], ([$history]) => $history.isLoading && $history.data == null);
-	const experimentalBranchTree = (0, svelte_store.derived)([branchContext], ([$branchContext]) => {
-		if (historyLimit === false) throw new Error("`fetchStateHistory` must be set to `true` to use `experimental_branchTree`");
-		return $branchContext.branchTree;
+	const activeSubagentsStore = (0, svelte_store.derived)(version, () => {
+		orchestrator.trackStreamMode("updates", "messages-tuple");
+		return orchestrator.activeSubagents;
 	});
-	function getMessagesMetadata(message, index) {
-		const streamMetadata = messageManager.get(message.id)?.metadata;
-		const historyMetadata = (0, svelte_store.get)(messageMetadata)?.find((m) => m.messageId === (message.id ?? index));
-		if (streamMetadata != null || historyMetadata != null) return {
-			...historyMetadata,
-			streamMetadata
-		};
-	}
-	const subagentsStore = (0, svelte_store.derived)(subagentVersion, () => stream.getSubagents());
-	const activeSubagentsStore = (0, svelte_store.derived)(subagentVersion, () => stream.getActiveSubagents());
-	const valuesRef = (0, svelte_store.fromStore)(values);
-	const errorRef = (0, svelte_store.fromStore)(error);
-	const isLoadingRef = (0, svelte_store.fromStore)(isLoading);
-	const isThreadLoadingRef = (0, svelte_store.fromStore)(isThreadLoading);
-	const branchRef = (0, svelte_store.fromStore)(branch);
-	const messagesRef = (0, svelte_store.fromStore)(messages);
-	const toolCallsRef = (0, svelte_store.fromStore)(toolCalls);
-	const interruptRef = (0, svelte_store.fromStore)(interrupt);
-	const interruptsRef = (0, svelte_store.fromStore)(interrupts);
-	const historyListRef = (0, svelte_store.fromStore)(historyList);
-	const experimentalBranchTreeRef = (0, svelte_store.fromStore)(experimentalBranchTree);
+	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)(queueEntries);
-	const queueSizeRef = (0, svelte_store.fromStore)(queueSize);
+	const queueEntriesRef = (0, svelte_store.fromStore)(queueEntriesStore);
+	const queueSizeRef = (0, svelte_store.fromStore)(queueSizeStore);
 	return {
 		assistantId: options.assistantId,
 		client,
@@ -498,14 +214,18 @@ function useStreamLGP(options) {
 		get branch() {
 			return branchRef.current;
 		},
-		setBranch,
+		setBranch(value) {
+			orchestrator.setBranch(value);
+		},
 		get messages() {
 			return messagesRef.current;
 		},
 		get toolCalls() {
 			return toolCallsRef.current;
 		},
-		getToolCalls,
+		getToolCalls(message) {
+			return orchestrator.getToolCalls(message);
+		},
 		get interrupt() {
 			return interruptRef.current;
 		},
@@ -518,10 +238,12 @@ function useStreamLGP(options) {
 		get experimental_branchTree() {
 			return experimentalBranchTreeRef.current;
 		},
-		getMessagesMetadata,
-		submit,
-		stop,
-		joinStream,
+		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;
@@ -529,27 +251,11 @@ function useStreamLGP(options) {
 			get size() {
 				return queueSizeRef.current;
 			},
-			async cancel(id) {
-				const tid = (0, svelte_store.get)(threadId);
-				const removed = pendingRuns.remove(id);
-				if (removed && tid) await client.runs.cancel(tid, id);
-				return removed;
-			},
-			async clear() {
-				const tid = (0, svelte_store.get)(threadId);
-				const removed = pendingRuns.removeAll();
-				if (tid && removed.length > 0) await Promise.all(removed.map((e) => client.runs.cancel(tid, e.id)));
-			}
+			cancel: (id) => orchestrator.cancelQueueItem(id),
+			clear: () => orchestrator.clearQueue()
 		},
 		switchThread(newThreadId) {
-			if (newThreadId !== ((0, svelte_store.get)(threadId) ?? null)) {
-				const prevThreadId = (0, svelte_store.get)(threadId);
-				threadId.set(newThreadId ?? void 0);
-				stream.clear();
-				const removed = pendingRuns.removeAll();
-				if (prevThreadId && removed.length > 0) Promise.all(removed.map((e) => client.runs.cancel(prevThreadId, e.id)));
-				if (newThreadId != null) options.onThreadId?.(newThreadId);
-			}
+			orchestrator.switchThread(newThreadId);
 		},
 		get subagents() {
 			return subagentsRef.current;
@@ -558,13 +264,13 @@ function useStreamLGP(options) {
 			return activeSubagentsRef.current;
 		},
 		getSubagent(toolCallId) {
-			return stream.getSubagent(toolCallId);
+			return orchestrator.getSubagent(toolCallId);
 		},
 		getSubagentsByType(type) {
-			return stream.getSubagentsByType(type);
+			return orchestrator.getSubagentsByType(type);
 		},
 		getSubagentsByMessage(messageId) {
-			return stream.getSubagentsByMessage(messageId);
+			return orchestrator.getSubagentsByMessage(messageId);
 		}
 	};
 }
@@ -594,7 +300,7 @@ Object.defineProperty(exports, "extractToolCallIdFromNamespace", {
 		return _langchain_langgraph_sdk_ui.extractToolCallIdFromNamespace;
 	}
 });
-exports.getStream = require_context.getStream;
+exports.getStream = getStream;
 exports.getStreamContext = getStreamContext;
 Object.defineProperty(exports, "isSubagentNamespace", {
 	enumerable: true,
@@ -602,7 +308,7 @@ Object.defineProperty(exports, "isSubagentNamespace", {
 		return _langchain_langgraph_sdk_ui.isSubagentNamespace;
 	}
 });
-exports.provideStream = require_context.provideStream;
+exports.provideStream = provideStream;
 exports.setStreamContext = setStreamContext;
 exports.useStream = useStream;