@assistant-ui/react-ink 0.0.1

package/dist/runtimes/RemoteThreadListHookInstanceManager.js

@@ -0,0 +1,110 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useCallback, useRef, useEffect, memo, useMemo, } from "react";
+import { create } from "zustand";
+import { useAui } from "@assistant-ui/store";
+import { ThreadListItemRuntimeProvider } from "../context/providers/ThreadListItemRuntimeProvider.js";
+import { BaseSubscribable, ThreadListRuntimeImpl, } from "@assistant-ui/core/internal";
+export class RemoteThreadListHookInstanceManager extends BaseSubscribable {
+    useRuntimeHook;
+    instances = new Map();
+    useAliveThreadsKeysChanged = create(() => ({}));
+    parent;
+    constructor(runtimeHook, parent) {
+        super();
+        this.parent = parent;
+        this.useRuntimeHook = create(() => ({ useRuntime: runtimeHook }));
+    }
+    startThreadRuntime(threadId) {
+        if (!this.instances.has(threadId)) {
+            this.instances.set(threadId, {});
+            this.useAliveThreadsKeysChanged.setState({}, true);
+        }
+        return new Promise((resolve, reject) => {
+            const callback = () => {
+                const instance = this.instances.get(threadId);
+                if (!instance) {
+                    dispose();
+                    reject(new Error("Thread was deleted before runtime was started"));
+                }
+                else if (!instance.runtime) {
+                    return; // misc update
+                }
+                else {
+                    dispose();
+                    resolve(instance.runtime);
+                }
+            };
+            const dispose = this.subscribe(callback);
+            callback();
+        });
+    }
+    getThreadRuntimeCore(threadId) {
+        const instance = this.instances.get(threadId);
+        if (!instance)
+            return undefined;
+        return instance.runtime;
+    }
+    stopThreadRuntime(threadId) {
+        this.instances.delete(threadId);
+        this.useAliveThreadsKeysChanged.setState({}, true);
+    }
+    setRuntimeHook(newRuntimeHook) {
+        const prevRuntimeHook = this.useRuntimeHook.getState().useRuntime;
+        if (prevRuntimeHook !== newRuntimeHook) {
+            this.useRuntimeHook.setState({ useRuntime: newRuntimeHook }, true);
+        }
+    }
+    _InnerActiveThreadProvider = ({ threadId }) => {
+        const { useRuntime } = this.useRuntimeHook();
+        const runtime = useRuntime();
+        const threadBinding = runtime.thread
+            .__internal_threadBinding;
+        const updateRuntime = useCallback(() => {
+            const aliveThread = this.instances.get(threadId);
+            if (!aliveThread)
+                throw new Error("Thread not found. This is a bug in assistant-ui.");
+            aliveThread.runtime = threadBinding.getState();
+            this._notifySubscribers();
+        }, [threadId, threadBinding]);
+        const isMounted = useRef(false);
+        if (!isMounted.current) {
+            updateRuntime();
+        }
+        useEffect(() => {
+            isMounted.current = true;
+            updateRuntime();
+            return threadBinding.outerSubscribe(updateRuntime);
+        }, [threadBinding, updateRuntime]);
+        const aui = useAui();
+        const initPromiseRef = useRef(undefined);
+        useEffect(() => {
+            const runtimeCore = threadBinding.getState();
+            const setGetInitializePromise = runtimeCore["__internal_setGetInitializePromise"];
+            if (typeof setGetInitializePromise === "function") {
+                setGetInitializePromise.call(runtimeCore, () => initPromiseRef.current);
+            }
+        }, [threadBinding]);
+        useEffect(() => {
+            return runtime.threads.main.unstable_on("initialize", () => {
+                const state = aui.threadListItem().getState();
+                if (state.status === "new") {
+                    initPromiseRef.current = aui.threadListItem().initialize();
+                    const dispose = runtime.thread.unstable_on("runEnd", () => {
+                        dispose();
+                        aui.threadListItem().generateTitle();
+                    });
+                }
+            });
+        }, [runtime, aui]);
+        return null;
+    };
+    _OuterActiveThreadProvider = memo(({ threadId, provider: Provider }) => {
+        const runtime = useMemo(() => new ThreadListRuntimeImpl(this.parent).getItemById(threadId), [threadId]);
+        return (_jsx(ThreadListItemRuntimeProvider, { runtime: runtime, children: _jsx(Provider, { children: _jsx(this._InnerActiveThreadProvider, { threadId: threadId }) }) }));
+    });
+    __internal_RenderThreadRuntimes = ({ provider }) => {
+        this.useAliveThreadsKeysChanged(); // trigger re-render on alive threads change
+        return Array.from(this.instances.keys()).map((threadId) => (_jsx(this._OuterActiveThreadProvider, { threadId: threadId, provider: provider }, threadId)));
+    };
+}
+//# sourceMappingURL=RemoteThreadListHookInstanceManager.js.map

