@assistant-ui/core 0.3.15 → 0.3.17

package/dist/react/client/RemoteThreadList.js

@@ -1,29 +1,20 @@
-import { generateId } from "../../utils/id.js";
 import { OptimisticState } from "../../runtimes/remote-thread-list/optimistic-state.js";
-import { classifyThreads, createThreadMappingId, getThreadData, normalizeCursor, updateStatusReducer } from "../../runtimes/remote-thread-list/remote-thread-state.js";
+import { classifyThreads, createEmptyRemoteThreadState, createThreadMappingId, getThreadData, normalizeCursor, preserveMidLoadTransitions, seedNewThread, statusSnapshot, updateStatusReducer } from "../../runtimes/remote-thread-list/remote-thread-state.js";
 import { handleThreadListAction } from "../../store/runtime-clients/handle-thread-list-action.js";
 import { useThreadSelectionEvents } from "../../store/clients/thread-selection-events.js";
 import { isDevelopment } from "../../store/env.js";
 import { inMemoryThreadListTransformScopes } from "./InMemoryThreadList.js";
 import { ThreadListAdapterChangedError } from "../../runtimes/remote-thread-list/adapter-changed.js";
 import { AdaptedRemoteThread } from "./AdaptedRemoteThread.js";
+import { isTitleSourceMessage } from "../../runtimes/remote-thread-list/title.js";
+import { Derived, attachTransformScopes, useAssistantContextProvider, useAssistantContextValue, useClientLookup, useClientResource, useConfiguredAui } from "@assistant-ui/store/client";
 import { AssistantMessageStream } from "assistant-stream";
 import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
-import { useCallback, useEffect, useMemo, useState, useSyncExternalStore } from "@assistant-ui/tap/react-shim";
+import { useCallback, useEffect, useMemo, useRef, useState, useSyncExternalStore } from "@assistant-ui/tap/react-shim";
 import { resource, withKey } from "@assistant-ui/tap";
-import { attachTransformScopes, useClientLookup, useClientResource } from "@assistant-ui/store/client";
 //#region src/react/client/RemoteThreadList.ts
 const RESOLVED_PROMISE = Promise.resolve();
