@assistant-ui/core 0.3.16 → 0.3.18

package/dist/react/client/RemoteThreadList.js

@@ -1,16 +1,17 @@
 import { OptimisticState } from "../../runtimes/remote-thread-list/optimistic-state.js";
-import { classifyThreads, createEmptyRemoteThreadState, createThreadMappingId, getThreadData, normalizeCursor, preserveMidLoadTransitions, seedNewThread, statusSnapshot, updateStatusReducer } from "../../runtimes/remote-thread-list/remote-thread-state.js";
+import { classifyThreads, createEmptyRemoteThreadState, createThreadMappingId, getThreadData, normalizeCursor, preserveMidLoadTransitions, promoteNewThreadReducer, reconcileInitializedThread, 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 { AssistantMessageStream } from "assistant-stream";
+import { applyTitleStream, isTitleSourceMessage } from "../../runtimes/remote-thread-list/title.js";
+import { clearThreadTitleState, finishThreadTitleRename, runThreadTitleGeneration, startThreadTitleRename } from "../../runtimes/remote-thread-list/title-generation.js";
+import { Derived, attachTransformScopes, useAssistantContextProvider, useAssistantContextValue, useClientLookup, useClientResource, useConfiguredAui } from "@assistant-ui/store/client";
 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 = createEmptyRemoteThreadState();
@@ -20,10 +21,6 @@ const toInitializeResult = (result) => ({
 	remoteId: result.remoteId,
 	externalId: result.externalId
 });
-const applyTitleStream = async (stream, onTitle) => {
-	const messageStream = AssistantMessageStream.fromAssistantStream(stream);
-	for await (const result of messageStream) await onTitle(result.parts.filter((part) => part.type === "text")[0]?.text);
-};
 const useThreadListItemClient = (props) => {
 	const $ = c(22);
 	const { data, isRunning, onSwitchTo, onRename, onUpdateCustom, onArchive, onUnarchive, onDelete, onGenerateTitle, onInitialize, onDetach } = props;
@@ -115,98 +112,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({ automatic: true });
+		}, [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: (options_0) => handleThreadListAction("generate title", () => onGenerateTitle(data_0.id, backgroundThreads ? bodyStateOf(data_0.id)?.messages : mainThreadClient.state.messages, options_0)),
+		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;
@@ -219,6 +293,7 @@ const useRemoteThreadList = (props) => {
 				adapter,
 				adapterAtLoad: adapter,
 				adapterGeneration: 0,
+				titleStates: /* @__PURE__ */ new Map(),
 				loadGeneration: 0,
 				switchGeneration: 0,
 				loadPromise: void 0,
@@ -234,12 +309,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(() => {
@@ -268,33 +345,32 @@ const useRemoteThreadList = (props) => {
 		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,
+					loadError: void 0
+				};
+			},
 			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 }
 				});
 				const merged = {
 					...state_0,
 					isLoading: false,
+					loadError: void 0,
 					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);
 			}
@@ -304,7 +380,8 @@ const useRemoteThreadList = (props) => {
 			session.loadPromise = void 0;
 			store.update({
 				...store.baseValue,
-				isLoading: false
+				isLoading: false,
+				loadError: error
 			});
 		}).then(() => {});
 		return session.loadPromise;
