ikoncomponents 1.6.5 → 1.6.8

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime/RuntimePathTypes.d.ts

@@ -1,63 +0,0 @@
-export type ThreadListItemRuntimePath = {
-    readonly ref: string;
-    readonly threadSelector: {
-        readonly type: "main";
-    } | {
-        readonly type: "index";
-        readonly index: number;
-    } | {
-        readonly type: "archiveIndex";
-        readonly index: number;
-    } | {
-        readonly type: "threadId";
-        readonly threadId: string;
-    };
-};
-export type ThreadRuntimePath = {
-    readonly ref: string;
-    readonly threadSelector: {
-        readonly type: "main";
-    } | {
-        readonly type: "threadId";
-        readonly threadId: string;
-    };
-};
-export type MessageRuntimePath = ThreadRuntimePath & {
-    readonly messageSelector: {
-        readonly type: "messageId";
-        readonly messageId: string;
-    } | {
-        readonly type: "index";
-        readonly index: number;
-    };
-};
-export type MessagePartRuntimePath = MessageRuntimePath & {
-    readonly messagePartSelector: {
-        readonly type: "index";
-        readonly index: number;
-    } | {
-        readonly type: "toolCallId";
-        readonly toolCallId: string;
-    };
-};
-export type AttachmentRuntimePath = ((MessageRuntimePath & {
-    readonly attachmentSource: "message" | "edit-composer";
-}) | (ThreadRuntimePath & {
-    readonly attachmentSource: "thread-composer";
-})) & {
-    readonly attachmentSelector: {
-        readonly type: "index";
-        readonly index: number;
-    } | {
-        readonly type: "index";
-        readonly index: number;
-    } | {
-        readonly type: "index";
-        readonly index: number;
-    };
-};
-export type ComposerRuntimePath = (ThreadRuntimePath & {
-    readonly composerSource: "thread";
-}) | (MessageRuntimePath & {
-    readonly composerSource: "edit";
-});

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime/RuntimePathTypes.js

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

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime/ThreadListItemRuntime.d.ts

@@ -1,53 +0,0 @@
-import { Unsubscribe } from "../../types";
-import { ThreadListItemRuntimePath } from "./RuntimePathTypes";
-import { SubscribableWithState } from "./subscribable/Subscribable";
-import { ThreadListRuntimeCoreBinding } from "./ThreadListRuntime";
-export type ThreadListItemEventType = "switchedTo" | "switchedAway";
-import type { ThreadListItemState, ThreadListItemStatus } from "./RuntimeBindings";
-export type { ThreadListItemState, ThreadListItemStatus };
-export type ThreadListItemRuntime = {
-    readonly path: ThreadListItemRuntimePath;
-    getState(): ThreadListItemState;
-    initialize(): Promise<{
-        remoteId: string;
-        externalId: string | undefined;
-    }>;
-    generateTitle(): Promise<void>;
-    switchTo(): Promise<void>;
-    rename(newTitle: string): Promise<void>;
-    archive(): Promise<void>;
-    unarchive(): Promise<void>;
-    delete(): Promise<void>;
-    /**
-     * Detaches the ThreadListItem instance, unmounting the ThreadRuntime hook.
-     */
-    detach(): void;
-    subscribe(callback: () => void): Unsubscribe;
-    unstable_on(event: ThreadListItemEventType, callback: () => void): Unsubscribe;
-    /** @internal */
-    __internal_getRuntime(): ThreadListItemRuntime;
-};
-export type ThreadListItemStateBinding = SubscribableWithState<ThreadListItemState, ThreadListItemRuntimePath>;
-export declare class ThreadListItemRuntimeImpl implements ThreadListItemRuntime {
-    private _core;
-    private _threadListBinding;
-    get path(): ThreadListItemRuntimePath;
-    constructor(_core: ThreadListItemStateBinding, _threadListBinding: ThreadListRuntimeCoreBinding);
-    protected __internal_bindMethods(): void;
-    getState(): ThreadListItemState;
-    switchTo(): Promise<void>;
-    rename(newTitle: string): Promise<void>;
-    archive(): Promise<void>;
-    unarchive(): Promise<void>;
-    delete(): Promise<void>;
-    initialize(): Promise<{
-        remoteId: string;
-        externalId: string | undefined;
-    }>;
-    generateTitle(): Promise<void>;
-    unstable_on(event: ThreadListItemEventType, callback: () => void): Unsubscribe;
-    subscribe(callback: () => void): Unsubscribe;
-    detach(): void;
-    /** @internal */
-    __internal_getRuntime(): ThreadListItemRuntime;
-}

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime/ThreadListItemRuntime.js