-const EMPTY_LIST = {
-	isLoading: true,
-	isLoadingMore: false,
-	cursor: void 0,
-	newThreadId: void 0,
-	threadIds: [],
-	archivedThreadIds: [],
-	threadIdMap: {},
-	threadData: {}
-};
+const EMPTY_LIST = createEmptyRemoteThreadState();
 const threadNotFoundError = (threadIdOrRemoteId, action) => /* @__PURE__ */ new Error(`Thread "${threadIdOrRemoteId}" was not found while ${action}.`);
 const threadStatusError = (threadIdOrRemoteId, status, action) => /* @__PURE__ */ new Error(`Thread "${threadIdOrRemoteId}" has status "${status}", so it cannot ${action}.`);
 const toInitializeResult = (result) => ({
@@ -32,36 +23,7 @@ const toInitializeResult = (result) => ({
 });
 const applyTitleStream = async (stream, onTitle) => {
 	const messageStream = AssistantMessageStream.fromAssistantStream(stream);
-	for await (const result of messageStream) onTitle(result.parts.filter((part) => part.type === "text")[0]?.text);
-};
-const seedNewThread = (state) => {
-	let id;
-	do
-		id = `__LOCALID_${generateId()}`;
-	while (state.threadIdMap[id]);
-	const mappingId = createThreadMappingId(id);
-	return {
-		id,
-		state: {
-			...state,
-			newThreadId: id,
-			threadIdMap: {
-				...state.threadIdMap,
-				[id]: mappingId
-			},
-			threadData: {
-				...state.threadData,
-				[mappingId]: {
-					status: "new",
-					id,
-					remoteId: void 0,
-					externalId: void 0,
-					title: void 0,
-					custom: void 0
-				}
-			}
-		}
-	};
+	for await (const result of messageStream) await onTitle(result.parts.filter((part) => part.type === "text")[0]?.text);
 };
 const useThreadListItemClient = (props) => {
 	const $ = c(22);
@@ -154,98 +116,175 @@ const isSameThread = (listState, left, right) => {
 	const data = getThreadData(listState, left);
 	return data !== void 0 && itemMatchesId(data, listState, right);
 };
+const useRemoteThreadBody = ({ id, status, remoteId, item, thread }) => {
+	const parent = useAssistantContextValue();
+	const [isRunning, setIsRunning] = useState(false);
+	const itemHandle = useClientResource(item(isRunning));
+	const { client } = useConfiguredAui(parent, { threadListItem: Derived({
+		source: "threads",
+		query: {
+			type: "id",
+			id
+		},
+		get: () => itemHandle.methods
+	}) });
+	const bornNewRef = useRef(status === "new");
+	const titleFiredRef = useRef(false);
+	return useAssistantContextProvider(client, function useBoundRemoteBody() {
+		const body = useClientResource(thread);
+		const bodyRunning = body.state.isRunning === true;
+		useEffect(() => {
+			setIsRunning(bodyRunning);
+		}, [bodyRunning]);
+		const hasTitleSource = bornNewRef.current && !titleFiredRef.current && remoteId !== void 0 && body.state.messages.some(isTitleSourceMessage);
+		useEffect(() => {
+			if (!hasTitleSource || titleFiredRef.current) return;
+			titleFiredRef.current = true;
+			client.threadListItem.generateTitle();
+		}, [hasTitleSource]);
+		return body.methods;
+	});
+};
+const RemoteThreadBody = resource(useRemoteThreadBody);
+const useMainThreadFacade = (current) => {
+	const currentRef = useRef(current);
+	useEffect(() => {
+		currentRef.current = current;
+	}, [current]);
+	const [facade] = useState(() => new Proxy({}, {
+		get: (_, prop) => currentRef.current[prop],
+		has: (__0, prop_0) => prop_0 in currentRef.current,
+		ownKeys: () => Reflect.ownKeys(currentRef.current),
+		getOwnPropertyDescriptor: (__1, prop_1) => Reflect.getOwnPropertyDescriptor(currentRef.current, prop_1)
+	}));
+	return facade;
+};
 const useRemoteThreadListView = (t0) => {
-	const $ = c(39);
-	const { listState, mainThreadId, threadFactory, useAdapters, onSwitchTo, onRename, onUpdateCustom, onArchive, onUnarchive, onDelete, onGenerateTitle, onInitialize, onDetach } = t0;
+	const $ = c(21);
+	const { listState, mainThreadId, startedIds, backgroundThreads, threadFactory, useAdapters, onSwitchTo, onRename, onUpdateCustom, onArchive, onUnarchive, onDelete, onGenerateTitle, onInitialize, onDetach } = t0;
 	let t1;
-	let t2;
-	if ($[0] !== mainThreadId || $[1] !== threadFactory || $[2] !== useAdapters) {
-		const thread = threadFactory(mainThreadId);
+	bb0: {
+		if (!backgroundThreads) {
+			let t2;
+			if ($[0] !== mainThreadId) {
+				t2 = [mainThreadId];
+				$[0] = mainThreadId;
+				$[1] = t2;
+			} else t2 = $[1];
+			t1 = t2;
+			break bb0;
+		}
+		let ids;
+		if ($[2] !== listState || $[3] !== startedIds) {
+			const seen = /* @__PURE__ */ new Set();
+			const seenRemoteIds = /* @__PURE__ */ new Set();
+			ids = [];
+			for (const id of startedIds) {
+				const data = getThreadData(listState, id);
+				if (!data || seen.has(data.id)) continue;
+				if (data.remoteId !== void 0 && seenRemoteIds.has(data.remoteId)) continue;
+				seen.add(data.id);
+				if (data.remoteId !== void 0) seenRemoteIds.add(data.remoteId);
+				ids.push(data.id);
+			}
+			$[2] = listState;
+			$[3] = startedIds;
+			$[4] = ids;
+		} else ids = $[4];
+		t1 = ids;
+	}
+	const bodyIds = t1;
+	const itemElementFor = (data_0, isRunning) => ThreadListItemClient({
+		data: data_0,
+		isRunning,
+		onSwitchTo: (options) => handleThreadListAction("switch", () => onSwitchTo(data_0.id, options)),
+		onRename: (title) => handleThreadListAction("rename", () => onRename(data_0.id, title)),
+		onUpdateCustom: (custom) => handleThreadListAction("update custom metadata", () => onUpdateCustom(data_0.id, custom)),
+		onArchive: () => handleThreadListAction("archive", () => onArchive(data_0.id)),
+		onUnarchive: () => handleThreadListAction("unarchive", () => onUnarchive(data_0.id)),
+		onDelete: () => handleThreadListAction("delete", () => onDelete(data_0.id)),
+		onGenerateTitle: () => handleThreadListAction("generate title", () => onGenerateTitle(data_0.id, backgroundThreads ? bodyStateOf(data_0.id)?.messages : mainThreadClient.state.messages)),
+		onInitialize: () => onInitialize(data_0.id),
+		onDetach: () => handleThreadListAction("detach", () => onDetach(data_0.id))
+	});
+	const bodies = useClientLookup(bodyIds.map((id_0) => {
+		const made = threadFactory(id_0);
+		const thread = backgroundThreads && made.key === void 0 ? withKey(id_0, made) : made;
 		const wrapped = useAdapters === void 0 ? thread : AdaptedRemoteThread({
 			useAdapters,
 			thread
 		});
-		t1 = useClientResource;
-		t2 = thread.key === void 0 ? wrapped : withKey(thread.key, wrapped);
-		$[0] = mainThreadId;
-		$[1] = threadFactory;
-		$[2] = useAdapters;
-		$[3] = t1;
-		$[4] = t2;
-	} else {
-		t1 = $[3];
-		t2 = $[4];
-	}
-	const mainThreadClient = t1(t2);
+		const data_1 = getThreadData(listState, id_0);
+		const element = backgroundThreads && data_1 !== void 0 ? RemoteThreadBody({
+			id: id_0,
+			status: data_1.status,
+			remoteId: data_1.remoteId,
+			item: (isRunning_0) => itemElementFor(data_1, isRunning_0),
+			thread: wrapped
+		}) : wrapped;
+		return withKey(backgroundThreads ? id_0 : made.key ?? "main", element);
+	}));
+	let t2;
+	if ($[5] !== bodyIds || $[6] !== listState) {
+		t2 = (id_1) => {
+			const direct = bodyIds.indexOf(id_1);
+			if (direct !== -1) return direct;
+			return bodyIds.findIndex((bodyId) => isSameThread(listState, bodyId, id_1));
+		};
+		$[5] = bodyIds;
+		$[6] = listState;
+		$[7] = t2;
+	} else t2 = $[7];
+	const bodyIndexOf = t2;
+	const bodyStateOf = (id_2) => {
+		const index = bodyIndexOf(id_2);
+		return index === -1 ? void 0 : bodies.state[index];
+	};
 	let t3;
-	if ($[5] !== listState || $[6] !== mainThreadId) {
-		t3 = collectItemOrder(listState, mainThreadId);
-		$[5] = listState;
-		$[6] = mainThreadId;
-		$[7] = t3;
-	} else t3 = $[7];
-	const itemOrder = t3;
 	let t4;
-	if ($[8] !== itemOrder || $[9] !== listState || $[10] !== mainThreadClient || $[11] !== mainThreadId || $[12] !== onArchive || $[13] !== onDelete || $[14] !== onDetach || $[15] !== onGenerateTitle || $[16] !== onInitialize || $[17] !== onRename || $[18] !== onSwitchTo || $[19] !== onUnarchive || $[20] !== onUpdateCustom) {
-		let t5;
-		if ($[22] !== listState || $[23] !== mainThreadClient || $[24] !== mainThreadId || $[25] !== onArchive || $[26] !== onDelete || $[27] !== onDetach || $[28] !== onGenerateTitle || $[29] !== onInitialize || $[30] !== onRename || $[31] !== onSwitchTo || $[32] !== onUnarchive || $[33] !== onUpdateCustom) {
-			t5 = (data) => withKey(data.id, ThreadListItemClient({
-				data,
-				isRunning: itemMatchesId(data, listState, mainThreadId) && mainThreadClient.state.isRunning,
-				onSwitchTo: (options) => handleThreadListAction("switch", () => onSwitchTo(data.id, options)),
-				onRename: (title) => handleThreadListAction("rename", () => onRename(data.id, title)),
-				onUpdateCustom: (custom) => handleThreadListAction("update custom metadata", () => onUpdateCustom(data.id, custom)),
-				onArchive: () => handleThreadListAction("archive", () => onArchive(data.id)),
-				onUnarchive: () => handleThreadListAction("unarchive", () => onUnarchive(data.id)),
-				onDelete: () => handleThreadListAction("delete", () => onDelete(data.id)),
-				onGenerateTitle: () => handleThreadListAction("generate title", () => onGenerateTitle(data.id, mainThreadClient.state.messages)),
-				onInitialize: () => onInitialize(data.id),
-				onDetach: () => handleThreadListAction("detach", () => onDetach(data.id))
-			}));
-			$[22] = listState;
-			$[23] = mainThreadClient;
-			$[24] = mainThreadId;
-			$[25] = onArchive;
-			$[26] = onDelete;
-			$[27] = onDetach;
-			$[28] = onGenerateTitle;
-			$[29] = onInitialize;
-			$[30] = onRename;
-			$[31] = onSwitchTo;
-			$[32] = onUnarchive;
-			$[33] = onUpdateCustom;
-			$[34] = t5;
-		} else t5 = $[34];
-		t4 = itemOrder.map(t5);
-		$[8] = itemOrder;
-		$[9] = listState;
-		$[10] = mainThreadClient;
-		$[11] = mainThreadId;
-		$[12] = onArchive;
-		$[13] = onDelete;
-		$[14] = onDetach;
-		$[15] = onGenerateTitle;
-		$[16] = onInitialize;
-		$[17] = onRename;
-		$[18] = onSwitchTo;
-		$[19] = onUnarchive;
-		$[20] = onUpdateCustom;
-		$[21] = t4;
-	} else t4 = $[21];
-	const threadListItems = useClientLookup(t4);
 	let t5;
-	if ($[35] !== itemOrder || $[36] !== mainThreadClient || $[37] !== threadListItems) {
-		t5 = {
+	if ($[8] !== bodies || $[9] !== bodyIndexOf || $[10] !== mainThreadId) {
+		const mainIndex = bodyIndexOf(mainThreadId);
+		t5 = bodies.state[mainIndex];
+		t3 = useMainThreadFacade;
+		t4 = bodies.get({ index: mainIndex });
+		$[8] = bodies;
+		$[9] = bodyIndexOf;
+		$[10] = mainThreadId;
+		$[11] = t3;
+		$[12] = t4;
+		$[13] = t5;
+	} else {
+		t3 = $[11];
+		t4 = $[12];
+		t5 = $[13];
+	}
+	const mainThreadClient = {
+		state: t5,
+		methods: t3(t4)
+	};
+	let t6;
+	if ($[14] !== listState || $[15] !== mainThreadId) {
+		t6 = collectItemOrder(listState, mainThreadId);
+		$[14] = listState;
+		$[15] = mainThreadId;
+		$[16] = t6;
+	} else t6 = $[16];
+	const itemOrder = t6;
+	const threadListItems = useClientLookup(itemOrder.map((data_2) => withKey(data_2.id, itemElementFor(data_2, backgroundThreads ? bodyStateOf(data_2.id)?.isRunning ?? false : itemMatchesId(data_2, listState, mainThreadId) && mainThreadClient.state.isRunning))));
+	let t7;
+	if ($[17] !== itemOrder || $[18] !== mainThreadClient || $[19] !== threadListItems) {
+		t7 = {
 			mainThreadClient,
 			itemOrder,
 			threadListItems
 		};
-		$[35] = itemOrder;
-		$[36] = mainThreadClient;
-		$[37] = threadListItems;
-		$[38] = t5;
-	} else t5 = $[38];
-	return t5;
+		$[17] = itemOrder;
+		$[18] = mainThreadClient;
+		$[19] = threadListItems;
+		$[20] = t7;
+	} else t7 = $[20];
+	return t7;
 };
 const useRemoteThreadList = (props) => {
 	const { adapter, thread: threadFactory, threadId, onThreadIdChange, onSwitchToThread, onSwitchToNewThread, onDelete } = props;
@@ -273,12 +312,14 @@ const useRemoteThreadList = (props) => {
 			}
 		};
 	});
-	session.adapter = adapter;
 	const listState = useSyncExternalStore((onStoreChange) => store.subscribe(onStoreChange), () => store.value, () => store.value);
 	const [mainThreadId, setMainThreadId] = useState(initialMainId);
+	const [startedIds, setStartedIds] = useState([initialMainId]);
+	const [backgroundThreads] = useState(props.backgroundThreads === true);
 	const assignMainThreadId = useCallback((id) => {
 		session.mainThreadId = id;
 		setMainThreadId(id);
+		setStartedIds((prev) => prev.includes(id) ? prev : [...prev, id]);
 	}, [session]);
 	useThreadSelectionEvents(mainThreadId);
 	useEffect(() => {
@@ -304,36 +345,35 @@ const useRemoteThreadList = (props) => {
 		if (session.loadPromise) return session.loadPromise;
 		const generation = session.loadGeneration;
 		const adapter_0 = session.adapter;
+		const statusAtRequest = statusSnapshot(store.baseValue);
 		session.loadPromise = store.optimisticUpdate({
 			execute: () => adapter_0.list(),
-			loading: (state) => ({
-				...state,
-				isLoading: true
-			}),
+			loading: (state) => {
+				if (generation !== session.loadGeneration) return state;
+				return {
+					...state,
+					isLoading: true
+				};
+			},
 			then: (state_0, page) => {
 				if (generation !== session.loadGeneration) return state_0;
 				session.adapterAtLoad = adapter_0;
 				const fresh = classifyThreads(page.threads, {
 					threadIds: [],
 					archivedThreadIds: [],
-					threadIdMap: {},
-					threadData: {}
+					threadIdMap: { ...state_0.threadIdMap },
+					threadData: { ...state_0.threadData }
 				});
-				return {
+				const merged = {
 					...state_0,
 					isLoading: false,
 					cursor: normalizeCursor(page.nextCursor),
 					threadIds: fresh.threadIds,
 					archivedThreadIds: fresh.archivedThreadIds,
-					threadIdMap: {
-						...state_0.threadIdMap,
-						...fresh.threadIdMap
-					},
-					threadData: {
-						...state_0.threadData,
-						...fresh.threadData
-					}
+					threadIdMap: fresh.threadIdMap,
+					threadData: fresh.threadData
 				};
+				return preserveMidLoadTransitions(merged, state_0, statusAtRequest);
 			}
 		}).catch((error) => {
 			if (generation !== session.loadGeneration) return;
@@ -362,6 +402,7 @@ const useRemoteThreadList = (props) => {
 				isLoading: true
 			});
 			assignMainThreadId(seeded_0.id);
+			setStartedIds([seeded_0.id]);
 			notifyRemoteId(void 0, true);
 		} else store.update({
 			...store.baseValue,
@@ -394,10 +435,13 @@ const useRemoteThreadList = (props) => {
 		const currentAdapter = session.adapter;
 		const task = store.optimisticUpdate({
 			execute: () => currentAdapter.list({ after: cursor }),
-			loading: (state_1) => ({
-				...state_1,
-				isLoadingMore: true
-			}),
+			loading: (state_1) => {
+				if (generation_0 !== session.loadGeneration) return state_1;
+				return {
+					...state_1,
+					isLoadingMore: true
+				};
+			},
 			then: (state_2, page_0) => {
 				if (generation_0 !== session.loadGeneration) return state_2;
 				const appended = classifyThreads(page_0.threads, {
@@ -477,21 +521,27 @@ const useRemoteThreadList = (props) => {
 		}
 		if (!data) throw threadNotFoundError(threadIdOrRemoteId, "switching to it");
 		if (isSameThread(store.value, data.id, session.mainThreadId)) return;
-		if (data.status === "archived" && options?.unarchive !== false) {
-			const current = data;
+		const targetId = data.id;
+		let current = data;
+		if (current.status === "archived" && options?.unarchive !== false) {
 			const { remoteId: remoteId_0 } = await current.initializeTask;
 			if (generation_2 !== session.switchGeneration) return;
-			await store.optimisticUpdate({
-				execute: () => session.adapter.unarchive(remoteId_0),
-				optimistic: (state_4) => updateStatusReducer(state_4, current.id, "regular")
-			});
-			if (generation_2 !== session.switchGeneration) return;
-			data = getThreadData(store.value, current.id) ?? current;
+			current = getThreadData(store.value, targetId);
+			if (current?.id !== targetId) return;
+			if (current.status === "archived") {
+				await store.optimisticUpdate({
+					execute: () => session.adapter.unarchive(remoteId_0),
+					optimistic: (state_4) => updateStatusReducer(state_4, targetId, "regular")
+				});
+				if (generation_2 !== session.switchGeneration) return;
+				current = getThreadData(store.value, targetId);
+				if (current?.id !== targetId) return;
+			}
 		}
 		if (generation_2 !== session.switchGeneration) return;
-		assignMainThreadId(data.id);
-		notifyRemoteId(data.remoteId, emitThreadIdChange);
-		session.onSwitchToThread?.(data.id);
+		assignMainThreadId(current.id);
+		notifyRemoteId(current.remoteId, emitThreadIdChange);
+		session.onSwitchToThread?.(current.id);
 	}), [
 		assignMainThreadId,
 		notifyRemoteId,
@@ -583,24 +633,29 @@ const useRemoteThreadList = (props) => {
 				const data_1 = getThreadData(state_7, threadId_1);
 				if (!data_1) return state_7;
 				const mappingId_1 = createThreadMappingId(threadId_1);
+				const listedMappingId = state_7.threadIdMap[remoteId_1];
+				const orphan = listedMappingId !== void 0 && listedMappingId !== mappingId_1 ? state_7.threadData[listedMappingId] : void 0;
+				const threadData = { ...state_7.threadData };
+				if (orphan !== void 0) delete threadData[listedMappingId];
+				threadData[mappingId_1] = {
+					...data_1,
+					initializeTask: Promise.resolve({
+						remoteId: remoteId_1,
+						externalId
+					}),
+					remoteId: remoteId_1,
+					externalId
+				};
+				const rewire = (ids) => orphan === void 0 ? ids : ids.filter((id_2) => id_2 !== orphan.id);
 				return {
 					...state_7,
+					threadIds: rewire(state_7.threadIds),
+					archivedThreadIds: rewire(state_7.archivedThreadIds),
 					threadIdMap: {
 						...state_7.threadIdMap,
 						[remoteId_1]: mappingId_1
 					},
-					threadData: {
-						...state_7.threadData,
-						[mappingId_1]: {
-							...data_1,
-							initializeTask: Promise.resolve({
-								remoteId: remoteId_1,
-								externalId
-							}),
-							remoteId: remoteId_1,
-							externalId
-						}
-					}
+					threadData
 				};
 			}
 		});
@@ -758,45 +813,56 @@ const useRemoteThreadList = (props) => {
 		if (data_7.status === "new") throw threadStatusError(threadIdOrRemoteId_5, data_7.status, "generate a title");
 		const { remoteId: remoteId_7 } = await data_7.initializeTask;
 		requireAdapterGeneration(adapterGeneration_5);
-		if (!isSameThread(store.value, data_7.id, session.mainThreadId)) return;
+		if (!backgroundThreads && !isSameThread(store.value, data_7.id, session.mainThreadId)) return;
 		if (!messages) return;
 		const stream = await currentAdapter_6.generateTitle(remoteId_7, messages);
 		requireAdapterGeneration(adapterGeneration_5);
-		await applyTitleStream(stream, (newTitle_0) => {
-			if (adapterGeneration_5 !== session.adapterGeneration) return;
-			const state_13 = store.baseValue;
-			const current_2 = getThreadData(state_13, data_7.id);
-			if (!current_2) return;
-			store.update({
-				...state_13,
-				threadData: {
-					...state_13.threadData,
-					[current_2.id]: {
-						...current_2,
-						title: newTitle_0
-					}
+		await applyTitleStream(stream, async (newTitle_0) => {
+			await store.optimisticUpdate({
+				execute: async () => {},
+				optimistic: (state_13) => {
+					if (adapterGeneration_5 !== session.adapterGeneration) return state_13;
+					const current_2 = getThreadData(state_13, data_7.id);
+					if (!current_2) return state_13;
+					return {
+						...state_13,
+						threadData: {
+							...state_13.threadData,
+							[current_2.id]: {
+								...current_2,
+								title: newTitle_0
+							}
+						}
+					};
 				}
 			});
 		});
 	}, [
+		backgroundThreads,
 		requireAdapterGeneration,
 		session,
 		store
 	]);
+	const detach = useCallback(async (threadId_2) => {
+		await ensureNotMain(threadId_2);
+		setStartedIds((prev_0) => prev_0.filter((id_3) => id_3 !== threadId_2));
+	}, [ensureNotMain]);
 	const { mainThreadClient, itemOrder, threadListItems } = useRemoteThreadListView({
 		listState,
 		mainThreadId,
+		startedIds,
+		backgroundThreads,
 		threadFactory,
 		useAdapters: adapter.unstable_useAdapters,
-		onSwitchTo: (id_2, options_0) => switchToThread(id_2, options_0),
-		onRename: (id_3, title) => rename(id_3, title),
-		onUpdateCustom: (id_4, custom_0) => updateCustom(id_4, custom_0),
-		onArchive: (id_5) => archive(id_5),
-		onUnarchive: (id_6) => unarchive(id_6),
-		onDelete: (id_7) => deleteThread(id_7),
-		onGenerateTitle: (id_8, messages_0) => generateTitle(id_8, messages_0),
-		onInitialize: async (id_9) => toInitializeResult(await initialize(id_9)),
-		onDetach: (id_10) => ensureNotMain(id_10)
+		onSwitchTo: (id_4, options_0) => switchToThread(id_4, options_0),
+		onRename: (id_5, title) => rename(id_5, title),
+		onUpdateCustom: (id_6, custom_0) => updateCustom(id_6, custom_0),
+		onArchive: (id_7) => archive(id_7),
+		onUnarchive: (id_8) => unarchive(id_8),
+		onDelete: (id_9) => deleteThread(id_9),
+		onGenerateTitle: (id_10, messages_0) => generateTitle(id_10, messages_0),
+		onInitialize: async (id_11) => toInitializeResult(await initialize(id_11)),
+		onDetach: (id_12) => detach(id_12)
 	});
 	const mainRemoteId = getThreadData(listState, mainThreadId)?.remoteId;
 	useEffect(() => {
@@ -852,8 +918,8 @@ const useRemoteThreadList = (props) => {
 	]);
 	return {
 		getState: () => state_14,
-		switchToThread: (id_11, options_1) => {
-			handleThreadListAction("switch", () => switchToThread(id_11, options_1));
+		switchToThread: (id_13, options_1) => {
+			handleThreadListAction("switch", () => switchToThread(id_13, options_1));
 		},
 		switchToNewThread: () => {
 			handleThreadListAction("create", () => switchToNewThread());
@@ -874,9 +940,9 @@ const useRemoteThreadList = (props) => {
 				const index_0 = itemOrder.findIndex((item_0) => itemMatchesId(item_0, listState, selector.id));
 				return threadListItems.get({ index: index_0 });
 			}
-			const id_12 = (selector.archived ? listState.archivedThreadIds : listState.threadIds)[selector.index];
-			if (id_12 === void 0) return threadListItems.get({ index: -1 });
-			const index_1 = itemOrder.findIndex((item_1) => itemMatchesId(item_1, listState, id_12));
+			const id_14 = (selector.archived ? listState.archivedThreadIds : listState.threadIds)[selector.index];
+			if (id_14 === void 0) return threadListItems.get({ index: -1 });
+			const index_1 = itemOrder.findIndex((item_1) => itemMatchesId(item_1, listState, id_14));
 			return threadListItems.get({ index: index_1 });
 		},
 		thread: () => mainThreadClient.methods
@@ -889,6 +955,9 @@ const useRemoteThreadList = (props) => {
 * and attachments come from `unstable_useAdapters`. `useRemoteThreadListRuntime`
 * uses the same hook when `unstable_Provider` is omitted. Key the factory
 * with `withKey` so history reloads when the visible thread changes.
+* With `backgroundThreads`, every visited thread stays mounted: runs continue
+* across switches, per-item `isRunning` is live, and freshly initialized
+* threads title themselves.
 */
 const RemoteThreadList = resource(useRemoteThreadList);
 attachTransformScopes(useRemoteThreadList, inMemoryThreadListTransformScopes);