@assistant-ui/core 0.3.13 → 0.3.15

package/dist/react/runtimes/RemoteThreadListThreadListRuntimeCore.js

@@ -1,43 +1,102 @@
-import { generateId } from "../../utils/id.js";
 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 { ThreadListAdapterChangedError } from "../../runtimes/remote-thread-list/adapter-changed.js";
+import { useStableRuntimeAdapters } from "./useRuntimeAdapters.js";
 import { RuntimeAdapterProvider } from "./RuntimeAdapterProvider.js";
+import { isTitleSourceMessage } from "./RemoteThreadResource.js";
 import { RemoteThreadListHookInstanceManager } from "./RemoteThreadListHookInstanceManager.js";
 import { AssistantMessageStream } from "assistant-stream";
 import { Fragment, useEffect, useId } from "@assistant-ui/tap/react-shim";
-import { jsx } from "react/jsx-runtime";
+import { useAui } from "@assistant-ui/store";
+import { jsx, jsxs } from "react/jsx-runtime";
 import { create } from "zustand";
 //#region src/react/runtimes/RemoteThreadListThreadListRuntimeCore.tsx
-const asProviderComponent = (provider) => provider ?? Fragment;
 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 = {
+	isLoading: true,
+	isLoadingMore: false,
+	cursor: void 0,
+	newThreadId: void 0,
+	threadIds: [],
+	archivedThreadIds: [],
+	threadIdMap: {},
+	threadData: {}
+};
+const addNewThread = (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
+				}
+			}
+		}
+	};
+};
 var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 	_options;
 	_hookManager;
+	_runtimeAdapters;
 	_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;
+		return /* @__PURE__ */ jsx(this._SynthesizedAdapters, {
+			useAdapters,
+			children
+		});
+	};
+	_SynthesizedAdapters = ({ useAdapters, children }) => {
+		const adapters = useStableRuntimeAdapters(useAdapters());
+		if (adapters == null) return children;
+		return /* @__PURE__ */ jsx(RuntimeAdapterProvider, {
+			adapters,
+			children
+		});
+	};
+	resolveProvider(adapter) {
+		if (adapter.unstable_Provider !== void 0) return adapter.unstable_Provider;
+		if (adapter.unstable_useAdapters === void 0) return Fragment;
+		return this._useAdaptersProvider;
+	}
 	get threadItems() {
 		return this._state.value.threadData;
 	}
 	getLoadThreadsPromise() {
 		if (!this._loadThreadsPromise) {
 			const generation = this._loadGeneration;
+			let replacedList = false;
 			this._loadThreadsPromise = this._state.optimisticUpdate({
 				execute: () => this._options.adapter.list(),
 				loading: (state) => {
@@ -48,6 +107,11 @@ 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: [],
@@ -74,11 +138,23 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 				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;
 	}
@@ -115,6 +191,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;
@@ -122,17 +199,20 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 		this._loadMorePromise = dedup;
 		return dedup;
 	}
-	contextProvider;
 	constructor(options, contextProvider) {
 		super();
-		this.contextProvider = contextProvider;
 		this._state.subscribe(() => {
 			this._notifySubscribers();
 			this._notifyThreadIdChange();
 		});
+		this._runtimeAdapters = { modelContext: contextProvider };
 		this._hookManager = new RemoteThreadListHookInstanceManager(options.runtimeHook, this);
+		this._hookManager.__internal_setDefaultAdapters(this._runtimeAdapters);
 		this._hookManager.__internal_subscribeRunningChanged(() => this._notifySubscribers());
-		this.useProvider = create(() => ({ Provider: asProviderComponent(options.adapter.unstable_Provider) }));
+		this._hookManager.__internal_subscribeRuntimeReplaced(() => {
+			queueMicrotask(() => this._notifySubscribers());
+		});
+		this.useProvider = create(() => ({ Provider: this.resolveProvider(options.adapter) }));
 		this.__internal_setOptions(options);
 		this.switchToNewThread();
 	}
@@ -143,13 +223,18 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 		const adapterChanged = this._options !== void 0 && this._options.adapter !== options.adapter;
 		const controlledThreadIdChanged = this._initialThreadLoaded && this._options !== void 0 && this._options.threadId !== options.threadId;
 		this._options = options;
-		const Provider = asProviderComponent(options.adapter.unstable_Provider);
+		const Provider = this.resolveProvider(options.adapter);
 		if (Provider !== this.useProvider.getState().Provider) this.useProvider.setState({ Provider }, true);
 		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
@@ -157,6 +242,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 = addNewThread(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;
@@ -251,6 +401,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);
@@ -323,41 +474,25 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 			await this._state.waitForUpdate();
 			if (generation !== this._switchGeneration) return;
 		}
-		const state = this._state.value;
+		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 = addNewThread(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
@@ -365,7 +500,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");
@@ -384,6 +520,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);
@@ -408,22 +545,28 @@ 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;
-		const stream = await this._options.adapter.generateTitle(remoteId, messages);
+		const messages = runtimeCore.messages.filter(isTitleSourceMessage);
+		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);
@@ -440,14 +583,18 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 			});
 		}
 	};
-	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);
@@ -465,15 +612,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);
 			},
@@ -509,21 +659,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");
@@ -531,9 +689,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;
 				}
 			},
@@ -543,26 +702,36 @@ 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");
 			}
 		});
 	}
+	__internal_dispose() {
+		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(() => []);
@@ -576,10 +745,10 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 		}, [id]);
 		const boundIds = this.useBoundIds();
 		const { Provider } = this.useProvider();
-		const adapters = { modelContext: this.contextProvider };
-		return (boundIds.length === 0 || boundIds[0] === id) && /* @__PURE__ */ jsx(RuntimeAdapterProvider, {
-			adapters,
-			children: /* @__PURE__ */ jsx(this._hookManager.__internal_RenderThreadRuntimes, { provider: Provider })
+		const aui = useAui();
+		return (boundIds.length === 0 || boundIds[0] === id) && /* @__PURE__ */ jsxs(RuntimeAdapterProvider, {
+			adapters: this._runtimeAdapters,
+			children: [/* @__PURE__ */ jsx(this._hookManager.__internal_RenderThreadRuntimes, { provider: Provider }), /* @__PURE__ */ jsx(this._hookManager.__internal_Host, { parentClient: aui })]
 		});
 	};
 };