package/dist/runtimes/RemoteThreadListHookInstanceManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RemoteThreadListHookInstanceManager.js","sourceRoot":"","sources":["../../src/runtimes/RemoteThreadListHookInstanceManager.tsx"],"names":[],"mappings":"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"}

package/dist/runtimes/RemoteThreadListThreadListRuntimeCore.d.ts

@@ -0,0 +1,113 @@
+import type { ThreadListRuntimeCore } from "@assistant-ui/core";
+import { BaseSubscribable, type RemoteThreadData, type THREAD_MAPPING_ID, type RemoteThreadListOptions } from "@assistant-ui/core/internal";
+import { FC } from "react";
+import type { ModelContextProvider } from "@assistant-ui/core";
+export declare class RemoteThreadListThreadListRuntimeCore extends BaseSubscribable implements ThreadListRuntimeCore {
+    private _options;
+    private readonly _hookManager;
+    private _loadThreadsPromise;
+    private _mainThreadId;
+    private readonly _state;
+    get threadItems(): Readonly<Record<THREAD_MAPPING_ID, RemoteThreadData>>;
+    getLoadThreadsPromise(): Promise<void>;
+    private readonly contextProvider;
+    constructor(options: RemoteThreadListOptions, contextProvider: ModelContextProvider);
+    private useProvider;
+    __internal_setOptions(options: RemoteThreadListOptions): void;
+    __internal_load(): void;
+    get isLoading(): boolean;
+    get threadIds(): readonly string[];
+    get archivedThreadIds(): readonly string[];
+    get newThreadId(): string | undefined;
+    get mainThreadId(): string;
+    getMainThreadRuntimeCore(): Readonly<{
+        getMessageById: (messageId: string) => {
+            parentId: string | null;
+            message: import("@assistant-ui/core").ThreadMessage;
+            index: number;
+        } | undefined;
+        getBranches: (messageId: string) => readonly string[];
+        switchToBranch: (branchId: string) => void;
+        append: (message: import("@assistant-ui/core").AppendMessage) => void;
+        startRun: (config: import("@assistant-ui/core").StartRunConfig) => void;
+        resumeRun: (config: import("@assistant-ui/core").ResumeRunConfig) => void;
+        cancelRun: () => void;
+        addToolResult: (options: import("@assistant-ui/core").AddToolResultOptions) => void;
+        resumeToolCall: (options: import("@assistant-ui/core").ResumeToolCallOptions) => void;
+        speak: (messageId: string) => void;
+        stopSpeaking: () => void;
+        submitFeedback: (feedback: import("@assistant-ui/core").SubmitFeedbackOptions) => void;
+        getModelContext: () => import("@assistant-ui/core").ModelContext;
+        composer: import("@assistant-ui/core").ThreadComposerRuntimeCore;
+        getEditComposer: (messageId: string) => import("@assistant-ui/core").ComposerRuntimeCore | undefined;
+        beginEdit: (messageId: string) => void;
+        speech: import("@assistant-ui/core").SpeechState | undefined;
+        capabilities: Readonly<import("@assistant-ui/core").RuntimeCapabilities>;
+        isDisabled: boolean;
+        isLoading: boolean;
+        messages: readonly import("@assistant-ui/core").ThreadMessage[];
+        state: import("assistant-stream/utils").ReadonlyJSONValue;
+        suggestions: readonly import("@assistant-ui/core").ThreadSuggestion[];
+        extras: unknown;
+        subscribe: (callback: () => void) => import("@assistant-ui/core").Unsubscribe;
+        import(repository: import("@assistant-ui/core").ExportedMessageRepository): void;
+        export(): import("@assistant-ui/core").ExportedMessageRepository;
+        exportExternalState(): any;
+        importExternalState(state: any): void;
+        reset(initialMessages?: readonly import("@assistant-ui/core").ThreadMessageLike[]): void;
+        unstable_on(event: import("@assistant-ui/core").ThreadRuntimeEventType, callback: () => void): import("@assistant-ui/core").Unsubscribe;
+        unstable_loadExternalState: (state: any) => void;
+    }>;
+    getThreadRuntimeCore(threadIdOrRemoteId: string): Readonly<{
+        getMessageById: (messageId: string) => {
+            parentId: string | null;
+            message: import("@assistant-ui/core").ThreadMessage;
+            index: number;
+        } | undefined;
+        getBranches: (messageId: string) => readonly string[];
+        switchToBranch: (branchId: string) => void;
+        append: (message: import("@assistant-ui/core").AppendMessage) => void;
+        startRun: (config: import("@assistant-ui/core").StartRunConfig) => void;
+        resumeRun: (config: import("@assistant-ui/core").ResumeRunConfig) => void;
+        cancelRun: () => void;
+        addToolResult: (options: import("@assistant-ui/core").AddToolResultOptions) => void;
+        resumeToolCall: (options: import("@assistant-ui/core").ResumeToolCallOptions) => void;
+        speak: (messageId: string) => void;
+        stopSpeaking: () => void;
+        submitFeedback: (feedback: import("@assistant-ui/core").SubmitFeedbackOptions) => void;
+        getModelContext: () => import("@assistant-ui/core").ModelContext;
+        composer: import("@assistant-ui/core").ThreadComposerRuntimeCore;
+        getEditComposer: (messageId: string) => import("@assistant-ui/core").ComposerRuntimeCore | undefined;
+        beginEdit: (messageId: string) => void;
+        speech: import("@assistant-ui/core").SpeechState | undefined;
+        capabilities: Readonly<import("@assistant-ui/core").RuntimeCapabilities>;
+        isDisabled: boolean;
+        isLoading: boolean;
+        messages: readonly import("@assistant-ui/core").ThreadMessage[];
+        state: import("assistant-stream/utils").ReadonlyJSONValue;
+        suggestions: readonly import("@assistant-ui/core").ThreadSuggestion[];
+        extras: unknown;
+        subscribe: (callback: () => void) => import("@assistant-ui/core").Unsubscribe;
+        import(repository: import("@assistant-ui/core").ExportedMessageRepository): void;
+        export(): import("@assistant-ui/core").ExportedMessageRepository;
+        exportExternalState(): any;
+        importExternalState(state: any): void;
+        reset(initialMessages?: readonly import("@assistant-ui/core").ThreadMessageLike[]): void;
+        unstable_on(event: import("@assistant-ui/core").ThreadRuntimeEventType, callback: () => void): import("@assistant-ui/core").Unsubscribe;
+        unstable_loadExternalState: (state: any) => void;
+    }>;
+    getItemById(threadIdOrRemoteId: string): RemoteThreadData | undefined;
+    switchToThread(threadIdOrRemoteId: string): Promise<void>;
+    switchToNewThread(): Promise<void>;
+    initialize: (threadId: string) => Promise<import("@assistant-ui/core").RemoteThreadInitializeResponse>;
+    generateTitle: (threadId: string) => Promise<void>;
+    rename(threadIdOrRemoteId: string, newTitle: string): Promise<void>;
+    private _ensureThreadIsNotMain;
+    archive(threadIdOrRemoteId: string): Promise<void>;
+    unarchive(threadIdOrRemoteId: string): Promise<void>;
+    delete(threadIdOrRemoteId: string): Promise<void>;
+    detach(threadIdOrRemoteId: string): Promise<void>;
+    private useBoundIds;
+    __internal_RenderComponent: FC;
+}
+//# sourceMappingURL=RemoteThreadListThreadListRuntimeCore.d.ts.map

