@assistant-ui/core 0.3.16 → 0.3.18

package/dist/react/runtimes/RemoteThreadListThreadListRuntimeCore.js

@@ -1,17 +1,18 @@
-import { BaseSubscribable } from "../../subscribable/subscribable.js";
+import { nullProtoRecord } from "../../utils/record.js";
+import { BaseSubscribable, WritableSubscribable } from "../../subscribable/subscribable.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, createEmptyRemoteThreadState, createThreadMappingId, getThreadData, normalizeCursor, preserveMidLoadTransitions, seedNewThread, statusSnapshot, updateStatusReducer } from "../../runtimes/remote-thread-list/remote-thread-state.js";
+import { classifyThreads, createEmptyRemoteThreadState, createThreadMappingId, getThreadData, normalizeCursor, preserveMidLoadTransitions, promoteNewThreadReducer, reconcileInitializedThread, seedNewThread, statusSnapshot, updateStatusReducer } from "../../runtimes/remote-thread-list/remote-thread-state.js";
+import { useSubscribable } from "../../store/runtime-clients/useSubscribable.js";
 import { ThreadListAdapterChangedError } from "../../runtimes/remote-thread-list/adapter-changed.js";
 import { useStableRuntimeAdapters } from "./useRuntimeAdapters.js";
+import { applyTitleStream, isTitleSourceMessage } from "../../runtimes/remote-thread-list/title.js";
+import { clearThreadTitleState, finishThreadTitleRename, runThreadTitleGeneration, startThreadTitleRename } from "../../runtimes/remote-thread-list/title-generation.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 { useAui } from "@assistant-ui/store";
 import { jsx, jsxs } from "react/jsx-runtime";
