@assistant-ui/core 0.3.15 → 0.3.17

package/dist/react/runtimes/RemoteThreadListThreadListRuntimeCore.js

@@ -1,60 +1,21 @@
-import { BaseSubscribable } from "../../subscribable/subscribable.js";
-import { generateId } from "../../utils/id.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, 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 { useSubscribable } from "../../store/runtime-clients/useSubscribable.js";
 import { ThreadListAdapterChangedError } from "../../runtimes/remote-thread-list/adapter-changed.js";
 import { useStableRuntimeAdapters } from "./useRuntimeAdapters.js";
+import { isTitleSourceMessage } from "../../runtimes/remote-thread-list/title.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}.`);
-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
-				}
-			}
-		}
-	};
-};
+const EMPTY_REMOTE_STATE = createEmptyRemoteThreadState();
 var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 	_options;
 	_hookManager;
@@ -97,9 +58,11 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 		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) => {
+					if (generation !== this._loadGeneration) return state;
 					return {
 						...state,
 						isLoading: true
@@ -115,24 +78,19 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 					const fresh = classifyThreads(l.threads, {
 						threadIds: [],
 						archivedThreadIds: [],
-						threadIdMap: {},
-						threadData: {}
+						threadIdMap: { ...state.threadIdMap },
+						threadData: { ...state.threadData }
 					});
-					return {
+					const merged = {
 						...state,
 						isLoading: false,
 						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);
 				}
 			}).catch((error) => {
 				if (generation !== this._loadGeneration) return;
@@ -167,10 +125,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;
@@ -212,19 +173,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++;
@@ -249,38 +209,40 @@ 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;
-			}
+			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: {},
+			threadData: {}
+		};
+		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 (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 current = threadData[createThreadMappingId(item.id)];
+			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,
@@ -295,7 +257,7 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 			const preservedDraft = nextState.newThreadId;
 			if (preservedDraft !== void 0) this._mainThreadId = preservedDraft;
 			else {
-				const seeded = addNewThread(nextState);
+				const seeded = seedNewThread(nextState);
 				this._mainThreadId = seeded.id;
 				nextState = seeded.state;
 			}
@@ -388,6 +350,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);
 	}
@@ -449,11 +414,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);
 	}
@@ -477,7 +452,7 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 		const state = this._state.baseValue;
 		let id = this._state.value.newThreadId;
 		if (id === void 0) {
-			const next = addNewThread(state);
+			const next = seedNewThread(state);
 			id = next.id;
 			this._state.update(next.state);
 		}
@@ -524,24 +499,29 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 				const data = getThreadData(state, threadId);
 				if (!data) return state;
 				const mappingId = createThreadMappingId(threadId);
+				const listedMappingId = state.threadIdMap[remoteId];
+				const orphan = listedMappingId !== void 0 && listedMappingId !== mappingId ? state.threadData[listedMappingId] : void 0;
+				const threadData = { ...state.threadData };
+				if (orphan !== void 0) delete threadData[listedMappingId];
+				threadData[mappingId] = {
+					...data,
+					initializeTask: Promise.resolve({
+						remoteId,
+						externalId
+					}),
+					remoteId,
+					externalId
+				};
+				const rewire = (ids) => orphan === void 0 ? ids : ids.filter((id) => id !== orphan.id);
 				return {
 					...state,
+					threadIds: rewire(state.threadIds),
+					archivedThreadIds: rewire(state.archivedThreadIds),
 					threadIdMap: {
 						...state.threadIdMap,
 						[remoteId]: mappingId
 					},
-					threadData: {
-						...state.threadData,
-						[mappingId]: {
-							...data,
-							initializeTask: Promise.resolve({
-								remoteId,
-								externalId
-							}),
-							remoteId,
-							externalId
-						}
-					}
+					threadData
 				};
 			}
 		});
@@ -568,17 +548,22 @@ var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
 		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
+							}
+						}
+					};
 				}
 			});
 		}
@@ -734,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,