ikoncomponents 1.6.5 → 1.6.7

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

@@ -1,433 +0,0 @@
-"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

@@ -1,12 +0,0 @@
-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

@@ -1,103 +0,0 @@
-"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

@@ -1,12 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

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

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

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