@assistant-ui/core 0.3.14 → 0.3.16

package/dist/react/client/RemoteThreadList.js

@@ -1,10 +1,10 @@
-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 { AssistantMessageStream } from "assistant-stream";
 import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
@@ -13,16 +13,7 @@ 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) => ({
@@ -31,36 +22,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);
@@ -255,6 +217,8 @@ const useRemoteThreadList = (props) => {
 			initialMainId: seeded.id,
 			session: {
 				adapter,
+				adapterAtLoad: adapter,
+				adapterGeneration: 0,
 				loadGeneration: 0,
 				switchGeneration: 0,
 				loadPromise: void 0,
@@ -270,6 +234,7 @@ const useRemoteThreadList = (props) => {
 			}
 		};
 	});
+	session.adapter = adapter;
 	const listState = useSyncExternalStore((onStoreChange) => store.subscribe(onStoreChange), () => store.value, () => store.value);
 	const [mainThreadId, setMainThreadId] = useState(initialMainId);
 	const assignMainThreadId = useCallback((id) => {
@@ -299,21 +264,24 @@ const useRemoteThreadList = (props) => {
 	const getLoadThreadsPromise = useCallback(() => {
 		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: () => session.adapter.list(),
+			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 {
+				const merged = {
 					...state_0,
 					isLoading: false,
 					cursor: normalizeCursor(page.nextCursor),
@@ -328,6 +296,7 @@ const useRemoteThreadList = (props) => {
 						...fresh.threadData
 					}
 				};
+				return preserveMidLoadTransitions(merged, state_0, statusAtRequest);
 			}
 		}).catch((error) => {
 			if (generation !== session.loadGeneration) return;
@@ -341,16 +310,32 @@ const useRemoteThreadList = (props) => {
 		return session.loadPromise;
 	}, [session, store]);
 	const reload = useCallback(() => {
+		const adapterChanged = adapter !== session.adapterAtLoad;
 		session.loadGeneration++;
 		session.loadPromise = void 0;
 		session.loadMorePromise = void 0;
-		store.update({
+		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
 	]);
@@ -395,6 +380,7 @@ const useRemoteThreadList = (props) => {
 				};
 			}
 		}).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;
@@ -490,10 +476,10 @@ const useRemoteThreadList = (props) => {
 			session.onSwitchToNewThread?.();
 			return;
 		}
-		const seeded_0 = seedNewThread(store.baseValue);
-		store.update(seeded_0.state);
+		const seeded_1 = seedNewThread(store.baseValue);
+		store.update(seeded_1.state);
 		if (generation_3 !== session.switchGeneration) return;
-		assignMainThreadId(seeded_0.id);
+		assignMainThreadId(seeded_1.id);
 		notifyRemoteId(void 0, emitThreadIdChange_0);
 		session.onSwitchToNewThread?.();
 	}), [
@@ -522,15 +508,25 @@ const useRemoteThreadList = (props) => {
 		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");
-			return toInitializeResult(await data_0.initializeTask);
+			const result = toInitializeResult(await data_0.initializeTask);
+			requireAdapterGeneration(adapterGeneration);
+			return result;
 		}
-		const result = await store.optimisticUpdate({
-			execute: () => session.adapter.initialize(threadId_1),
+		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);
@@ -546,6 +542,7 @@ const useRemoteThreadList = (props) => {
 				};
 			},
 			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);
@@ -570,21 +567,26 @@ const useRemoteThreadList = (props) => {
 				};
 			}
 		});
-		if (threadId_1 === session.mainThreadId) notifyRemoteId(result.remoteId, true);
-		return toInitializeResult(result);
+		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;
-				return session.adapter.rename(remoteId_2, newTitle);
+				requireAdapterGeneration(adapterGeneration_0);
+				return currentAdapter_1.rename(remoteId_2, newTitle);
 			},
 			optimistic: (state_8) => {
 				const current_0 = getThreadData(state_8, threadIdOrRemoteId_0);
@@ -601,18 +603,24 @@ const useRemoteThreadList = (props) => {
 				};
 			}
 		});
-	}, [session, store]);
+	}, [
+		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 (!session.adapter.updateCustom) throw new Error("Remote thread list adapter does not support updating 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 currentAdapter_0 = session.adapter;
-				if (!currentAdapter_0.updateCustom) throw new Error("Remote thread list adapter does not support updating custom metadata");
-				return currentAdapter_0.updateCustom(remoteId_3, custom);
+				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);
@@ -629,25 +637,36 @@ const useRemoteThreadList = (props) => {
 				};
 			}
 		});
-	}, [session, store]);
+	}, [
+		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;
-				return session.adapter.archive(remoteId_4);
+				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");
@@ -655,9 +674,10 @@ const useRemoteThreadList = (props) => {
 			execute: async () => {
 				try {
 					const { remoteId: remoteId_5 } = await data_5.initializeTask;
-					return await session.adapter.unarchive(remoteId_5);
+					requireAdapterGeneration(adapterGeneration_3);
+					return await currentAdapter_4.unarchive(remoteId_5);
 				} catch (error_4) {
-					await ensureNotMain(data_5.id);
+					if (adapterGeneration_3 === session.adapterGeneration) await ensureNotMain(data_5.id);
 					throw error_4;
 				}
 			},
@@ -665,52 +685,71 @@ const useRemoteThreadList = (props) => {
 		});
 	}, [
 		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;
-				return session.adapter.delete(remoteId_6);
+				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 session.adapter.generateTitle(remoteId_7, messages);
-		await applyTitleStream(stream, (newTitle_0) => {
-			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
-					}
+		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
+							}
+						}
+					};
 				}
 			});
 		});
-	}, [session, store]);
+	}, [
+		requireAdapterGeneration,
+		session,
+		store
+	]);
 	const { mainThreadClient, itemOrder, threadListItems } = useRemoteThreadListView({
 		listState,
 		mainThreadId,