@@ -1,85 +0,0 @@
-export class ThreadListItemRuntimeImpl {
-    get path() {
-        return this._core.path;
-    }
-    constructor(_core, _threadListBinding) {
-        this._core = _core;
-        this._threadListBinding = _threadListBinding;
-        this.__internal_bindMethods();
-    }
-    __internal_bindMethods() {
-        this.switchTo = this.switchTo.bind(this);
-        this.rename = this.rename.bind(this);
-        this.archive = this.archive.bind(this);
-        this.unarchive = this.unarchive.bind(this);
-        this.delete = this.delete.bind(this);
-        this.initialize = this.initialize.bind(this);
-        this.generateTitle = this.generateTitle.bind(this);
-        this.subscribe = this.subscribe.bind(this);
-        this.unstable_on = this.unstable_on.bind(this);
-        this.getState = this.getState.bind(this);
-        this.detach = this.detach.bind(this);
-    }
-    getState() {
-        return this._core.getState();
-    }
-    switchTo() {
-        const state = this._core.getState();
-        return this._threadListBinding.switchToThread(state.id);
-    }
-    rename(newTitle) {
-        const state = this._core.getState();
-        return this._threadListBinding.rename(state.id, newTitle);
-    }
-    archive() {
-        const state = this._core.getState();
-        return this._threadListBinding.archive(state.id);
-    }
-    unarchive() {
-        const state = this._core.getState();
-        return this._threadListBinding.unarchive(state.id);
-    }
-    delete() {
-        const state = this._core.getState();
-        return this._threadListBinding.delete(state.id);
-    }
-    initialize() {
-        const state = this._core.getState();
-        return this._threadListBinding.initialize(state.id);
-    }
-    generateTitle() {
-        const state = this._core.getState();
-        return this._threadListBinding.generateTitle(state.id);
-    }
-    unstable_on(event, callback) {
-        // if the runtime is bound to a specific thread, trigger if isMain is toggled
-        // if the runtime is bound to the main thread, trigger switchedTo if threadId changes
-        let prevIsMain = this._core.getState().isMain;
-        let prevThreadId = this._core.getState().id;
-        return this.subscribe(() => {
-            const currentState = this._core.getState();
-            const newIsMain = currentState.isMain;
-            const newThreadId = currentState.id;
-            if (prevIsMain === newIsMain && prevThreadId === newThreadId)
-                return;
-            prevIsMain = newIsMain;
-            prevThreadId = newThreadId;
-            if (event === "switchedTo" && !newIsMain)
-                return;
-            if (event === "switchedAway" && newIsMain)
-                return;
-            callback();
-        });
-    }
-    subscribe(callback) {
-        return this._core.subscribe(callback);
-    }
-    detach() {
-        const state = this._core.getState();
-        this._threadListBinding.detach(state.id);
-    }
-    /** @internal */
-    __internal_getRuntime() {
-        return this;
-    }
-}

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime/ThreadListRuntime.d.ts

