@langchain/vue 0.2.0 → 0.3.0

package/dist/index.cjs

@@ -3,444 +3,91 @@ const require_stream_custom = require("./stream.custom.cjs");
 const require_context = require("./context.cjs");
 let vue = require("vue");
 let _langchain_langgraph_sdk_ui = require("@langchain/langgraph-sdk/ui");
-let _langchain_langgraph_sdk_utils = require("@langchain/langgraph-sdk/utils");
 let _langchain_langgraph_sdk = require("@langchain/langgraph-sdk");
 //#region src/index.ts
-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 });
-}
 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 = (0, vue.toValue)(options.messagesKey) ?? "messages";
-		return Array.isArray(value[messagesKey]) ? value[messagesKey] : [];
-	};
-	const setMessages = (current, messages) => {
-		const messagesKey = (0, vue.toValue)(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, vue.ref)((0, vue.toValue)(options.threadId) ?? void 0);
-	let threadIdPromise = null;
-	let threadIdStreaming = null;
+	const pluginOptions = (0, vue.inject)(require_context.LANGCHAIN_OPTIONS, {});
 	const client = (0, vue.computed)(() => {
-		const c = (0, vue.toValue)(options.client);
+		const c = (0, vue.toValue)(options.client) ?? pluginOptions.client;
 		if (c) return c;
 		return new _langchain_langgraph_sdk.Client({
-			apiUrl: (0, vue.toValue)(options.apiUrl),
-			apiKey: (0, vue.toValue)(options.apiKey),
+			apiUrl: (0, vue.toValue)(options.apiUrl) ?? pluginOptions.apiUrl,
+			apiKey: (0, vue.toValue)(options.apiKey) ?? pluginOptions.apiKey,
 			callerOptions: (0, vue.toValue)(options.callerOptions),
 			defaultHeaders: (0, vue.toValue)(options.defaultHeaders)
 		});
 	});
-	const history = (0, vue.shallowRef)({
-		data: void 0,
-		error: void 0,
-		isLoading: false,
-		mutate: async () => void 0
-	});
-	async function mutate(mutateId) {
-		const tid = mutateId ?? threadId.value;
-		if (!tid) return void 0;
-		try {
-			const data = await fetchHistory(client.value, tid, { limit: historyLimit });
-			history.value = {
-				data,
-				error: void 0,
-				isLoading: false,
-				mutate
-			};
-			return data;
-		} catch (err) {
-			history.value = {
-				...history.value,
-				error: err,
-				isLoading: false
-			};
-			options.onError?.(err, void 0);
-			return;
-		}
-	}
-	history.value = {
-		...history.value,
-		mutate
-	};
-	const branch = (0, vue.ref)("");
-	const branchContext = (0, vue.computed)(() => (0, _langchain_langgraph_sdk_ui.getBranchContext)(branch.value, history.value.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 orchestrator = new _langchain_langgraph_sdk_ui.StreamOrchestrator(options, {
+		getClient: () => client.value,
+		getAssistantId: () => (0, vue.toValue)(options.assistantId),
+		getMessagesKey: () => (0, vue.toValue)(options.messagesKey) ?? "messages"
 	});
+	const initialThreadId = (0, vue.toValue)(options.threadId) ?? void 0;
+	orchestrator.initThreadId(initialThreadId);
 	(0, vue.watch)(() => (0, vue.toValue)(options.threadId), (newId) => {
 		const resolved = newId ?? void 0;
-		if (resolved !== threadId.value) {
-			threadId.value = resolved;
-			stream.clear();
-		}
+		orchestrator.setThreadId(resolved);
 	}, { flush: "sync" });
-	(0, vue.watch)(() => threadId.value, (newThreadId) => {
-		if (threadIdStreaming != null && threadIdStreaming === newThreadId) return;
-		if (newThreadId != null) {
-			history.value = {
-				...history.value,
-				isLoading: true
-			};
-			mutate(newThreadId);
-		} else history.value = {
-			data: void 0,
-			error: void 0,
-			isLoading: false,
-			mutate
-		};
-	}, { immediate: true });
-	const pendingRuns = new _langchain_langgraph_sdk_ui.PendingRunsTracker();
-	const queueEntries = (0, vue.shallowRef)(pendingRuns.entries);
-	const queueSize = (0, vue.ref)(pendingRuns.size);
-	const trackedStreamModes = [];
-	function trackStreamMode(...modes) {
-		for (const mode of modes) if (!trackedStreamModes.includes(mode)) trackedStreamModes.push(mode);
-	}
-	const callbackStreamModes = [];
-	if (options.onUpdateEvent) callbackStreamModes.push("updates");
-	if (options.onCustomEvent) callbackStreamModes.push("custom");
-	if (options.onCheckpointEvent) callbackStreamModes.push("checkpoints");
-	if (options.onTaskEvent) callbackStreamModes.push("tasks");
-	if ("onDebugEvent" in options && options.onDebugEvent) callbackStreamModes.push("debug");
-	if ("onLangChainEvent" in options && options.onLangChainEvent) callbackStreamModes.push("events");
-	const historyValues = (0, vue.computed)(() => branchContext.value.threadHead?.values ?? options.initialValues ?? {});
-	const historyError = (0, vue.computed)(() => {
-		const error = branchContext.value.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, vue.shallowRef)(stream.values);
-	const streamError = (0, vue.shallowRef)(stream.error);
-	const isLoading = (0, vue.shallowRef)(stream.isLoading);
-	const values = (0, vue.computed)(() => streamValues.value ?? historyValues.value);
-	const error = (0, vue.computed)(() => streamError.value ?? historyError.value ?? history.value.error);
-	const messageMetadata = (0, vue.computed)(() => (0, _langchain_langgraph_sdk_ui.getMessagesMetadataMap)({
-		initialValues: options.initialValues,
-		history: history.value.data,
-		getMessages,
-		branchContext: branchContext.value
-	}));
-	const subagentVersion = (0, vue.shallowRef)(0);
-	const unsubscribe = stream.subscribe(() => {
-		streamValues.value = stream.values;
-		streamError.value = stream.error;
-		isLoading.value = stream.isLoading;
-		subagentVersion.value += 1;
-	});
-	const unsubQueue = pendingRuns.subscribe(() => {
-		queueEntries.value = pendingRuns.entries;
-		queueSize.value = pendingRuns.size;
+	const version = (0, vue.shallowRef)(0);
+	const subagentsRef = (0, vue.shallowRef)(orchestrator.subagents);
+	const activeSubagentsRef = (0, vue.shallowRef)(orchestrator.activeSubagents);
+	const unsubscribe = orchestrator.subscribe(() => {
+		version.value += 1;
+		subagentsRef.value = orchestrator.subagents;
+		activeSubagentsRef.value = orchestrator.activeSubagents;
 	});
 	(0, vue.onScopeDispose)(() => {
 		unsubscribe();
-		unsubQueue();
-		stop();
+		orchestrator.dispose();
 	});
 	(0, vue.watch)(() => {
-		const hvMessages = getMessages(historyValues.value);
+		version.value;
+		const hvMessages = orchestrator.messages;
 		return {
-			should: options.filterSubagentMessages && !isLoading.value && !history.value.isLoading && hvMessages.length > 0,
+			should: options.filterSubagentMessages && !orchestrator.isLoading && !orchestrator.historyData.isLoading && hvMessages.length > 0,
 			len: hvMessages.length
 		};
 	}, ({ should }, _prev, onCleanup) => {
 		if (should) {
-			const hvMessages = getMessages(historyValues.value);
-			stream.reconstructSubagents(hvMessages, { skipIfPopulated: true });
-			const tid = threadId.value;
-			if (tid) {
-				const controller = new AbortController();
-				stream.fetchSubagentHistory(client.value.threads, tid, {
-					messagesKey: (0, vue.toValue)(options.messagesKey) ?? "messages",
-					signal: controller.signal
-				});
-				onCleanup(() => controller.abort());
-			}
+			const controller = orchestrator.reconstructSubagentsIfNeeded();
+			if (controller) onCleanup(() => controller.abort());
 		}
 	}, { immediate: true });
-	function stop() {
-		return stream.stop(historyValues.value, { onStop: (args) => {
-			if (runMetadataStorage && threadId.value) {
-				const runId = runMetadataStorage.getItem(`lg:stream:${threadId.value}`);
-				if (runId) client.value.runs.cancel(threadId.value, runId);
-				runMetadataStorage.removeItem(`lg:stream:${threadId.value}`);
-			}
-			options.onStop?.(args);
-		} });
-	}
-	function setBranch(value) {
-		branch.value = value;
-	}
-	async function joinStream(runId, lastEventId, joinOptions) {
-		lastEventId ??= "-1";
-		if (!threadId.value) return;
-		threadIdStreaming = threadId.value;
-		const callbackMeta = {
-			thread_id: threadId.value,
-			run_id: runId
-		};
-		await stream.start(async (signal) => {
-			const rawStream = client.value.runs.joinStream(threadId.value, runId, {
-				signal,
-				lastEventId,
-				streamMode: joinOptions?.streamMode
-			});
-			return joinOptions?.filter != null ? (0, _langchain_langgraph_sdk_ui.filterStream)(rawStream, joinOptions.filter) : rawStream;
-		}, {
-			getMessages,
-			setMessages,
-			initialValues: historyValues.value,
-			callbacks: options,
-			async onSuccess() {
-				runMetadataStorage?.removeItem(`lg:stream:${threadId.value}`);
-				const lastHead = (await mutate(threadId.value))?.at(0);
-				if (lastHead) options.onFinish?.(lastHead, callbackMeta);
-			},
-			onError(error) {
-				options.onError?.(error, callbackMeta);
-			},
-			onFinish() {
-				threadIdStreaming = null;
-			}
-		});
-	}
-	function submitDirect(values, submitOptions) {
-		const currentBranchContext = branchContext.value;
-		const checkpointId = submitOptions?.checkpoint?.checkpoint_id;
-		branch.value = 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 = threadId.value;
-			if (usableThreadId) threadIdStreaming = usableThreadId;
-			if (!usableThreadId) {
-				const threadPromise = client.value.threads.create({
-					threadId: submitOptions?.threadId,
-					metadata: submitOptions?.metadata
-				});
-				threadIdPromise = threadPromise.then((t) => t.thread_id);
-				usableThreadId = (await threadPromise).thread_id;
-				threadIdStreaming = usableThreadId;
-				threadId.value = usableThreadId;
-				options.onThreadId?.(usableThreadId);
-			}
-			const streamMode = (0, _langchain_langgraph_sdk_ui.unique)([
-				"values",
-				"updates",
-				...submitOptions?.streamMode ?? [],
-				...trackedStreamModes,
-				...callbackStreamModes
-			]);
-			stream.setStreamValues(() => {
-				const prev = {
-					...historyValues.value,
-					...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.value.runs.stream(usableThreadId, (0, vue.toValue)(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: historyValues.value,
-			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: () => {
-				threadIdStreaming = null;
-			}
-		});
-	}
-	const submitting = (0, vue.ref)(false);
-	function drainQueue() {
-		if (!isLoading.value && !submitting.value && pendingRuns.size > 0) {
-			const next = pendingRuns.shift();
-			if (next) {
-				submitting.value = true;
-				joinStream(next.id).finally(() => {
-					submitting.value = false;
-					drainQueue();
-				});
-			}
-		}
-	}
 	(0, vue.watch)(() => ({
-		loading: isLoading.value,
-		submitting: submitting.value,
-		size: pendingRuns.size
+		loading: orchestrator.isLoading,
+		size: orchestrator.queueSize,
+		v: version.value
 	}), () => {
-		drainQueue();
-	});
-	async function submit(values, submitOptions) {
-		if (stream.isLoading || submitting.value) {
-			if (submitOptions?.multitaskStrategy === "interrupt" || submitOptions?.multitaskStrategy === "rollback") {
-				submitting.value = true;
-				try {
-					await submitDirect(values, submitOptions);
-				} finally {
-					submitting.value = false;
-				}
-				return;
-			}
-			let usableThreadId = threadId.value;
-			if (!usableThreadId && threadIdPromise) usableThreadId = await threadIdPromise;
-			if (usableThreadId) {
-				try {
-					const run = await client.value.runs.create(usableThreadId, (0, vue.toValue)(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.value = true;
-		const result = submitDirect(values, submitOptions);
-		Promise.resolve(result).finally(() => {
-			submitting.value = false;
-			drainQueue();
-		});
-		return result;
-	}
-	let shouldReconnect = !!runMetadataStorage;
-	function tryReconnect() {
-		if (shouldReconnect && runMetadataStorage && threadId.value) {
-			const runId = runMetadataStorage.getItem(`lg:stream:${threadId.value}`);
-			if (runId) {
-				shouldReconnect = false;
-				joinStream(runId);
-			}
-		}
-	}
-	tryReconnect();
-	(0, vue.watch)(() => threadId.value, () => {
-		shouldReconnect = !!runMetadataStorage;
-		tryReconnect();
+		orchestrator.drainQueue();
 	});
-	const toolCalls = (0, vue.computed)(() => {
-		trackStreamMode("messages-tuple");
-		return (0, _langchain_langgraph_sdk_utils.getToolCallsWithResults)(getMessages(values.value));
+	let { shouldReconnect } = orchestrator;
+	if (shouldReconnect) orchestrator.tryReconnect();
+	(0, vue.watch)(() => {
+		version.value;
+		return orchestrator.threadId;
+	}, () => {
+		({shouldReconnect} = orchestrator);
+		if (shouldReconnect) orchestrator.tryReconnect();
 	});
-	function getToolCalls(message) {
-		trackStreamMode("messages-tuple");
-		return (0, _langchain_langgraph_sdk_utils.getToolCallsWithResults)(getMessages(values.value)).filter((tc) => tc.aiMessage.id === message.id);
-	}
-	const interrupts = (0, vue.computed)(() => {
-		const v = values.value;
-		if (v != null && "__interrupt__" in v && Array.isArray(v.__interrupt__)) {
-			const valueInterrupts = v.__interrupt__;
-			if (valueInterrupts.length === 0) return [{ when: "breakpoint" }];
-			return valueInterrupts;
-		}
-		if (isLoading.value) return [];
-		const allInterrupts = (branchContext.value.threadHead?.tasks ?? []).flatMap((t) => t.interrupts ?? []);
-		if (allInterrupts.length > 0) return allInterrupts;
-		if (!(branchContext.value.threadHead?.next ?? []).length || error.value != null) return [];
-		return [{ when: "breakpoint" }];
+	const values = (0, vue.computed)(() => {
+		version.value;
+		return orchestrator.values;
 	});
-	const flatHistory = (0, vue.computed)(() => {
-		if (historyLimit === false) throw new Error("`fetchStateHistory` must be set to `true` to use `history`");
-		return (0, _langchain_langgraph_sdk_ui.ensureHistoryMessageInstances)(branchContext.value.flatHistory, (0, vue.toValue)(options.messagesKey) ?? "messages");
+	const error = (0, vue.computed)(() => {
+		version.value;
+		return orchestrator.error;
 	});
-	const isThreadLoading = (0, vue.computed)(() => history.value.isLoading && history.value.data == null);
-	const experimentalBranchTree = (0, vue.computed)(() => {
-		if (historyLimit === false) throw new Error("`fetchStateHistory` must be set to `true` to use `experimental_branchTree`");
-		return branchContext.value.branchTree;
+	const isLoading = (0, vue.computed)(() => {
+		version.value;
+		return orchestrator.isLoading;
 	});
+	const branch = (0, vue.ref)("");
+	(0, vue.watch)(() => {
+		version.value;
+		return orchestrator.branch;
+	}, (newBranch) => {
+		if (branch.value !== newBranch) branch.value = newBranch;
+	}, { immediate: true });
 	return {
 		get assistantId() {
 			return (0, vue.toValue)(options.assistantId);
@@ -452,74 +99,77 @@ function useStreamLGP(options) {
 		error,
 		isLoading,
 		branch,
-		setBranch,
+		setBranch(value) {
+			orchestrator.setBranch(value);
+		},
 		messages: (0, vue.computed)(() => {
-			trackStreamMode("messages-tuple");
-			return (0, _langchain_langgraph_sdk_ui.ensureMessageInstances)(getMessages(streamValues.value ?? historyValues.value));
+			version.value;
+			orchestrator.trackStreamMode("messages-tuple");
+			return (0, _langchain_langgraph_sdk_ui.ensureMessageInstances)(orchestrator.messages);
+		}),
+		toolCalls: (0, vue.computed)(() => {
+			version.value;
+			return orchestrator.toolCalls;
+		}),
+		getToolCalls(message) {
+			orchestrator.trackStreamMode("messages-tuple");
+			return orchestrator.getToolCalls(message);
+		},
+		interrupt: (0, vue.computed)(() => {
+			version.value;
+			return orchestrator.interrupt;
+		}),
+		interrupts: (0, vue.computed)(() => {
+			version.value;
+			return orchestrator.interrupts;
+		}),
+		history: (0, vue.computed)(() => {
+			version.value;
+			return orchestrator.flatHistory;
+		}),
+		isThreadLoading: (0, vue.computed)(() => {
+			version.value;
+			return orchestrator.isThreadLoading;
+		}),
+		experimental_branchTree: (0, vue.computed)(() => {
+			version.value;
+			return orchestrator.experimental_branchTree;
 		}),
-		toolCalls,
-		getToolCalls,
-		interrupt: (0, vue.computed)(() => (0, _langchain_langgraph_sdk_ui.extractInterrupts)(streamValues.value, {
-			isLoading: isLoading.value,
-			threadState: branchContext.value.threadHead,
-			error: streamError.value
-		})),
-		interrupts,
-		history: flatHistory,
-		isThreadLoading,
-		experimental_branchTree: experimentalBranchTree,
 		getMessagesMetadata: (message, index) => {
-			const streamMetadata = messageManager.get(message.id)?.metadata;
-			const historyMetadata = messageMetadata.value?.find((m) => m.messageId === (message.id ?? index));
-			if (streamMetadata != null || historyMetadata != null) return {
-				...historyMetadata,
-				streamMetadata
-			};
+			return orchestrator.getMessagesMetadata(message, index);
 		},
-		submit,
-		stop,
-		joinStream,
+		submit: (...args) => orchestrator.submit(...args),
+		stop: () => orchestrator.stop(),
+		joinStream: (...args) => orchestrator.joinStream(...args),
 		queue: (0, vue.reactive)({
-			entries: queueEntries,
-			size: queueSize,
-			async cancel(id) {
-				const tid = threadId.value;
-				const removed = pendingRuns.remove(id);
-				if (removed && tid) await client.value.runs.cancel(tid, id);
-				return removed;
-			},
-			async clear() {
-				const tid = threadId.value;
-				const removed = pendingRuns.removeAll();
-				if (tid && removed.length > 0) await Promise.all(removed.map((e) => client.value.runs.cancel(tid, e.id)));
-			}
+			entries: (0, vue.computed)(() => {
+				version.value;
+				return orchestrator.queueEntries;
+			}),
+			size: (0, vue.computed)(() => {
+				version.value;
+				return orchestrator.queueSize;
+			}),
+			cancel: (id) => orchestrator.cancelQueueItem(id),
+			clear: () => orchestrator.clearQueue()
 		}),
 		switchThread(newThreadId) {
-			if (newThreadId !== (threadId.value ?? null)) {
-				const prevThreadId = threadId.value;
-				threadId.value = newThreadId ?? void 0;
-				stream.clear();
-				const removed = pendingRuns.removeAll();
-				if (prevThreadId && removed.length > 0) Promise.all(removed.map((e) => client.value.runs.cancel(prevThreadId, e.id)));
-				if (newThreadId != null) options.onThreadId?.(newThreadId);
-			}
+			orchestrator.switchThread(newThreadId);
 		},
 		get subagents() {
-			subagentVersion.value;
-			return stream.getSubagents();
+			return subagentsRef.value;
 		},
 		get activeSubagents() {
-			subagentVersion.value;
-			return stream.getActiveSubagents();
+			return activeSubagentsRef.value;
 		},
 		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);
 		}
 	};
 }