ikoncomponents 1.6.3 → 1.6.5

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/external-store/ExternalStoreAdapter.d.ts

@@ -0,0 +1,80 @@
+import type { AppendMessage, ThreadMessage } from "../../../types";
+import type { AttachmentAdapter } from "../adapters/attachment";
+import type { AddToolResultOptions, ResumeRunConfig, StartRunConfig, ThreadSuggestion } from "../core/ThreadRuntimeCore";
+import type { FeedbackAdapter } from "../adapters/feedback/FeedbackAdapter";
+import type { SpeechSynthesisAdapter, DictationAdapter } from "../adapters/speech/SpeechAdapterTypes";
+import type { ThreadMessageLike } from "./ThreadMessageLike";
+import type { ExportedMessageRepository } from "../utils/MessageRepository";
+import type { ReadonlyJSONValue } from "assistant-stream/utils";
+export type ExternalStoreThreadData<TState extends "regular" | "archived"> = {
+    status: TState;
+    id: string;
+    remoteId?: string | undefined;
+    externalId?: string | undefined;
+    title?: string | undefined;
+};
+export type ExternalStoreThreadListAdapter = {
+    /**
+     * @deprecated This API is still under active development and might change without notice.
+     */
+    threadId?: string | undefined;
+    isLoading?: boolean | undefined;
+    threads?: readonly ExternalStoreThreadData<"regular">[] | undefined;
+    archivedThreads?: readonly ExternalStoreThreadData<"archived">[] | undefined;
+    /**
+     * @deprecated This API is still under active development and might change without notice.
+     */
+    onSwitchToNewThread?: (() => Promise<void> | void) | undefined;
+    /**
+     * @deprecated This API is still under active development and might change without notice.
+     */
+    onSwitchToThread?: ((threadId: string) => Promise<void> | void) | undefined;
+    onRename?: (threadId: string, newTitle: string) => (Promise<void> | void) | undefined;
+    onArchive?: ((threadId: string) => Promise<void> | void) | undefined;
+    onUnarchive?: ((threadId: string) => Promise<void> | void) | undefined;
+    onDelete?: ((threadId: string) => Promise<void> | void) | undefined;
+};
+export type ExternalStoreMessageConverter<T> = (message: T, idx: number) => ThreadMessageLike;
+type ExternalStoreMessageConverterAdapter<T> = {
+    convertMessage: ExternalStoreMessageConverter<T>;
+};
+type ExternalStoreAdapterBase<T> = {
+    isDisabled?: boolean | undefined;
+    isRunning?: boolean | undefined;
+    isLoading?: boolean | undefined;
+    messages?: readonly T[];
+    messageRepository?: ExportedMessageRepository;
+    suggestions?: readonly ThreadSuggestion[] | undefined;
+    state?: ReadonlyJSONValue | undefined;
+    extras?: unknown;
+    setMessages?: ((messages: readonly T[]) => void) | undefined;
+    onImport?: ((messages: readonly ThreadMessage[]) => void) | undefined;
+    onExportExternalState?: (() => any) | undefined;
+    onLoadExternalState?: ((state: any) => void) | undefined;
+    onNew: (message: AppendMessage) => Promise<void>;
+    onEdit?: ((message: AppendMessage) => Promise<void>) | undefined;
+    onReload?: ((parentId: string | null, config: StartRunConfig) => Promise<void>) | undefined;
+    onResume?: ((config: ResumeRunConfig) => Promise<void>) | undefined;
+    onCancel?: (() => Promise<void>) | undefined;
+    onAddToolResult?: ((options: AddToolResultOptions) => Promise<void> | void) | undefined;
+    onResumeToolCall?: ((options: {
+        toolCallId: string;
+        payload: unknown;
+    }) => void) | undefined;
+    convertMessage?: ExternalStoreMessageConverter<T> | undefined;
+    adapters?: {
+        attachments?: AttachmentAdapter | undefined;
+        speech?: SpeechSynthesisAdapter | undefined;
+        dictation?: DictationAdapter | undefined;
+        feedback?: FeedbackAdapter | undefined;
+        /**
+         * @deprecated This API is still under active development and might change without notice.
+         */
+        threadList?: ExternalStoreThreadListAdapter | undefined;
+    } | undefined;
+    unstable_capabilities?: {
+        copy?: boolean | undefined;
+    } | undefined;
+};
+export type ExternalStoreAdapter<T = ThreadMessage> = ExternalStoreAdapterBase<T> & (T extends ThreadMessage ? object : ExternalStoreMessageConverterAdapter<T>);
+export {};

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/external-store/ExternalStoreAdapter.js

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

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/external-store/ExternalStoreRuntimeCore.d.ts

