@assistant-ui/core 0.3.13 → 0.3.15

package/dist/react/client/RemoteThreadList.js

@@ -0,0 +1,898 @@
+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 { 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 { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
+import { useCallback, useEffect, useMemo, 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 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) => ({
+	remoteId: result.remoteId,
+	externalId: result.externalId
+});
+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
+				}
+			}
+		}
+	};
+};
+const useThreadListItemClient = (props) => {
+	const $ = c(22);
+	const { data, isRunning, onSwitchTo, onRename, onUpdateCustom, onArchive, onUnarchive, onDelete, onGenerateTitle, onInitialize, onDetach } = props;
+	const t0 = "lastMessageAt" in data ? data.lastMessageAt : void 0;
+	let t1;
+	if ($[0] !== data.custom || $[1] !== data.externalId || $[2] !== data.id || $[3] !== data.remoteId || $[4] !== data.status || $[5] !== data.title || $[6] !== isRunning || $[7] !== t0) {
+		t1 = {
+			id: data.id,
+			remoteId: data.remoteId,
+			externalId: data.externalId,
+			title: data.title,
+			lastMessageAt: t0,
+			status: data.status,
+			custom: data.custom,
+			isRunning
+		};
+		$[0] = data.custom;
+		$[1] = data.externalId;
+		$[2] = data.id;
+		$[3] = data.remoteId;
+		$[4] = data.status;
+		$[5] = data.title;
+		$[6] = isRunning;
+		$[7] = t0;
+		$[8] = t1;
+	} else t1 = $[8];
+	const state = t1;
+	let t2;
+	if ($[9] !== state) {
+		t2 = () => state;
+		$[9] = state;
+		$[10] = t2;
+	} else t2 = $[10];
+	let t3;
+	if ($[11] !== onArchive || $[12] !== onDelete || $[13] !== onDetach || $[14] !== onGenerateTitle || $[15] !== onInitialize || $[16] !== onRename || $[17] !== onSwitchTo || $[18] !== onUnarchive || $[19] !== onUpdateCustom || $[20] !== t2) {
+		t3 = {
+			getState: t2,
+			switchTo: onSwitchTo,
+			rename: onRename,
+			updateCustom: onUpdateCustom,
+			archive: onArchive,
+			unarchive: onUnarchive,
+			delete: onDelete,
+			generateTitle: onGenerateTitle,
+			initialize: onInitialize,
+			detach: onDetach
+		};
+		$[11] = onArchive;
+		$[12] = onDelete;
+		$[13] = onDetach;
+		$[14] = onGenerateTitle;
+		$[15] = onInitialize;
+		$[16] = onRename;
+		$[17] = onSwitchTo;
+		$[18] = onUnarchive;
+		$[19] = onUpdateCustom;
+		$[20] = t2;
+		$[21] = t3;
+	} else t3 = $[21];
+	return t3;
+};
+const ThreadListItemClient = resource(useThreadListItemClient);
+const collectItemOrder = (listState, mainThreadId) => {
+	const ids = [
+		listState.newThreadId,
+		...listState.threadIds,
+		...listState.archivedThreadIds,
+		mainThreadId
+	].filter((id) => id !== void 0);
+	const seenIds = /* @__PURE__ */ new Set();
+	const seenRemoteIds = /* @__PURE__ */ new Set();
+	const items = [];
+	for (const id of ids) {
+		const data = getThreadData(listState, id);
+		if (!data || seenIds.has(data.id)) continue;
+		if (data.remoteId !== void 0 && seenRemoteIds.has(data.remoteId)) continue;
+		seenIds.add(data.id);
+		if (data.remoteId !== void 0) seenRemoteIds.add(data.remoteId);
+		items.push(data);
+	}
+	return items;
+};
+const itemMatchesId = (item, listState, id) => {
+	const data = getThreadData(listState, id);
+	return item.id === id || item.id === data?.id || data?.remoteId !== void 0 && (item.id === data.remoteId || item.remoteId === data.remoteId);
+};
+const isSameThread = (listState, left, right) => {
+	if (left === right) return true;
+	const data = getThreadData(listState, left);
+	return data !== void 0 && itemMatchesId(data, listState, right);
+};
+const useRemoteThreadListView = (t0) => {
+	const $ = c(39);
+	const { listState, mainThreadId, 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);
+		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);
+	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 = {
+			mainThreadClient,
+			itemOrder,
+			threadListItems
+		};
+		$[35] = itemOrder;
+		$[36] = mainThreadClient;
+		$[37] = threadListItems;
+		$[38] = t5;
+	} else t5 = $[38];
+	return t5;
+};
+const useRemoteThreadList = (props) => {
+	const { adapter, thread: threadFactory, threadId, onThreadIdChange, onSwitchToThread, onSwitchToNewThread, onDelete } = props;
+	const [{ store, initialMainId, session }] = useState(() => {
+		const seeded = seedNewThread(EMPTY_LIST);
+		return {
+			store: new OptimisticState(seeded.state),
+			initialMainId: seeded.id,
+			session: {
+				adapter,
+				adapterAtLoad: adapter,
+				adapterGeneration: 0,
+				loadGeneration: 0,
+				switchGeneration: 0,
+				loadPromise: void 0,
+				loadMorePromise: void 0,
+				lastNotifiedRemoteId: void 0,
+				lastControlledThreadId: void 0,
+				switchTask: void 0,
+				mainThreadId: seeded.id,
+				isFirstThreadIdEffect: true,
+				onThreadIdChange,
+				onSwitchToThread,
+				onSwitchToNewThread
+			}
+		};
+	});
+	session.adapter = adapter;
+	const listState = useSyncExternalStore((onStoreChange) => store.subscribe(onStoreChange), () => store.value, () => store.value);
+	const [mainThreadId, setMainThreadId] = useState(initialMainId);
+	const assignMainThreadId = useCallback((id) => {
+		session.mainThreadId = id;
+		setMainThreadId(id);
+	}, [session]);
+	useThreadSelectionEvents(mainThreadId);
+	useEffect(() => {
+		session.adapter = adapter;
+		session.mainThreadId = mainThreadId;
+		session.onThreadIdChange = onThreadIdChange;
+		session.onSwitchToThread = onSwitchToThread;
+		session.onSwitchToNewThread = onSwitchToNewThread;
+	}, [
+		adapter,
+		mainThreadId,
+		onSwitchToNewThread,
+		onSwitchToThread,
+		onThreadIdChange,
+		session
+	]);
+	const notifyRemoteId = useCallback((remoteId, emit) => {
+		if (session.lastNotifiedRemoteId === remoteId) return;
+		session.lastNotifiedRemoteId = remoteId;
+		if (emit) session.onThreadIdChange?.(remoteId);
+	}, [session]);
+	const getLoadThreadsPromise = useCallback(() => {
+		if (session.loadPromise) return session.loadPromise;
+		const generation = session.loadGeneration;
+		const adapter_0 = session.adapter;
+		session.loadPromise = store.optimisticUpdate({
+			execute: () => adapter_0.list(),
+			loading: (state) => ({
+				...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: {}
+				});
+				return {
+					...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
+					}
+				};
+			}
+		}).catch((error) => {
+			if (generation !== session.loadGeneration) return;
+			console.error("[assistant-ui] thread list load failed:", error);
+			session.loadPromise = void 0;
+			store.update({
+				...store.baseValue,
+				isLoading: false
+			});
+		}).then(() => {});
+		return session.loadPromise;
+	}, [session, store]);
+	const reload = useCallback(() => {
+		const adapterChanged = adapter !== session.adapterAtLoad;
+		session.loadGeneration++;
+		session.loadPromise = void 0;
+		session.loadMorePromise = void 0;
+		if (adapterChanged) {
+			session.adapterGeneration++;
+			session.switchGeneration++;
+			session.switchTask = void 0;
+			session.adapterAtLoad = adapter;
+			const seeded_0 = seedNewThread(EMPTY_LIST);
+			store.reset({
+				...seeded_0.state,
+				isLoading: true
+			});
+			assignMainThreadId(seeded_0.id);
+			notifyRemoteId(void 0, true);
+		} else store.update({
+			...store.baseValue,
+			cursor: void 0
+		});
+		return getLoadThreadsPromise();
+	}, [
+		adapter,
+		assignMainThreadId,
+		getLoadThreadsPromise,
+		notifyRemoteId,
+		session,
+		store
+	]);
+	useEffect(() => {
+		getLoadThreadsPromise();
+	}, [getLoadThreadsPromise]);
+	useEffect(() => {
+		if (!isDevelopment) return;
+		if (adapter.unstable_useAdapters !== void 0) return;
+		if (adapter.unstable_Provider === void 0) return;
+		console.warn("[assistant-ui] RemoteThreadList ignores RemoteThreadListAdapter.unstable_Provider. Expose unstable_useAdapters so per-thread history loads on this entry. useRemoteThreadListRuntime still honors unstable_Provider.");
+	}, [adapter]);
+	const loadMore = useCallback(() => {
+		if (session.loadMorePromise) return session.loadMorePromise;
+		const snapshot = store.value;
+		if (snapshot.cursor === void 0 || snapshot.isLoading) return RESOLVED_PROMISE;
+		const generation_0 = session.loadGeneration;
+		const cursor = snapshot.cursor;
+		const currentAdapter = session.adapter;
+		const task = store.optimisticUpdate({
+			execute: () => currentAdapter.list({ after: cursor }),
+			loading: (state_1) => ({
+				...state_1,
+				isLoadingMore: true
+			}),
+			then: (state_2, page_0) => {
+				if (generation_0 !== session.loadGeneration) return state_2;
+				const appended = classifyThreads(page_0.threads, {
+					threadIds: [...state_2.threadIds],
+					archivedThreadIds: [...state_2.archivedThreadIds],
+					threadIdMap: { ...state_2.threadIdMap },
+					threadData: { ...state_2.threadData }
+				});
+				return {
+					...state_2,
+					isLoadingMore: false,
+					cursor: normalizeCursor(page_0.nextCursor),
+					threadIds: appended.threadIds,
+					archivedThreadIds: appended.archivedThreadIds,
+					threadIdMap: appended.threadIdMap,
+					threadData: appended.threadData
+				};
+			}
+		}).catch((error_0) => {
+			if (generation_0 !== session.loadGeneration) return;
+			console.error("[assistant-ui] thread list loadMore failed:", error_0);
+		}).then(() => {
+			if (session.loadMorePromise === task) session.loadMorePromise = void 0;
+		});
+		session.loadMorePromise = task;
+		return task;
+	}, [session, store]);
+	const startSwitch = useCallback((run) => {
+		const generation_1 = ++session.switchGeneration;
+		let settle;
+		const task_0 = new Promise((resolve, reject) => {
+			settle = (error_1) => {
+				if (error_1 === void 0) resolve();
+				else reject(error_1);
+			};
+		});
+		session.switchTask = task_0;
+		run(generation_1).then(() => settle(), (error_2) => settle(error_2));
+		return task_0;
+	}, [session]);
+	const switchToThread = useCallback((threadIdOrRemoteId, options, emitThreadIdChange = true) => startSwitch(async (generation_2) => {
+		let data = getThreadData(store.value, threadIdOrRemoteId);
+		if (!data) {
+			const remoteMetadata = await session.adapter.fetch(threadIdOrRemoteId);
+			if (generation_2 !== session.switchGeneration) return;
+			const state_3 = store.value;
+			const mappingId = createThreadMappingId(remoteMetadata.remoteId);
+			const wasInTarget = remoteMetadata.status === "regular" ? state_3.threadIds.includes(remoteMetadata.remoteId) : state_3.archivedThreadIds.includes(remoteMetadata.remoteId);
+			const threadIdsWithoutRemote = state_3.threadIds.filter((id_0) => id_0 !== remoteMetadata.remoteId);
+			const archivedThreadIdsWithoutRemote = state_3.archivedThreadIds.filter((id_1) => id_1 !== remoteMetadata.remoteId);
+			store.update({
+				...state_3,
+				threadIds: remoteMetadata.status === "regular" ? wasInTarget ? state_3.threadIds : [...threadIdsWithoutRemote, remoteMetadata.remoteId] : threadIdsWithoutRemote,
+				archivedThreadIds: remoteMetadata.status === "archived" ? wasInTarget ? state_3.archivedThreadIds : [...archivedThreadIdsWithoutRemote, remoteMetadata.remoteId] : archivedThreadIdsWithoutRemote,
+				threadIdMap: {
+					...state_3.threadIdMap,
+					[remoteMetadata.remoteId]: mappingId
+				},
+				threadData: {
+					...state_3.threadData,
+					[mappingId]: {
+						id: mappingId,
+						initializeTask: Promise.resolve({
+							remoteId: remoteMetadata.remoteId,
+							externalId: remoteMetadata.externalId
+						}),
+						remoteId: remoteMetadata.remoteId,
+						externalId: remoteMetadata.externalId,
+						status: remoteMetadata.status,
+						title: remoteMetadata.title,
+						lastMessageAt: remoteMetadata.lastMessageAt,
+						custom: remoteMetadata.custom
+					}
+				}
+			});
+			data = getThreadData(store.value, threadIdOrRemoteId);
+		}
+		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 { 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;
+		}
+		if (generation_2 !== session.switchGeneration) return;
+		assignMainThreadId(data.id);
+		notifyRemoteId(data.remoteId, emitThreadIdChange);
+		session.onSwitchToThread?.(data.id);
+	}), [
+		assignMainThreadId,
+		notifyRemoteId,
+		session,
+		startSwitch,
+		store
+	]);
+	const switchToNewThread = useCallback((emitThreadIdChange_0 = true) => startSwitch(async (generation_3) => {
+		while (store.baseValue.newThreadId !== void 0 && store.value.newThreadId === void 0) {
+			await store.waitForUpdate();
+			if (generation_3 !== session.switchGeneration) return;
+		}
+		const existing = store.value.newThreadId;
+		if (existing !== void 0) {
+			const existingId = getThreadData(store.value, existing)?.id ?? existing;
+			if (isSameThread(store.value, existingId, session.mainThreadId)) return;
+			assignMainThreadId(existingId);
+			notifyRemoteId(void 0, emitThreadIdChange_0);
+			session.onSwitchToNewThread?.();
+			return;
+		}
+		const seeded_1 = seedNewThread(store.baseValue);
+		store.update(seeded_1.state);
+		if (generation_3 !== session.switchGeneration) return;
+		assignMainThreadId(seeded_1.id);
+		notifyRemoteId(void 0, emitThreadIdChange_0);
+		session.onSwitchToNewThread?.();
+	}), [
+		assignMainThreadId,
+		notifyRemoteId,
+		session,
+		startSwitch,
+		store
+	]);
+	const ensureNotMain = useCallback(async (threadId_0) => {
+		if (threadId_0 === store.value.newThreadId) throw new Error("Cannot ensure new thread is not main");
+		let lastAwaitedTask;
+		while (isSameThread(store.value, threadId_0, session.mainThreadId)) {
+			let switchTask = session.switchTask;
+			const startedFallback = !switchTask || switchTask === lastAwaitedTask;
+			if (startedFallback) switchTask = switchToNewThread();
+			lastAwaitedTask = switchTask;
+			try {
+				await switchTask;
+			} catch (error_3) {
+				if (startedFallback && session.switchTask === switchTask) throw error_3;
+			}
+		}
+	}, [
+		session,
+		store,
+		switchToNewThread
+	]);
+	const requireAdapterGeneration = useCallback((generation_4) => {
+		if (generation_4 !== session.adapterGeneration) throw new ThreadListAdapterChangedError();
+	}, [session]);
+	const initialize = useCallback(async (threadId_1) => {
+		const currentAdapter_0 = session.adapter;
+		const adapterGeneration = session.adapterGeneration;
+		if (store.value.newThreadId !== threadId_1) {
+			const data_0 = getThreadData(store.value, threadId_1);
+			if (!data_0) throw threadNotFoundError(threadId_1, "initializing it");
+			if (data_0.status === "new") throw threadStatusError(threadId_1, data_0.status, "be initialized here");
+			const result = toInitializeResult(await data_0.initializeTask);
+			requireAdapterGeneration(adapterGeneration);
+			return result;
+		}
+		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
+						}
+					}
+				};
+			}
+		});
+		requireAdapterGeneration(adapterGeneration);
+		if (threadId_1 === session.mainThreadId) notifyRemoteId(result_0.remoteId, true);
+		return toInitializeResult(result_0);
+	}, [
+		notifyRemoteId,
+		requireAdapterGeneration,
+		session,
+		store
+	]);
+	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");
+		return store.optimisticUpdate({
+			execute: async () => {
+				const { remoteId: remoteId_2 } = await data_2.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;
+				return {
+					...state_8,
+					threadData: {
+						...state_8.threadData,
+						[current_0.id]: {
+							...current_0,
+							title: newTitle
+						}
+					}
+				};
+			}
+		});
+	}, [
+		requireAdapterGeneration,
+		session,
+		store
+	]);
+	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");
+		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;
+				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;
+				return {
+					...state_9,
+					threadData: {
+						...state_9.threadData,
+						[current_1.id]: {
+							...current_1,
+							custom
+						}
+					}
+				};
+			}
+		});
+	}, [
+		requireAdapterGeneration,
+		session,
+		store
+	]);
+	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);
+		requireAdapterGeneration(adapterGeneration_2);
+		return store.optimisticUpdate({
+			execute: async () => {
+				const { remoteId: remoteId_4 } = await data_4.initializeTask;
+				requireAdapterGeneration(adapterGeneration_2);
+				return currentAdapter_3.archive(remoteId_4);
+			},
+			optimistic: (state_10) => updateStatusReducer(state_10, data_4.id, "archived")
+		});
+	}, [
+		ensureNotMain,
+		requireAdapterGeneration,
+		session,
+		store
+	]);
+	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");
+		return store.optimisticUpdate({
+			execute: async () => {
+				try {
+					const { remoteId: remoteId_5 } = await data_5.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;
+				}
+			},
+			optimistic: (state_11) => updateStatusReducer(state_11, data_5.id, "regular")
+		});
+	}, [
+		ensureNotMain,
+		requireAdapterGeneration,
+		session,
+		store
+	]);
+	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);
+		requireAdapterGeneration(adapterGeneration_4);
+		onDelete?.(data_6.id);
+		return store.optimisticUpdate({
+			execute: async () => {
+				const { remoteId: remoteId_6 } = await data_6.initializeTask;
+				requireAdapterGeneration(adapterGeneration_4);
+				return currentAdapter_5.delete(remoteId_6);
+			},
+			optimistic: (state_12) => updateStatusReducer(state_12, data_6.id, "deleted")
+		});
+	}, [
+		ensureNotMain,
+		onDelete,
+		requireAdapterGeneration,
+		session,
+		store
+	]);
+	const generateTitle = useCallback(async (threadIdOrRemoteId_5, messages) => {
+		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;
+		requireAdapterGeneration(adapterGeneration_5);
+		if (!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
+					}
+				}
+			});
+		});
+	}, [
+		requireAdapterGeneration,
+		session,
+		store
+	]);
+	const { mainThreadClient, itemOrder, threadListItems } = useRemoteThreadListView({
+		listState,
+		mainThreadId,
+		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)
+	});
+	const mainRemoteId = getThreadData(listState, mainThreadId)?.remoteId;
+	useEffect(() => {
+		if (session.lastNotifiedRemoteId === mainRemoteId) return;
+		session.lastNotifiedRemoteId = mainRemoteId;
+		onThreadIdChange?.(mainRemoteId);
+	}, [
+		mainRemoteId,
+		onThreadIdChange,
+		session
+	]);
+	useEffect(() => {
+		if (session.isFirstThreadIdEffect) {
+			session.isFirstThreadIdEffect = false;
+			session.lastControlledThreadId = threadId;
+			if (threadId === void 0) return;
+			handleThreadListAction("switch", () => switchToThread(threadId, void 0, false));
+			return;
+		}
+		if (Object.is(session.lastControlledThreadId, threadId)) return;
+		session.lastControlledThreadId = threadId;
+		if (threadId === void 0) {
+			handleThreadListAction("create", () => switchToNewThread(false));
+			return;
+		}
+		handleThreadListAction("switch", () => switchToThread(threadId, void 0, false));
+	}, [
+		session,
+		switchToNewThread,
+		switchToThread,
+		threadId
+	]);
+	const state_14 = useMemo(() => ({
+		mainThreadId,
+		newThreadId: listState.newThreadId ?? null,
+		isLoading: listState.isLoading,
+		isLoadingMore: listState.isLoadingMore,
+		hasMore: listState.cursor !== void 0,
+		threadIds: listState.threadIds,
+		archivedThreadIds: listState.archivedThreadIds,
+		threadItems: threadListItems.state,
+		main: mainThreadClient.state
+	}), [
+		listState.archivedThreadIds,
+		listState.cursor,
+		listState.isLoading,
+		listState.isLoadingMore,
+		listState.newThreadId,
+		listState.threadIds,
+		mainThreadClient.state,
+		mainThreadId,
+		threadListItems.state
+	]);
+	return {
+		getState: () => state_14,
+		switchToThread: (id_11, options_1) => {
+			handleThreadListAction("switch", () => switchToThread(id_11, options_1));
+		},
+		switchToNewThread: () => {
+			handleThreadListAction("create", () => switchToNewThread());
+		},
+		getLoadThreadsPromise,
+		reload,
+		reloadMainThread: () => {
+			if (getThreadData(store.value, mainThreadId)?.status === "new") return RESOLVED_PROMISE;
+			return mainThreadClient.methods.unstable_refetchThread?.() ?? RESOLVED_PROMISE;
+		},
+		loadMore,
+		item: (selector) => {
+			if (selector === "main") {
+				const index = itemOrder.findIndex((item) => itemMatchesId(item, listState, mainThreadId));
+				return threadListItems.get({ index });
+			}
+			if ("id" in selector) {
+				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));
+			return threadListItems.get({ index: index_1 });
+		},
+		thread: () => mainThreadClient.methods
+	};
+};
+/**
+* `AuiConfig` `threads` entry backed by a `RemoteThreadListAdapter`. Thread
+* bodies are born from the `thread` factory inside the client tree, so any
+* `AssistantClient` host can run a remote or cloud list. Per-thread history
+* 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.
+*/
+const RemoteThreadList = resource(useRemoteThreadList);
+attachTransformScopes(useRemoteThreadList, inMemoryThreadListTransformScopes);
+//#endregion
+export { RemoteThreadList };
+
+//# sourceMappingURL=RemoteThreadList.js.map