@assistant-ui/core 0.2.4 → 0.2.5

package/dist/react/runtimes/RemoteThreadListThreadListRuntimeCore.js

@@ -1,523 +1,468 @@
-import { jsx as _jsx } from "react/jsx-runtime";
 import { generateId } from "../../utils/id.js";
 import { BaseSubscribable } 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, createThreadMappingId, getThreadData, normalizeCursor, updateStatusReducer } from "../../runtimes/remote-thread-list/remote-thread-state.js";
+import { RuntimeAdapterProvider } from "./RuntimeAdapterProvider.js";
 import { RemoteThreadListHookInstanceManager } from "./RemoteThreadListHookInstanceManager.js";
+import { AssistantMessageStream } from "assistant-stream";
 import { Fragment, useEffect, useId } from "react";
+import { jsx } from "react/jsx-runtime";
 import { create } from "zustand";
-import { AssistantMessageStream } from "assistant-stream";
-import { RuntimeAdapterProvider } from "./RuntimeAdapterProvider.js";
-export class RemoteThreadListThreadListRuntimeCore extends BaseSubscribable {
-    _options;
-    _hookManager;
-    _loadThreadsPromise;
-    _loadMorePromise;
-    _loadGeneration = 0;
-    _mainThreadId;
-    _state = new OptimisticState({
-        isLoading: true,
-        isLoadingMore: false,
-        cursor: undefined,
-        newThreadId: undefined,
-        threadIds: [],
-        archivedThreadIds: [],
-        threadIdMap: {},
-        threadData: {},
-    });
-    get threadItems() {
-        return this._state.value.threadData;
-    }
-    getLoadThreadsPromise() {
-        // TODO this needs to be cached in case this promise is loaded during suspense
-        if (!this._loadThreadsPromise) {
-            const generation = this._loadGeneration;
-            this._loadThreadsPromise = this._state
-                .optimisticUpdate({
-                execute: () => this._options.adapter.list(),
-                loading: (state) => {
-                    return {
-                        ...state,
-                        isLoading: true,
-                    };
-                },
-                // biome-ignore lint/suspicious/noThenProperty: OptimisticState reducer pattern
-                then: (state, l) => {
-                    if (generation !== this._loadGeneration)
-                        return state;
-                    const fresh = classifyThreads(l.threads, {
-                        threadIds: [],
-                        archivedThreadIds: [],
-                        threadIdMap: {},
-                        threadData: {},
-                    });
-                    return {
-                        ...state,
-                        isLoading: false,
-                        cursor: normalizeCursor(l.nextCursor),
-                        threadIds: fresh.threadIds,
-                        archivedThreadIds: fresh.archivedThreadIds,
-                        threadIdMap: {
-                            ...state.threadIdMap,
-                            ...fresh.threadIdMap,
-                        },
-                        threadData: {
-                            ...state.threadData,
-                            ...fresh.threadData,
-                        },
-                    };
-                },
-            })
-                .catch((error) => {
-                if (generation !== this._loadGeneration)
-                    return;
-                console.error("[assistant-ui] thread list load failed:", error);
-                this._loadThreadsPromise = undefined;
-                this._state.update({
-                    ...this._state.baseValue,
-                    isLoading: false,
-                });
-            })
-                .then(() => { });
-        }
-        return this._loadThreadsPromise;
-    }
-    loadMore() {
-        if (this._loadMorePromise)
-            return this._loadMorePromise;
-        const initialState = this._state.value;
-        if (initialState.cursor === undefined || initialState.isLoading) {
-            return Promise.resolve();
-        }
-        const generation = this._loadGeneration;
-        const adapter = this._options.adapter;
-        const cursor = initialState.cursor;
-        const dedup = this._state
-            .optimisticUpdate({
-            execute: () => adapter.list({ after: cursor }),
-            loading: (state) => ({ ...state, isLoadingMore: true }),
-            // biome-ignore lint/suspicious/noThenProperty: OptimisticState reducer pattern
-            then: (state, l) => {
-                if (generation !== this._loadGeneration)
-                    return state;
-                if (adapter !== this._options.adapter)
-                    return state;
-                const appended = classifyThreads(l.threads, {
-                    threadIds: [...state.threadIds],
-                    archivedThreadIds: [...state.archivedThreadIds],
-                    threadIdMap: { ...state.threadIdMap },
-                    threadData: { ...state.threadData },
-                });
-                return {
-                    ...state,
-                    isLoadingMore: false,
-                    cursor: normalizeCursor(l.nextCursor),
-                    threadIds: appended.threadIds,
-                    archivedThreadIds: appended.archivedThreadIds,
-                    threadIdMap: appended.threadIdMap,
-                    threadData: appended.threadData,
-                };
-            },
-        })
-            .catch((error) => {
-            console.error("[assistant-ui] thread list loadMore failed:", error);
-        })
-            .then(() => {
-            if (this._loadMorePromise === dedup) {
-                this._loadMorePromise = undefined;
-            }
-        });
-        this._loadMorePromise = dedup;
-        return dedup;
-    }
-    contextProvider;
-    constructor(options, contextProvider) {
-        super();
-        this.contextProvider = contextProvider;
-        this._state.subscribe(() => this._notifySubscribers());
-        this._hookManager = new RemoteThreadListHookInstanceManager(options.runtimeHook, this);
-        this.useProvider = create(() => ({
-            Provider: options.adapter.unstable_Provider ?? Fragment,
-        }));
-        this.__internal_setOptions(options);
-        this.switchToNewThread();
-    }
-    _initialThreadLoaded = false;
-    useProvider;
-    __internal_setOptions(options) {
-        if (this._options === options)
-            return;
-        const adapterChanged = this._options !== undefined && this._options.adapter !== options.adapter;
-        this._options = options;
-        const Provider = options.adapter.unstable_Provider ?? Fragment;
-        if (Provider !== this.useProvider.getState().Provider) {
-            this.useProvider.setState({ Provider }, true);
-        }
-        this._hookManager.setRuntimeHook(options.runtimeHook);
-        if (adapterChanged) {
-            this._loadGeneration++;
-            this._loadThreadsPromise = undefined;
-            this._loadMorePromise = undefined;
-            this._state.update({
-                ...this._state.baseValue,
-                cursor: undefined,
-            });
-        }
-    }
-    __internal_load() {
-        this.getLoadThreadsPromise(); // begin loading on initial bind
-        const startThreadId = this._options.threadId ?? this._options.initialThreadId;
-        if (!this._initialThreadLoaded && startThreadId) {
-            this._initialThreadLoaded = true;
-            this.switchToThread(startThreadId).catch(() => { });
-        }
-    }
-    reload() {
-        this._loadGeneration++;
-        this._loadThreadsPromise = undefined;
-        this._loadMorePromise = undefined;
-        this._state.update({
-            ...this._state.baseValue,
-            cursor: undefined,
-        });
-        return this.getLoadThreadsPromise();
-    }
-    get isLoading() {
-        return this._state.value.isLoading;
-    }
-    get isLoadingMore() {
-        return this._state.value.isLoadingMore;
-    }
-    get hasMore() {
-        return this._state.value.cursor !== undefined;
-    }
-    get threadIds() {
-        return this._state.value.threadIds;
-    }
-    get archivedThreadIds() {
-        return this._state.value.archivedThreadIds;
-    }
-    get newThreadId() {
-        return this._state.value.newThreadId;
-    }
-    get mainThreadId() {
-        return this._mainThreadId;
-    }
-    getMainThreadRuntimeCore() {
-        const result = this._hookManager.getThreadRuntimeCore(this._mainThreadId);
-        if (!result)
-            return EMPTY_THREAD_CORE;
-        return result;
-    }
-    getThreadRuntimeCore(threadIdOrRemoteId) {
-        const data = this.getItemById(threadIdOrRemoteId);
-        if (!data)
-            throw new Error("Thread not found");
-        const result = this._hookManager.getThreadRuntimeCore(data.id);
-        if (!result)
-            throw new Error("Thread not found");
-        return result;
-    }
-    getItemById(threadIdOrRemoteId) {
-        return getThreadData(this._state.value, threadIdOrRemoteId);
-    }
-    async switchToThread(threadIdOrRemoteId) {
-        let data = this.getItemById(threadIdOrRemoteId);
-        if (!data) {
-            const remoteMetadata = await this._options.adapter.fetch(threadIdOrRemoteId);
-            const state = this._state.value;
-            const mappingId = createThreadMappingId(remoteMetadata.remoteId);
-            const newThreadData = {
-                ...state.threadData,
-                [mappingId]: {
-                    id: mappingId,
-                    initializeTask: Promise.resolve({
-                        remoteId: remoteMetadata.remoteId,
-                        externalId: remoteMetadata.externalId,
-                    }),
-                    remoteId: remoteMetadata.remoteId,
-                    externalId: remoteMetadata.externalId,
-                    status: remoteMetadata.status,
-                    title: remoteMetadata.title,
-                    custom: remoteMetadata.custom,
-                },
-            };
-            const newThreadIdMap = {
-                ...state.threadIdMap,
-                [remoteMetadata.remoteId]: mappingId,
-            };
-            // Filter both arrays first so a concurrent `list()` can't leave the id
-            // duplicated or under the wrong status.
-            const threadIdsWithoutRemote = state.threadIds.filter((id) => id !== remoteMetadata.remoteId);
-            const archivedThreadIdsWithoutRemote = state.archivedThreadIds.filter((id) => id !== remoteMetadata.remoteId);
-            const newThreadIds = remoteMetadata.status === "regular"
-                ? [...threadIdsWithoutRemote, remoteMetadata.remoteId]
-                : threadIdsWithoutRemote;
-            const newArchivedThreadIds = remoteMetadata.status === "archived"
-                ? [...archivedThreadIdsWithoutRemote, remoteMetadata.remoteId]
-                : archivedThreadIdsWithoutRemote;
-            this._state.update({
-                ...state,
-                threadIds: newThreadIds,
-                archivedThreadIds: newArchivedThreadIds,
-                threadIdMap: newThreadIdMap,
-                threadData: newThreadData,
-            });
-            data = this.getItemById(threadIdOrRemoteId);
-        }
-        if (!data)
-            throw new Error("Thread not found");
-        if (this._mainThreadId === data.id)
-            return;
-        const task = this._hookManager.startThreadRuntime(data.id);
-        if (this.mainThreadId !== undefined) {
-            await task;
-        }
-        else {
-            task.then(() => this._notifySubscribers());
-        }
-        if (data.status === "archived")
-            await this.unarchive(data.id);
-        this._mainThreadId = data.id;
-        this._notifySubscribers();
-    }
-    async switchToNewThread() {
-        // an initialization transaction is in progress, wait for it to settle
-        while (this._state.baseValue.newThreadId !== undefined &&
-            this._state.value.newThreadId === undefined) {
-            await this._state.waitForUpdate();
-        }
-        const state = this._state.value;
-        let id = this._state.value.newThreadId;
-        if (id === undefined) {
-            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: undefined,
-                        externalId: undefined,
-                        title: undefined,
-                        custom: undefined,
-                    },
-                },
-            });
-        }
-        return this.switchToThread(id);
-    }
-    initialize = async (threadId) => {
-        if (this._state.value.newThreadId !== threadId) {
-            const data = this.getItemById(threadId);
-            if (!data)
-                throw new Error("Thread not found");
-            if (data.status === "new")
-                throw new Error("Unexpected new state");
-            return data.initializeTask;
-        }
-        return this._state.optimisticUpdate({
-            execute: () => {
-                return this._options.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,
-                        },
-                    },
-                };
-            },
-            // biome-ignore lint/suspicious/noThenProperty: OptimisticState reducer pattern
-            then: (state, { remoteId, externalId }) => {
-                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,
-                        },
-                    },
-                };
-            },
-        });
-    };
-    generateTitle = async (threadId) => {
-        const data = this.getItemById(threadId);
-        if (!data)
-            throw new Error("Thread not found");
-        if (data.status === "new")
-            throw new Error("Thread is not yet initialized");
-        const { remoteId } = await data.initializeTask;
-        const runtimeCore = this._hookManager.getThreadRuntimeCore(data.id);
-        if (!runtimeCore)
-            return; // thread is no longer running
-        const messages = runtimeCore.messages;
-        const stream = await this._options.adapter.generateTitle(remoteId, messages);
-        const messageStream = AssistantMessageStream.fromAssistantStream(stream);
-        for await (const result of messageStream) {
-            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,
-                    },
-                },
-            });
-        }
-    };
-    rename(threadIdOrRemoteId, newTitle) {
-        const data = this.getItemById(threadIdOrRemoteId);
-        if (!data)
-            throw new Error("Thread not found");
-        if (data.status === "new")
-            throw new Error("Thread is not yet initialized");
-        return this._state.optimisticUpdate({
-            execute: async () => {
-                const { remoteId } = await data.initializeTask;
-                return this._options.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 _ensureThreadIsNotMain(threadId) {
-        if (threadId === this.newThreadId)
-            throw new Error("Cannot ensure new thread is not main");
-        if (threadId === this._mainThreadId) {
-            await this.switchToNewThread();
-        }
-    }
-    async archive(threadIdOrRemoteId) {
-        const data = this.getItemById(threadIdOrRemoteId);
-        if (!data)
-            throw new Error("Thread not found");
-        if (data.status !== "regular")
-            throw new Error("Thread is not yet initialized or already archived");
-        await this._ensureThreadIsNotMain(data.id);
-        return this._state.optimisticUpdate({
-            execute: async () => {
-                const { remoteId } = await data.initializeTask;
-                return this._options.adapter.archive(remoteId);
-            },
-            optimistic: (state) => {
-                return updateStatusReducer(state, data.id, "archived");
-            },
-        });
-    }
-    unarchive(threadIdOrRemoteId) {
-        const data = this.getItemById(threadIdOrRemoteId);
-        if (!data)
-            throw new Error("Thread not found");
-        if (data.status !== "archived")
-            throw new Error("Thread is not archived");
-        return this._state.optimisticUpdate({
-            execute: async () => {
-                try {
-                    const { remoteId } = await data.initializeTask;
-                    return await this._options.adapter.unarchive(remoteId);
-                }
-                catch (error) {
-                    await this._ensureThreadIsNotMain(data.id);
-                    throw error;
-                }
-            },
-            optimistic: (state) => {
-                return updateStatusReducer(state, data.id, "regular");
-            },
-        });
-    }
-    async delete(threadIdOrRemoteId) {
-        const data = this.getItemById(threadIdOrRemoteId);
-        if (!data)
-            throw new Error("Thread not found");
-        if (data.status !== "regular" && data.status !== "archived")
-            throw new Error("Thread is not yet initialized");
-        await this._ensureThreadIsNotMain(data.id);
-        this._hookManager.stopThreadRuntime(data.id);
-        return this._state.optimisticUpdate({
-            execute: async () => {
-                const { remoteId } = await data.initializeTask;
-                return await this._options.adapter.delete(remoteId);
-            },
-            optimistic: (state) => {
-                return updateStatusReducer(state, data.id, "deleted");
-            },
-        });
-    }
-    async detach(threadIdOrRemoteId) {
-        const data = this.getItemById(threadIdOrRemoteId);
-        if (!data)
-            throw new Error("Thread not found");
-        if (data.status !== "regular" && data.status !== "archived")
-            throw new Error("Thread is not yet initialized");
-        await this._ensureThreadIsNotMain(data.id);
-        this._hookManager.stopThreadRuntime(data.id);
-    }
-    useBoundIds = create(() => []);
-    __internal_RenderComponent = () => {
-        const id = useId();
-        useEffect(() => {
-            this.useBoundIds.setState((s) => [...s, id], true);
-            return () => {
-                this.useBoundIds.setState((s) => s.filter((i) => i !== id), true);
-            };
-        }, [id]);
-        const boundIds = this.useBoundIds();
-        const { Provider } = this.useProvider();
-        const adapters = {
-            modelContext: this.contextProvider,
-        };
-        return ((boundIds.length === 0 || boundIds[0] === id) && (_jsx(RuntimeAdapterProvider, { adapters: adapters, children: _jsx(this._hookManager.__internal_RenderThreadRuntimes, { provider: Provider }) })));
-    };
-}
+//#region src/react/runtimes/RemoteThreadListThreadListRuntimeCore.tsx
+var RemoteThreadListThreadListRuntimeCore = class extends BaseSubscribable {
+	_options;
+	_hookManager;
+	_loadThreadsPromise;
+	_loadMorePromise;
+	_loadGeneration = 0;
+	_mainThreadId;
+	_state = new OptimisticState({
+		isLoading: true,
+		isLoadingMore: false,
+		cursor: void 0,
+		newThreadId: void 0,
+		threadIds: [],
+		archivedThreadIds: [],
+		threadIdMap: {},
+		threadData: {}
+	});
+	get threadItems() {
+		return this._state.value.threadData;
+	}
+	getLoadThreadsPromise() {
+		if (!this._loadThreadsPromise) {
+			const generation = this._loadGeneration;
+			this._loadThreadsPromise = this._state.optimisticUpdate({
+				execute: () => this._options.adapter.list(),
+				loading: (state) => {
+					return {
+						...state,
+						isLoading: true
+					};
+				},
+				then: (state, l) => {
+					if (generation !== this._loadGeneration) return state;
+					const fresh = classifyThreads(l.threads, {
+						threadIds: [],
+						archivedThreadIds: [],
+						threadIdMap: {},
+						threadData: {}
+					});
+					return {
+						...state,
+						isLoading: false,
+						cursor: normalizeCursor(l.nextCursor),
+						threadIds: fresh.threadIds,
+						archivedThreadIds: fresh.archivedThreadIds,
+						threadIdMap: {
+							...state.threadIdMap,
+							...fresh.threadIdMap
+						},
+						threadData: {
+							...state.threadData,
+							...fresh.threadData
+						}
+					};
+				}
+			}).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(() => {});
+		}
+		return this._loadThreadsPromise;
+	}
+	loadMore() {
+		if (this._loadMorePromise) return this._loadMorePromise;
+		const initialState = this._state.value;
+		if (initialState.cursor === void 0 || initialState.isLoading) return Promise.resolve();
+		const generation = this._loadGeneration;
+		const adapter = this._options.adapter;
+		const cursor = initialState.cursor;
+		const dedup = this._state.optimisticUpdate({
+			execute: () => adapter.list({ after: cursor }),
+			loading: (state) => ({
+				...state,
+				isLoadingMore: true
+			}),
+			then: (state, l) => {
+				if (generation !== this._loadGeneration) return state;
+				if (adapter !== this._options.adapter) return state;
+				const appended = classifyThreads(l.threads, {
+					threadIds: [...state.threadIds],
+					archivedThreadIds: [...state.archivedThreadIds],
+					threadIdMap: { ...state.threadIdMap },
+					threadData: { ...state.threadData }
+				});
+				return {
+					...state,
+					isLoadingMore: false,
+					cursor: normalizeCursor(l.nextCursor),
+					threadIds: appended.threadIds,
+					archivedThreadIds: appended.archivedThreadIds,
+					threadIdMap: appended.threadIdMap,
+					threadData: appended.threadData
+				};
+			}
+		}).catch((error) => {
+			console.error("[assistant-ui] thread list loadMore failed:", error);
+		}).then(() => {
+			if (this._loadMorePromise === dedup) this._loadMorePromise = void 0;
+		});
+		this._loadMorePromise = dedup;
+		return dedup;
+	}
+	contextProvider;
+	constructor(options, contextProvider) {
+		super();
+		this.contextProvider = contextProvider;
+		this._state.subscribe(() => this._notifySubscribers());
+		this._hookManager = new RemoteThreadListHookInstanceManager(options.runtimeHook, this);
+		this.useProvider = create(() => ({ Provider: options.adapter.unstable_Provider ?? Fragment }));
+		this.__internal_setOptions(options);
+		this.switchToNewThread();
+	}
+	_initialThreadLoaded = false;
+	useProvider;
+	__internal_setOptions(options) {
+		if (this._options === options) return;
+		const adapterChanged = this._options !== void 0 && this._options.adapter !== options.adapter;
+		this._options = options;
+		const Provider = options.adapter.unstable_Provider ?? Fragment;
+		if (Provider !== this.useProvider.getState().Provider) this.useProvider.setState({ Provider }, true);
+		this._hookManager.setRuntimeHook(options.runtimeHook);
+		if (adapterChanged) {
+			this._loadGeneration++;
+			this._loadThreadsPromise = void 0;
+			this._loadMorePromise = void 0;
+			this._state.update({
+				...this._state.baseValue,
+				cursor: void 0
+			});
+		}
+	}
+	__internal_load() {
+		this.getLoadThreadsPromise();
+		const startThreadId = this._options.threadId ?? this._options.initialThreadId;
+		if (!this._initialThreadLoaded && startThreadId) {
+			this._initialThreadLoaded = true;
+			this.switchToThread(startThreadId).catch(() => {});
+		}
+	}
+	reload() {
+		this._loadGeneration++;
+		this._loadThreadsPromise = void 0;
+		this._loadMorePromise = void 0;
+		this._state.update({
+			...this._state.baseValue,
+			cursor: void 0
+		});
+		return this.getLoadThreadsPromise();
+	}
+	get isLoading() {
+		return this._state.value.isLoading;
+	}
+	get isLoadingMore() {
+		return this._state.value.isLoadingMore;
+	}
+	get hasMore() {
+		return this._state.value.cursor !== void 0;
+	}
+	get threadIds() {
+		return this._state.value.threadIds;
+	}
+	get archivedThreadIds() {
+		return this._state.value.archivedThreadIds;
+	}
+	get newThreadId() {
+		return this._state.value.newThreadId;
+	}
+	get mainThreadId() {
+		return this._mainThreadId;
+	}
+	getMainThreadRuntimeCore() {
+		const result = this._hookManager.getThreadRuntimeCore(this._mainThreadId);
+		if (!result) return EMPTY_THREAD_CORE;
+		return result;
+	}
+	getThreadRuntimeCore(threadIdOrRemoteId) {
+		const data = this.getItemById(threadIdOrRemoteId);
+		if (!data) throw new Error("Thread not found");
+		const result = this._hookManager.getThreadRuntimeCore(data.id);
+		if (!result) throw new Error("Thread not found");
+		return result;
+	}
+	getItemById(threadIdOrRemoteId) {
+		return getThreadData(this._state.value, threadIdOrRemoteId);
+	}
+	async switchToThread(threadIdOrRemoteId, options) {
+		let data = this.getItemById(threadIdOrRemoteId);
+		if (!data) {
+			const remoteMetadata = await this._options.adapter.fetch(threadIdOrRemoteId);
+			const state = this._state.value;
+			const mappingId = createThreadMappingId(remoteMetadata.remoteId);
+			const newThreadData = {
+				...state.threadData,
+				[mappingId]: {
+					id: mappingId,
+					initializeTask: Promise.resolve({
+						remoteId: remoteMetadata.remoteId,
+						externalId: remoteMetadata.externalId
+					}),
+					remoteId: remoteMetadata.remoteId,
+					externalId: remoteMetadata.externalId,
+					status: remoteMetadata.status,
+					title: remoteMetadata.title,
+					custom: remoteMetadata.custom
+				}
+			};
+			const newThreadIdMap = {
+				...state.threadIdMap,
+				[remoteMetadata.remoteId]: mappingId
+			};
+			const threadIdsWithoutRemote = state.threadIds.filter((id) => id !== remoteMetadata.remoteId);
+			const archivedThreadIdsWithoutRemote = state.archivedThreadIds.filter((id) => id !== remoteMetadata.remoteId);
+			const newThreadIds = remoteMetadata.status === "regular" ? [...threadIdsWithoutRemote, remoteMetadata.remoteId] : threadIdsWithoutRemote;
+			const newArchivedThreadIds = remoteMetadata.status === "archived" ? [...archivedThreadIdsWithoutRemote, remoteMetadata.remoteId] : archivedThreadIdsWithoutRemote;
+			this._state.update({
+				...state,
+				threadIds: newThreadIds,
+				archivedThreadIds: newArchivedThreadIds,
+				threadIdMap: newThreadIdMap,
+				threadData: newThreadData
+			});
+			data = this.getItemById(threadIdOrRemoteId);
+		}
+		if (!data) throw new Error("Thread not found");
+		if (this._mainThreadId === data.id) return;
+		const task = this._hookManager.startThreadRuntime(data.id);
+		if (this.mainThreadId !== void 0) await task;
+		else task.then(() => this._notifySubscribers());
+		if (data.status === "archived" && options?.unarchive !== false) await this.unarchive(data.id);
+		this._mainThreadId = data.id;
+		this._notifySubscribers();
+	}
+	async switchToNewThread() {
+		while (this._state.baseValue.newThreadId !== void 0 && this._state.value.newThreadId === void 0) await this._state.waitForUpdate();
+		const state = this._state.value;
+		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
+					}
+				}
+			});
+		}
+		return this.switchToThread(id);
+	}
+	initialize = async (threadId) => {
+		if (this._state.value.newThreadId !== threadId) {
+			const data = this.getItemById(threadId);
+			if (!data) throw new Error("Thread not found");
+			if (data.status === "new") throw new Error("Unexpected new state");
+			return data.initializeTask;
+		}
+		return this._state.optimisticUpdate({
+			execute: () => {
+				return this._options.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
+						}
+					}
+				};
+			},
+			then: (state, { remoteId, externalId }) => {
+				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
+						}
+					}
+				};
+			}
+		});
+	};
+	generateTitle = async (threadId) => {
+		const data = this.getItemById(threadId);
+		if (!data) throw new Error("Thread not found");
+		if (data.status === "new") throw new Error("Thread is not yet initialized");
+		const { remoteId } = await data.initializeTask;
+		const runtimeCore = this._hookManager.getThreadRuntimeCore(data.id);
+		if (!runtimeCore) return;
+		const messages = runtimeCore.messages;
+		const stream = await this._options.adapter.generateTitle(remoteId, messages);
+		const messageStream = AssistantMessageStream.fromAssistantStream(stream);
+		for await (const result of messageStream) {
+			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
+					}
+				}
+			});
+		}
+	};
+	rename(threadIdOrRemoteId, newTitle) {
+		const data = this.getItemById(threadIdOrRemoteId);
+		if (!data) throw new Error("Thread not found");
+		if (data.status === "new") throw new Error("Thread is not yet initialized");
+		return this._state.optimisticUpdate({
+			execute: async () => {
+				const { remoteId } = await data.initializeTask;
+				return this._options.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 _ensureThreadIsNotMain(threadId) {
+		if (threadId === this.newThreadId) throw new Error("Cannot ensure new thread is not main");
+		if (threadId === this._mainThreadId) await this.switchToNewThread();
+	}
+	async archive(threadIdOrRemoteId) {
+		const data = this.getItemById(threadIdOrRemoteId);
+		if (!data) throw new Error("Thread not found");
+		if (data.status !== "regular") throw new Error("Thread is not yet initialized or already archived");
+		await this._ensureThreadIsNotMain(data.id);
+		return this._state.optimisticUpdate({
+			execute: async () => {
+				const { remoteId } = await data.initializeTask;
+				return this._options.adapter.archive(remoteId);
+			},
+			optimistic: (state) => {
+				return updateStatusReducer(state, data.id, "archived");
+			}
+		});
+	}
+	unarchive(threadIdOrRemoteId) {
+		const data = this.getItemById(threadIdOrRemoteId);
+		if (!data) throw new Error("Thread not found");
+		if (data.status !== "archived") throw new Error("Thread is not archived");
+		return this._state.optimisticUpdate({
+			execute: async () => {
+				try {
+					const { remoteId } = await data.initializeTask;
+					return await this._options.adapter.unarchive(remoteId);
+				} catch (error) {
+					await this._ensureThreadIsNotMain(data.id);
+					throw error;
+				}
+			},
+			optimistic: (state) => {
+				return updateStatusReducer(state, data.id, "regular");
+			}
+		});
+	}
+	async delete(threadIdOrRemoteId) {
+		const data = this.getItemById(threadIdOrRemoteId);
+		if (!data) throw new Error("Thread not found");
+		if (data.status !== "regular" && data.status !== "archived") throw new Error("Thread is not yet initialized");
+		await this._ensureThreadIsNotMain(data.id);
+		this._hookManager.stopThreadRuntime(data.id);
+		return this._state.optimisticUpdate({
+			execute: async () => {
+				const { remoteId } = await data.initializeTask;
+				return await this._options.adapter.delete(remoteId);
+			},
+			optimistic: (state) => {
+				return updateStatusReducer(state, data.id, "deleted");
+			}
+		});
+	}
+	async detach(threadIdOrRemoteId) {
+		const data = this.getItemById(threadIdOrRemoteId);
+		if (!data) throw new Error("Thread not found");
+		if (data.status !== "regular" && data.status !== "archived") throw new Error("Thread is not yet initialized");
+		await this._ensureThreadIsNotMain(data.id);
+		this._hookManager.stopThreadRuntime(data.id);
+	}
+	useBoundIds = create(() => []);
+	__internal_RenderComponent = () => {
+		const id = useId();
+		useEffect(() => {
+			this.useBoundIds.setState((s) => [...s, id], true);
+			return () => {
+				this.useBoundIds.setState((s) => s.filter((i) => i !== id), true);
+			};
+		}, [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 })
+		});
+	};
+};
+//#endregion
+export { RemoteThreadListThreadListRuntimeCore };
+
 //# sourceMappingURL=RemoteThreadListThreadListRuntimeCore.js.map