@@ -0,0 +1,8 @@
+import { BaseAssistantRuntimeCore } from "../core/BaseAssistantRuntimeCore";
+import { ExternalStoreThreadListRuntimeCore } from "./ExternalStoreThreadListRuntimeCore";
+import { ExternalStoreAdapter } from "./ExternalStoreAdapter";
+export declare class ExternalStoreRuntimeCore extends BaseAssistantRuntimeCore {
+    readonly threads: ExternalStoreThreadListRuntimeCore;
+    constructor(adapter: ExternalStoreAdapter<any>);
+    setAdapter(adapter: ExternalStoreAdapter<any>): void;
+}

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/external-store/ExternalStoreRuntimeCore.js

@@ -0,0 +1,18 @@
+import { BaseAssistantRuntimeCore } from "../core/BaseAssistantRuntimeCore";
+import { ExternalStoreThreadListRuntimeCore } from "./ExternalStoreThreadListRuntimeCore";
+import { ExternalStoreThreadRuntimeCore } from "./ExternalStoreThreadRuntimeCore";
+const getThreadListAdapter = (store) => {
+    var _a, _b;
+    return (_b = (_a = store.adapters) === null || _a === void 0 ? void 0 : _a.threadList) !== null && _b !== void 0 ? _b : {};
+};
+export class ExternalStoreRuntimeCore extends BaseAssistantRuntimeCore {
+    constructor(adapter) {
+        super();
+        this.threads = new ExternalStoreThreadListRuntimeCore(getThreadListAdapter(adapter), () => new ExternalStoreThreadRuntimeCore(this._contextProvider, adapter));
+    }
+    setAdapter(adapter) {
+        // Update the thread list adapter and propagate store changes to the main thread
+        this.threads.__internal_setAdapter(getThreadListAdapter(adapter));
+        this.threads.getMainThreadRuntimeCore().__internal_setAdapter(adapter);
+    }
+}

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/external-store/ExternalStoreThreadListRuntimeCore.d.ts

@@ -0,0 +1,41 @@
+import type { Unsubscribe } from "../../../types";
+import { ExternalStoreThreadRuntimeCore } from "./ExternalStoreThreadRuntimeCore";
+import { ThreadListItemCoreState, ThreadListRuntimeCore } from "../core/ThreadListRuntimeCore";
+import { ExternalStoreThreadListAdapter } from "./ExternalStoreAdapter";
+export type ExternalStoreThreadFactory = () => ExternalStoreThreadRuntimeCore;
+export declare class ExternalStoreThreadListRuntimeCore implements ThreadListRuntimeCore {
+    private adapter;
+    private threadFactory;
+    private _mainThreadId;
+    private _threads;
+    private _archivedThreads;
+    private _threadData;
+    get isLoading(): boolean;
+    get newThreadId(): undefined;
+    get threadIds(): readonly string[];
+    get archivedThreadIds(): readonly string[];
+    get threadItems(): Readonly<Record<string, ThreadListItemCoreState>>;
+    getLoadThreadsPromise(): Promise<void>;
+    private _mainThread;
+    get mainThreadId(): string;
+    constructor(adapter: ExternalStoreThreadListAdapter | undefined, threadFactory: ExternalStoreThreadFactory);
+    getMainThreadRuntimeCore(): ExternalStoreThreadRuntimeCore;
+    getThreadRuntimeCore(): never;
+    getItemById(threadId: string): any;
+    __internal_setAdapter(adapter: ExternalStoreThreadListAdapter, initialLoad?: boolean): void;
+    switchToThread(threadId: string): Promise<void>;
+    switchToNewThread(): Promise<void>;
+    rename(threadId: string, newTitle: string): Promise<void>;
+    detach(): Promise<void>;
+    archive(threadId: string): Promise<void>;
+    unarchive(threadId: string): Promise<void>;
+    delete(threadId: string): Promise<void>;
+    initialize(threadId: string): Promise<{
+        remoteId: string;
+        externalId: string | undefined;
+    }>;
+    generateTitle(): never;
+    private _subscriptions;
+    subscribe(callback: () => void): Unsubscribe;
+    private _notifySubscribers;
+}

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/external-store/ExternalStoreThreadListRuntimeCore.js

