ikoncomponents 1.6.3 → 1.6.5

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/composer/DefaultEditComposerRuntimeCore.js

@@ -0,0 +1,41 @@
+import { getThreadMessageText } from "../../../utils/getThreadMessageText";
+import { BaseComposerRuntimeCore } from "./BaseComposerRuntimeCore";
+export class DefaultEditComposerRuntimeCore extends BaseComposerRuntimeCore {
+    get canCancel() {
+        return true;
+    }
+    getAttachmentAdapter() {
+        var _a;
+        return (_a = this.runtime.adapters) === null || _a === void 0 ? void 0 : _a.attachments;
+    }
+    getDictationAdapter() {
+        var _a;
+        return (_a = this.runtime.adapters) === null || _a === void 0 ? void 0 : _a.dictation;
+    }
+    constructor(runtime, endEditCallback, { parentId, message }) {
+        var _a;
+        super();
+        this.runtime = runtime;
+        this.endEditCallback = endEditCallback;
+        this._parentId = parentId;
+        this._sourceId = message.id;
+        this._previousText = getThreadMessageText(message);
+        this.setText(this._previousText);
+        this.setRole(message.role);
+        this.setAttachments((_a = message.attachments) !== null && _a !== void 0 ? _a : []);
+        this._nonTextParts = message.content.filter((part) => part.type !== "text");
+        // Use the runConfig from the regular (non-edit) composer as the initial runConfig for the edit composer
+        this.setRunConfig(Object.assign({}, runtime.composer.runConfig));
+    }
+    async handleSend(message) {
+        const text = getThreadMessageText(message);
+        if (text !== this._previousText) {
+            this.runtime.append(Object.assign(Object.assign({}, message), { content: [...message.content, ...this._nonTextParts], parentId: this._parentId, sourceId: this._sourceId }));
+        }
+        this.handleCancel();
+    }
+    handleCancel() {
+        this.endEditCallback();
+        this._notifySubscribers();
+    }
+}

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/composer/DefaultThreadComposerRuntimeCore.d.ts

@@ -0,0 +1,23 @@
+import type { AppendMessage, PendingAttachment } from "../../../types";
+import type { AttachmentAdapter } from "../adapters/attachment";
+import type { DictationAdapter } from "../adapters/speech/SpeechAdapterTypes";
+import type { ThreadComposerRuntimeCore } from "../core/ComposerRuntimeCore";
+import type { ThreadRuntimeCore } from "../core/ThreadRuntimeCore";
+import { BaseComposerRuntimeCore } from "./BaseComposerRuntimeCore";
+export declare class DefaultThreadComposerRuntimeCore extends BaseComposerRuntimeCore implements ThreadComposerRuntimeCore {
+    private runtime;
+    private _canCancel;
+    get canCancel(): boolean;
+    get attachments(): readonly PendingAttachment[];
+    protected getAttachmentAdapter(): AttachmentAdapter | undefined;
+    protected getDictationAdapter(): DictationAdapter | undefined;
+    constructor(runtime: Omit<ThreadRuntimeCore, "composer"> & {
+        adapters?: {
+            attachments?: AttachmentAdapter | undefined;
+            dictation?: DictationAdapter | undefined;
+        } | undefined;
+    });
+    connect(): import("../../..").Unsubscribe;
+    handleSend(message: Omit<AppendMessage, "parentId" | "sourceId">): Promise<void>;
+    handleCancel(): Promise<void>;
+}

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/composer/DefaultThreadComposerRuntimeCore.js

