ikoncomponents 1.6.3 → 1.6.5

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

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

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

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

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

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

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

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

@@ -0,0 +1,270 @@
+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;
+}