@@ -0,0 +1,159 @@
+const EMPTY_ARRAY = Object.freeze([]);
+const DEFAULT_THREAD_ID = "DEFAULT_THREAD_ID";
+const DEFAULT_THREADS = Object.freeze([DEFAULT_THREAD_ID]);
+const DEFAULT_THREAD = Object.freeze({
+    id: DEFAULT_THREAD_ID,
+    remoteId: undefined,
+    externalId: undefined,
+    status: "regular",
+});
+const RESOLVED_PROMISE = Promise.resolve();
+const DEFAULT_THREAD_DATA = Object.freeze({
+    [DEFAULT_THREAD_ID]: DEFAULT_THREAD,
+});
+export class ExternalStoreThreadListRuntimeCore {
+    get isLoading() {
+        var _a;
+        return (_a = this.adapter.isLoading) !== null && _a !== void 0 ? _a : false;
+    }
+    get newThreadId() {
+        return undefined;
+    }
+    get threadIds() {
+        return this._threads;
+    }
+    get archivedThreadIds() {
+        return this._archivedThreads;
+    }
+    get threadItems() {
+        return this._threadData;
+    }
+    getLoadThreadsPromise() {
+        return RESOLVED_PROMISE;
+    }
+    get mainThreadId() {
+        return this._mainThreadId;
+    }
+    constructor(adapter = {}, threadFactory) {
+        this.adapter = adapter;
+        this.threadFactory = threadFactory;
+        this._mainThreadId = DEFAULT_THREAD_ID;
+        this._threads = DEFAULT_THREADS;
+        this._archivedThreads = EMPTY_ARRAY;
+        this._threadData = DEFAULT_THREAD_DATA;
+        this._subscriptions = new Set();
+        this._mainThread = this.threadFactory();
+        this.__internal_setAdapter(adapter, true);
+    }
+    getMainThreadRuntimeCore() {
+        return this._mainThread;
+    }
+    getThreadRuntimeCore() {
+        throw new Error("Method not implemented.");
+    }
+    getItemById(threadId) {
+        var _a, _b;
+        for (const thread of (_a = this.adapter.threads) !== null && _a !== void 0 ? _a : []) {
+            if (thread.id === threadId)
+                return thread;
+        }
+        for (const thread of (_b = this.adapter.archivedThreads) !== null && _b !== void 0 ? _b : []) {
+            if (thread.id === threadId)
+                return thread;
+        }
+        if (threadId === DEFAULT_THREAD_ID)
+            return DEFAULT_THREAD;
+        return undefined;
+    }
+    __internal_setAdapter(adapter, initialLoad = false) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+        const previousAdapter = this.adapter;
+        this.adapter = adapter;
+        const newThreadId = (_a = adapter.threadId) !== null && _a !== void 0 ? _a : DEFAULT_THREAD_ID;
+        const newThreads = (_b = adapter.threads) !== null && _b !== void 0 ? _b : EMPTY_ARRAY;
+        const newArchivedThreads = (_c = adapter.archivedThreads) !== null && _c !== void 0 ? _c : EMPTY_ARRAY;
+        const previousThreadId = (_d = previousAdapter.threadId) !== null && _d !== void 0 ? _d : DEFAULT_THREAD_ID;
+        const previousThreads = (_e = previousAdapter.threads) !== null && _e !== void 0 ? _e : EMPTY_ARRAY;
+        const previousArchivedThreads = (_f = previousAdapter.archivedThreads) !== null && _f !== void 0 ? _f : EMPTY_ARRAY;
+        if (!initialLoad &&
+            previousThreadId === newThreadId &&
+            previousThreads === newThreads &&
+            previousArchivedThreads === newArchivedThreads) {
+            return;
+        }
+        this._threadData = Object.assign(Object.assign(Object.assign({}, DEFAULT_THREAD_DATA), Object.fromEntries((_h = (_g = adapter.threads) === null || _g === void 0 ? void 0 : _g.map((t) => [
+            t.id,
+            Object.assign(Object.assign({}, t), { remoteId: t.remoteId, externalId: t.externalId, status: "regular" }),
+        ])) !== null && _h !== void 0 ? _h : [])), Object.fromEntries((_k = (_j = adapter.archivedThreads) === null || _j === void 0 ? void 0 : _j.map((t) => [
+            t.id,
+            Object.assign(Object.assign({}, t), { remoteId: t.remoteId, externalId: t.externalId, status: "archived" }),
+        ])) !== null && _k !== void 0 ? _k : []));
+        if (previousThreads !== newThreads) {
+            this._threads = (_m = (_l = this.adapter.threads) === null || _l === void 0 ? void 0 : _l.map((t) => t.id)) !== null && _m !== void 0 ? _m : EMPTY_ARRAY;
+        }
+        if (previousArchivedThreads !== newArchivedThreads) {
+            this._archivedThreads =
+                (_p = (_o = this.adapter.archivedThreads) === null || _o === void 0 ? void 0 : _o.map((t) => t.id)) !== null && _p !== void 0 ? _p : EMPTY_ARRAY;
+        }
+        if (previousThreadId !== newThreadId) {
+            this._mainThreadId = newThreadId;
+            this._mainThread = this.threadFactory();
+        }
+        this._notifySubscribers();
+    }
+    async switchToThread(threadId) {
+        if (this._mainThreadId === threadId)
+            return;
+        const onSwitchToThread = this.adapter.onSwitchToThread;
+        if (!onSwitchToThread)
+            throw new Error("External store adapter does not support switching to thread");
+        onSwitchToThread(threadId);
+    }
+    async switchToNewThread() {
+        const onSwitchToNewThread = this.adapter.onSwitchToNewThread;
+        if (!onSwitchToNewThread)
+            throw new Error("External store adapter does not support switching to new thread");
+        onSwitchToNewThread();
+    }
+    async rename(threadId, newTitle) {
+        const onRename = this.adapter.onRename;
+        if (!onRename)
+            throw new Error("External store adapter does not support renaming");
+        onRename(threadId, newTitle);
+    }
+    async detach() {
+        // no-op
+    }
+    async archive(threadId) {
+        const onArchive = this.adapter.onArchive;
+        if (!onArchive)
+            throw new Error("External store adapter does not support archiving");
+        onArchive(threadId);
+    }
+    async unarchive(threadId) {
+        const onUnarchive = this.adapter.onUnarchive;
+        if (!onUnarchive)
+            throw new Error("External store adapter does not support unarchiving");
+        onUnarchive(threadId);
+    }
+    async delete(threadId) {
+        const onDelete = this.adapter.onDelete;
+        if (!onDelete)
+            throw new Error("External store adapter does not support deleting");
+        onDelete(threadId);
+    }
+    initialize(threadId) {
+        return Promise.resolve({ remoteId: threadId, externalId: undefined });
+    }
+    generateTitle() {
+        throw new Error("Method not implemented.");
+    }
+    subscribe(callback) {
+        this._subscriptions.add(callback);
+        return () => this._subscriptions.delete(callback);
+    }
+    _notifySubscribers() {
+        for (const callback of this._subscriptions)
+            callback();
+    }
+}

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/external-store/ExternalStoreThreadRuntimeCore.d.ts