@@ -316,6 +393,7 @@ const useRemoteThreadList = (props) => {
 		session.loadMorePromise = void 0;
 		if (adapterChanged) {
 			session.adapterGeneration++;
+			session.titleStates.clear();
 			session.switchGeneration++;
 			session.switchTask = void 0;
 			session.adapterAtLoad = adapter;
@@ -325,6 +403,7 @@ const useRemoteThreadList = (props) => {
 				isLoading: true
 			});
 			assignMainThreadId(seeded_0.id);
+			setStartedIds([seeded_0.id]);
 			notifyRemoteId(void 0, true);
 		} else store.update({
 			...store.baseValue,
@@ -339,6 +418,21 @@ const useRemoteThreadList = (props) => {
 		session,
 		store
 	]);
+	useEffect(() => {
+		if (typeof window === "undefined" || typeof document === "undefined") return;
+		const retryAfterError = () => {
+			if (store.value.loadError !== void 0) getLoadThreadsPromise();
+		};
+		const retryAfterVisible = () => {
+			if (document.visibilityState === "visible") retryAfterError();
+		};
+		window.addEventListener("online", retryAfterError);
+		document.addEventListener("visibilitychange", retryAfterVisible);
+		return () => {
+			window.removeEventListener("online", retryAfterError);
+			document.removeEventListener("visibilitychange", retryAfterVisible);
+		};
+	}, [getLoadThreadsPromise, store]);
 	useEffect(() => {
 		getLoadThreadsPromise();
 	}, [getLoadThreadsPromise]);
@@ -357,10 +451,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, {
@@ -440,21 +537,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,
@@ -522,55 +625,30 @@ const useRemoteThreadList = (props) => {
 			requireAdapterGeneration(adapterGeneration);
 			return result;
 		}
+		requireAdapterGeneration(adapterGeneration);
+		const initializeTask = currentAdapter_0.initialize(threadId_1);
+		let removedMappingId;
+		let replacementMainThreadId;
 		const result_0 = await store.optimisticUpdate({
-			execute: () => {
-				requireAdapterGeneration(adapterGeneration);
-				return currentAdapter_0.initialize(threadId_1);
-			},
-			optimistic: (state_5) => updateStatusReducer(state_5, threadId_1, "regular"),
-			loading: (state_6, task_1) => {
-				const mappingId_0 = createThreadMappingId(threadId_1);
-				return {
-					...state_6,
-					threadData: {
-						...state_6.threadData,
-						[mappingId_0]: {
-							...state_6.threadData[mappingId_0],
-							initializeTask: task_1
-						}
-					}
-				};
-			},
-			then: (state_7, { remoteId: remoteId_1, externalId }) => {
-				if (adapterGeneration !== session.adapterGeneration) return state_7;
-				const data_1 = getThreadData(state_7, threadId_1);
-				if (!data_1) return state_7;
-				const mappingId_1 = createThreadMappingId(threadId_1);
-				return {
-					...state_7,
-					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
-						}
-					}
-				};
+			execute: () => initializeTask,
+			optimistic: (state_5) => promoteNewThreadReducer(state_5, threadId_1, initializeTask),
+			then: (state_6, { remoteId: remoteId_1, externalId }) => {
+				if (adapterGeneration !== session.adapterGeneration) return state_6;
+				const retainedThreadId = backgroundThreads ? threadId_1 : session.mainThreadId;
+				const reconciliation = reconcileInitializedThread(state_6, threadId_1, remoteId_1, externalId, retainedThreadId);
+				removedMappingId = reconciliation.removedMappingId;
+				if (removedMappingId === session.mainThreadId) replacementMainThreadId = reconciliation.survivorMappingId;
+				return reconciliation.state;
 			}
 		});
 		requireAdapterGeneration(adapterGeneration);
+		if (removedMappingId !== void 0) setStartedIds((prev_0) => prev_0.filter((startedId) => startedId !== removedMappingId));
+		if (replacementMainThreadId !== void 0 && session.mainThreadId === removedMappingId) assignMainThreadId(replacementMainThreadId);
 		if (threadId_1 === session.mainThreadId) notifyRemoteId(result_0.remoteId, true);
 		return toInitializeResult(result_0);
 	}, [
+		assignMainThreadId,
+		backgroundThreads,
 		notifyRemoteId,
 		requireAdapterGeneration,
 		session,
@@ -579,22 +657,23 @@ const useRemoteThreadList = (props) => {
 	const rename = useCallback((threadIdOrRemoteId_0, newTitle) => {
 		const currentAdapter_1 = session.adapter;
 		const adapterGeneration_0 = session.adapterGeneration;
-		const data_2 = getThreadData(store.value, threadIdOrRemoteId_0);
-		if (!data_2) throw threadNotFoundError(threadIdOrRemoteId_0, "renaming it");
-		if (data_2.status === "new") throw threadStatusError(threadIdOrRemoteId_0, data_2.status, "be renamed");
+		const data_1 = getThreadData(store.value, threadIdOrRemoteId_0);
+		if (!data_1) throw threadNotFoundError(threadIdOrRemoteId_0, "renaming it");
+		if (data_1.status === "new") throw threadStatusError(threadIdOrRemoteId_0, data_1.status, "be renamed");
+		const claim = startThreadTitleRename(session.titleStates, data_1.id, newTitle);
 		return store.optimisticUpdate({
 			execute: async () => {
-				const { remoteId: remoteId_2 } = await data_2.initializeTask;
+				const { remoteId: remoteId_2 } = await data_1.initializeTask;
 				requireAdapterGeneration(adapterGeneration_0);
 				return currentAdapter_1.rename(remoteId_2, newTitle);
 			},
-			optimistic: (state_8) => {
-				const current_0 = getThreadData(state_8, threadIdOrRemoteId_0);
-				if (!current_0) return state_8;
+			optimistic: (state_7) => {
+				const current_0 = getThreadData(state_7, threadIdOrRemoteId_0);
+				if (!current_0) return state_7;
 				return {
-					...state_8,
+					...state_7,
 					threadData: {
-						...state_8.threadData,
+						...state_7.threadData,
 						[current_0.id]: {
 							...current_0,
 							title: newTitle
@@ -602,6 +681,12 @@ const useRemoteThreadList = (props) => {
 					}
 				};
 			}
+		}).then((result_1) => {
+			finishThreadTitleRename(session.titleStates, data_1.id, claim, true);
+			return result_1;
+		}, (error_4) => {
+			finishThreadTitleRename(session.titleStates, data_1.id, claim, false);
+			throw error_4;
 		});
 	}, [
 		requireAdapterGeneration,
@@ -611,24 +696,24 @@ const useRemoteThreadList = (props) => {
 	const updateCustom = useCallback((threadIdOrRemoteId_1, custom) => {
 		const currentAdapter_2 = session.adapter;
 		const adapterGeneration_1 = session.adapterGeneration;
-		const data_3 = getThreadData(store.value, threadIdOrRemoteId_1);
-		if (!data_3) throw threadNotFoundError(threadIdOrRemoteId_1, "updating its custom metadata");
-		if (data_3.status === "new") throw threadStatusError(threadIdOrRemoteId_1, data_3.status, "update custom metadata");
+		const data_2 = getThreadData(store.value, threadIdOrRemoteId_1);
+		if (!data_2) throw threadNotFoundError(threadIdOrRemoteId_1, "updating its custom metadata");
+		if (data_2.status === "new") throw threadStatusError(threadIdOrRemoteId_1, data_2.status, "update custom metadata");
 		if (!currentAdapter_2.updateCustom) throw new Error("Remote thread list adapter does not support updating custom metadata");
 		return store.optimisticUpdate({
 			execute: async () => {
-				const { remoteId: remoteId_3 } = await data_3.initializeTask;
+				const { remoteId: remoteId_3 } = await data_2.initializeTask;
 				requireAdapterGeneration(adapterGeneration_1);
 				if (!currentAdapter_2.updateCustom) throw new Error("Remote thread list adapter does not support updating custom metadata");
 				return currentAdapter_2.updateCustom(remoteId_3, custom);
 			},
-			optimistic: (state_9) => {
-				const current_1 = getThreadData(state_9, threadIdOrRemoteId_1);
-				if (!current_1) return state_9;
+			optimistic: (state_8) => {
+				const current_1 = getThreadData(state_8, threadIdOrRemoteId_1);
+				if (!current_1) return state_8;
 				return {
-					...state_9,
+					...state_8,
 					threadData: {
-						...state_9.threadData,
+						...state_8.threadData,
 						[current_1.id]: {
 							...current_1,
 							custom
@@ -645,18 +730,18 @@ const useRemoteThreadList = (props) => {
 	const archive = useCallback(async (threadIdOrRemoteId_2) => {
 		const currentAdapter_3 = session.adapter;
 		const adapterGeneration_2 = session.adapterGeneration;
-		const data_4 = getThreadData(store.value, threadIdOrRemoteId_2);
-		if (!data_4) throw threadNotFoundError(threadIdOrRemoteId_2, "archiving it");
-		if (data_4.status !== "regular") throw threadStatusError(threadIdOrRemoteId_2, data_4.status, "be archived");
-		await ensureNotMain(data_4.id);
+		const data_3 = getThreadData(store.value, threadIdOrRemoteId_2);
+		if (!data_3) throw threadNotFoundError(threadIdOrRemoteId_2, "archiving it");
+		if (data_3.status !== "regular") throw threadStatusError(threadIdOrRemoteId_2, data_3.status, "be archived");
+		await ensureNotMain(data_3.id);
 		requireAdapterGeneration(adapterGeneration_2);
 		return store.optimisticUpdate({
 			execute: async () => {
-				const { remoteId: remoteId_4 } = await data_4.initializeTask;
+				const { remoteId: remoteId_4 } = await data_3.initializeTask;
 				requireAdapterGeneration(adapterGeneration_2);
 				return currentAdapter_3.archive(remoteId_4);
 			},
-			optimistic: (state_10) => updateStatusReducer(state_10, data_4.id, "archived")
+			optimistic: (state_9) => updateStatusReducer(state_9, data_3.id, "archived")
 		});
 	}, [
 		ensureNotMain,
@@ -667,21 +752,21 @@ const useRemoteThreadList = (props) => {
 	const unarchive = useCallback((threadIdOrRemoteId_3) => {
 		const currentAdapter_4 = session.adapter;
 		const adapterGeneration_3 = session.adapterGeneration;
-		const data_5 = getThreadData(store.value, threadIdOrRemoteId_3);
-		if (!data_5) throw threadNotFoundError(threadIdOrRemoteId_3, "unarchiving it");
-		if (data_5.status !== "archived") throw threadStatusError(threadIdOrRemoteId_3, data_5.status, "be unarchived");
+		const data_4 = getThreadData(store.value, threadIdOrRemoteId_3);
+		if (!data_4) throw threadNotFoundError(threadIdOrRemoteId_3, "unarchiving it");
+		if (data_4.status !== "archived") throw threadStatusError(threadIdOrRemoteId_3, data_4.status, "be unarchived");
 		return store.optimisticUpdate({
 			execute: async () => {
 				try {
-					const { remoteId: remoteId_5 } = await data_5.initializeTask;
+					const { remoteId: remoteId_5 } = await data_4.initializeTask;
 					requireAdapterGeneration(adapterGeneration_3);
 					return await currentAdapter_4.unarchive(remoteId_5);
-				} catch (error_4) {
-					if (adapterGeneration_3 === session.adapterGeneration) await ensureNotMain(data_5.id);
-					throw error_4;
+				} catch (error_5) {
+					if (adapterGeneration_3 === session.adapterGeneration) await ensureNotMain(data_4.id);
+					throw error_5;
 				}
 			},
-			optimistic: (state_11) => updateStatusReducer(state_11, data_5.id, "regular")
+			optimistic: (state_10) => updateStatusReducer(state_10, data_4.id, "regular")
 		});
 	}, [
 		ensureNotMain,
@@ -692,20 +777,23 @@ const useRemoteThreadList = (props) => {
 	const deleteThread = useCallback(async (threadIdOrRemoteId_4) => {
 		const currentAdapter_5 = session.adapter;
 		const adapterGeneration_4 = session.adapterGeneration;
-		const data_6 = getThreadData(store.value, threadIdOrRemoteId_4);
-		if (!data_6) throw threadNotFoundError(threadIdOrRemoteId_4, "deleting it");
-		if (data_6.status !== "regular" && data_6.status !== "archived") throw threadStatusError(threadIdOrRemoteId_4, data_6.status, "be deleted");
-		await ensureNotMain(data_6.id);
+		const data_5 = getThreadData(store.value, threadIdOrRemoteId_4);
+		if (!data_5) throw threadNotFoundError(threadIdOrRemoteId_4, "deleting it");
+		if (data_5.status !== "regular" && data_5.status !== "archived") throw threadStatusError(threadIdOrRemoteId_4, data_5.status, "be deleted");
+		await ensureNotMain(data_5.id);
 		requireAdapterGeneration(adapterGeneration_4);
-		onDelete?.(data_6.id);
-		return store.optimisticUpdate({
+		const result_2 = await store.optimisticUpdate({
 			execute: async () => {
-				const { remoteId: remoteId_6 } = await data_6.initializeTask;
+				const { remoteId: remoteId_6 } = await data_5.initializeTask;
 				requireAdapterGeneration(adapterGeneration_4);
 				return currentAdapter_5.delete(remoteId_6);
 			},
-			optimistic: (state_12) => updateStatusReducer(state_12, data_6.id, "deleted")
+			optimistic: (state_11) => updateStatusReducer(state_11, data_5.id, "deleted")
 		});
+		if (getThreadData(store.value, data_5.id) !== void 0) return result_2;
+		clearThreadTitleState(session.titleStates, data_5.id);
+		onDelete?.(data_5.id);
+		return result_2;
 	}, [
 		ensureNotMain,
 		onDelete,
@@ -713,57 +801,76 @@ const useRemoteThreadList = (props) => {
 		session,
 		store
 	]);
-	const generateTitle = useCallback(async (threadIdOrRemoteId_5, messages) => {
+	const generateTitle = useCallback(async (threadIdOrRemoteId_5, messages, options_0) => {
 		const currentAdapter_6 = session.adapter;
 		const adapterGeneration_5 = session.adapterGeneration;
-		const data_7 = getThreadData(store.value, threadIdOrRemoteId_5);
-		if (!data_7) throw threadNotFoundError(threadIdOrRemoteId_5, "generating its title");
-		if (data_7.status === "new") throw threadStatusError(threadIdOrRemoteId_5, data_7.status, "generate a title");
-		const { remoteId: remoteId_7 } = await data_7.initializeTask;
+		const data_6 = getThreadData(store.value, threadIdOrRemoteId_5);
+		if (!data_6) throw threadNotFoundError(threadIdOrRemoteId_5, "generating its title");
+		if (data_6.status === "new") throw threadStatusError(threadIdOrRemoteId_5, data_6.status, "generate a title");
+		const { remoteId: remoteId_7 } = await data_6.initializeTask;
 		requireAdapterGeneration(adapterGeneration_5);
-		if (!isSameThread(store.value, data_7.id, session.mainThreadId)) return;
+		if (!backgroundThreads && !isSameThread(store.value, data_6.id, session.mainThreadId)) return;
 		if (!messages) return;
-		const stream = await currentAdapter_6.generateTitle(remoteId_7, messages);
-		requireAdapterGeneration(adapterGeneration_5);
-		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
+		await runThreadTitleGeneration({
+			states: session.titleStates,
+			threadId: data_6.id,
+			automatic: options_0?.automatic === true,
+			generate: async (onTitle) => {
+				const stream = await currentAdapter_6.generateTitle(remoteId_7, messages);
+				requireAdapterGeneration(adapterGeneration_5);
+				await applyTitleStream(stream, onTitle);
+			},
+			rename: async (title) => {
+				requireAdapterGeneration(adapterGeneration_5);
+				await currentAdapter_6.rename(remoteId_7, title);
+			},
+			applyTitle: async (title_0) => {
+				await store.optimisticUpdate({
+					execute: async () => {},
+					optimistic: (state_12) => {
+						if (adapterGeneration_5 !== session.adapterGeneration) return state_12;
+						const current_2 = getThreadData(state_12, data_6.id);
+						if (!current_2) return state_12;
+						return {
+							...state_12,
+							threadData: {
+								...state_12.threadData,
+								[current_2.id]: {
+									...current_2,
+									title: title_0
+								}
 							}
-						}
-					};
-				}
-			});
+						};
+					}
+				});
+			}
 		});
 	}, [
+		backgroundThreads,
 		requireAdapterGeneration,
 		session,
 		store
 	]);
+	const detach = useCallback(async (threadId_2) => {
+		await ensureNotMain(threadId_2);
+		setStartedIds((prev_1) => prev_1.filter((id_2) => id_2 !== 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_3, options_1) => switchToThread(id_3, options_1),
+		onRename: (id_4, title_1) => rename(id_4, title_1),
+		onUpdateCustom: (id_5, custom_0) => updateCustom(id_5, custom_0),
+		onArchive: (id_6) => archive(id_6),
+		onUnarchive: (id_7) => unarchive(id_7),
+		onDelete: (id_8) => deleteThread(id_8),
+		onGenerateTitle: (id_9, messages_0, options_2) => generateTitle(id_9, messages_0, options_2),
+		onInitialize: async (id_10) => toInitializeResult(await initialize(id_10)),
+		onDetach: (id_11) => detach(id_11)
 	});
 	const mainRemoteId = getThreadData(listState, mainThreadId)?.remoteId;
 	useEffect(() => {
@@ -796,10 +903,11 @@ const useRemoteThreadList = (props) => {
 		switchToThread,
 		threadId
 	]);
-	const state_14 = useMemo(() => ({
+	const state_13 = useMemo(() => ({
 		mainThreadId,
 		newThreadId: listState.newThreadId ?? null,
 		isLoading: listState.isLoading,
+		loadError: listState.loadError,
 		isLoadingMore: listState.isLoadingMore,
 		hasMore: listState.cursor !== void 0,
 		threadIds: listState.threadIds,
@@ -810,6 +918,7 @@ const useRemoteThreadList = (props) => {
 		listState.archivedThreadIds,
 		listState.cursor,
 		listState.isLoading,
+		listState.loadError,
 		listState.isLoadingMore,
 		listState.newThreadId,
 		listState.threadIds,
@@ -818,9 +927,9 @@ const useRemoteThreadList = (props) => {
 		threadListItems.state
 	]);
 	return {
-		getState: () => state_14,
-		switchToThread: (id_11, options_1) => {
-			handleThreadListAction("switch", () => switchToThread(id_11, options_1));
+		getState: () => state_13,
+		switchToThread: (id_12, options_3) => {
+			handleThreadListAction("switch", () => switchToThread(id_12, options_3));
 		},
 		switchToNewThread: () => {
 			handleThreadListAction("create", () => switchToNewThread());
@@ -841,9 +950,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_13 = (selector.archived ? listState.archivedThreadIds : listState.threadIds)[selector.index];
+			if (id_13 === void 0) return threadListItems.get({ index: -1 });
+			const index_1 = itemOrder.findIndex((item_1) => itemMatchesId(item_1, listState, id_13));
 			return threadListItems.get({ index: index_1 });
 		},
 		thread: () => mainThreadClient.methods
@@ -856,6 +965,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);