ikoncomponents 1.6.3 → 1.6.5

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/remote-thread-list/RemoteThreadListThreadListRuntimeCore.js

@@ -0,0 +1,433 @@
+"use client";
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { generateId } from "../../../internal";
+import { RemoteThreadListHookInstanceManager } from "./RemoteThreadListHookInstanceManager";
+import { BaseSubscribable } from "./BaseSubscribable";
+import { EMPTY_THREAD_CORE } from "./EMPTY_THREAD_CORE";
+import { OptimisticState } from "./OptimisticState";
+import { Fragment, useEffect, useId } from "react";
+import { create } from "zustand";
+import { AssistantMessageStream } from "assistant-stream";
+import { RuntimeAdapterProvider } from "../adapters/RuntimeAdapterProvider";
+function createThreadMappingId(id) {
+    return id;
+}
+const getThreadData = (state, threadIdOrRemoteId) => {
+    const idx = state.threadIdMap[threadIdOrRemoteId];
+    if (idx === undefined)
+        return undefined;
+    return state.threadData[idx];
+};
+const updateStatusReducer = (state, threadIdOrRemoteId, newStatus) => {
+    const data = getThreadData(state, threadIdOrRemoteId);
+    if (!data)
+        return state;
+    const { id, remoteId, status: lastStatus } = data;
+    if (lastStatus === newStatus)
+        return state;
+    const newState = Object.assign({}, state);
+    // lastStatus
+    switch (lastStatus) {
+        case "new":
+            newState.newThreadId = undefined;
+            break;
+        case "regular":
+            newState.threadIds = newState.threadIds.filter((t) => t !== id);
+            break;
+        case "archived":
+            newState.archivedThreadIds = newState.archivedThreadIds.filter((t) => t !== id);
+            break;
+        default: {
+            const _exhaustiveCheck = lastStatus;
+            throw new Error(`Unsupported state: ${_exhaustiveCheck}`);
+        }
+    }
+    // newStatus
+    switch (newStatus) {
+        case "regular":
+            newState.threadIds = [id, ...newState.threadIds];
+            break;
+        case "archived":
+            newState.archivedThreadIds = [id, ...newState.archivedThreadIds];
+            break;
+        case "deleted":
+            newState.threadData = Object.fromEntries(Object.entries(newState.threadData).filter(([key]) => key !== id));
+            newState.threadIdMap = Object.fromEntries(Object.entries(newState.threadIdMap).filter(([key]) => key !== id && key !== remoteId));
+            break;
+        default: {
+            const _exhaustiveCheck = newStatus;
+            throw new Error(`Unsupported state: ${_exhaustiveCheck}`);
+        }
+    }
+    if (newStatus !== "deleted") {
+        newState.threadData = Object.assign(Object.assign({}, newState.threadData), { [id]: Object.assign(Object.assign({}, data), { status: newStatus }) });
+    }
+    return newState;
+};
+export class RemoteThreadListThreadListRuntimeCore extends BaseSubscribable {
+    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) {
+            this._loadThreadsPromise = this._state
+                .optimisticUpdate({
+                execute: () => this._options.adapter.list(),
+                loading: (state) => {
+                    return Object.assign(Object.assign({}, state), { isLoading: true });
+                },
+                then: (state, l) => {
+                    const newThreadIds = [];
+                    const newArchivedThreadIds = [];
+                    const newThreadIdMap = {};
+                    const newThreadData = {};
+                    for (const thread of l.threads) {
+                        switch (thread.status) {
+                            case "regular":
+                                newThreadIds.push(thread.remoteId);
+                                break;
+                            case "archived":
+                                newArchivedThreadIds.push(thread.remoteId);
+                                break;
+                            default: {
+                                const _exhaustiveCheck = thread.status;
+                                throw new Error(`Unsupported state: ${_exhaustiveCheck}`);
+                            }
+                        }
+                        const mappingId = createThreadMappingId(thread.remoteId);
+                        newThreadIdMap[thread.remoteId] = mappingId;
+                        newThreadData[mappingId] = {
+                            id: thread.remoteId,
+                            remoteId: thread.remoteId,
+                            externalId: thread.externalId,
+                            status: thread.status,
+                            title: thread.title,
+                            initializeTask: Promise.resolve({
+                                remoteId: thread.remoteId,
+                                externalId: thread.externalId,
+                            }),
+                        };
+                    }
+                    return Object.assign(Object.assign({}, state), { threadIds: newThreadIds, archivedThreadIds: newArchivedThreadIds, threadIdMap: Object.assign(Object.assign({}, state.threadIdMap), newThreadIdMap), threadData: Object.assign(Object.assign({}, state.threadData), newThreadData) });
+                },
+            })
+                .then(() => { });
+        }
+        return this._loadThreadsPromise;
+    }
+    constructor(options, contextProvider) {
+        super();
+        this.contextProvider = contextProvider;
+        this._state = new OptimisticState({
+            isLoading: false,
+            newThreadId: undefined,
+            threadIds: [],
+            archivedThreadIds: [],
+            threadIdMap: {},
+            threadData: {},
+        });
+        this.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 Object.assign(Object.assign({}, state), { threadData: Object.assign(Object.assign({}, state.threadData), { [mappingId]: Object.assign(Object.assign({}, state.threadData[mappingId]), { initializeTask: task }) }) });
+                },
+                then: (state, { remoteId, externalId }) => {
+                    const data = getThreadData(state, threadId);
+                    if (!data)
+                        return state;
+                    const mappingId = createThreadMappingId(threadId);
+                    return Object.assign(Object.assign({}, state), { threadIdMap: Object.assign(Object.assign({}, state.threadIdMap), { [remoteId]: mappingId }), threadData: Object.assign(Object.assign({}, state.threadData), { [mappingId]: Object.assign(Object.assign({}, data), { initializeTask: Promise.resolve({ remoteId, externalId }), remoteId,
+                                externalId }) }) });
+                },
+            });
+        };
+        this.generateTitle = async (threadId) => {
+            var _a, e_1, _b, _c;
+            var _d;
+            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);
+            try {
+                for (var _e = true, messageStream_1 = __asyncValues(messageStream), messageStream_1_1; messageStream_1_1 = await messageStream_1.next(), _a = messageStream_1_1.done, !_a; _e = true) {
+                    _c = messageStream_1_1.value;
+                    _e = false;
+                    const result = _c;
+                    const newTitle = (_d = result.parts.filter((c) => c.type === "text")[0]) === null || _d === void 0 ? void 0 : _d.text;
+                    const state = this._state.baseValue;
+                    this._state.update(Object.assign(Object.assign({}, state), { threadData: Object.assign(Object.assign({}, state.threadData), { [data.id]: Object.assign(Object.assign({}, data), { title: newTitle }) }) }));
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_e && !_a && (_b = messageStream_1.return)) await _b.call(messageStream_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        };
+        this.useBoundIds = create(() => []);
+        this.__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) && (
+            // only render if the component is the first one mounted
+            _jsx(RuntimeAdapterProvider, { adapters: adapters, children: _jsx(this._hookManager.__internal_RenderThreadRuntimes, { provider: Provider }) })));
+        };
+        this._state.subscribe(() => this._notifySubscribers());
+        this._hookManager = new RemoteThreadListHookInstanceManager(options.runtimeHook, this);
+        this.useProvider = create(() => {
+            var _a;
+            return ({
+                Provider: (_a = options.adapter.unstable_Provider) !== null && _a !== void 0 ? _a : Fragment,
+            });
+        });
+        this.__internal_setOptions(options);
+        this.switchToNewThread();
+    }
+    __internal_setOptions(options) {
+        var _a;
+        if (this._options === options)
+            return;
+        this._options = options;
+        const Provider = (_a = options.adapter.unstable_Provider) !== null && _a !== void 0 ? _a : Fragment;
+        if (Provider !== this.useProvider.getState().Provider) {
+            this.useProvider.setState({ Provider }, true);
+        }
+        this._hookManager.setRuntimeHook(options.runtimeHook);
+    }
+    __internal_load() {
+        this.getLoadThreadsPromise(); // begin loading on initial bind
+    }
+    get isLoading() {
+        return this._state.value.isLoading;
+    }
+    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 = Object.assign(Object.assign({}, 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,
+                } });
+            const newThreadIdMap = Object.assign(Object.assign({}, state.threadIdMap), { [remoteMetadata.remoteId]: mappingId });
+            const newThreadIds = remoteMetadata.status === "regular"
+                ? [...state.threadIds, remoteMetadata.remoteId]
+                : state.threadIds;
+            const newArchivedThreadIds = remoteMetadata.status === "archived"
+                ? [...state.archivedThreadIds, remoteMetadata.remoteId]
+                : state.archivedThreadIds;
+            this._state.update(Object.assign(Object.assign({}, 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(Object.assign(Object.assign({}, state), { newThreadId: id, threadIdMap: Object.assign(Object.assign({}, state.threadIdMap), { [id]: mappingId }), threadData: Object.assign(Object.assign({}, state.threadData), { [mappingId]: {
+                        status: "new",
+                        id,
+                        remoteId: undefined,
+                        externalId: undefined,
+                        title: undefined,
+                    } }) }));
+        }
+        return this.switchToThread(id);
+    }
+    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 Object.assign(Object.assign({}, state), { threadData: Object.assign(Object.assign({}, state.threadData), { [data.id]: Object.assign(Object.assign({}, 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");
+        return this._state.optimisticUpdate({
+            execute: async () => {
+                await this._ensureThreadIsNotMain(data.id);
+                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");
+        return this._state.optimisticUpdate({
+            execute: async () => {
+                await this._ensureThreadIsNotMain(data.id);
+                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);
+    }
+}

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/remote-thread-list/adapter/cloud.d.ts

@@ -0,0 +1,12 @@
+import { AssistantCloud } from "assistant-cloud";
+import { RemoteThreadListAdapter } from "../types";
+type ThreadData = {
+    externalId: string | undefined;
+};
+type CloudThreadListAdapterOptions = {
+    cloud?: AssistantCloud | undefined;
+    create?: (() => Promise<ThreadData>) | undefined;
+    delete?: ((threadId: string) => Promise<void>) | undefined;
+};
+export declare const useCloudThreadListAdapter: (adapter: CloudThreadListAdapterOptions) => RemoteThreadListAdapter;
+export {};

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/remote-thread-list/adapter/cloud.js

@@ -0,0 +1,103 @@
+"use client";
+var _a;
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useCallback, useEffect, useMemo, useRef, } from "react";
+import { AssistantCloud } from "assistant-cloud";
+import { useAssistantCloudThreadHistoryAdapter } from "../../../cloud/AssistantCloudThreadHistoryAdapter";
+import { RuntimeAdapterProvider } from "../../adapters/RuntimeAdapterProvider";
+import { InMemoryThreadListAdapter } from "./in-memory";
+import { CloudFileAttachmentAdapter } from "../../adapters";
+const baseUrl = typeof process !== "undefined" &&
+    ((_a = process === null || process === void 0 ? void 0 : process.env) === null || _a === void 0 ? void 0 : _a["NEXT_PUBLIC_ASSISTANT_BASE_URL"]);
+const autoCloud = baseUrl
+    ? new AssistantCloud({ baseUrl, anonymous: true })
+    : undefined;
+export const useCloudThreadListAdapter = (adapter) => {
+    var _a;
+    const adapterRef = useRef(adapter);
+    useEffect(() => {
+        adapterRef.current = adapter;
+    }, [adapter]);
+    const unstable_Provider = useCallback(function Provider({ children }) {
+        var _a;
+        const history = useAssistantCloudThreadHistoryAdapter({
+            get current() {
+                var _a;
+                return (_a = adapterRef.current.cloud) !== null && _a !== void 0 ? _a : autoCloud;
+            },
+        });
+        const cloudInstance = (_a = adapterRef.current.cloud) !== null && _a !== void 0 ? _a : autoCloud;
+        const attachments = useMemo(() => new CloudFileAttachmentAdapter(cloudInstance), [cloudInstance]);
+        const adapters = useMemo(() => ({
+            history,
+            attachments,
+        }), [history, attachments]);
+        return (_jsx(RuntimeAdapterProvider, { adapters: adapters, children: children }));
+    }, []);
+    const cloud = (_a = adapter.cloud) !== null && _a !== void 0 ? _a : autoCloud;
+    if (!cloud)
+        return new InMemoryThreadListAdapter();
+    return {
+        list: async () => {
+            const { threads } = await cloud.threads.list();
+            return {
+                threads: threads.map((t) => {
+                    var _a;
+                    return ({
+                        status: t.is_archived ? "archived" : "regular",
+                        remoteId: t.id,
+                        title: t.title,
+                        externalId: (_a = t.external_id) !== null && _a !== void 0 ? _a : undefined,
+                    });
+                }),
+            };
+        },
+        initialize: async () => {
+            var _a, _b;
+            const createTask = (_b = (_a = adapter.create) === null || _a === void 0 ? void 0 : _a.call(adapter)) !== null && _b !== void 0 ? _b : Promise.resolve();
+            const t = await createTask;
+            const external_id = t ? t.externalId : undefined;
+            const { thread_id: remoteId } = await cloud.threads.create({
+                last_message_at: new Date(),
+                external_id,
+            });
+            return { externalId: external_id, remoteId: remoteId };
+        },
+        rename: async (threadId, newTitle) => {
+            return cloud.threads.update(threadId, { title: newTitle });
+        },
+        archive: async (threadId) => {
+            return cloud.threads.update(threadId, { is_archived: true });
+        },
+        unarchive: async (threadId) => {
+            return cloud.threads.update(threadId, { is_archived: false });
+        },
+        delete: async (threadId) => {
+            var _a;
+            await ((_a = adapter.delete) === null || _a === void 0 ? void 0 : _a.call(adapter, threadId));
+            return cloud.threads.delete(threadId);
+        },
+        generateTitle: async (threadId, messages) => {
+            // Filter messages to only include content types the title generator understands
+            // (reasoning, source, etc. are not needed for title generation)
+            // TODO serialize these to a more efficient format
+            const filteredMessages = messages.map((msg) => (Object.assign(Object.assign({}, msg), { content: msg.content.filter((part) => part.type === "text" || part.type === "tool-call") })));
+            return cloud.runs.stream({
+                thread_id: threadId,
+                assistant_id: "system/thread_title",
+                messages: filteredMessages,
+            });
+        },
+        fetch: async (threadId) => {
+            var _a;
+            const thread = await cloud.threads.get(threadId);
+            return {
+                status: thread.is_archived ? "archived" : "regular",
+                remoteId: thread.id,
+                title: thread.title,
+                externalId: (_a = thread.external_id) !== null && _a !== void 0 ? _a : undefined,
+            };
+        },
+        unstable_Provider,
+    };
+};

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/remote-thread-list/adapter/in-memory.d.ts

@@ -0,0 +1,12 @@
+import { AssistantStream } from "assistant-stream";
+import { RemoteThreadInitializeResponse, RemoteThreadListAdapter, RemoteThreadListResponse, RemoteThreadMetadata } from "../types";
+export declare class InMemoryThreadListAdapter implements RemoteThreadListAdapter {
+    list(): Promise<RemoteThreadListResponse>;
+    rename(): Promise<void>;
+    archive(): Promise<void>;
+    unarchive(): Promise<void>;
+    delete(): Promise<void>;
+    initialize(threadId: string): Promise<RemoteThreadInitializeResponse>;
+    generateTitle(): Promise<AssistantStream>;
+    fetch(_threadId: string): Promise<RemoteThreadMetadata>;
+}

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/remote-thread-list/adapter/in-memory.js

@@ -0,0 +1,28 @@
+export class InMemoryThreadListAdapter {
+    list() {
+        return Promise.resolve({
+            threads: [],
+        });
+    }
+    rename() {
+        return Promise.resolve();
+    }
+    archive() {
+        return Promise.resolve();
+    }
+    unarchive() {
+        return Promise.resolve();
+    }
+    delete() {
+        return Promise.resolve();
+    }
+    initialize(threadId) {
+        return Promise.resolve({ remoteId: threadId, externalId: undefined });
+    }
+    generateTitle() {
+        return Promise.resolve(new ReadableStream());
+    }
+    fetch(_threadId) {
+        return Promise.reject(new Error("Thread not found"));
+    }
+}

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/remote-thread-list/index.d.ts

@@ -0,0 +1,4 @@
+export { useRemoteThreadListRuntime as unstable_useRemoteThreadListRuntime } from "./useRemoteThreadListRuntime";
+export type { RemoteThreadListAdapter as unstable_RemoteThreadListAdapter } from "./types";
+export { InMemoryThreadListAdapter as unstable_InMemoryThreadListAdapter } from "./adapter/in-memory";
+export { useCloudThreadListAdapter as unstable_useCloudThreadListAdapter } from "./adapter/cloud";

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/remote-thread-list/index.js

@@ -0,0 +1,3 @@
+export { useRemoteThreadListRuntime as unstable_useRemoteThreadListRuntime } from "./useRemoteThreadListRuntime";
+export { InMemoryThreadListAdapter as unstable_InMemoryThreadListAdapter } from "./adapter/in-memory";
+export { useCloudThreadListAdapter as unstable_useCloudThreadListAdapter } from "./adapter/cloud";

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/remote-thread-list/types.d.ts

@@ -0,0 +1,38 @@
+import { ComponentType, PropsWithChildren } from "react";
+import { AssistantRuntime } from "../../runtime";
+import { AssistantStream } from "assistant-stream";
+import { ThreadMessage } from "../../../types";
+export type RemoteThreadInitializeResponse = {
+    remoteId: string;
+    externalId: string | undefined;
+};
+export type RemoteThreadMetadata = {
+    readonly status: "regular" | "archived";
+    readonly remoteId: string;
+    readonly externalId?: string | undefined;
+    readonly title?: string | undefined;
+};
+export type RemoteThreadListResponse = {
+    threads: RemoteThreadMetadata[];
+};
+export type RemoteThreadListAdapter = {
+    list(): Promise<RemoteThreadListResponse>;
+    rename(remoteId: string, newTitle: string): Promise<void>;
+    archive(remoteId: string): Promise<void>;
+    unarchive(remoteId: string): Promise<void>;
+    delete(remoteId: string): Promise<void>;
+    initialize(threadId: string): Promise<RemoteThreadInitializeResponse>;
+    generateTitle(remoteId: string, unstable_messages: readonly ThreadMessage[]): Promise<AssistantStream>;
+    fetch(threadId: string): Promise<RemoteThreadMetadata>;
+    unstable_Provider?: ComponentType<PropsWithChildren>;
+};
+export type RemoteThreadListOptions = {
+    runtimeHook: () => AssistantRuntime;
+    adapter: RemoteThreadListAdapter;
+    /**
+     * When true, if this runtime is used inside another RemoteThreadListRuntime,
+     * it becomes a no-op and simply calls the runtimeHook directly.
+     * This allows wrapping runtimes that internally use RemoteThreadListRuntime.
+     */
+    allowNesting?: boolean | undefined;
+};

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/remote-thread-list/types.js

@@ -0,0 +1 @@
+export {};

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/remote-thread-list/useRemoteThreadListRuntime.d.ts

@@ -0,0 +1,3 @@
+import { RemoteThreadListOptions } from "./types";
+import { AssistantRuntime } from "../../runtime/AssistantRuntime";
+export declare const useRemoteThreadListRuntime: (options: RemoteThreadListOptions) => AssistantRuntime;