@@ -0,0 +1,46 @@
+import type { AddToolResultOptions, ResumeRunConfig, ResumeToolCallOptions, StartRunConfig, ThreadSuggestion } from "../core/ThreadRuntimeCore";
+import type { AppendMessage, ThreadMessage } from "../../../types";
+import type { ExternalStoreAdapter } from "./ExternalStoreAdapter";
+import { type ThreadMessageLike } from "./ThreadMessageLike";
+import type { RuntimeCapabilities, ThreadRuntimeCore } from "../core/ThreadRuntimeCore";
+import { BaseThreadRuntimeCore } from "../core/BaseThreadRuntimeCore";
+import type { ModelContextProvider } from "../../../model-context";
+import { ExportedMessageRepository } from "../utils/MessageRepository";
+export declare const hasUpcomingMessage: (isRunning: boolean, messages: readonly ThreadMessage[]) => boolean;
+export declare class ExternalStoreThreadRuntimeCore extends BaseThreadRuntimeCore implements ThreadRuntimeCore {
+    private _assistantOptimisticId;
+    private _capabilities;
+    get capabilities(): RuntimeCapabilities;
+    private _messages;
+    isDisabled: boolean;
+    get isLoading(): boolean;
+    get messages(): readonly ThreadMessage[];
+    get state(): any;
+    get adapters(): {
+        attachments?: import("..").AttachmentAdapter | undefined;
+        speech?: import("..").SpeechSynthesisAdapter | undefined;
+        dictation?: import("..").DictationAdapter | undefined;
+        feedback?: import("..").FeedbackAdapter | undefined;
+        threadList?: import("./ExternalStoreAdapter").ExternalStoreThreadListAdapter | undefined;
+    } | undefined;
+    suggestions: readonly ThreadSuggestion[];
+    extras: unknown;
+    private _converter;
+    private _store;
+    beginEdit(messageId: string): void;
+    constructor(contextProvider: ModelContextProvider, store: ExternalStoreAdapter<any>);
+    __internal_setAdapter(store: ExternalStoreAdapter<any>): void;
+    switchToBranch(branchId: string): void;
+    append(message: AppendMessage): Promise<void>;
+    startRun(config: StartRunConfig): Promise<void>;
+    resumeRun(config: ResumeRunConfig): Promise<void>;
+    exportExternalState(): any;
+    importExternalState(state: any): void;
+    unstable_loadExternalState(state: any): void;
+    cancelRun(): void;
+    addToolResult(options: AddToolResultOptions): void;
+    resumeToolCall(options: ResumeToolCallOptions): void;
+    reset(initialMessages?: readonly ThreadMessageLike[]): void;
+    import(data: ExportedMessageRepository): void;
+    private updateMessages;
+}

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/external-store/ExternalStoreThreadRuntimeCore.js