@@ -1,43 +0,0 @@
-import { ThreadListRuntimeCore } from "../runtime-cores/core/ThreadListRuntimeCore";
-import { Unsubscribe } from "../../types";
-import { ThreadListItemRuntime, ThreadListItemRuntimeImpl, ThreadListItemState } from "./ThreadListItemRuntime";
-import { ThreadListItemRuntimeBinding, ThreadRuntime, ThreadRuntimeCoreBinding } from "./ThreadRuntime";
-export type ThreadListState = {
-    readonly mainThreadId: string;
-    readonly newThreadId: string | undefined;
-    readonly threadIds: readonly string[];
-    readonly archivedThreadIds: readonly string[];
-    readonly isLoading: boolean;
-    readonly threadItems: Readonly<Record<string, Omit<ThreadListItemState, "isMain" | "threadId">>>;
-};
-export type ThreadListRuntime = {
-    getState(): ThreadListState;
-    subscribe(callback: () => void): Unsubscribe;
-    readonly main: ThreadRuntime;
-    getById(threadId: string): ThreadRuntime;
-    readonly mainItem: ThreadListItemRuntime;
-    getItemById(threadId: string): ThreadListItemRuntime;
-    getItemByIndex(idx: number): ThreadListItemRuntime;
-    getArchivedItemByIndex(idx: number): ThreadListItemRuntime;
-    switchToThread(threadId: string): Promise<void>;
-    switchToNewThread(): Promise<void>;
-};
-export type ThreadListRuntimeCoreBinding = ThreadListRuntimeCore;
-export declare class ThreadListRuntimeImpl implements ThreadListRuntime {
-    private _core;
-    private _runtimeFactory;
-    private _getState;
-    constructor(_core: ThreadListRuntimeCoreBinding, _runtimeFactory?: new (binding: ThreadRuntimeCoreBinding, threadListItemBinding: ThreadListItemRuntimeBinding) => ThreadRuntime);
-    protected __internal_bindMethods(): void;
-    switchToThread(threadId: string): Promise<void>;
-    switchToNewThread(): Promise<void>;
-    getState(): ThreadListState;
-    subscribe(callback: () => void): Unsubscribe;
-    private _mainThreadListItemRuntime;
-    readonly main: ThreadRuntime;
-    get mainItem(): ThreadListItemRuntimeImpl;
-    getById(threadId: string): ThreadRuntime;
-    getItemByIndex(idx: number): ThreadListItemRuntimeImpl;
-    getArchivedItemByIndex(idx: number): ThreadListItemRuntimeImpl;
-    getItemById(threadId: string): ThreadListItemRuntimeImpl;
-}

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime/ThreadListRuntime.js