-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}.`);
@@ -28,6 +29,7 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 	_staleThreadIdsOnReplace;
 	_switchGeneration = 0;
 	_switchTask;
+	_titleStates = /* @__PURE__ */ new Map();
 	_mainThreadId;
 	_state = new OptimisticState(EMPTY_REMOTE_STATE);
 	_useAdaptersProvider = ({ children }) => {
@@ -62,9 +64,11 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 			this._loadThreadsPromise = this._state.optimisticUpdate({
 				execute: () => this._options.adapter.list(),
 				loading: (state) => {
+					if (generation !== this._loadGeneration) return state;
 					return {
 						...state,
-						isLoading: true
+						isLoading: true,
+						loadError: void 0
 					};
 				},
 				then: (state, l) => {
@@ -72,28 +76,26 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 					if (this._replaceListOnNextLoad) {
 						this._replaceListOnNextLoad = false;
 						replacedList = true;
-						return this._replaceWithThreads(state, l.threads, normalizeCursor(l.nextCursor));
+						return this._replaceWithThreads({
+							...state,
+							loadError: void 0
+						}, l.threads, normalizeCursor(l.nextCursor));
 					}
 					const fresh = classifyThreads(l.threads, {
 						threadIds: [],
 						archivedThreadIds: [],
-						threadIdMap: {},
-						threadData: {}
+						threadIdMap: { ...state.threadIdMap },
+						threadData: { ...state.threadData }
 					});
 					const merged = {
 						...state,
 						isLoading: false,
+						loadError: void 0,
 						cursor: normalizeCursor(l.nextCursor),
 						threadIds: fresh.threadIds,
 						archivedThreadIds: fresh.archivedThreadIds,
-						threadIdMap: {
-							...state.threadIdMap,
-							...fresh.threadIdMap
-						},
-						threadData: {
-							...state.threadData,
-							...fresh.threadData
-						}
+						threadIdMap: fresh.threadIdMap,
+						threadData: fresh.threadData
 					};
 					return preserveMidLoadTransitions(merged, state, statusAtRequest);
 				}
@@ -104,13 +106,17 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 				if (!this._replaceListOnNextLoad) {
 					this._state.update({
 						...this._state.baseValue,
-						isLoading: false
+						isLoading: false,
+						loadError: error
 					});
 					return;
 				}
 				this._replaceListOnNextLoad = false;
 				replacedList = true;
-				this._state.update(this._replaceWithThreads(this._state.baseValue, [], void 0));
+				this._state.update(this._replaceWithThreads({
+					...this._state.baseValue,
+					loadError: error
+				}, [], void 0));
 			}).then(() => {
 				if (!replacedList) return;
 				const threadId = this._options.threadId;
@@ -130,10 +136,13 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 		const cursor = initialState.cursor;
 		const dedup = this._state.optimisticUpdate({
 			execute: () => adapter.list({ after: cursor }),
-			loading: (state) => ({
-				...state,
-				isLoadingMore: true
-			}),
+			loading: (state) => {
+				if (generation !== this._loadGeneration) return state;
+				return {
+					...state,
+					isLoadingMore: true
+				};
+			},
 			then: (state, l) => {
 				if (generation !== this._loadGeneration) return state;
 				if (adapter !== this._options.adapter) return state;
@@ -175,19 +184,18 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 		this._hookManager.__internal_subscribeRuntimeReplaced(() => {
 			queueMicrotask(() => this._notifySubscribers());
 		});
-		this.useProvider = create(() => ({ Provider: this.resolveProvider(options.adapter) }));
+		this.providerStore = new WritableSubscribable(this.resolveProvider(options.adapter));
 		this.__internal_setOptions(options);
 		this.switchToNewThread();
 	}
 	_initialThreadLoaded = false;
-	useProvider;
+	providerStore;
 	__internal_setOptions(options) {
 		if (this._options === options) return;
 		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 = this.resolveProvider(options.adapter);
-		if (Provider !== this.useProvider.getState().Provider) this.useProvider.setState({ Provider }, true);
+		this.providerStore.setState(this.resolveProvider(options.adapter));
 		this._hookManager.setRuntimeHook(options.runtimeHook);
 		if (adapterChanged) {
 			this._loadGeneration++;
@@ -200,8 +208,10 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 			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
+				cursor: void 0,
+				loadError: void 0
 			});
+			this._titleStates.clear();
 		}
 		if (controlledThreadIdChanged) this._switchToThreadFromProp(options.threadId).catch(() => {});
 	}
@@ -212,38 +222,41 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 		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];
+		const carried = [];
 		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 mappingId = Object.hasOwn(state.threadIdMap, state.newThreadId) ? state.threadIdMap[state.newThreadId] : void 0;
+			const draft = mappingId && Object.hasOwn(state.threadData, mappingId) ? state.threadData[mappingId] : void 0;
+			if (draft?.status === "new") carried.push(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;
+			carried.push(item);
+		}
+		this._staleThreadIdsOnReplace = void 0;
+		const seed = {
+			threadIds: [],
+			archivedThreadIds: [],
+			threadIdMap: nullProtoRecord(),
+			threadData: nullProtoRecord()
+		};
+		for (const item of carried) {
 			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 (Object.hasOwn(seed.threadData, mappingId)) continue;
+			seed.threadIdMap[item.id] = mappingId;
+			if (item.remoteId !== void 0) seed.threadIdMap[item.remoteId] = mappingId;
+			seed.threadData[mappingId] = item;
+		}
+		const { threadIds, archivedThreadIds, threadIdMap, threadData } = classifyThreads(threads, seed);
+		for (const item of carried) {
 			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);
+			const currentMappingId = createThreadMappingId(item.id);
+			const current = Object.hasOwn(threadData, currentMappingId) ? threadData[currentMappingId] : void 0;
+			if (current === void 0) continue;
+			if (current.status === "regular" && !threadIds.includes(current.id)) threadIds.push(current.id);
+			else if (current.status === "archived" && !archivedThreadIds.includes(current.id)) archivedThreadIds.push(current.id);
 		}
-		this._staleThreadIdsOnReplace = void 0;
 		let nextState = {
 			...state,
 			isLoading: false,
@@ -252,7 +265,7 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 			archivedThreadIds,
 			threadIdMap,
 			threadData,
-			newThreadId: state.newThreadId !== void 0 && threadIdMap[state.newThreadId] === void 0 ? void 0 : state.newThreadId
+			newThreadId: state.newThreadId !== void 0 && !Object.hasOwn(threadIdMap, state.newThreadId) ? void 0 : state.newThreadId
 		};
 		if (getThreadData(nextState, this._mainThreadId) === void 0) {
 			const preservedDraft = nextState.newThreadId;
@@ -305,6 +318,9 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 	get isLoading() {
 		return this._state.value.isLoading;
 	}
+	get loadError() {
+		return this._state.value.loadError;
+	}
 	get isLoadingMore() {
 		return this._state.value.isLoadingMore;
 	}
@@ -351,6 +367,9 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 		if (!data) return false;
 		return this._hookManager.__internal_isThreadRunning(data.id);
 	}
+	unstable_subscribeThreadEvents(callback) {
+		return this._hookManager.__internal_subscribeThreadEvents(callback);
+	}
 	getItemById(threadIdOrRemoteId) {
 		return getThreadData(this._state.value, threadIdOrRemoteId);
 	}
@@ -412,11 +431,21 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 		if (this.mainThreadId !== void 0) await task;
 		else task.then(() => this._notifySubscribers(), () => void 0);
 		if (generation !== this._switchGeneration) return;
-		if (data.status === "archived" && options?.unarchive !== false) {
-			await this.unarchive(data.id);
+		let current = this.getItemById(data.id);
+		if (current?.id !== data.id) return;
+		if (current.status === "archived" && options?.unarchive !== false) {
+			await current.initializeTask;
 			if (generation !== this._switchGeneration) return;
+			current = this.getItemById(data.id);
+			if (current?.id !== data.id) return;
+			if (current.status === "archived") {
+				await this.unarchive(current.id);
+				if (generation !== this._switchGeneration) return;
+				current = this.getItemById(data.id);
+				if (current?.id !== data.id) return;
+			}
 		}
-		this._mainThreadId = data.id;
+		this._mainThreadId = current.id;
 		this._notifySubscribers();
 		this._notifyThreadIdChange(emitThreadIdChange);
 	}
@@ -461,60 +490,28 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 				externalId
 			};
 		}
+		this._requireAdapterGeneration(adapterGeneration);
+		const initializeTask = adapter.initialize(threadId);
+		let removedMappingId;
 		const { remoteId, externalId } = await this._state.optimisticUpdate({
-			execute: () => {
-				this._requireAdapterGeneration(adapterGeneration);
-				return adapter.initialize(threadId);
-			},
-			optimistic: (state) => {
-				return updateStatusReducer(state, threadId, "regular");
-			},
-			loading: (state, task) => {
-				const mappingId = createThreadMappingId(threadId);
-				return {
-					...state,
-					threadData: {
-						...state.threadData,
-						[mappingId]: {
-							...state.threadData[mappingId],
-							initializeTask: task
-						}
-					}
-				};
-			},
+			execute: () => initializeTask,
+			optimistic: (state) => promoteNewThreadReducer(state, threadId, initializeTask),
 			then: (state, { remoteId, externalId }) => {
 				if (adapterGeneration !== this._adapterGeneration) return state;
-				const data = getThreadData(state, threadId);
-				if (!data) return state;
-				const mappingId = createThreadMappingId(threadId);
-				return {
-					...state,
-					threadIdMap: {
-						...state.threadIdMap,
-						[remoteId]: mappingId
-					},
-					threadData: {
-						...state.threadData,
-						[mappingId]: {
-							...data,
-							initializeTask: Promise.resolve({
-								remoteId,
-								externalId
-							}),
-							remoteId,
-							externalId
-						}
-					}
-				};
+				const reconciliation = reconcileInitializedThread(state, threadId, remoteId, externalId, threadId);
+				removedMappingId = reconciliation.removedMappingId;
+				if (removedMappingId === this._mainThreadId) this._mainThreadId = reconciliation.survivorMappingId;
+				return reconciliation.state;
 			}
 		});
 		this._requireAdapterGeneration(adapterGeneration);
+		if (removedMappingId !== void 0) this._hookManager.stopThreadRuntime(removedMappingId);
 		return {
 			remoteId,
 			externalId
 		};
 	};
-	generateTitle = async (threadId) => {
+	generateTitle = async (threadId, options) => {
 		this._requireAdapterSettled();
 		const adapter = this._options.adapter;
 		const adapterGeneration = this._adapterGeneration;
@@ -526,16 +523,58 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 		const runtimeCore = this._hookManager.getThreadRuntimeCore(data.id);
 		if (!runtimeCore) return;
 		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;
-			await this._state.optimisticUpdate({
-				execute: async () => {},
+		await runThreadTitleGeneration({
+			states: this._titleStates,
+			threadId: data.id,
+			automatic: options?.automatic === true,
+			generate: async (onTitle) => {
+				const stream = await adapter.generateTitle(remoteId, messages);
+				this._requireAdapterGeneration(adapterGeneration);
+				await applyTitleStream(stream, onTitle);
+			},
+			rename: async (title) => {
+				this._requireAdapterGeneration(adapterGeneration);
+				await adapter.rename(remoteId, title);
+			},
+			applyTitle: async (title) => {
+				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
+								}
+							}
+						};
+					}
+				});
+			}
+		});
+	};
+	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");
+		const claim = startThreadTitleRename(this._titleStates, data.id, newTitle);
+		try {
+			const result = await this._state.optimisticUpdate({
+				execute: async () => {
+					const { remoteId } = await data.initializeTask;
+					this._requireAdapterGeneration(adapterGeneration);
+					return adapter.rename(remoteId, newTitle);
+				},
 				optimistic: (state) => {
-					if (adapterGeneration !== this._adapterGeneration) return state;
-					const currentData = getThreadData(state, data.id);
+					const currentData = getThreadData(state, threadIdOrRemoteId);
 					if (!currentData) return state;
 					return {
 						...state,
@@ -549,36 +588,12 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 					};
 				}
 			});
+			finishThreadTitleRename(this._titleStates, data.id, claim, true);
+			return result;
+		} catch (error) {
+			finishThreadTitleRename(this._titleStates, data.id, claim, false);
+			throw error;
 		}
-	};
-	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;
-				this._requireAdapterGeneration(adapterGeneration);
-				return adapter.rename(remoteId, newTitle);
-			},
-			optimistic: (state) => {
-				const data = getThreadData(state, threadIdOrRemoteId);
-				if (!data) return state;
-				return {
-					...state,
-					threadData: {
-						...state.threadData,
-						[data.id]: {
-							...data,
-							title: newTitle
-						}
-					}
-				};
-			}
-		});
 	}
 	async updateCustom(threadIdOrRemoteId, custom) {
 		this._requireAdapterSettled();
@@ -678,8 +693,7 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 		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({
+		const result = await this._state.optimisticUpdate({
 			execute: async () => {
 				const { remoteId } = await data.initializeTask;
 				this._requireAdapterGeneration(adapterGeneration);
@@ -689,6 +703,9 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 				return updateStatusReducer(state, data.id, "deleted");
 			}
 		});
+		this._hookManager.stopThreadRuntime(data.id);
+		clearThreadTitleState(this._titleStates, data.id);
+		return result;
 	}
 	__internal_dispose() {
 		this._hookManager.__internal_dispose();
@@ -702,17 +719,17 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 		this._requireAdapterGeneration(adapterGeneration);
 		this._hookManager.stopThreadRuntime(data.id);
 	}
-	useBoundIds = create(() => []);
+	boundIdsStore = new WritableSubscribable([]);
 	__internal_RenderComponent = () => {
 		const id = useId();
 		useEffect(() => {
-			this.useBoundIds.setState((s) => [...s, id], true);
+			this.boundIdsStore.setState([...this.boundIdsStore.getState(), id]);
 			return () => {
-				this.useBoundIds.setState((s) => s.filter((i) => i !== id), true);
+				this.boundIdsStore.setState(this.boundIdsStore.getState().filter((i) => i !== id));
 			};
 		}, [id]);
-		const boundIds = this.useBoundIds();
-		const { Provider } = this.useProvider();
+		const boundIds = useSubscribable(this.boundIdsStore);
+		const Provider = useSubscribable(this.providerStore);
 		const aui = useAui();
 		return (boundIds.length === 0 || boundIds[0] === id) && /* @__PURE__ */ jsxs(RuntimeAdapterProvider, {
 			adapters: this._runtimeAdapters,