@@ -0,0 +1,265 @@
+import { getExternalStoreMessage, symbolInnerMessage, } from "./getExternalStoreMessage";
+import { ThreadMessageConverter } from "./ThreadMessageConverter";
+import { getAutoStatus, isAutoStatus } from "./auto-status";
+import { fromThreadMessageLike, } from "./ThreadMessageLike";
+import { getThreadMessageText } from "../../../utils/getThreadMessageText";
+import { BaseThreadRuntimeCore } from "../core/BaseThreadRuntimeCore";
+import { ExportedMessageRepository, MessageRepository, } from "../utils/MessageRepository";
+const EMPTY_ARRAY = Object.freeze([]);
+export const hasUpcomingMessage = (isRunning, messages) => {
+    var _a;
+    return isRunning && ((_a = messages[messages.length - 1]) === null || _a === void 0 ? void 0 : _a.role) !== "assistant";
+};
+export class ExternalStoreThreadRuntimeCore extends BaseThreadRuntimeCore {
+    get capabilities() {
+        return this._capabilities;
+    }
+    get isLoading() {
+        var _a;
+        return (_a = this._store.isLoading) !== null && _a !== void 0 ? _a : false;
+    }
+    get messages() {
+        return this._messages;
+    }
+    get state() {
+        var _a;
+        return (_a = this._store.state) !== null && _a !== void 0 ? _a : super.state;
+    }
+    get adapters() {
+        return this._store.adapters;
+    }
+    beginEdit(messageId) {
+        if (!this._store.onEdit)
+            throw new Error("Runtime does not support editing.");
+        super.beginEdit(messageId);
+    }
+    constructor(contextProvider, store) {
+        super(contextProvider);
+        this._assistantOptimisticId = null;
+        this._capabilities = {
+            switchToBranch: false,
+            switchBranchDuringRun: false,
+            edit: false,
+            reload: false,
+            cancel: false,
+            unstable_copy: false,
+            speech: false,
+            dictation: false,
+            attachments: false,
+            feedback: false,
+        };
+        this.suggestions = [];
+        this.extras = undefined;
+        this._converter = new ThreadMessageConverter();
+        this.updateMessages = (messages) => {
+            var _a, _b, _c, _d;
+            const hasConverter = this._store.convertMessage !== undefined;
+            if (hasConverter) {
+                (_b = (_a = this._store).setMessages) === null || _b === void 0 ? void 0 : _b.call(_a, messages.flatMap(getExternalStoreMessage).filter((m) => m != null));
+            }
+            else {
+                // TODO mark this as readonly in v0.12.0
+                (_d = (_c = this._store).setMessages) === null || _d === void 0 ? void 0 : _d.call(_c, messages);
+            }
+        };
+        this.__internal_setAdapter(store);
+    }
+    __internal_setAdapter(store) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
+        if (this._store === store)
+            return;
+        const isRunning = (_a = store.isRunning) !== null && _a !== void 0 ? _a : false;
+        this.isDisabled = (_b = store.isDisabled) !== null && _b !== void 0 ? _b : false;
+        const oldStore = this._store;
+        this._store = store;
+        this.extras = store.extras;
+        this.suggestions = (_c = store.suggestions) !== null && _c !== void 0 ? _c : EMPTY_ARRAY;
+        this._capabilities = {
+            switchToBranch: this._store.setMessages !== undefined,
+            switchBranchDuringRun: false, // External store never supports branch switching during run
+            edit: this._store.onEdit !== undefined,
+            reload: this._store.onReload !== undefined,
+            cancel: this._store.onCancel !== undefined,
+            speech: ((_d = this._store.adapters) === null || _d === void 0 ? void 0 : _d.speech) !== undefined,
+            dictation: ((_e = this._store.adapters) === null || _e === void 0 ? void 0 : _e.dictation) !== undefined,
+            unstable_copy: ((_f = this._store.unstable_capabilities) === null || _f === void 0 ? void 0 : _f.copy) !== false, // default true
+            attachments: !!((_g = this._store.adapters) === null || _g === void 0 ? void 0 : _g.attachments),
+            feedback: !!((_h = this._store.adapters) === null || _h === void 0 ? void 0 : _h.feedback),
+        };
+        let messages;
+        if (store.messageRepository) {
+            // Handle messageRepository
+            if (oldStore &&
+                oldStore.isRunning === store.isRunning &&
+                oldStore.messageRepository === store.messageRepository) {
+                this._notifySubscribers();
+                return;
+            }
+            // Clear and import the message repository
+            this.repository.clear();
+            this._assistantOptimisticId = null;
+            this.repository.import(store.messageRepository);
+            messages = this.repository.getMessages();
+        }
+        else if (store.messages) {
+            // Handle messages array
+            if (oldStore) {
+                // flush the converter cache when the convertMessage prop changes
+                if (oldStore.convertMessage !== store.convertMessage) {
+                    this._converter = new ThreadMessageConverter();
+                }
+                else if (oldStore.isRunning === store.isRunning &&
+                    oldStore.messages === store.messages) {
+                    this._notifySubscribers();
+                    // no conversion update
+                    return;
+                }
+            }
+            messages = !store.convertMessage
+                ? store.messages
+                : this._converter.convertMessages(store.messages, (cache, m, idx) => {
+                    var _a, _b;
+                    if (!store.convertMessage)
+                        return m;
+                    const isLast = idx === ((_b = (_a = store.messages) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) - 1;
+                    const autoStatus = getAutoStatus(isLast, isRunning, false, false, undefined);
+                    if (cache &&
+                        (cache.role !== "assistant" ||
+                            !isAutoStatus(cache.status) ||
+                            cache.status === autoStatus))
+                        return cache;
+                    const messageLike = store.convertMessage(m, idx);
+                    const newMessage = fromThreadMessageLike(messageLike, idx.toString(), autoStatus);
+                    newMessage[symbolInnerMessage] = m;
+                    return newMessage;
+                });
+            for (let i = 0; i < messages.length; i++) {
+                const message = messages[i];
+                const parent = messages[i - 1];
+                this.repository.addOrUpdateMessage((_j = parent === null || parent === void 0 ? void 0 : parent.id) !== null && _j !== void 0 ? _j : null, message);
+            }
+        }
+        else {
+            throw new Error("ExternalStoreAdapter must provide either 'messages' or 'messageRepository'");
+        }
+        // Common logic for both paths
+        if (messages.length > 0)
+            this.ensureInitialized();
+        if (((_k = oldStore === null || oldStore === void 0 ? void 0 : oldStore.isRunning) !== null && _k !== void 0 ? _k : false) !== ((_l = store.isRunning) !== null && _l !== void 0 ? _l : false)) {
+            if (store.isRunning) {
+                this._notifyEventSubscribers("runStart");
+            }
+            else {
+                this._notifyEventSubscribers("runEnd");
+            }
+        }
+        if (this._assistantOptimisticId) {
+            this.repository.deleteMessage(this._assistantOptimisticId);
+            this._assistantOptimisticId = null;
+        }
+        if (hasUpcomingMessage(isRunning, messages)) {
+            this._assistantOptimisticId = this.repository.appendOptimisticMessage((_o = (_m = messages.at(-1)) === null || _m === void 0 ? void 0 : _m.id) !== null && _o !== void 0 ? _o : null, {
+                role: "assistant",
+                content: [],
+            });
+        }
+        this.repository.resetHead((_r = (_p = this._assistantOptimisticId) !== null && _p !== void 0 ? _p : (_q = messages.at(-1)) === null || _q === void 0 ? void 0 : _q.id) !== null && _r !== void 0 ? _r : null);
+        this._messages = this.repository.getMessages();
+        this._notifySubscribers();
+    }
+    switchToBranch(branchId) {
+        if (!this._store.setMessages)
+            throw new Error("Runtime does not support switching branches.");
+        // Silently ignore branch switches while running
+        if (this._store.isRunning) {
+            return;
+        }
+        this.repository.switchToBranch(branchId);
+        this.updateMessages(this.repository.getMessages());
+    }
+    async append(message) {
+        var _a, _b;
+        if (message.parentId !== ((_b = (_a = this.messages.at(-1)) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : null)) {
+            if (!this._store.onEdit)
+                throw new Error("Runtime does not support editing messages.");
+            await this._store.onEdit(message);
+        }
+        else {
+            await this._store.onNew(message);
+        }
+    }
+    async startRun(config) {
+        if (!this._store.onReload)
+            throw new Error("Runtime does not support reloading messages.");
+        await this._store.onReload(config.parentId, config);
+    }
+    async resumeRun(config) {
+        if (!this._store.onResume)
+            throw new Error("Runtime does not support resuming runs.");
+        await this._store.onResume(config);
+    }
+    exportExternalState() {
+        if (!this._store.onExportExternalState)
+            throw new Error("Runtime does not support exporting external states.");
+        return this._store.onExportExternalState();
+    }
+    importExternalState(state) {
+        if (!this._store.onLoadExternalState)
+            throw new Error("Runtime does not support importing external states.");
+        this._store.onLoadExternalState(state);
+    }
+    unstable_loadExternalState(state) {
+        this.importExternalState(state);
+    }
+    cancelRun() {
+        var _a;
+        if (!this._store.onCancel)
+            throw new Error("Runtime does not support cancelling runs.");
+        this._store.onCancel();
+        if (this._assistantOptimisticId) {
+            this.repository.deleteMessage(this._assistantOptimisticId);
+            this._assistantOptimisticId = null;
+        }
+        let messages = this.repository.getMessages();
+        const previousMessage = messages[messages.length - 1];
+        if ((previousMessage === null || previousMessage === void 0 ? void 0 : previousMessage.role) === "user" &&
+            previousMessage.id === ((_a = messages.at(-1)) === null || _a === void 0 ? void 0 : _a.id) // ensure the previous message is a leaf node
+        ) {
+            this.repository.deleteMessage(previousMessage.id);
+            if (!this.composer.text.trim()) {
+                this.composer.setText(getThreadMessageText(previousMessage));
+            }
+            messages = this.repository.getMessages();
+        }
+        else {
+            this._notifySubscribers();
+        }
+        // resync messages (for reloading, to restore the previous branch)
+        setTimeout(() => {
+            this.updateMessages(messages);
+        }, 0);
+    }
+    addToolResult(options) {
+        var _a, _b;
+        if (!this._store.onAddToolResult && !this._store.onAddToolResult)
+            throw new Error("Runtime does not support tool results.");
+        (_b = (_a = this._store).onAddToolResult) === null || _b === void 0 ? void 0 : _b.call(_a, options);
+    }
+    resumeToolCall(options) {
+        if (!this._store.onResumeToolCall)
+            throw new Error("Runtime does not support resuming tool calls.");
+        this._store.onResumeToolCall(options);
+    }
+    reset(initialMessages) {
+        const repo = new MessageRepository();
+        repo.import(ExportedMessageRepository.fromArray(initialMessages !== null && initialMessages !== void 0 ? initialMessages : []));
+        this.updateMessages(repo.getMessages());
+    }
+    import(data) {
+        this._assistantOptimisticId = null;
+        super.import(data);
+        if (this._store.onImport) {
+            this._store.onImport(this.repository.getMessages());
+        }
+    }
+}

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/external-store/ThreadMessageConverter.d.ts

@@ -0,0 +1,6 @@
+import { ThreadMessage } from "../../../types";
+export type ConverterCallback<TIn> = (cache: ThreadMessage | undefined, message: TIn, idx: number) => ThreadMessage;
+export declare class ThreadMessageConverter {
+    private readonly cache;
+    convertMessages<TIn extends WeakKey>(messages: readonly TIn[], converter: ConverterCallback<TIn>): ThreadMessage[];
+}

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/external-store/ThreadMessageConverter.js

@@ -0,0 +1,13 @@
+export class ThreadMessageConverter {
+    constructor() {
+        this.cache = new WeakMap();
+    }
+    convertMessages(messages, converter) {
+        return messages.map((m, idx) => {
+            const cached = this.cache.get(m);
+            const newMessage = converter(cached, m, idx);
+            this.cache.set(m, newMessage);
+            return newMessage;
+        });
+    }
+}