@@ -1,133 +0,0 @@
-import { LazyMemoizeSubject } from "./subscribable/LazyMemoizeSubject";
-import { ThreadListItemRuntimeImpl, } from "./ThreadListItemRuntime";
-import { SKIP_UPDATE } from "./subscribable/SKIP_UPDATE";
-import { ShallowMemoizeSubject } from "./subscribable/ShallowMemoizeSubject";
-import { ThreadRuntimeImpl, } from "./ThreadRuntime";
-import { NestedSubscriptionSubject } from "./subscribable/NestedSubscriptionSubject";
-const getThreadListState = (threadList) => {
-    return {
-        mainThreadId: threadList.mainThreadId,
-        newThreadId: threadList.newThreadId,
-        threadIds: threadList.threadIds,
-        archivedThreadIds: threadList.archivedThreadIds,
-        isLoading: threadList.isLoading,
-        threadItems: threadList.threadItems,
-    };
-};
-const getThreadListItemState = (threadList, threadId) => {
-    if (threadId === undefined)
-        return SKIP_UPDATE;
-    const threadData = threadList.getItemById(threadId);
-    if (!threadData)
-        return SKIP_UPDATE;
-    return {
-        id: threadData.id,
-        remoteId: threadData.remoteId,
-        externalId: threadData.externalId,
-        title: threadData.title,
-        status: threadData.status,
-        isMain: threadData.id === threadList.mainThreadId,
-    };
-};
-export class ThreadListRuntimeImpl {
-    constructor(_core, _runtimeFactory = ThreadRuntimeImpl) {
-        this._core = _core;
-        this._runtimeFactory = _runtimeFactory;
-        const stateBinding = new LazyMemoizeSubject({
-            path: {},
-            getState: () => getThreadListState(_core),
-            subscribe: (callback) => _core.subscribe(callback),
-        });
-        this._getState = stateBinding.getState.bind(stateBinding);
-        this._mainThreadListItemRuntime = new ThreadListItemRuntimeImpl(new ShallowMemoizeSubject({
-            path: {
-                ref: `threadItems[main]`,
-                threadSelector: { type: "main" },
-            },
-            getState: () => {
-                return getThreadListItemState(this._core, this._core.mainThreadId);
-            },
-            subscribe: (callback) => this._core.subscribe(callback),
-        }), this._core);
-        this.main = new _runtimeFactory(new NestedSubscriptionSubject({
-            path: {
-                ref: "threads.main",
-                threadSelector: { type: "main" },
-            },
-            getState: () => _core.getMainThreadRuntimeCore(),
-            subscribe: (callback) => _core.subscribe(callback),
-        }), this._mainThreadListItemRuntime);
-        this.__internal_bindMethods();
-    }
-    __internal_bindMethods() {
-        this.switchToThread = this.switchToThread.bind(this);
-        this.switchToNewThread = this.switchToNewThread.bind(this);
-        this.getState = this.getState.bind(this);
-        this.subscribe = this.subscribe.bind(this);
-        this.getById = this.getById.bind(this);
-        this.getItemById = this.getItemById.bind(this);
-        this.getItemByIndex = this.getItemByIndex.bind(this);
-        this.getArchivedItemByIndex = this.getArchivedItemByIndex.bind(this);
-    }
-    switchToThread(threadId) {
-        return this._core.switchToThread(threadId);
-    }
-    switchToNewThread() {
-        return this._core.switchToNewThread();
-    }
-    getState() {
-        return this._getState();
-    }
-    subscribe(callback) {
-        return this._core.subscribe(callback);
-    }
-    get mainItem() {
-        return this._mainThreadListItemRuntime;
-    }
-    getById(threadId) {
-        return new this._runtimeFactory(new NestedSubscriptionSubject({
-            path: {
-                ref: `threads[threadId=${JSON.stringify(threadId)}]`,
-                threadSelector: { type: "threadId", threadId },
-            },
-            getState: () => this._core.getThreadRuntimeCore(threadId),
-            subscribe: (callback) => this._core.subscribe(callback),
-        }), this.mainItem);
-    }
-    getItemByIndex(idx) {
-        return new ThreadListItemRuntimeImpl(new ShallowMemoizeSubject({
-            path: {
-                ref: `threadItems[${idx}]`,
-                threadSelector: { type: "index", index: idx },
-            },
-            getState: () => {
-                return getThreadListItemState(this._core, this._core.threadIds[idx]);
-            },
-            subscribe: (callback) => this._core.subscribe(callback),
-        }), this._core);
-    }
-    getArchivedItemByIndex(idx) {
-        return new ThreadListItemRuntimeImpl(new ShallowMemoizeSubject({
-            path: {
-                ref: `archivedThreadItems[${idx}]`,
-                threadSelector: { type: "archiveIndex", index: idx },
-            },
-            getState: () => {
-                return getThreadListItemState(this._core, this._core.archivedThreadIds[idx]);
-            },
-            subscribe: (callback) => this._core.subscribe(callback),
-        }), this._core);
-    }
-    getItemById(threadId) {
-        return new ThreadListItemRuntimeImpl(new ShallowMemoizeSubject({
-            path: {
-                ref: `threadItems[threadId=${threadId}]`,
-                threadSelector: { type: "threadId", threadId },
-            },
-            getState: () => {
-                return getThreadListItemState(this._core, threadId);
-            },
-            subscribe: (callback) => this._core.subscribe(callback),
-        }), this._core);
-    }
-}

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime/ThreadRuntime.d.ts

