@assistant-ui/core 0.3.14 → 0.3.16

package/dist/react/runtimes/RemoteThreadListThreadListRuntimeCore.js

@@ -1,8 +1,8 @@
 import { BaseSubscribable } from "../../subscribable/subscribable.js";
-import { generateId } from "../../utils/id.js";
 import { OptimisticState } from "../../runtimes/remote-thread-list/optimistic-state.js";
 import { EMPTY_THREAD_CORE } from "../../runtimes/remote-thread-list/empty-thread-core.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 { ThreadListAdapterChangedError } from "../../runtimes/remote-thread-list/adapter-changed.js";
 import { useStableRuntimeAdapters } from "./useRuntimeAdapters.js";
 import { RuntimeAdapterProvider } from "./RuntimeAdapterProvider.js";
 import { isTitleSourceMessage } from "./RemoteThreadResource.js";
@@ -15,6 +15,7 @@ import { create } from "zustand";
 //#region src/react/runtimes/RemoteThreadListThreadListRuntimeCore.tsx
 const threadNotFoundError = (threadIdOrRemoteId, action) => /* @__PURE__ */ new Error(`Thread "${threadIdOrRemoteId}" not found while ${action}.`);
 const threadStatusError = (threadIdOrRemoteId, status, action) => /* @__PURE__ */ new Error(`Thread "${threadIdOrRemoteId}" has status "${status}", so it cannot ${action}.`);
+const EMPTY_REMOTE_STATE = createEmptyRemoteThreadState();
 var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 	_options;
 	_hookManager;
@@ -22,19 +23,13 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 	_loadThreadsPromise;
 	_loadMorePromise;
 	_loadGeneration = 0;
+	_adapterGeneration = 0;
+	_replaceListOnNextLoad = false;
+	_staleThreadIdsOnReplace;
 	_switchGeneration = 0;
 	_switchTask;
 	_mainThreadId;
-	_state = new OptimisticState({
-		isLoading: true,
-		isLoadingMore: false,
-		cursor: void 0,
-		newThreadId: void 0,
-		threadIds: [],
-		archivedThreadIds: [],
-		threadIdMap: {},
-		threadData: {}
-	});
+	_state = new OptimisticState(EMPTY_REMOTE_STATE);
 	_useAdaptersProvider = ({ children }) => {
 		const useAdapters = this._options.adapter.unstable_useAdapters;
 		if (useAdapters === void 0) return children;
@@ -62,6 +57,8 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 	getLoadThreadsPromise() {
 		if (!this._loadThreadsPromise) {
 			const generation = this._loadGeneration;
+			let replacedList = false;
+			const statusAtRequest = statusSnapshot(this._state.baseValue);
 			this._loadThreadsPromise = this._state.optimisticUpdate({
 				execute: () => this._options.adapter.list(),
 				loading: (state) => {
@@ -72,13 +69,18 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 				},
 				then: (state, l) => {
 					if (generation !== this._loadGeneration) return state;
+					if (this._replaceListOnNextLoad) {
+						this._replaceListOnNextLoad = false;
+						replacedList = true;
+						return this._replaceWithThreads(state, l.threads, normalizeCursor(l.nextCursor));
+					}
 					const fresh = classifyThreads(l.threads, {
 						threadIds: [],
 						archivedThreadIds: [],
 						threadIdMap: {},
 						threadData: {}
 					});
-					return {
+					const merged = {
 						...state,
 						isLoading: false,
 						cursor: normalizeCursor(l.nextCursor),
@@ -93,16 +95,29 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 							...fresh.threadData
 						}
 					};
+					return preserveMidLoadTransitions(merged, state, statusAtRequest);
 				}
 			}).catch((error) => {
 				if (generation !== this._loadGeneration) return;
 				console.error("[assistant-ui] thread list load failed:", error);
 				this._loadThreadsPromise = void 0;
-				this._state.update({
-					...this._state.baseValue,
-					isLoading: false
-				});
-			}).then(() => {});
+				if (!this._replaceListOnNextLoad) {
+					this._state.update({
+						...this._state.baseValue,
+						isLoading: false
+					});
+					return;
+				}
+				this._replaceListOnNextLoad = false;
+				replacedList = true;
+				this._state.update(this._replaceWithThreads(this._state.baseValue, [], void 0));
+			}).then(() => {
+				if (!replacedList) return;
+				const threadId = this._options.threadId;
+				if (threadId === void 0) return;
+				if (this.getItemById(threadId)?.id === this._mainThreadId) return;
+				this._switchToThreadFromProp(threadId).catch(() => {});
+			});
 		}
 		return this._loadThreadsPromise;
 	}