package/dist/runtimes/RemoteThreadListThreadListRuntimeCore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RemoteThreadListThreadListRuntimeCore.d.ts","sourceRoot":"","sources":["../../src/runtimes/RemoteThreadListThreadListRuntimeCore.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAChE,OAAO,EAEL,gBAAgB,EAGhB,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EAKtB,KAAK,uBAAuB,EAC7B,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAEL,EAAE,EAKH,MAAM,OAAO,CAAC;AAGf,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAG/D,qBAAa,qCACX,SAAQ,gBACR,YAAW,qBAAqB;IAEhC,OAAO,CAAC,QAAQ,CAA2B;IAC3C,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAsC;IAEnE,OAAO,CAAC,mBAAmB,CAA4B;IAEvD,OAAO,CAAC,aAAa,CAAU;IAC/B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAOpB;IAEH,IAAW,WAAW,0DAErB;IAEM,qBAAqB;IAsE5B,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAuB;gBAGrD,OAAO,EAAE,uBAAuB,EAChC,eAAe,EAAE,oBAAoB;IAkBvC,OAAO,CAAC,WAAW,CAAC;IAEb,qBAAqB,CAAC,OAAO,EAAE,uBAAuB;IActD,eAAe;IAItB,IAAW,SAAS,YAEnB;IAED,IAAW,SAAS,sBAEnB;IAED,IAAW,iBAAiB,sBAE3B;IAED,IAAW,WAAW,uBAErB;IAED,IAAW,YAAY,IAAI,MAAM,CAEhC;IAEM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAMxB,oBAAoB,CAAC,kBAAkB,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAS/C,WAAW,CAAC,kBAAkB,EAAE,MAAM;IAIhC,cAAc,CAAC,kBAAkB,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAkEzD,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC;IAwCxC,UAAU,GAAU,UAAU,MAAM,0EAmDzC;IAEK,aAAa,GAAU,UAAU,MAAM,mBAoC5C;IAEK,MAAM,CAAC,kBAAkB,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;YA4B5D,sBAAsB;IASvB,OAAO,CAAC,kBAAkB,EAAE,MAAM;IAmBxC,SAAS,CAAC,kBAAkB,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAqB9C,MAAM,CAAC,kBAAkB,EAAE,MAAM;IAmBjC,MAAM,CAAC,kBAAkB,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAU9D,OAAO,CAAC,WAAW,CAA8B;IAE1C,0BAA0B,EAAE,EAAE,CA6BnC;CACH"}