@@ -1,270 +0,0 @@
-import { ThreadSuggestion, RuntimeCapabilities, ThreadRuntimeCore, SpeechState, ThreadRuntimeEventType, StartRunConfig, ResumeRunConfig } from "../runtime-cores/core/ThreadRuntimeCore";
-import { ExportedMessageRepository } from "../runtime-cores/utils/MessageRepository";
-import { AppendMessage, ThreadMessage, Unsubscribe } from "../../types";
-import { ThreadMessageLike } from "../runtime-cores/external-store";
-import { MessageRuntime, MessageRuntimeImpl } from "./MessageRuntime";
-import { SubscribableWithState } from "./subscribable/Subscribable";
-import { ThreadComposerRuntime, ThreadComposerRuntimeImpl } from "./ComposerRuntime";
-import { ThreadListItemRuntimePath, ThreadRuntimePath } from "./RuntimePathTypes";
-import type { ThreadListItemState } from "./RuntimeBindings";
-import { RunConfig } from "../../types/AssistantTypes";
-import { ModelContext } from "../../model-context";
-import { ChatModelRunOptions, ChatModelRunResult } from "../runtime-cores";
-import { ReadonlyJSONValue } from "assistant-stream/utils";
-export type CreateStartRunConfig = {
-    parentId: string | null;
-    sourceId?: string | null | undefined;
-    runConfig?: RunConfig | undefined;
-};
-export type CreateResumeRunConfig = CreateStartRunConfig & {
-    stream?: (options: ChatModelRunOptions) => AsyncGenerator<ChatModelRunResult, void, unknown>;
-};
-export type CreateAppendMessage = string | {
-    parentId?: string | null | undefined;
-    sourceId?: string | null | undefined;
-    role?: AppendMessage["role"] | undefined;
-    content: AppendMessage["content"];
-    attachments?: AppendMessage["attachments"] | undefined;
-    metadata?: AppendMessage["metadata"] | undefined;
-    createdAt?: Date | undefined;
-    runConfig?: AppendMessage["runConfig"] | undefined;
-    startRun?: boolean | undefined;
-};
-export type ThreadRuntimeCoreBinding = SubscribableWithState<ThreadRuntimeCore, ThreadRuntimePath> & {
-    outerSubscribe(callback: () => void): Unsubscribe;
-};
-export type ThreadListItemRuntimeBinding = SubscribableWithState<ThreadListItemState, ThreadListItemRuntimePath>;
-export type ThreadState = {
-    /**
-     * The thread ID.
-     * @deprecated This field is deprecated and will be removed in 0.12.0. Use `useThreadListItem().id` instead.
-     */
-    readonly threadId: string;
-    /**
-     * The thread metadata.
-     *
-     * @deprecated Use `useThreadListItem()` instead. This field is deprecated and will be removed in 0.12.0.
-     */
-    readonly metadata: ThreadListItemState;
-    /**
-     * Whether the thread is disabled. Disabled threads cannot receive new messages.
-     */
-    readonly isDisabled: boolean;
-    /**
-     * Whether the thread is loading its history.
-     */
-    readonly isLoading: boolean;
-    /**
-     * Whether the thread is running. A thread is considered running when there is an active stream connection to the backend.
-     */
-    readonly isRunning: boolean;
-    /**
-     * The capabilities of the thread, such as whether the thread supports editing, branch switching, etc.
-     */
-    readonly capabilities: RuntimeCapabilities;
-    /**
-     * The messages in the currently selected branch of the thread.
-     */
-    readonly messages: readonly ThreadMessage[];
-    /**
-     * The thread state.
-     *
-     * @deprecated This feature is experimental
-     */
-    readonly state: ReadonlyJSONValue;
-    /**
-     * Follow up message suggestions to show the user.
-     */
-    readonly suggestions: readonly ThreadSuggestion[];
-    /**
-     * Custom extra information provided by the runtime.
-     */
-    readonly extras: unknown;
-    /**
-     * @deprecated This API is still under active development and might change without notice.
-     */
-    readonly speech: SpeechState | undefined;
-};
-export declare const getThreadState: (runtime: ThreadRuntimeCore, threadListItemState: ThreadListItemState) => ThreadState;
-export type ThreadRuntime = {
-    /**
-     * The selector for the thread runtime.
-     */
-    readonly path: ThreadRuntimePath;
-    /**
-     * The thread composer runtime.
-     */
-    readonly composer: ThreadComposerRuntime;
-    /**
-     * Gets a snapshot of the thread state.
-     */
-    getState(): ThreadState;
-    /**
-     * Append a new message to the thread.
-     *
-     * @example ```ts
-     * // append a new user message with the text "Hello, world!"
-     * threadRuntime.append("Hello, world!");
-     * ```
-     *
-     * @example ```ts
-     * // append a new assistant message with the text "Hello, world!"
-     * threadRuntime.append({
-     *   role: "assistant",
-     *   content: [{ type: "text", text: "Hello, world!" }],
-     * });
-     * ```
-     */
-    append(message: CreateAppendMessage): void;
-    /**
-     * @deprecated pass an object with `parentId` instead. This will be removed in 0.12.0.
-     */
-    startRun(parentId: string | null): void;
-    /**
-     * Start a new run with the given configuration.
-     * @param config The configuration for starting the run
-     */
-    startRun(config: CreateStartRunConfig): void;
-    /**
-     * Resume a run with the given configuration.
-     * @param config The configuration for resuming the run
-     **/
-    unstable_resumeRun(config: CreateResumeRunConfig): void;
-    /**
-     * Export the thread state in the external store format.
-     * For AI SDK runtimes, this returns the AI SDK message format.
-     * For other runtimes, this may return different formats or throw an error.
-     * @returns The thread state in the external format (typed as any)
-     */
-    exportExternalState(): any;
-    /**
-     * Import thread state from the external store format.
-     * For AI SDK runtimes, this accepts AI SDK messages.
-     * For other runtimes, this may accept different formats or throw an error.
-     * @param state The thread state in the external format (typed as any)
-     */
-    importExternalState(state: any): void;
-    /**
-     * Load external state into the thread.
-     * @deprecated Use importExternalState instead. This method will be removed in 0.12.0.
-     * @param state The state to load into the thread
-     */
-    unstable_loadExternalState(state: any): void;
-    subscribe(callback: () => void): Unsubscribe;
-    cancelRun(): void;
-    getModelContext(): ModelContext;
-    /**
-     * @deprecated This method was renamed to `getModelContext`.
-     */
-    getModelConfig(): ModelContext;
-    export(): ExportedMessageRepository;
-    import(repository: ExportedMessageRepository): void;
-    /**
-     * Reset the thread with optional initial messages.
-     *
-     * @param initialMessages - Optional array of initial messages to populate the thread
-     */
-    reset(initialMessages?: readonly ThreadMessageLike[]): void;
-    getMessageByIndex(idx: number): MessageRuntime;
-    getMessageById(messageId: string): MessageRuntime;
-    /**
-     * @deprecated This API is still under active development and might change without notice.
-     */
-    stopSpeaking(): void;
-    unstable_on(event: ThreadRuntimeEventType, callback: () => void): Unsubscribe;
-};
-export declare class ThreadRuntimeImpl implements ThreadRuntime {
-    get path(): ThreadRuntimePath;
-    get __internal_threadBinding(): import("./subscribable/Subscribable").Subscribable & {
-        path: ThreadRuntimePath;
-        getState: () => Readonly<{
-            getMessageById: (messageId: string) => {
-                parentId: string | null;
-                message: ThreadMessage;
-                index: number;
-            } | undefined;
-            getBranches: (messageId: string) => readonly string[];
-            switchToBranch: (branchId: string) => void;
-            append: (message: AppendMessage) => void;
-            startRun: (config: StartRunConfig) => void;
-            resumeRun: (config: ResumeRunConfig) => void;
-            cancelRun: () => void;
-            addToolResult: (options: import("../runtime-cores").AddToolResultOptions) => void;
-            resumeToolCall: (options: import("../runtime-cores/core/ThreadRuntimeCore").ResumeToolCallOptions) => void;
-            speak: (messageId: string) => void;
-            stopSpeaking: () => void;
-            submitFeedback: (feedback: import("../runtime-cores").SubmitFeedbackOptions) => void;
-            getModelContext: () => ModelContext;
-            composer: import("../runtime-cores/core/ComposerRuntimeCore").ThreadComposerRuntimeCore;
-            getEditComposer: (messageId: string) => Readonly<{
-                isEditing: boolean;
-                canCancel: boolean;
-                isEmpty: boolean;
-                attachments: readonly import("../..").Attachment[];
-                attachmentAccept: string;
-                addAttachment: (file: File) => Promise<void>;
-                removeAttachment: (attachmentId: string) => Promise<void>;
-                text: string;
-                setText: (value: string) => void;
-                role: import("../../types/AssistantTypes").MessageRole;
-                setRole: (role: import("../../types/AssistantTypes").MessageRole) => void;
-                runConfig: RunConfig;
-                setRunConfig: (runConfig: RunConfig) => void;
-                reset: () => Promise<void>;
-                clearAttachments: () => Promise<void>;
-                send: () => void;
-                cancel: () => void;
-                dictation: import("../runtime-cores").DictationState | undefined;
-                startDictation: () => void;
-                stopDictation: () => void;
-                subscribe: (callback: () => void) => Unsubscribe;
-                unstable_on: (event: import("../runtime-cores/core/ComposerRuntimeCore").ComposerRuntimeEventType, callback: () => void) => Unsubscribe;
-            }> | undefined;
-            beginEdit: (messageId: string) => void;
-            speech: SpeechState | undefined;
-            capabilities: Readonly<RuntimeCapabilities>;
-            isDisabled: boolean;
-            isLoading: boolean;
-            messages: readonly ThreadMessage[];
-            state: ReadonlyJSONValue;
-            suggestions: readonly ThreadSuggestion[];
-            extras: unknown;
-            subscribe: (callback: () => void) => Unsubscribe;
-            import(repository: ExportedMessageRepository): void;
-            export(): ExportedMessageRepository;
-            exportExternalState(): any;
-            importExternalState(state: any): void;
-            reset(initialMessages?: readonly ThreadMessageLike[]): void;
-            unstable_on(event: ThreadRuntimeEventType, callback: () => void): Unsubscribe;
-            unstable_loadExternalState: (state: any) => void;
-        }>;
-    } & {
-        outerSubscribe(callback: () => void): Unsubscribe;
-    } & {
-        getStateState(): ThreadState;
-    };
-    private readonly _threadBinding;
-    constructor(threadBinding: ThreadRuntimeCoreBinding, threadListItemBinding: ThreadListItemRuntimeBinding);
-    protected __internal_bindMethods(): void;
-    readonly composer: ThreadComposerRuntimeImpl;
-    getState(): ThreadState;
-    append(message: CreateAppendMessage): void;
-    subscribe(callback: () => void): Unsubscribe;
-    getModelContext(): ModelContext;
-    getModelConfig(): ModelContext;
-    startRun(configOrParentId: string | null | CreateStartRunConfig): void;
-    unstable_resumeRun(config: CreateResumeRunConfig): void;
-    exportExternalState(): any;
-    importExternalState(state: any): void;
-    unstable_loadExternalState(state: any): void;
-    cancelRun(): void;
-    stopSpeaking(): void;
-    export(): ExportedMessageRepository;
-    import(data: ExportedMessageRepository): void;
-    reset(initialMessages?: readonly ThreadMessageLike[]): void;
-    getMessageByIndex(idx: number): MessageRuntimeImpl;
-    getMessageById(messageId: string): MessageRuntimeImpl;
-    private _getMessageRuntime;
-    private _eventSubscriptionSubjects;
-    unstable_on(event: ThreadRuntimeEventType, callback: () => void): Unsubscribe;
-}