@@ -0,0 +1,38 @@
+import { BaseComposerRuntimeCore } from "./BaseComposerRuntimeCore";
+export class DefaultThreadComposerRuntimeCore extends BaseComposerRuntimeCore {
+    get canCancel() {
+        return this._canCancel;
+    }
+    get attachments() {
+        return super.attachments;
+    }
+    getAttachmentAdapter() {
+        var _a;
+        return (_a = this.runtime.adapters) === null || _a === void 0 ? void 0 : _a.attachments;
+    }
+    getDictationAdapter() {
+        var _a;
+        return (_a = this.runtime.adapters) === null || _a === void 0 ? void 0 : _a.dictation;
+    }
+    constructor(runtime) {
+        super();
+        this.runtime = runtime;
+        this._canCancel = false;
+        this.connect();
+    }
+    connect() {
+        return this.runtime.subscribe(() => {
+            if (this.canCancel !== this.runtime.capabilities.cancel) {
+                this._canCancel = this.runtime.capabilities.cancel;
+                this._notifySubscribers();
+            }
+        });
+    }
+    async handleSend(message) {
+        var _a, _b;
+        this.runtime.append(Object.assign(Object.assign({}, message), { parentId: (_b = (_a = this.runtime.messages.at(-1)) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : null, sourceId: null }));
+    }
+    async handleCancel() {
+        this.runtime.cancelRun();
+    }
+}

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/core/AssistantRuntimeCore.d.ts

@@ -0,0 +1,16 @@
+import { ComponentType } from "react";
+import type { ModelContextProvider } from "../../../model-context/ModelContextTypes";
+import type { Unsubscribe } from "../../../types/Unsubscribe";
+import { ThreadListRuntimeCore } from "./ThreadListRuntimeCore";
+export type AssistantRuntimeCore = {
+    readonly threads: ThreadListRuntimeCore;
+    registerModelContextProvider: (provider: ModelContextProvider) => Unsubscribe;
+    getModelContextProvider: () => ModelContextProvider;
+    /**
+     * EXPERIMENTAL: A component that is rendered inside the AssistantRuntimeProvider.
+     *
+     * Note: This field is expected to never change.
+     * To update the component, use a zustand store.
+     */
+    readonly RenderComponent?: ComponentType | undefined;
+};

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/core/AssistantRuntimeCore.js

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

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/core/BaseAssistantRuntimeCore.d.ts

@@ -0,0 +1,11 @@
+import { type ModelContextProvider } from "../../../model-context/ModelContextTypes";
+import type { Unsubscribe } from "../../../types/Unsubscribe";
+import type { AssistantRuntimeCore } from "./AssistantRuntimeCore";
+import { CompositeContextProvider } from "../../../utils/CompositeContextProvider";
+import { ThreadListRuntimeCore } from "./ThreadListRuntimeCore";
+export declare abstract class BaseAssistantRuntimeCore implements AssistantRuntimeCore {
+    protected readonly _contextProvider: CompositeContextProvider;
+    abstract get threads(): ThreadListRuntimeCore;
+    registerModelContextProvider(provider: ModelContextProvider): Unsubscribe;
+    getModelContextProvider(): ModelContextProvider;
+}

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/core/BaseAssistantRuntimeCore.js

@@ -0,0 +1,12 @@
+import { CompositeContextProvider } from "../../../utils/CompositeContextProvider";
+export class BaseAssistantRuntimeCore {
+    constructor() {
+        this._contextProvider = new CompositeContextProvider();
+    }
+    registerModelContextProvider(provider) {
+        return this._contextProvider.registerModelContextProvider(provider);
+    }
+    getModelContextProvider() {
+        return this._contextProvider;
+    }
+}

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/core/BaseThreadRuntimeCore.d.ts

@@ -0,0 +1,66 @@
+import type { AppendMessage, ThreadMessage, Unsubscribe } from "../../../types";
+import { ExportedMessageRepository, MessageRepository } from "../utils/MessageRepository";
+import { DefaultThreadComposerRuntimeCore } from "../composer/DefaultThreadComposerRuntimeCore";
+import { AddToolResultOptions, ResumeToolCallOptions, ThreadSuggestion, SubmitFeedbackOptions, ThreadRuntimeCore, SpeechState, RuntimeCapabilities, ThreadRuntimeEventType, StartRunConfig, ResumeRunConfig } from "./ThreadRuntimeCore";
+import { DefaultEditComposerRuntimeCore } from "../composer/DefaultEditComposerRuntimeCore";
+import { SpeechSynthesisAdapter } from "../adapters/speech/SpeechAdapterTypes";
+import { FeedbackAdapter } from "../adapters/feedback/FeedbackAdapter";
+import { AttachmentAdapter } from "../adapters/attachment";
+import { ModelContextProvider } from "../../../model-context";
+import { ThreadMessageLike } from "../external-store";
+type BaseThreadAdapters = {
+    speech?: SpeechSynthesisAdapter | undefined;
+    feedback?: FeedbackAdapter | undefined;
+    attachments?: AttachmentAdapter | undefined;
+};
+export declare abstract class BaseThreadRuntimeCore implements ThreadRuntimeCore {
+    private readonly _contextProvider;
+    private _subscriptions;
+    private _isInitialized;
+    protected readonly repository: MessageRepository;
+    abstract get adapters(): BaseThreadAdapters | undefined;
+    abstract get isDisabled(): boolean;
+    abstract get isLoading(): boolean;
+    abstract get suggestions(): readonly ThreadSuggestion[];
+    abstract get extras(): unknown;
+    abstract get capabilities(): RuntimeCapabilities;
+    abstract append(message: AppendMessage): void;
+    abstract startRun(config: StartRunConfig): void;
+    abstract resumeRun(config: ResumeRunConfig): void;
+    abstract addToolResult(options: AddToolResultOptions): void;
+    abstract resumeToolCall(options: ResumeToolCallOptions): void;
+    abstract cancelRun(): void;
+    abstract exportExternalState(): any;
+    abstract importExternalState(state: any): void;
+    abstract unstable_loadExternalState(state: any): void;
+    get messages(): readonly ThreadMessage[];
+    get state(): any;
+    readonly composer: DefaultThreadComposerRuntimeCore;
+    constructor(_contextProvider: ModelContextProvider);
+    getModelContext(): import("../../..").ModelContext;
+    private _editComposers;
+    getEditComposer(messageId: string): DefaultEditComposerRuntimeCore | undefined;
+    beginEdit(messageId: string): void;
+    getMessageById(messageId: string): {
+        parentId: string | null;
+        message: ThreadMessage;
+        index: number;
+    } | undefined;
+    getBranches(messageId: string): string[];
+    switchToBranch(branchId: string): void;
+    protected _notifySubscribers(): void;
+    _notifyEventSubscribers(event: ThreadRuntimeEventType): void;
+    subscribe(callback: () => void): Unsubscribe;
+    submitFeedback({ messageId, type }: SubmitFeedbackOptions): void;
+    private _stopSpeaking;
+    speech: SpeechState | undefined;
+    speak(messageId: string): void;
+    stopSpeaking(): void;
+    protected ensureInitialized(): void;
+    export(): ExportedMessageRepository;
+    import(data: ExportedMessageRepository): void;
+    reset(initialMessages?: readonly ThreadMessageLike[]): void;
+    private _eventSubscribers;
+    unstable_on(event: ThreadRuntimeEventType, callback: () => void): Unsubscribe;
+}
+export {};

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/core/BaseThreadRuntimeCore.js

@@ -0,0 +1,154 @@
+import { ExportedMessageRepository, MessageRepository, } from "../utils/MessageRepository";
+import { DefaultThreadComposerRuntimeCore } from "../composer/DefaultThreadComposerRuntimeCore";
+import { DefaultEditComposerRuntimeCore } from "../composer/DefaultEditComposerRuntimeCore";
+import { getThreadMessageText } from "../../../utils/getThreadMessageText";
+export class BaseThreadRuntimeCore {
+    get messages() {
+        return this.repository.getMessages();
+    }
+    get state() {
+        var _a;
+        let mostRecentAssistantMessage;
+        for (const message of this.messages) {
+            if (message.role === "assistant") {
+                mostRecentAssistantMessage = message;
+                break;
+            }
+        }
+        return (_a = mostRecentAssistantMessage === null || mostRecentAssistantMessage === void 0 ? void 0 : mostRecentAssistantMessage.metadata.unstable_state) !== null && _a !== void 0 ? _a : null;
+    }
+    constructor(_contextProvider) {
+        this._contextProvider = _contextProvider;
+        this._subscriptions = new Set();
+        this._isInitialized = false;
+        this.repository = new MessageRepository();
+        this.composer = new DefaultThreadComposerRuntimeCore(this);
+        this._editComposers = new Map();
+        this._eventSubscribers = new Map();
+    }
+    getModelContext() {
+        return this._contextProvider.getModelContext();
+    }
+    getEditComposer(messageId) {
+        return this._editComposers.get(messageId);
+    }
+    beginEdit(messageId) {
+        if (this._editComposers.has(messageId))
+            throw new Error("Edit already in progress");
+        this._editComposers.set(messageId, new DefaultEditComposerRuntimeCore(this, () => this._editComposers.delete(messageId), this.repository.getMessage(messageId)));
+        this._notifySubscribers();
+    }
+    getMessageById(messageId) {
+        try {
+            return this.repository.getMessage(messageId);
+        }
+        catch (_a) {
+            return undefined;
+        }
+    }
+    getBranches(messageId) {
+        return this.repository.getBranches(messageId);
+    }
+    switchToBranch(branchId) {
+        this.repository.switchToBranch(branchId);
+        this._notifySubscribers();
+    }
+    _notifySubscribers() {
+        for (const callback of this._subscriptions)
+            callback();
+    }
+    _notifyEventSubscribers(event) {
+        const subscribers = this._eventSubscribers.get(event);
+        if (!subscribers)
+            return;
+        for (const callback of subscribers)
+            callback();
+    }
+    subscribe(callback) {
+        this._subscriptions.add(callback);
+        return () => this._subscriptions.delete(callback);
+    }
+    submitFeedback({ messageId, type }) {
+        var _a;
+        const adapter = (_a = this.adapters) === null || _a === void 0 ? void 0 : _a.feedback;
+        if (!adapter)
+            throw new Error("Feedback adapter not configured");
+        const { message, parentId } = this.repository.getMessage(messageId);
+        adapter.submit({ message, type });
+        // Update the message metadata with the feedback
+        if (message.role === "assistant") {
+            const updatedMessage = Object.assign(Object.assign({}, message), { metadata: Object.assign(Object.assign({}, message.metadata), { submittedFeedback: { type } }) });
+            this.repository.addOrUpdateMessage(parentId, updatedMessage);
+        }
+        this._notifySubscribers();
+    }
+    speak(messageId) {
+        var _a, _b;
+        const adapter = (_a = this.adapters) === null || _a === void 0 ? void 0 : _a.speech;
+        if (!adapter)
+            throw new Error("Speech adapter not configured");
+        const { message } = this.repository.getMessage(messageId);
+        (_b = this._stopSpeaking) === null || _b === void 0 ? void 0 : _b.call(this);
+        const utterance = adapter.speak(getThreadMessageText(message));
+        const unsub = utterance.subscribe(() => {
+            if (utterance.status.type === "ended") {
+                this._stopSpeaking = undefined;
+                this.speech = undefined;
+            }
+            else {
+                this.speech = { messageId, status: utterance.status };
+            }
+            this._notifySubscribers();
+        });
+        this.speech = { messageId, status: utterance.status };
+        this._notifySubscribers();
+        this._stopSpeaking = () => {
+            utterance.cancel();
+            unsub();
+            this.speech = undefined;
+            this._stopSpeaking = undefined;
+        };
+    }
+    stopSpeaking() {
+        if (!this._stopSpeaking)
+            throw new Error("No message is being spoken");
+        this._stopSpeaking();
+        this._notifySubscribers();
+    }
+    ensureInitialized() {
+        if (!this._isInitialized) {
+            this._isInitialized = true;
+            this._notifyEventSubscribers("initialize");
+        }
+    }
+    // TODO import()/export() on external store doesn't make much sense
+    export() {
+        return this.repository.export();
+    }
+    import(data) {
+        this.ensureInitialized();
+        this.repository.clear();
+        this.repository.import(data);
+        this._notifySubscribers();
+    }
+    reset(initialMessages) {
+        this.import(ExportedMessageRepository.fromArray(initialMessages !== null && initialMessages !== void 0 ? initialMessages : []));
+    }
+    unstable_on(event, callback) {
+        var _a, _b, _c;
+        if (event === "modelContextUpdate") {
+            return (_c = (_b = (_a = this._contextProvider).subscribe) === null || _b === void 0 ? void 0 : _b.call(_a, callback)) !== null && _c !== void 0 ? _c : (() => { });
+        }
+        const subscribers = this._eventSubscribers.get(event);
+        if (!subscribers) {
+            this._eventSubscribers.set(event, new Set([callback]));
+        }
+        else {
+            subscribers.add(callback);
+        }
+        return () => {
+            const subscribers = this._eventSubscribers.get(event);
+            subscribers.delete(callback);
+        };
+    }
+}

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/core/ComposerRuntimeCore.d.ts

@@ -0,0 +1,61 @@
+import type { Attachment, PendingAttachment, Unsubscribe } from "../../../types";
+import type { MessageRole, RunConfig } from "../../../types/AssistantTypes";
+import type { DictationAdapter } from "../adapters/speech/SpeechAdapterTypes";
+export type ComposerRuntimeEventType = "send" | "attachmentAdd";
+/**
+ * State representing an active dictation session.
+ */
+export type DictationState = {
+    readonly status: DictationAdapter.Status;
+    /**
+     * The current interim (partial) transcript being recognized.
+     * This is a preview of what the user is saying and may change
+     * as dictation refines its prediction.
+     *
+     * Note: By default, interim transcripts are shown directly in the composer
+     * input field (like native dictation). This property is provided for
+     * advanced customization when you want to display or style the interim
+     * transcript separately.
+     */
+    readonly transcript?: string;
+    /** Whether text input is disabled during this dictation session. */
+    readonly inputDisabled?: boolean;
+};
+export type ComposerRuntimeCore = Readonly<{
+    isEditing: boolean;
+    canCancel: boolean;
+    isEmpty: boolean;
+    attachments: readonly Attachment[];
+    attachmentAccept: string;
+    addAttachment: (file: File) => Promise<void>;
+    removeAttachment: (attachmentId: string) => Promise<void>;
+    text: string;
+    setText: (value: string) => void;
+    role: MessageRole;
+    setRole: (role: MessageRole) => void;
+    runConfig: RunConfig;
+    setRunConfig: (runConfig: RunConfig) => void;
+    reset: () => Promise<void>;
+    clearAttachments: () => Promise<void>;
+    send: () => void;
+    cancel: () => void;
+    /**
+     * The current state of dictation.
+     * Undefined when dictation is not active.
+     */
+    dictation: DictationState | undefined;
+    /**
+     * Start dictation to convert voice to text input.
+     * Requires a DictationAdapter to be configured.
+     */
+    startDictation: () => void;
+    /**
+     * Stop the current dictation session.
+     */
+    stopDictation: () => void;
+    subscribe: (callback: () => void) => Unsubscribe;
+    unstable_on: (event: ComposerRuntimeEventType, callback: () => void) => Unsubscribe;
+}>;
+export type ThreadComposerRuntimeCore = ComposerRuntimeCore & Readonly<{
+    attachments: readonly PendingAttachment[];
+}>;

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/core/ComposerRuntimeCore.js

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

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/core/ThreadListRuntimeCore.d.ts

@@ -0,0 +1,36 @@
+import { Unsubscribe } from "../../../types";
+import { ThreadRuntimeCore } from "./ThreadRuntimeCore";
+import type { ThreadListItemStatus } from "../../runtime/RuntimeBindings";
+export type ThreadListItemCoreState = {
+    readonly id: string;
+    readonly remoteId: string | undefined;
+    readonly externalId: string | undefined;
+    readonly status: ThreadListItemStatus;
+    readonly title?: string | undefined;
+    readonly runtime?: ThreadRuntimeCore | undefined;
+};
+export type ThreadListRuntimeCore = {
+    readonly isLoading: boolean;
+    mainThreadId: string;
+    newThreadId: string | undefined;
+    threadIds: readonly string[];
+    archivedThreadIds: readonly string[];
+    readonly threadItems: Readonly<Record<string, ThreadListItemCoreState>>;
+    getMainThreadRuntimeCore(): ThreadRuntimeCore;
+    getThreadRuntimeCore(threadId: string): ThreadRuntimeCore;
+    getItemById(threadId: string): ThreadListItemCoreState | undefined;
+    switchToThread(threadId: string): Promise<void>;
+    switchToNewThread(): Promise<void>;
+    getLoadThreadsPromise(): Promise<void>;
+    detach(threadId: string): Promise<void>;
+    rename(threadId: string, newTitle: string): 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(threadId: string): Promise<void>;
+    subscribe(callback: () => void): Unsubscribe;
+};

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/core/ThreadListRuntimeCore.js

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

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/core/ThreadRuntimeCore.d.ts

@@ -0,0 +1,110 @@
+import type { ReadonlyJSONValue } from "assistant-stream/utils";
+import { ModelContext } from "../../../model-context";
+import { AppendMessage, ThreadMessage } from "../../../types";
+import { RunConfig } from "../../../types/AssistantTypes";
+import type { Unsubscribe } from "../../../types/Unsubscribe";
+import { SpeechSynthesisAdapter } from "../adapters/speech/SpeechAdapterTypes";
+import { ChatModelRunOptions, ChatModelRunResult } from "../local";
+import { ExportedMessageRepository } from "../utils/MessageRepository";
+import { ThreadMessageLike } from "../external-store";
+import { ComposerRuntimeCore, ThreadComposerRuntimeCore } from "./ComposerRuntimeCore";
+export type RuntimeCapabilities = {
+    readonly switchToBranch: boolean;
+    readonly switchBranchDuringRun: boolean;
+    readonly edit: boolean;
+    readonly reload: boolean;
+    readonly cancel: boolean;
+    readonly unstable_copy: boolean;
+    readonly speech: boolean;
+    readonly dictation: boolean;
+    readonly attachments: boolean;
+    readonly feedback: boolean;
+};
+export type AddToolResultOptions = {
+    messageId: string;
+    toolName: string;
+    toolCallId: string;
+    result: ReadonlyJSONValue;
+    isError: boolean;
+    artifact?: ReadonlyJSONValue | undefined;
+};
+export type ResumeToolCallOptions = {
+    toolCallId: string;
+    payload: unknown;
+};
+export type SubmitFeedbackOptions = {
+    messageId: string;
+    type: "negative" | "positive";
+};
+export type ThreadSuggestion = {
+    prompt: string;
+};
+export type SpeechState = {
+    readonly messageId: string;
+    readonly status: SpeechSynthesisAdapter.Status;
+};
+export type SubmittedFeedback = {
+    readonly type: "negative" | "positive";
+};
+export type ThreadRuntimeEventType = "runStart" | "runEnd" | "initialize" | "modelContextUpdate";
+export type StartRunConfig = {
+    parentId: string | null;
+    sourceId: string | null;
+    runConfig: RunConfig;
+};
+export type ResumeRunConfig = StartRunConfig & {
+    stream?: (options: ChatModelRunOptions) => AsyncGenerator<ChatModelRunResult, void, unknown>;
+};
+export type ThreadRuntimeCore = 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: AddToolResultOptions) => void;
+    resumeToolCall: (options: ResumeToolCallOptions) => void;
+    speak: (messageId: string) => void;
+    stopSpeaking: () => void;
+    submitFeedback: (feedback: SubmitFeedbackOptions) => void;
+    getModelContext: () => ModelContext;
+    composer: ThreadComposerRuntimeCore;
+    getEditComposer: (messageId: string) => ComposerRuntimeCore | 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;
+    /**
+     * 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;
+    reset(initialMessages?: readonly ThreadMessageLike[]): void;
+    unstable_on(event: ThreadRuntimeEventType, callback: () => void): Unsubscribe;
+    /**
+     * @deprecated Use importExternalState instead. This method will be removed in 0.12.0.
+     */
+    unstable_loadExternalState: (state: any) => void;
+}>;

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/core/ThreadRuntimeCore.js

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

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/core/index.d.ts

@@ -0,0 +1,2 @@
+export type { AddToolResultOptions, SubmitFeedbackOptions, ThreadSuggestion, } from "./ThreadRuntimeCore";
+export type { DictationState } from "./ComposerRuntimeCore";

package/dist/vendor/assistant-ui-react/src/legacy-runtime/runtime-cores/core/index.js

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