package/dist/runtimes/RemoteThreadListThreadListRuntimeCore.js

@@ -0,0 +1,440 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { generateId, BaseSubscribable, OptimisticState, EMPTY_THREAD_CORE, createThreadMappingId, getThreadData, updateStatusReducer, } from "@assistant-ui/core/internal";
+import { RemoteThreadListHookInstanceManager } from "./RemoteThreadListHookInstanceManager.js";
+import { Fragment, useEffect, useId, } from "react";
+import { create } from "zustand";
+import { AssistantMessageStream } from "assistant-stream";
+import { RuntimeAdapterProvider } from "../context/providers/RuntimeAdapterProvider.js";
+export class RemoteThreadListThreadListRuntimeCore extends BaseSubscribable {
+    _options;
+    _hookManager;
+    _loadThreadsPromise;
+    _mainThreadId;
+    _state = new OptimisticState({
+        isLoading: false,
+        newThreadId: undefined,
+        threadIds: [],
+        archivedThreadIds: [],
+        threadIdMap: {},
+        threadData: {},
+    });
+    get threadItems() {
+        return this._state.value.threadData;
+    }
+    getLoadThreadsPromise() {
+        if (!this._loadThreadsPromise) {
+            this._loadThreadsPromise = this._state
+                .optimisticUpdate({
+                execute: () => this._options.adapter.list(),
+                loading: (state) => {
+                    return {
+                        ...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 {
+                        ...state,
+                        threadIds: newThreadIds,
+                        archivedThreadIds: newArchivedThreadIds,
+                        threadIdMap: {
+                            ...state.threadIdMap,
+                            ...newThreadIdMap,
+                        },
+                        threadData: {
+                            ...state.threadData,
+                            ...newThreadData,
+                        },
+                    };
+                },
+            })
+                .then(() => { });
+        }
+        return this._loadThreadsPromise;
+    }
+    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();
+    }
+    useProvider;
+    __internal_setOptions(options) {
+        if (this._options === options)
+            return;
+        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);
+    }
+    __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 = {
+                ...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 = {
+                ...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({
+                ...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,
+                    },
+                },
+            });
+        }
+        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; // 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 textPart = result.parts.find((c) => c.type === "text");
+            const newTitle = textPart && "text" in textPart ? textPart.text : undefined;
+            const state = this._state.baseValue;
+            const currentData = getThreadData(state, data.id);
+            if (!currentData)
+                continue;
+            this._state.update({
+                ...state,
+                threadData: {
+                    ...state.threadData,
+                    [data.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);
+        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) && (
+        // only render if the component is the first one mounted
+        _jsx(RuntimeAdapterProvider, { adapters: adapters, children: _jsx(this._hookManager.__internal_RenderThreadRuntimes, { provider: Provider }) })));
+    };
+}
+//# sourceMappingURL=RemoteThreadListThreadListRuntimeCore.js.map