@assistant-ui/react-ai-sdk 0.6.10 → 0.6.11

package/dist/index.d.mts

@@ -1,9 +1,923 @@
-import * as _assistant_ui_react from '@assistant-ui/react';
-import { AppendMessage, ThreadMessage } from '@assistant-ui/react';
+import { LanguageModelV1LogProbs } from '@ai-sdk/provider';
 import { ReactNode } from 'react';
+import { z } from 'zod';
+import { JSONSchema7 } from 'json-schema';
+import { AppendMessage as AppendMessage$1, ThreadMessage as ThreadMessage$1 } from '@assistant-ui/react';
 import { useChat, useAssistant } from 'ai/react';
 import { Message } from 'ai';
 
+type TextContentPart = {
+    type: "text";
+    text: string;
+};
+type ImageContentPart = {
+    type: "image";
+    image: string;
+};
+type UIContentPart = {
+    type: "ui";
+    display: ReactNode;
+};
+type CoreToolCallContentPart<TArgs extends Record<string, unknown> = Record<string | number, unknown>, TResult = unknown> = {
+    type: "tool-call";
+    toolCallId: string;
+    toolName: string;
+    args: TArgs;
+    result?: TResult | undefined;
+    isError?: boolean | undefined;
+};
+type ToolCallContentPart<TArgs extends Record<string, unknown> = Record<string | number, unknown>, TResult = unknown> = CoreToolCallContentPart<TArgs, TResult> & {
+    argsText: string;
+};
+type ThreadUserContentPart = TextContentPart | ImageContentPart | UIContentPart;
+type ThreadAssistantContentPart = TextContentPart | ToolCallContentPart | UIContentPart;
+type MessageCommonProps = {
+    id: string;
+    createdAt: Date;
+};
+type ThreadStep = {
+    /**
+     * @deprecated This field will be removed in v0.6. Submit feedback if you need this functionality.
+     */
+    logprobs?: LanguageModelV1LogProbs | undefined;
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+    } | undefined;
+};
+type ContentPartStatus = {
+    type: "running";
+} | {
+    type: "complete";
+} | {
+    type: "incomplete";
+    reason: "cancelled" | "length" | "content-filter" | "other" | "error";
+    error?: unknown;
+};
+type ToolCallContentPartStatus = {
+    type: "requires-action";
+    reason: "tool-calls";
+} | ContentPartStatus;
+type MessageStatus = {
+    type: "running";
+} | {
+    type: "requires-action";
+    reason: "tool-calls";
+} | {
+    type: "complete";
+    reason: "stop" | "unknown";
+} | {
+    type: "incomplete";
+    reason: "cancelled" | "tool-calls" | "length" | "content-filter" | "other" | "error";
+    error?: unknown;
+};
+type ThreadSystemMessage = MessageCommonProps & {
+    role: "system";
+    content: [TextContentPart];
+};
+type ThreadUserMessage = MessageCommonProps & {
+    role: "user";
+    content: ThreadUserContentPart[];
+    attachments: readonly CompleteAttachment[];
+};
+type ThreadAssistantMessage = MessageCommonProps & {
+    role: "assistant";
+    content: ThreadAssistantContentPart[];
+    status: MessageStatus;
+    /**
+     * @deprecated Use `metadata.steps` instead.
+     */
+    roundtrips?: ThreadStep[] | undefined;
+    metadata?: {
+        /**
+         * @deprecated Use `steps` instead. This field will be removed in v0.6.
+         */
+        roundtrips?: ThreadStep[] | undefined;
+        steps?: ThreadStep[] | undefined;
+        custom?: Record<string, unknown> | undefined;
+    };
+};
+type AppendMessage = CoreMessage & {
+    parentId: string | null;
+    attachments?: readonly CompleteAttachment[] | undefined;
+};
+type BaseThreadMessage = {
+    status?: ThreadAssistantMessage["status"];
+    metadata?: ThreadAssistantMessage["metadata"];
+    attachments?: ThreadUserMessage["attachments"];
+};
+type ThreadMessage = BaseThreadMessage & (ThreadSystemMessage | ThreadUserMessage | ThreadAssistantMessage);
+/** Core Message Types (without UI content parts) */
+type CoreUserContentPart = TextContentPart | ImageContentPart;
+type CoreAssistantContentPart = TextContentPart | CoreToolCallContentPart;
+type CoreSystemMessage = {
+    role: "system";
+    content: [TextContentPart];
+};
+type CoreUserMessage = {
+    role: "user";
+    content: CoreUserContentPart[];
+};
+type CoreAssistantMessage = {
+    role: "assistant";
+    content: CoreAssistantContentPart[];
+};
+type CoreMessage = CoreSystemMessage | CoreUserMessage | CoreAssistantMessage;
+
+type PendingAttachmentStatus = {
+    type: "running";
+    reason: "uploading";
+    progress: number;
+} | {
+    type: "requires-action";
+    reason: "composer-send";
+} | {
+    type: "incomplete";
+    reason: "error" | "upload-paused";
+};
+type CompleteAttachmentStatus = {
+    type: "complete";
+};
+type BaseAttachment = {
+    id: string;
+    type: "image" | "document" | "file";
+    name: string;
+    contentType?: string;
+    file?: File;
+    content?: CoreUserContentPart[];
+};
+type PendingAttachment = BaseAttachment & {
+    status: PendingAttachmentStatus;
+    file: File;
+};
+type CompleteAttachment = BaseAttachment & {
+    status: CompleteAttachmentStatus;
+    content: CoreUserContentPart[];
+};
+type Attachment = PendingAttachment | CompleteAttachment;
+
+declare const LanguageModelV1CallSettingsSchema: z.ZodObject<{
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    topP: z.ZodOptional<z.ZodNumber>;
+    presencePenalty: z.ZodOptional<z.ZodNumber>;
+    frequencyPenalty: z.ZodOptional<z.ZodNumber>;
+    seed: z.ZodOptional<z.ZodNumber>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodOptional<z.ZodString>>>;
+}, "strip", z.ZodTypeAny, {
+    maxTokens?: number | undefined;
+    temperature?: number | undefined;
+    topP?: number | undefined;
+    presencePenalty?: number | undefined;
+    frequencyPenalty?: number | undefined;
+    seed?: number | undefined;
+    headers?: Record<string, string | undefined> | undefined;
+}, {
+    maxTokens?: number | undefined;
+    temperature?: number | undefined;
+    topP?: number | undefined;
+    presencePenalty?: number | undefined;
+    frequencyPenalty?: number | undefined;
+    seed?: number | undefined;
+    headers?: Record<string, string | undefined> | undefined;
+}>;
+type LanguageModelV1CallSettings = z.infer<typeof LanguageModelV1CallSettingsSchema>;
+declare const LanguageModelConfigSchema: z.ZodObject<{
+    apiKey: z.ZodOptional<z.ZodString>;
+    baseUrl: z.ZodOptional<z.ZodString>;
+    modelName: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    apiKey?: string | undefined;
+    baseUrl?: string | undefined;
+    modelName?: string | undefined;
+}, {
+    apiKey?: string | undefined;
+    baseUrl?: string | undefined;
+    modelName?: string | undefined;
+}>;
+type LanguageModelConfig = z.infer<typeof LanguageModelConfigSchema>;
+type ToolExecuteFunction<TArgs, TResult> = (args: TArgs, context: {
+    abortSignal: AbortSignal;
+}) => TResult | Promise<TResult>;
+type Tool<TArgs extends Record<string, unknown> = Record<string | number, unknown>, TResult = unknown> = {
+    description?: string | undefined;
+    parameters: z.ZodSchema<TArgs> | JSONSchema7;
+    execute?: ToolExecuteFunction<TArgs, TResult>;
+};
+type ModelConfig = {
+    priority?: number | undefined;
+    system?: string | undefined;
+    tools?: Record<string, Tool<any, any>> | undefined;
+    callSettings?: LanguageModelV1CallSettings | undefined;
+    config?: LanguageModelConfig | undefined;
+};
+type ModelConfigProvider = {
+    getModelConfig: () => ModelConfig;
+};
+
+type Unsubscribe = () => void;
+
+type AssistantRuntimeCore = {
+    readonly thread: ThreadRuntimeCore;
+    switchToNewThread: () => void;
+    switchToThread(threadId: string): void;
+    /**
+     * @deprecated Use `switchToNewThread` instead. This will be removed in 0.6.0.
+     */
+    switchToThread(threadId: string | null): void;
+    registerModelConfigProvider: (provider: ModelConfigProvider) => Unsubscribe;
+    subscribe: (callback: () => void) => Unsubscribe;
+};
+
+type AssistantRuntime = {
+    thread: ThreadRuntime;
+    switchToNewThread(): void;
+    switchToThread(threadId: string): void;
+    /**
+     * @deprecated Use `switchToNewThread` instead. This will be removed in 0.6.0.
+     */
+    switchToThread(threadId: string | null): void;
+    registerModelConfigProvider(provider: ModelConfigProvider): Unsubscribe;
+    /**
+     * @deprecated Thread is now static and never gets updated. This will be removed in 0.6.0.
+     */
+    subscribe(callback: () => void): Unsubscribe;
+};
+declare class AssistantRuntimeImpl<TThreadRuntime extends ThreadRuntime = ThreadRuntime> implements AssistantRuntimeCore, AssistantRuntime {
+    private _core;
+    constructor(_core: AssistantRuntimeCore, CustomThreadRuntime: new (binding: ThreadRuntimeCoreBinding) => TThreadRuntime);
+    readonly thread: TThreadRuntime;
+    switchToNewThread(): void;
+    switchToThread(threadId: string): void;
+    /**
+     * @deprecated Use `switchToNewThread` instead. This will be removed in 0.6.0.
+     */
+    switchToThread(threadId: string | null): void;
+    registerModelConfigProvider(provider: ModelConfigProvider): Unsubscribe;
+    /**
+     * @deprecated Thread is now static and never gets updated. This will be removed in 0.6.0.
+     */
+    subscribe(callback: () => void): Unsubscribe;
+}
+
+interface ExportedMessageRepository {
+    headId?: string | null;
+    messages: Array<{
+        message: ThreadMessage;
+        parentId: string | null;
+    }>;
+}
+
+type ComposerRuntimeCore = Readonly<{
+    attachmentAccept: string;
+    attachments: readonly Attachment[];
+    addAttachment: (file: File) => Promise<void>;
+    removeAttachment: (attachmentId: string) => Promise<void>;
+    isEditing: boolean;
+    canCancel: boolean;
+    isEmpty: boolean;
+    text: string;
+    setText: (value: string) => void;
+    /**
+     * @deprecated This method will be removed in 0.6.0. Submit feedback if you need this functionality.
+     */
+    reset: () => void;
+    send: () => void;
+    cancel: () => void;
+    subscribe: (callback: () => void) => Unsubscribe;
+}>;
+type ThreadComposerRuntimeCore = ComposerRuntimeCore & Readonly<{
+    attachments: readonly PendingAttachment[];
+}>;
+
+declare namespace SpeechSynthesisAdapter {
+    type Status = {
+        type: "starting" | "running";
+    } | {
+        type: "ended";
+        reason: "finished" | "cancelled" | "error";
+        error?: unknown;
+    };
+    type Utterance = {
+        status: Status;
+        cancel: () => void;
+        onEnd: (callback: () => void) => Unsubscribe;
+    };
+}
+type SpeechSynthesisAdapter = {
+    speak: (message: ThreadMessage) => SpeechSynthesisAdapter.Utterance;
+};
+
+type Subscribable = {
+    subscribe: (callback: () => void) => Unsubscribe;
+};
+type SubscribableWithState<TState> = Subscribable & {
+    getState: () => TState;
+};
+
+type ThreadComposerRuntimeCoreBinding = SubscribableWithState<ThreadComposerRuntimeCore | undefined>;
+type ComposerRuntimeCoreBinding = SubscribableWithState<ComposerRuntimeCore | undefined>;
+type LegacyEditComposerState = Readonly<{
+    type: "edit";
+    /** @deprecated Use `text` instead. This will be removed in 0.6.0. */
+    value: string;
+    /** @deprecated Use `useComposerRuntime().setText()` instead. This will be removed in 0.6.0. */
+    setValue: (value: string) => void;
+    text: string;
+    /**
+     * @deprecated Use `useComposerRuntime().setText()` instead. This will be removed in 0.6.0.
+     */
+    setText: (value: string) => void;
+    canCancel: boolean;
+    isEditing: boolean;
+    isEmpty: boolean;
+    /**
+     * @deprecated Use useComposerRuntime().beginEdit() instead. This will be removed in 0.6.0.
+     */
+    edit: () => void;
+    /**
+     * @deprecated Use `useComposerRuntime().send()` instead. This will be removed in 0.6.0.
+     */
+    send: () => void;
+    /**
+     * @deprecated Use `useComposerRuntime().cancel()` instead. This will be removed in 0.6.0.
+     */
+    cancel: () => void;
+}>;
+type LegacyThreadComposerState = Readonly<{
+    type: "thread";
+    /** @deprecated Use `text` instead. This will be removed in 0.6.0. */
+    value: string;
+    /** @deprecated Use `useComposerRuntime().setText` instead. This will be removed in 0.6.0. */
+    setValue: (value: string) => void;
+    attachmentAccept: string;
+    attachments: readonly Attachment[];
+    /** @deprecated Use `useComposerRuntime().addAttachment` instead. This will be removed in 0.6.0. */
+    addAttachment: (file: File) => Promise<void>;
+    /** @deprecated Use `useComposerRuntime().removeAttachment` instead. This will be removed in 0.6.0. */
+    removeAttachment: (attachmentId: string) => Promise<void>;
+    text: string;
+    /** @deprecated Use `useComposerRuntime().setText` instead. This will be removed in 0.6.0. */
+    setText: (value: string) => void;
+    /** @deprecated Use `useComposerRuntime().reset` instead. This will be removed in 0.6.0. */
+    reset: () => void;
+    canCancel: boolean;
+    isEditing: boolean;
+    isEmpty: boolean;
+    /**
+     * @deprecated Use `useComposerRuntime().send` instead. This will be removed in 0.6.0.
+     **/
+    send: () => void;
+    /** @deprecated Use `useComposerRuntime().cancel` instead. This will be removed in 0.6.0. */
+    cancel: () => void;
+    /** @deprecated This feature is being removed in 0.6.0. Submit feedback if you need it. */
+    focus: () => void;
+    /** @deprecated This feature is being removed in 0.6.0. Submit feedback if you need it. */
+    onFocus: (listener: () => void) => Unsubscribe;
+}>;
+type BaseComposerState = {
+    text: string;
+    attachmentAccept: string;
+    attachments: readonly Attachment[];
+    canCancel: boolean;
+    isEditing: boolean;
+    isEmpty: boolean;
+};
+type ThreadComposerState = LegacyThreadComposerState & BaseComposerState & {
+    type: "thread";
+    attachments: readonly PendingAttachment[];
+};
+type EditComposerState = LegacyEditComposerState & BaseComposerState & {
+    type: "edit";
+};
+type ComposerState = ThreadComposerState | EditComposerState;
+type ComposerRuntime = {
+    readonly type: "edit" | "thread";
+    getState(): ComposerState;
+    /** @deprecated Use `getState().isEditing` instead. This will be removed in 0.6.0. */
+    readonly isEditing: boolean;
+    /** @deprecated Use `getState().isEmpty` instead. This will be removed in 0.6.0. */
+    readonly isEmpty: boolean;
+    /** @deprecated Use `getState().canCancel` instead. This will be removed in 0.6.0. */
+    readonly canCancel: boolean;
+    /** @deprecated Use `getState().text` instead. This will be removed in 0.6.0. */
+    readonly text: string;
+    /** @deprecated Use `getState().attachmentAccept` instead. This will be removed in 0.6.0. */
+    readonly attachmentAccept: string;
+    /** @deprecated Use `getState().attachments` instead. This will be removed in 0.6.0. */
+    readonly attachments: readonly Attachment[];
+    /** @deprecated Use `getState().text` instead. This will be removed in 0.6.0. */
+    readonly value: string;
+    setText(text: string): void;
+    setValue(text: string): void;
+    addAttachment(file: File): Promise<void>;
+    /** @deprecated Use `getAttachmentById(id).removeAttachment()` instead. This will be removed in 0.6.0. */
+    removeAttachment(attachmentId: string): Promise<void>;
+    /** @deprecated This method will be removed in 0.6.0. Submit feedback if you need this functionality. */
+    reset(): void;
+    send(): void;
+    cancel(): void;
+    subscribe(callback: () => void): Unsubscribe;
+    getAttachmentByIndex(idx: number): AttachmentRuntime;
+};
+declare abstract class ComposerRuntimeImpl implements ComposerRuntimeCore, ComposerRuntime {
+    protected _core: ComposerRuntimeCoreBinding;
+    abstract get type(): "edit" | "thread";
+    constructor(_core: ComposerRuntimeCoreBinding);
+    /**
+     * @deprecated Use `getState().isEditing` instead. This will be removed in 0.6.0.
+     */
+    get isEditing(): boolean;
+    /**
+     * @deprecated Use `getState().isEmpty` instead. This will be removed in 0.6.0.
+     */
+    get isEmpty(): boolean;
+    /**
+     * @deprecated Use `getState().canCancel` instead. This will be removed in 0.6.0.
+     */
+    get canCancel(): boolean;
+    /**
+     * @deprecated Use `getState().text` instead. This will be removed in 0.6.0.
+     */
+    get text(): string;
+    /**
+     * @deprecated Use `getState().attachmentAccept` instead. This will be removed in 0.6.0.
+     */
+    get attachmentAccept(): string;
+    /**
+     * @deprecated Use `getState().attachments` instead. This will be removed in 0.6.0.
+     */
+    get attachments(): readonly Attachment[] | (readonly Attachment[] & readonly PendingAttachment[]);
+    /**
+     * @deprecated Use `getState().text` instead. This will be removed in 0.6.0.
+     */
+    get value(): string;
+    abstract getState(): ComposerState;
+    setText(text: string): void;
+    setValue(text: string): void;
+    addAttachment(file: File): Promise<void>;
+    /**
+     * @deprecated Use `getAttachmentById(id).removeAttachment()` instead. This will be removed in 0.6.0.
+     */
+    removeAttachment(attachmentId: string): Promise<void>;
+    /**
+     * @deprecated This method will be removed in 0.6.0. Submit feedback if you need this functionality.
+     */
+    reset(): void;
+    send(): void;
+    cancel(): void;
+    subscribe(callback: () => void): Unsubscribe;
+    abstract getAttachmentByIndex(idx: number): AttachmentRuntime;
+}
+type ThreadComposerRuntime = Omit<ComposerRuntime, "getState" | "getAttachmentByIndex"> & {
+    readonly type: "thread";
+    getState(): ThreadComposerState;
+    /**
+     * @deprecated Use `getState().attachments` instead. This will be removed in 0.6.0.
+     */
+    attachments: readonly PendingAttachment[];
+    /** @deprecated This feature is being removed in 0.6.0. Submit feedback if you need it. */
+    focus(): void;
+    /** @deprecated This feature is being removed in 0.6.0. Submit feedback if you need it. */
+    onFocus(callback: () => void): Unsubscribe;
+    getAttachmentByIndex(idx: number): AttachmentRuntime & {
+        source: "thread-composer";
+    };
+};
+declare class ThreadComposerRuntimeImpl extends ComposerRuntimeImpl implements ThreadComposerRuntime, ThreadComposerState {
+    get type(): "thread";
+    private _getState;
+    constructor(core: ThreadComposerRuntimeCoreBinding);
+    get attachments(): readonly Attachment[] & readonly PendingAttachment[];
+    getState(): ThreadComposerState;
+    private _focusListeners;
+    /**
+     * @deprecated This feature is being removed in 0.6.0. Submit feedback if you need it.
+     */
+    focus(): void;
+    /**
+     * @deprecated This feature is being removed in 0.6.0. Submit feedback if you need it.
+     */
+    onFocus(callback: () => void): () => boolean;
+    getAttachmentByIndex(idx: number): ThreadComposerAttachmentRuntimeImpl;
+}
+type EditComposerRuntime = Omit<ComposerRuntime, "getState" | "getAttachmentByIndex"> & {
+    readonly type: "edit";
+    getState(): EditComposerState;
+    beginEdit(): void;
+    /**
+     * @deprecated Use `beginEdit()` instead. This will be removed in 0.6.0.
+     */
+    edit(): void;
+    getAttachmentByIndex(idx: number): AttachmentRuntime & {
+        source: "edit-composer";
+    };
+};
+declare class EditComposerRuntimeImpl extends ComposerRuntimeImpl implements EditComposerRuntime, EditComposerState {
+    private _beginEdit;
+    get type(): "edit";
+    private _getState;
+    constructor(core: ComposerRuntimeCoreBinding, _beginEdit: () => void);
+    getState(): EditComposerState;
+    beginEdit(): void;
+    /**
+     * @deprecated Use `beginEdit()` instead. This will be removed in 0.6.0.
+     */
+    edit(): void;
+    getAttachmentByIndex(idx: number): EditComposerAttachmentRuntimeImpl;
+}
+
+type MessageAttachmentState = CompleteAttachment & {
+    source: "message";
+    /**
+     * @deprecated You can directly access content part fields in the state. Replace `.attachment.type` with `.type` etc. This will be removed in 0.6.0.
+     */
+    attachment: CompleteAttachment;
+};
+type ThreadComposerAttachmentState = PendingAttachment & {
+    source: "thread-composer";
+    /**
+     * @deprecated You can directly access content part fields in the state. Replace `.attachment.type` with `.type` etc. This will be removed in 0.6.0.
+     */
+    attachment: PendingAttachment;
+};
+type EditComposerAttachmentState = Attachment & {
+    source: "edit-composer";
+    /**
+     * @deprecated You can directly access content part fields in the state. Replace `.attachment.type` with `.type` etc. This will be removed in 0.6.0.
+     */
+    attachment: Attachment;
+};
+type AttachmentState = ThreadComposerAttachmentState | EditComposerAttachmentState | MessageAttachmentState;
+type AttachmentSnapshotBinding<Source extends AttachmentRuntimeSource> = SubscribableWithState<AttachmentState & {
+    source: Source;
+}>;
+type AttachmentRuntimeSource = AttachmentState["source"];
+type AttachmentRuntime<TSource extends AttachmentRuntimeSource = AttachmentRuntimeSource> = {
+    readonly source: TSource;
+    getState(): AttachmentState & {
+        source: TSource;
+    };
+    remove(): Promise<void>;
+    subscribe(callback: () => void): Unsubscribe;
+};
+declare abstract class AttachmentRuntimeImpl<Source extends AttachmentRuntimeSource = AttachmentRuntimeSource> implements AttachmentRuntime {
+    private _core;
+    abstract get source(): Source;
+    constructor(_core: AttachmentSnapshotBinding<Source>);
+    getState(): AttachmentState & {
+        source: Source;
+    };
+    abstract remove(): Promise<void>;
+    subscribe(callback: () => void): Unsubscribe;
+}
+declare abstract class ComposerAttachmentRuntime<Source extends "thread-composer" | "edit-composer"> extends AttachmentRuntimeImpl<Source> {
+    private _composerApi;
+    constructor(core: AttachmentSnapshotBinding<Source>, _composerApi: ComposerRuntimeCoreBinding);
+    remove(): Promise<void>;
+}
+declare class ThreadComposerAttachmentRuntimeImpl extends ComposerAttachmentRuntime<"thread-composer"> {
+    get source(): "thread-composer";
+}
+declare class EditComposerAttachmentRuntimeImpl extends ComposerAttachmentRuntime<"edit-composer"> {
+    get source(): "edit-composer";
+}
+declare class MessageAttachmentRuntimeImpl extends AttachmentRuntimeImpl<"message"> {
+    get source(): "message";
+    constructor(core: AttachmentSnapshotBinding<"message">);
+    remove(): never;
+}
+
+type MessageState = ThreadMessage & {
+    /**
+     * @deprecated You can directly access message fields in the state. Replace `.message.content` with `.content` etc. This will be removed in 0.6.0.
+     */
+    message: ThreadMessage;
+    parentId: string | null;
+    isLast: boolean;
+    /**
+     * @deprecated Use `branchNumber` and `branchCount` instead. This will be removed in 0.6.0.
+     */
+    branches: readonly string[];
+    branchNumber: number;
+    branchCount: number;
+};
+type MessageStateBinding = SubscribableWithState<MessageState>;
+type MessageRuntime = {
+    composer: EditComposerRuntime;
+    getState(): MessageState;
+    reload(): void;
+    speak(): SpeechSynthesisAdapter.Utterance;
+    submitFeedback({ type }: {
+        type: "positive" | "negative";
+    }): void;
+    switchToBranch({ position, branchId, }: {
+        position?: "previous" | "next" | undefined;
+        branchId?: string | undefined;
+    }): void;
+    subscribe(callback: () => void): Unsubscribe;
+    getContentPartByIndex(idx: number): ContentPartRuntime;
+    getAttachmentByIndex(idx: number): AttachmentRuntime & {
+        source: "message";
+    };
+};
+declare class MessageRuntimeImpl implements MessageRuntime {
+    private _core;
+    private _threadBinding;
+    constructor(_core: MessageStateBinding, _threadBinding: ThreadRuntimeCoreBinding);
+    composer: EditComposerRuntimeImpl;
+    getState(): MessageState;
+    reload(): void;
+    speak(): SpeechSynthesisAdapter.Utterance;
+    submitFeedback({ type }: {
+        type: "positive" | "negative";
+    }): void;
+    switchToBranch({ position, branchId, }: {
+        position?: "previous" | "next" | undefined;
+        branchId?: string | undefined;
+    }): void;
+    subscribe(callback: () => void): Unsubscribe;
+    getContentPartByIndex(idx: number): ContentPartRuntimeImpl;
+    getAttachmentByIndex(idx: number): MessageAttachmentRuntimeImpl;
+}
+
+type CreateAppendMessage = string | {
+    parentId?: string | null | undefined;
+    role?: AppendMessage["role"] | undefined;
+    content: AppendMessage["content"];
+    attachments?: AppendMessage["attachments"] | undefined;
+};
+type ThreadRuntimeCoreBinding = SubscribableWithState<ThreadRuntimeCore>;
+type ThreadState = Readonly<{
+    threadId: string;
+    isDisabled: boolean;
+    isRunning: boolean;
+    capabilities: RuntimeCapabilities;
+    messages: readonly ThreadMessage[];
+    suggestions: readonly ThreadSuggestion[];
+    extras: unknown;
+}>;
+type ThreadRuntime = {
+    composer: ThreadComposerRuntime;
+    getState(): ThreadState;
+    /**
+     * @deprecated This method will be removed in 0.6.0. Submit feedback if you need this functionality.
+     */
+    unstable_getCore(): ThreadRuntimeCore;
+    append(message: CreateAppendMessage): void;
+    startRun(parentId: string | null): void;
+    subscribe(callback: () => void): Unsubscribe;
+    cancelRun(): void;
+    getModelConfig(): ModelConfig;
+    export(): ExportedMessageRepository;
+    import(repository: ExportedMessageRepository): void;
+    getMesssageByIndex(idx: number): MessageRuntime;
+    /**
+     * @deprecated Use `getState().capabilities` instead. This will be removed in 0.6.0.
+     */
+    capabilities: Readonly<RuntimeCapabilities>;
+    /**
+     * @deprecated Use `getState().threadId` instead. This will be removed in 0.6.0.
+     */
+    threadId: string;
+    /**
+     * @deprecated Use `getState().isDisabled` instead. This will be removed in 0.6.0.
+     */
+    isDisabled: boolean;
+    /**
+     * @deprecated Use `getState().isRunning` instead. This will be removed in 0.6.0.
+     */
+    isRunning: boolean;
+    /**
+     * @deprecated Use `getState().messages` instead. This will be removed in 0.6.0.
+     */
+    messages: readonly ThreadMessage[];
+    /**
+     * @deprecated Use `getState().followupSuggestions` instead. This will be removed in 0.6.0.
+     */
+    suggestions: readonly ThreadSuggestion[];
+    /**
+     * @deprecated Use `getState().extras` instead. This will be removed in 0.6.0.
+     */
+    extras: unknown;
+    /**
+     * @deprecated Use `getMesssageById(id).getState().branchNumber` / `getMesssageById(id).getState().branchCount` instead. This will be removed in 0.6.0.
+     */
+    getBranches: (messageId: string) => readonly string[];
+    /**
+     * @deprecated Use `getMesssageById(id).switchToBranch({ options })` instead. This will be removed in 0.6.0.
+     */
+    switchToBranch: (branchId: string) => void;
+    /**
+     * @deprecated Use `getMesssageById(id).getContentPartByToolCallId(toolCallId).addToolResult({ result })` instead. This will be removed in 0.6.0.
+     */
+    addToolResult: (options: AddToolResultOptions) => void;
+    /**
+     * @deprecated Use `getMesssageById(id).speak()` instead. This will be removed in 0.6.0.
+     */
+    speak: (messageId: string) => SpeechSynthesisAdapter.Utterance;
+    /**
+     * @deprecated Use `getMesssageById(id).submitFeedback({ type })` instead. This will be removed in 0.6.0.
+     */
+    submitFeedback: (feedback: SubmitFeedbackOptions) => void;
+    /**
+     * @deprecated Use `getMesssageById(id).getMessageByIndex(idx).composer` instead. This will be removed in 0.6.0.
+     */
+    getEditComposer: (messageId: string) => ComposerRuntimeCore | undefined;
+    /**
+     * @deprecated Use `getMesssageById(id).getMessageByIndex(idx).composer.beginEdit()` instead. This will be removed in 0.6.0.
+     */
+    beginEdit: (messageId: string) => void;
+};
+declare class ThreadRuntimeImpl implements ThreadRuntimeCore, ThreadRuntime {
+    /**
+     * @deprecated Use `getState().threadId` instead. This will be removed in 0.6.0.
+     */
+    get threadId(): string;
+    /**
+     * @deprecated Use `getState().isDisabled` instead. This will be removed in 0.6.0.
+     */
+    get isDisabled(): boolean;
+    /**
+     * @deprecated Use `getState().isRunning` instead. This will be removed in 0.6.0.
+     */
+    get isRunning(): boolean;
+    /**
+     * @deprecated Use `getState().capabilities` instead. This will be removed in 0.6.0.
+     */
+    get capabilities(): Readonly<{
+        switchToBranch: boolean;
+        edit: boolean;
+        reload: boolean;
+        cancel: boolean;
+        unstable_copy: boolean;
+        speak: boolean;
+        attachments: boolean;
+        feedback: boolean;
+    }>;
+    /**
+     * @deprecated Use `getState().extras` instead. This will be removed in 0.6.0.
+     */
+    get extras(): unknown;
+    /**
+     * @deprecated Use `getState().followupSuggestions` instead. This will be removed in 0.6.0.
+     */
+    get suggestions(): readonly ThreadSuggestion[];
+    /**
+     * @deprecated Use `getState().messages` instead. This will be removed in 0.6.0.
+     */
+    get messages(): readonly ThreadMessage[];
+    unstable_getCore(): Readonly<{
+        getBranches: (messageId: string) => readonly string[];
+        switchToBranch: (branchId: string) => void;
+        append: (message: AppendMessage) => void;
+        startRun: (parentId: string | null) => void;
+        cancelRun: () => void;
+        addToolResult: (options: AddToolResultOptions) => void;
+        speak: (messageId: string) => SpeechSynthesisAdapter.Utterance;
+        submitFeedback: (feedback: SubmitFeedbackOptions) => void;
+        getModelConfig: () => ModelConfig;
+        composer: ThreadComposerRuntimeCore;
+        getEditComposer: (messageId: string) => ComposerRuntimeCore | undefined;
+        beginEdit: (messageId: string) => void;
+        capabilities: Readonly<RuntimeCapabilities>;
+        threadId: string;
+        isDisabled: boolean;
+        messages: readonly ThreadMessage[];
+        suggestions: readonly ThreadSuggestion[];
+        extras: unknown;
+        subscribe: (callback: () => void) => Unsubscribe;
+        import(repository: ExportedMessageRepository): void;
+        export(): ExportedMessageRepository;
+    }>;
+    private _threadBinding;
+    constructor(threadBinding: ThreadRuntimeCoreBinding);
+    readonly composer: ThreadComposerRuntimeImpl;
+    getState(): Readonly<{
+        threadId: string;
+        isDisabled: boolean;
+        isRunning: boolean;
+        capabilities: RuntimeCapabilities;
+        messages: readonly ThreadMessage[];
+        suggestions: readonly ThreadSuggestion[];
+        extras: unknown;
+    }>;
+    append(message: CreateAppendMessage): void;
+    subscribe(callback: () => void): Unsubscribe;
+    /**
+     * @derprecated Use `getMesssageById(id).getState().branchNumber` / `getMesssageById(id).getState().branchCount` instead. This will be removed in 0.6.0.
+     */
+    getBranches(messageId: string): readonly string[];
+    getModelConfig(): ModelConfig;
+    startRun(parentId: string | null): void;
+    cancelRun(): void;
+    /**
+     * @deprecated Use `getMesssageById(id).getContentPartByToolCallId(toolCallId).addToolResult({ result })` instead. This will be removed in 0.6.0.
+     */
+    addToolResult(options: AddToolResultOptions): void;
+    /**
+     * @deprecated Use `getMesssageById(id).switchToBranch({ options })` instead. This will be removed in 0.6.0.
+     */
+    switchToBranch(branchId: string): void;
+    speak(messageId: string): SpeechSynthesisAdapter.Utterance;
+    submitFeedback(options: SubmitFeedbackOptions): void;
+    /**
+     * @deprecated Use `getMesssageById(id).getMessageByIndex(idx).composer` instead. This will be removed in 0.6.0.
+     */
+    getEditComposer(messageId: string): Readonly<{
+        attachmentAccept: string;
+        attachments: readonly Attachment[];
+        addAttachment: (file: File) => Promise<void>;
+        removeAttachment: (attachmentId: string) => Promise<void>;
+        isEditing: boolean;
+        canCancel: boolean;
+        isEmpty: boolean;
+        text: string;
+        setText: (value: string) => void;
+        reset: () => void;
+        send: () => void;
+        cancel: () => void;
+        subscribe: (callback: () => void) => Unsubscribe;
+    }> | undefined;
+    /**
+     * @deprecated Use `getMesssageById(id).getMessageByIndex(idx).composer.beginEdit()` instead. This will be removed in 0.6.0.
+     */
+    beginEdit(messageId: string): void;
+    export(): ExportedMessageRepository;
+    import(data: ExportedMessageRepository): void;
+    getMesssageByIndex(idx: number): MessageRuntimeImpl;
+}
+
+type ContentPartState = (ThreadUserContentPart | ThreadAssistantContentPart) & {
+    /**
+     * @deprecated You can directly access content part fields in the state. Replace `.part.type` with `.type` etc. This will be removed in 0.6.0.
+     */
+    part: ThreadUserContentPart | ThreadAssistantContentPart;
+    status: ContentPartStatus | ToolCallContentPartStatus;
+};
+type ContentPartSnapshotBinding = SubscribableWithState<ContentPartState>;
+type ContentPartRuntime = {
+    getState(): ContentPartState;
+    addToolResult(result: any): void;
+    subscribe(callback: () => void): Unsubscribe;
+};
+declare class ContentPartRuntimeImpl implements ContentPartRuntime {
+    private contentBinding;
+    private messageApi;
+    private threadApi;
+    constructor(contentBinding: ContentPartSnapshotBinding, messageApi: MessageStateBinding, threadApi: ThreadRuntimeCoreBinding);
+    getState(): ContentPartState;
+    addToolResult(result: any): void;
+    subscribe(callback: () => void): Unsubscribe;
+}
+
+type RuntimeCapabilities = Readonly<{
+    switchToBranch: boolean;
+    edit: boolean;
+    reload: boolean;
+    cancel: boolean;
+    unstable_copy: boolean;
+    speak: boolean;
+    attachments: boolean;
+    feedback: boolean;
+}>;
+type AddToolResultOptions = {
+    messageId: string;
+    toolName: string;
+    toolCallId: string;
+    result: any;
+};
+type SubmitFeedbackOptions = {
+    messageId: string;
+    type: "negative" | "positive";
+};
+type ThreadSuggestion = {
+    prompt: string;
+};
+type ThreadRuntimeCore = Readonly<{
+    getBranches: (messageId: string) => readonly string[];
+    switchToBranch: (branchId: string) => void;
+    append: (message: AppendMessage) => void;
+    startRun: (parentId: string | null) => void;
+    cancelRun: () => void;
+    addToolResult: (options: AddToolResultOptions) => void;
+    speak: (messageId: string) => SpeechSynthesisAdapter.Utterance;
+    submitFeedback: (feedback: SubmitFeedbackOptions) => void;
+    getModelConfig: () => ModelConfig;
+    composer: ThreadComposerRuntimeCore;
+    getEditComposer: (messageId: string) => ComposerRuntimeCore | undefined;
+    beginEdit: (messageId: string) => void;
+    capabilities: Readonly<RuntimeCapabilities>;
+    threadId: string;
+    isDisabled: boolean;
+    messages: readonly ThreadMessage[];
+    suggestions: readonly ThreadSuggestion[];
+    extras: unknown;
+    subscribe: (callback: () => void) => Unsubscribe;
+    import(repository: ExportedMessageRepository): void;
+    export(): ExportedMessageRepository;
+}>;
+
 type VercelRSCMessage = {
     id?: string | undefined;
     role: "user" | "assistant";
@@ -17,18 +931,18 @@ type RSCMessageConverter<T> = {
 type VercelRSCAdapterBase<T> = {
     isRunning?: boolean | undefined;
     messages: T[];
-    onNew?: (message: AppendMessage) => Promise<void>;
-    onEdit?: ((message: AppendMessage) => Promise<void>) | undefined;
+    onNew?: (message: AppendMessage$1) => Promise<void>;
+    onEdit?: ((message: AppendMessage$1) => Promise<void>) | undefined;
     onReload?: ((parentId: string | null) => Promise<void>) | undefined;
     convertMessage?: ((message: T) => VercelRSCMessage) | undefined;
     /**
      * @deprecated Use `onNew` instead. This will be removed in 0.6.0.
      */
-    append?: (message: AppendMessage) => Promise<void>;
+    append?: (message: AppendMessage$1) => Promise<void>;
     /**
      * @deprecated Use `onEdit` instead. This will be removed in 0.6.0.
      */
-    edit?: ((message: AppendMessage) => Promise<void>) | undefined;
+    edit?: ((message: AppendMessage$1) => Promise<void>) | undefined;
     /**
      * @deprecated Use `onReload` instead. This will be removed in 0.6.0.
      */
@@ -36,14 +950,14 @@ type VercelRSCAdapterBase<T> = {
 };
 type VercelRSCAdapter<T = VercelRSCMessage> = VercelRSCAdapterBase<T> & (T extends VercelRSCMessage ? object : RSCMessageConverter<T>);
 
-declare const useVercelRSCRuntime: <T extends WeakKey>(adapter: VercelRSCAdapter<T>) => _assistant_ui_react.AssistantRuntime<_assistant_ui_react.ThreadRuntime>;
+declare const useVercelRSCRuntime: <T extends WeakKey>(adapter: VercelRSCAdapter<T>) => AssistantRuntimeImpl<ThreadRuntimeImpl>;
 
-declare const getVercelRSCMessage: (message: ThreadMessage) => unknown;
+declare const getVercelRSCMessage: (message: ThreadMessage$1) => unknown;
 
-declare const useVercelUseChatRuntime: (chatHelpers: ReturnType<typeof useChat>) => _assistant_ui_react.AssistantRuntime<_assistant_ui_react.ThreadRuntime>;
+declare const useVercelUseChatRuntime: (chatHelpers: ReturnType<typeof useChat>) => AssistantRuntimeImpl<ThreadRuntimeImpl>;
 
-declare const useVercelUseAssistantRuntime: (assistantHelpers: ReturnType<typeof useAssistant>) => _assistant_ui_react.AssistantRuntime<_assistant_ui_react.ThreadRuntime>;
+declare const useVercelUseAssistantRuntime: (assistantHelpers: ReturnType<typeof useAssistant>) => AssistantRuntimeImpl<ThreadRuntimeImpl>;
 
-declare const getVercelAIMessages: (message: ThreadMessage) => Message[];
+declare const getVercelAIMessages: (message: ThreadMessage$1) => Message[];
 
 export { type VercelRSCAdapter, type VercelRSCMessage, getVercelAIMessages as getVercelAIMessage, getVercelAIMessages, getVercelRSCMessage, useVercelRSCRuntime, useVercelUseAssistantRuntime, useVercelUseChatRuntime };