@@ -139,6 +154,7 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 				};
 			}
 		}).catch((error) => {
+			if (generation !== this._loadGeneration) return;
 			console.error("[assistant-ui] thread list loadMore failed:", error);
 		}).then(() => {
 			if (this._loadMorePromise === dedup) this._loadMorePromise = void 0;
@@ -156,6 +172,9 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 		this._hookManager = new RemoteThreadListHookInstanceManager(options.runtimeHook, this);
 		this._hookManager.__internal_setDefaultAdapters(this._runtimeAdapters);
 		this._hookManager.__internal_subscribeRunningChanged(() => this._notifySubscribers());
+		this._hookManager.__internal_subscribeRuntimeReplaced(() => {
+			queueMicrotask(() => this._notifySubscribers());
+		});
 		this.useProvider = create(() => ({ Provider: this.resolveProvider(options.adapter) }));
 		this.__internal_setOptions(options);
 		this.switchToNewThread();
@@ -172,8 +191,13 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 		this._hookManager.setRuntimeHook(options.runtimeHook);
 		if (adapterChanged) {
 			this._loadGeneration++;
+			this._adapterGeneration++;
+			this._switchGeneration++;
+			this._switchTask = void 0;
 			this._loadThreadsPromise = void 0;
 			this._loadMorePromise = void 0;
+			this._replaceListOnNextLoad = true;
+			this._staleThreadIdsOnReplace = new Set(Object.values(this._state.baseValue.threadData).filter((item) => item.status !== "new").map((item) => item.id));
 			this._state.update({
 				...this._state.baseValue,
 				cursor: void 0
@@ -181,6 +205,71 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 		}
 		if (controlledThreadIdChanged) this._switchToThreadFromProp(options.threadId).catch(() => {});
 	}
+	_requireAdapterGeneration(generation) {
+		if (generation !== this._adapterGeneration) throw new ThreadListAdapterChangedError();
+	}
+	_requireAdapterSettled() {
+		if (this._replaceListOnNextLoad) throw new ThreadListAdapterChangedError();
+	}
+	_replaceWithThreads(state, threads, cursor) {
+		const fresh = classifyThreads(threads, {
+			threadIds: [],
+			archivedThreadIds: [],
+			threadIdMap: {},
+			threadData: {}
+		});
+		const threadIdMap = { ...fresh.threadIdMap };
+		const threadData = { ...fresh.threadData };
+		const threadIds = [...fresh.threadIds];
+		const archivedThreadIds = [...fresh.archivedThreadIds];
+		if (state.newThreadId) {
+			const mappingId = state.threadIdMap[state.newThreadId];
+			const draft = mappingId ? state.threadData[mappingId] : void 0;
+			if (draft?.status === "new") {
+				threadIdMap[state.newThreadId] = mappingId;
+				threadData[mappingId] = draft;
+			}
+		}
+		const stale = this._staleThreadIdsOnReplace;
+		if (stale) for (const item of Object.values(state.threadData)) {
+			if (stale.has(item.id)) continue;
+			if (item.status !== "new" && item.remoteId === void 0) continue;
+			const mappingId = createThreadMappingId(item.id);
+			if (threadData[mappingId]) continue;
+			threadIdMap[item.id] = mappingId;
+			if (item.remoteId !== void 0) threadIdMap[item.remoteId] = mappingId;
+			threadData[mappingId] = item;
+			if (item.remoteId === void 0) continue;
+			if (item.status === "regular" && !threadIds.includes(item.remoteId)) threadIds.push(item.remoteId);
+			else if (item.status === "archived" && !archivedThreadIds.includes(item.remoteId)) archivedThreadIds.push(item.remoteId);
+		}
+		this._staleThreadIdsOnReplace = void 0;
+		let nextState = {
+			...state,
+			isLoading: false,
+			cursor,
+			threadIds,
+			archivedThreadIds,
+			threadIdMap,
+			threadData,
+			newThreadId: state.newThreadId !== void 0 && threadIdMap[state.newThreadId] === void 0 ? void 0 : state.newThreadId
+		};
+		if (getThreadData(nextState, this._mainThreadId) === void 0) {
+			const preservedDraft = nextState.newThreadId;
+			if (preservedDraft !== void 0) this._mainThreadId = preservedDraft;
+			else {
+				const seeded = seedNewThread(nextState);
+				this._mainThreadId = seeded.id;
+				nextState = seeded.state;
+			}
+			if (this._options.threadId === void 0) this._notifyThreadIdChange();
+			else this._lastNotifiedThreadId = void 0;
+		}
+		const nextIds = new Set(Object.values(nextState.threadData).map((item) => item.id));
+		for (const item of Object.values(state.threadData)) if (!nextIds.has(item.id)) this._hookManager.stopThreadRuntime(item.id);
+		this._hookManager.startThreadRuntime(this._mainThreadId).then(() => this._notifySubscribers(), () => void 0);
+		return nextState;
+	}
 	__internal_load() {
 		this.getLoadThreadsPromise();
 		if (this._initialThreadLoaded) return;
@@ -275,6 +364,7 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 		return task;
 	}
 	async _switchToThread(threadIdOrRemoteId, options, generation, emitThreadIdChange) {
+		if (this._replaceListOnNextLoad && threadIdOrRemoteId !== this._state.value.newThreadId) throw new ThreadListAdapterChangedError();
 		let data = this.getItemById(threadIdOrRemoteId);
 		if (!data) {
 			const remoteMetadata = await this._options.adapter.fetch(threadIdOrRemoteId);
@@ -350,38 +440,22 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 		const state = this._state.baseValue;
 		let id = this._state.value.newThreadId;
 		if (id === void 0) {
-			do
-				id = `__LOCALID_${generateId()}`;
-			while (state.threadIdMap[id]);
-			const mappingId = createThreadMappingId(id);
-			this._state.update({
-				...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 next = seedNewThread(state);
+			id = next.id;
+			this._state.update(next.state);
 		}
 		return this._switchToThread(id, void 0, generation, emitThreadIdChange);
 	}
 	initialize = async (threadId) => {
+		const adapter = this._options.adapter;
+		const adapterGeneration = this._adapterGeneration;
 		if (this._state.value.newThreadId !== threadId) {
+			this._requireAdapterSettled();
 			const data = this.getItemById(threadId);
 			if (!data) throw threadNotFoundError(threadId, "initializing it");
 			if (data.status === "new") throw threadStatusError(threadId, data.status, "be initialized here");
 			const { remoteId, externalId } = await data.initializeTask;
+			this._requireAdapterGeneration(adapterGeneration);
 			return {
 				remoteId,
 				externalId
@@ -389,7 +463,8 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 		}
 		const { remoteId, externalId } = await this._state.optimisticUpdate({
 			execute: () => {
-				return this._options.adapter.initialize(threadId);
+				this._requireAdapterGeneration(adapterGeneration);
+				return adapter.initialize(threadId);
 			},
 			optimistic: (state) => {
 				return updateStatusReducer(state, threadId, "regular");
@@ -408,6 +483,7 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 				};
 			},
 			then: (state, { remoteId, externalId }) => {
+				if (adapterGeneration !== this._adapterGeneration) return state;
 				const data = getThreadData(state, threadId);
 				if (!data) return state;
 				const mappingId = createThreadMappingId(threadId);
@@ -432,46 +508,61 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 				};
 			}
 		});
+		this._requireAdapterGeneration(adapterGeneration);
 		return {
 			remoteId,
 			externalId
 		};
 	};
 	generateTitle = async (threadId) => {
+		this._requireAdapterSettled();
+		const adapter = this._options.adapter;
+		const adapterGeneration = this._adapterGeneration;
 		const data = this.getItemById(threadId);
 		if (!data) throw threadNotFoundError(threadId, "generating its title");
 		if (data.status === "new") throw threadStatusError(threadId, data.status, "generate a title");
 		const { remoteId } = await data.initializeTask;
+		this._requireAdapterGeneration(adapterGeneration);
 		const runtimeCore = this._hookManager.getThreadRuntimeCore(data.id);
 		if (!runtimeCore) return;
 		const messages = runtimeCore.messages.filter(isTitleSourceMessage);
-		const stream = await this._options.adapter.generateTitle(remoteId, messages);
+		const stream = await adapter.generateTitle(remoteId, messages);
 		const messageStream = AssistantMessageStream.fromAssistantStream(stream);
 		for await (const result of messageStream) {
+			if (adapterGeneration !== this._adapterGeneration) return;
 			const newTitle = result.parts.filter((c) => c.type === "text")[0]?.text;
-			const state = this._state.baseValue;
-			const currentData = getThreadData(state, data.id);
-			if (!currentData) continue;
-			this._state.update({
-				...state,
-				threadData: {
-					...state.threadData,
-					[currentData.id]: {
-						...currentData,
-						title: newTitle
-					}
+			await this._state.optimisticUpdate({
+				execute: async () => {},
+				optimistic: (state) => {
+					if (adapterGeneration !== this._adapterGeneration) return state;
+					const currentData = getThreadData(state, data.id);
+					if (!currentData) return state;
+					return {
+						...state,
+						threadData: {
+							...state.threadData,
+							[currentData.id]: {
+								...currentData,
+								title: newTitle
+							}
+						}
+					};
 				}
 			});
 		}
 	};
-	rename(threadIdOrRemoteId, newTitle) {
+	async rename(threadIdOrRemoteId, newTitle) {
+		this._requireAdapterSettled();
+		const adapter = this._options.adapter;
+		const adapterGeneration = this._adapterGeneration;
 		const data = this.getItemById(threadIdOrRemoteId);
 		if (!data) throw threadNotFoundError(threadIdOrRemoteId, "renaming it");
 		if (data.status === "new") throw threadStatusError(threadIdOrRemoteId, data.status, "be renamed");
 		return this._state.optimisticUpdate({
 			execute: async () => {
 				const { remoteId } = await data.initializeTask;
-				return this._options.adapter.rename(remoteId, newTitle);
+				this._requireAdapterGeneration(adapterGeneration);
+				return adapter.rename(remoteId, newTitle);
 			},
 			optimistic: (state) => {
 				const data = getThreadData(state, threadIdOrRemoteId);
@@ -489,15 +580,18 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 			}
 		});
 	}
-	updateCustom(threadIdOrRemoteId, custom) {
+	async updateCustom(threadIdOrRemoteId, custom) {
+		this._requireAdapterSettled();
+		const adapter = this._options.adapter;
+		const adapterGeneration = this._adapterGeneration;
 		const data = this.getItemById(threadIdOrRemoteId);
 		if (!data) throw threadNotFoundError(threadIdOrRemoteId, "updating its custom metadata");
 		if (data.status === "new") throw threadStatusError(threadIdOrRemoteId, data.status, "update custom metadata");
-		if (!this._options.adapter.updateCustom) throw new Error("Remote thread list adapter does not support updating custom metadata");
+		if (!adapter.updateCustom) throw new Error("Remote thread list adapter does not support updating custom metadata");
 		return this._state.optimisticUpdate({
 			execute: async () => {
 				const { remoteId } = await data.initializeTask;
-				const adapter = this._options.adapter;
+				this._requireAdapterGeneration(adapterGeneration);
 				if (!adapter.updateCustom) throw new Error("Remote thread list adapter does not support updating custom metadata");
 				return adapter.updateCustom(remoteId, custom);
 			},
@@ -533,21 +627,29 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 		}
 	}
 	async archive(threadIdOrRemoteId) {
+		this._requireAdapterSettled();
+		const adapter = this._options.adapter;
+		const adapterGeneration = this._adapterGeneration;
 		const data = this.getItemById(threadIdOrRemoteId);
 		if (!data) throw threadNotFoundError(threadIdOrRemoteId, "archiving it");
 		if (data.status !== "regular") throw threadStatusError(threadIdOrRemoteId, data.status, "be archived");
 		await this._ensureThreadIsNotMain(data.id);
+		this._requireAdapterGeneration(adapterGeneration);
 		return this._state.optimisticUpdate({
 			execute: async () => {
 				const { remoteId } = await data.initializeTask;
-				return this._options.adapter.archive(remoteId);
+				this._requireAdapterGeneration(adapterGeneration);
+				return adapter.archive(remoteId);
 			},
 			optimistic: (state) => {
 				return updateStatusReducer(state, data.id, "archived");
 			}
 		});
 	}
-	unarchive(threadIdOrRemoteId) {
+	async unarchive(threadIdOrRemoteId) {
+		this._requireAdapterSettled();
+		const adapter = this._options.adapter;
+		const adapterGeneration = this._adapterGeneration;
 		const data = this.getItemById(threadIdOrRemoteId);
 		if (!data) throw threadNotFoundError(threadIdOrRemoteId, "unarchiving it");
 		if (data.status !== "archived") throw threadStatusError(threadIdOrRemoteId, data.status, "be unarchived");
@@ -555,9 +657,10 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 			execute: async () => {
 				try {
 					const { remoteId } = await data.initializeTask;
-					return await this._options.adapter.unarchive(remoteId);
+					this._requireAdapterGeneration(adapterGeneration);
+					return await adapter.unarchive(remoteId);
 				} catch (error) {
-					await this._ensureThreadIsNotMain(data.id);
+					if (adapterGeneration === this._adapterGeneration) await this._ensureThreadIsNotMain(data.id);
 					throw error;
 				}
 			},
@@ -567,15 +670,20 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 		});
 	}
 	async delete(threadIdOrRemoteId) {
+		this._requireAdapterSettled();
+		const adapter = this._options.adapter;
+		const adapterGeneration = this._adapterGeneration;
 		const data = this.getItemById(threadIdOrRemoteId);
 		if (!data) throw threadNotFoundError(threadIdOrRemoteId, "deleting it");
 		if (data.status !== "regular" && data.status !== "archived") throw threadStatusError(threadIdOrRemoteId, data.status, "be deleted");
 		await this._ensureThreadIsNotMain(data.id);
+		this._requireAdapterGeneration(adapterGeneration);
 		this._hookManager.stopThreadRuntime(data.id);
 		return this._state.optimisticUpdate({
 			execute: async () => {
 				const { remoteId } = await data.initializeTask;
-				return await this._options.adapter.delete(remoteId);
+				this._requireAdapterGeneration(adapterGeneration);
+				return await adapter.delete(remoteId);
 			},
 			optimistic: (state) => {
 				return updateStatusReducer(state, data.id, "deleted");
@@ -586,10 +694,12 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 		this._hookManager.__internal_dispose();
 	}
 	async detach(threadIdOrRemoteId) {
+		const adapterGeneration = this._adapterGeneration;
 		const data = this.getItemById(threadIdOrRemoteId);
 		if (!data) throw threadNotFoundError(threadIdOrRemoteId, "detaching it");
 		if (data.status !== "regular" && data.status !== "archived") throw threadStatusError(threadIdOrRemoteId, data.status, "be detached");
 		await this._ensureThreadIsNotMain(data.id);
+		this._requireAdapterGeneration(adapterGeneration);
 		this._hookManager.stopThreadRuntime(data.id);
 	}
 	useBoundIds = create(() => []);