@langchain/svelte 0.2.0 → 0.3.1

package/dist/index.js

@@ -1,10 +1,8 @@
 import { useStreamCustom } from "./stream.custom.js";
-import { getStream, provideStream } from "./context.js";
-import { derived, fromStore, get, writable } from "svelte/store";
+import { derived, fromStore, writable } from "svelte/store";
 import { getContext, onDestroy, onMount, setContext } from "svelte";
-import { FetchStreamTransport, MessageTupleManager, PendingRunsTracker, StreamError, StreamManager, SubagentManager, calculateDepthFromNamespace, ensureHistoryMessageInstances, ensureMessageInstances, extractInterrupts, extractParentIdFromNamespace, extractToolCallIdFromNamespace, filterStream, getBranchContext, getMessagesMetadataMap, isSubagentNamespace, toMessageClass } from "@langchain/langgraph-sdk/ui";
+import { FetchStreamTransport, StreamOrchestrator, SubagentManager, calculateDepthFromNamespace, ensureMessageInstances, extractParentIdFromNamespace, extractToolCallIdFromNamespace, isSubagentNamespace } from "@langchain/langgraph-sdk/ui";
 import { Client } from "@langchain/langgraph-sdk";
-import { getToolCallsWithResults } from "@langchain/langgraph-sdk/utils";
 //#region src/index.ts
 const STREAM_CONTEXT_KEY = Symbol.for("langchain:stream-context");
 /**
@@ -30,8 +28,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.
 *
@@ -49,436 +47,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);
+	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 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 = writable(void 0);
-	let threadIdPromise = null;
 	const client = options.client ?? new Client({ apiUrl: options.apiUrl });
-	const history = writable({
-		data: void 0,
-		error: void 0,
-		isLoading: false,
-		mutate: async () => void 0
-	});
-	async function mutate(mutateId) {
-		const tid = mutateId ?? 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 = writable("");
-	const branchContext = derived([branch, history], ([$branch, $history]) => getBranchContext($branch, $history.data ?? void 0));
-	const messageManager = new MessageTupleManager();
-	const stream = new StreamManager(messageManager, {
-		throttle: options.throttle ?? false,
-		subagentToolNames: options.subagentToolNames,
-		filterSubagentMessages: options.filterSubagentMessages,
-		toMessage: toMessageClass
-	});
-	const pendingRuns = new PendingRunsTracker();
-	const historyValues = derived([branchContext], ([$branchContext]) => $branchContext.threadHead?.values ?? options.initialValues ?? {});
-	const historyError = derived([branchContext], ([$branchContext]) => {
-		const error = $branchContext.threadHead?.tasks?.at(-1)?.error;
-		if (error == null) return void 0;
-		try {
-			const parsed = JSON.parse(error);
-			if (StreamError.isStructuredError(parsed)) return new StreamError(parsed);
-			return parsed;
-		} catch {}
-		return error;
-	});
-	const streamValues = writable(stream.values);
-	const streamError = writable(stream.error);
-	const isLoading = writable(stream.isLoading);
-	const queueEntries = writable(pendingRuns.entries);
-	const queueSize = writable(pendingRuns.size);
-	const values = derived([streamValues, historyValues], ([$streamValues, $historyValues]) => $streamValues ?? $historyValues);
-	const error = derived([
-		streamError,
-		historyError,
-		history
-	], ([$streamError, $historyError, $history]) => $streamError ?? $historyError ?? $history.error);
-	const messageMetadata = derived([history, branchContext], ([$history, $branchContext]) => getMessagesMetadataMap({
-		initialValues: options.initialValues,
-		history: $history.data,
-		getMessages,
-		branchContext: $branchContext
-	}));
-	const subagentVersion = 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 StreamOrchestrator(options, {
+		getClient: () => client,
+		getAssistantId: () => options.assistantId,
+		getMessagesKey: () => options.messagesKey ?? "messages"
 	});
-	const shouldReconstructSubagents = derived([isLoading, history], ([$isLoading, $history]) => {
-		if (!options.filterSubagentMessages) return false;
-		if ($isLoading || $history.isLoading) return false;
-		return getMessages(get(historyValues)).length > 0;
+	orchestrator.initThreadId(options.threadId ?? void 0);
+	const version = writable(0);
+	const unsubscribe = orchestrator.subscribe(() => {
+		version.update((v) => v + 1);
 	});
 	let fetchController = null;
-	const unsubReconstruct = shouldReconstructSubagents.subscribe(($should) => {
+	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) {
-			const hvMessages = getMessages(get(historyValues));
-			stream.reconstructSubagents(hvMessages, { skipIfPopulated: true });
 			fetchController?.abort();
-			fetchController = new AbortController();
-			const tid = get(threadId);
-			if (tid) stream.fetchSubagentHistory(client.threads, tid, {
-				messagesKey: options.messagesKey ?? "messages",
-				signal: fetchController.signal
-			});
+			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();
-		unsubQueue();
+		unsubDrain();
+		orchestrator.dispose();
 	});
-	function stop() {
-		return stream.stop(get(historyValues), { onStop: (args) => {
-			const tid = 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 = 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 = 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 = {
-					...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: 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 (!get(isLoading) && !submitting && pendingRuns.size > 0) {
-			const next = pendingRuns.shift();
-			if (next) {
-				submitting = true;
-				joinStream(next.id).finally(() => {
-					submitting = false;
-					drainQueue();
-				});
-			}
-		}
-	}
-	isLoading.subscribe(() => {
-		drainQueue();
+	const valuesStore = derived(version, () => {
+		orchestrator.trackStreamMode("values");
+		return orchestrator.values;
 	});
-	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 = 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 = 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 ? filterStream(rawStream, joinOptions.filter) : rawStream;
-		}, {
-			getMessages,
-			setMessages,
-			initialValues: 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;
-	onMount(() => {
-		const tid = get(threadId);
-		if (shouldReconnect && runMetadataStorage && tid) {
-			const runId = runMetadataStorage.getItem(`lg:stream:${tid}`);
-			if (runId) {
-				shouldReconnect = false;
-				joinStream(runId);
-			}
-		}
+	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 messages = derived([streamValues, historyValues], ([$streamValues, $historyValues]) => ensureMessageInstances(getMessages($streamValues ?? $historyValues)));
-	const interrupt = derived([
-		streamValues,
-		streamError,
-		branchContext,
-		isLoading
-	], ([$streamValues, $streamError, $branchContext, $isLoading]) => {
-		return extractInterrupts($streamValues, {
-			isLoading: $isLoading,
-			threadState: $branchContext.threadHead,
-			error: $streamError
-		});
+	const toolCallsStore = derived(version, () => {
+		orchestrator.trackStreamMode("messages-tuple", "values");
+		return orchestrator.toolCalls;
 	});
-	const interrupts = derived([
-		streamValues,
-		streamError,
-		branchContext,
-		isLoading
-	], ([$streamValues, $streamError, $branchContext, $isLoading]) => {
-		const vals = $streamValues ?? 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 toolCalls = derived([streamValues, historyValues], ([$streamValues, $historyValues]) => getToolCallsWithResults(getMessages($streamValues ?? $historyValues)));
-	function getToolCalls(message) {
-		return getToolCallsWithResults(getMessages(get(streamValues) ?? get(historyValues))).filter((tc) => tc.aiMessage.id === message.id);
-	}
-	const historyList = derived([branchContext], ([$branchContext]) => {
-		if (historyLimit === false) throw new Error("`fetchStateHistory` must be set to `true` to use `history`");
-		return ensureHistoryMessageInstances($branchContext.flatHistory, options.messagesKey ?? "messages");
+	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 orchestrator.subagents;
 	});
-	const isThreadLoading = derived([history], ([$history]) => $history.isLoading && $history.data == null);
-	const experimentalBranchTree = derived([branchContext], ([$branchContext]) => {
-		if (historyLimit === false) throw new Error("`fetchStateHistory` must be set to `true` to use `experimental_branchTree`");
-		return $branchContext.branchTree;
+	const activeSubagentsStore = derived(version, () => {
+		orchestrator.trackStreamMode("updates", "messages-tuple");
+		return orchestrator.activeSubagents;
 	});
-	function getMessagesMetadata(message, index) {
-		const streamMetadata = messageManager.get(message.id)?.metadata;
-		const historyMetadata = get(messageMetadata)?.find((m) => m.messageId === (message.id ?? index));
-		if (streamMetadata != null || historyMetadata != null) return {
-			...historyMetadata,
-			streamMetadata
-		};
-	}
-	const subagentsStore = derived(subagentVersion, () => stream.getSubagents());
-	const activeSubagentsStore = derived(subagentVersion, () => stream.getActiveSubagents());
-	const valuesRef = fromStore(values);
-	const errorRef = fromStore(error);
-	const isLoadingRef = fromStore(isLoading);
-	const isThreadLoadingRef = fromStore(isThreadLoading);
-	const branchRef = fromStore(branch);
-	const messagesRef = fromStore(messages);
-	const toolCallsRef = fromStore(toolCalls);
-	const interruptRef = fromStore(interrupt);
-	const interruptsRef = fromStore(interrupts);
-	const historyListRef = fromStore(historyList);
-	const experimentalBranchTreeRef = fromStore(experimentalBranchTree);
+	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(queueEntries);
-	const queueSizeRef = fromStore(queueSize);
+	const queueEntriesRef = fromStore(queueEntriesStore);
+	const queueSizeRef = fromStore(queueSizeStore);
 	return {
 		assistantId: options.assistantId,
 		client,
@@ -497,14 +213,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;
 		},
@@ -517,10 +237,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;
@@ -528,27 +250,11 @@ function useStreamLGP(options) {
 			get size() {
 				return queueSizeRef.current;
 			},
-			async cancel(id) {
-				const tid = get(threadId);
-				const removed = pendingRuns.remove(id);
-				if (removed && tid) await client.runs.cancel(tid, id);
-				return removed;
-			},
-			async clear() {
-				const tid = 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 !== (get(threadId) ?? null)) {
-				const prevThreadId = 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;
@@ -557,13 +263,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);
 		}
 	};
 }