@assistant-ui/react 0.5.52 → 0.5.55

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 import * as react from 'react';
 import { ComponentType, PropsWithChildren, FC, ComponentPropsWithoutRef, ElementType, ReactNode } from 'react';
-import { T as ThreadAssistantContentPart, M as MessageStatus, a as ThreadRoundtrip, b as ThreadMessage, c as ModelConfig, d as ModelConfigProvider, e as TextContentPart, C as ContentPartStatus, I as ImageContentPart, U as UIContentPart, f as ToolCallContentPart, g as ToolCallContentPartStatus, h as CoreMessage, i as ThreadComposerAttachment, j as MessageAttachment, A as AppendMessage, k as Tool, l as CoreToolCallContentPart, m as CreateEdgeRuntimeAPIOptions } from './edge-BJordJU0.js';
+import { T as ThreadAssistantContentPart, M as MessageStatus, a as ThreadRoundtrip, b as ThreadMessage, c as ModelConfig, d as ModelConfigProvider, C as ContentPartStatus, e as TextContentPart, I as ImageContentPart, U as UIContentPart, f as ToolCallContentPart, g as ToolCallContentPartStatus, h as CoreMessage, i as ThreadComposerAttachment, j as MessageAttachment, A as AppendMessage, k as Tool, l as CoreToolCallContentPart, m as CreateEdgeRuntimeAPIOptions } from './edge-BJordJU0.js';
 export { s as CoreAssistantContentPart, v as CoreAssistantMessage, t as CoreSystemMessage, r as CoreUserContentPart, u as CoreUserMessage, E as EdgeRuntimeRequestOptions, p as ThreadAssistantMessage, o as ThreadSystemMessage, n as ThreadUserContentPart, q as ThreadUserMessage } from './edge-BJordJU0.js';
-import { UseBoundStore, StoreApi } from 'zustand';
+import { StoreApi, UseBoundStore } from 'zustand';
 import { Primitive } from '@radix-ui/react-primitive';
 import * as PopoverPrimitive from '@radix-ui/react-popover';
 import * as react_textarea_autosize from 'react-textarea-autosize';
@@ -16,7 +16,7 @@ import 'zod';
 
 type Unsubscribe = () => void;
 
-type ReadonlyStore<T> = UseBoundStore<Omit<StoreApi<T>, "setState" | "destroy">>;
+type ReadonlyStore<T> = Omit<StoreApi<T>, "setState" | "destroy">;
 
 type ReactThreadRuntime = ThreadRuntime & {
     unstable_synchronizer?: ComponentType;
@@ -54,6 +54,7 @@ declare abstract class BaseAssistantRuntime<TThreadRuntime extends ReactThreadRu
     constructor(_thread: TThreadRuntime);
     get thread(): TThreadRuntime;
     set thread(thread: TThreadRuntime);
+    abstract switchToNewThread(): void;
     abstract registerModelConfigProvider(provider: ModelConfigProvider): Unsubscribe;
     abstract switchToThread(threadId: string | null): void;
     private _subscriptions;
@@ -61,6 +62,10 @@ declare abstract class BaseAssistantRuntime<TThreadRuntime extends ReactThreadRu
     private subscriptionHandler;
 }
 
+type EmptyContentPartProps = {
+    status: ContentPartStatus;
+};
+type EmptyContentPartComponent = ComponentType<EmptyContentPartProps>;
 type TextContentPartProps = {
     part: TextContentPart;
     status: ContentPartStatus;
@@ -216,7 +221,8 @@ declare class LocalRuntime extends BaseAssistantRuntime<LocalThreadRuntime> {
     set adapter(adapter: ChatModelAdapter);
     set options(options: LocalRuntimeOptions);
     registerModelConfigProvider(provider: ModelConfigProvider): () => void;
-    switchToThread(threadId: string | null): LocalThreadRuntime;
+    switchToNewThread(): LocalThreadRuntime;
+    switchToThread(threadId: string | null): void;
     reset({ initialMessages, }?: {
         initialMessages?: readonly CoreMessage[] | undefined;
     }): void;
@@ -232,9 +238,10 @@ type fromLanguageModelMessagesOptions = {
 declare const fromLanguageModelMessages: (lm: LanguageModelV1Message[], { mergeRoundtrips }: fromLanguageModelMessagesOptions) => CoreMessage[];
 
 declare const fromCoreMessages: (message: readonly CoreMessage[]) => ThreadMessage[];
-declare const fromCoreMessage: (message: CoreMessage, { id, status, }?: {
+declare const fromCoreMessage: (message: CoreMessage, { id, status, attachments, }?: {
     id?: string | undefined;
     status?: MessageStatus | undefined;
+    attachments?: readonly MessageAttachment[] | undefined;
 }) => ThreadMessage;
 
 declare const toCoreMessages: (message: ThreadMessage[]) => CoreMessage[];
@@ -366,17 +373,60 @@ type ContentPartState = Readonly<{
 declare const useSmooth: (state: TextContentPartState, smooth?: boolean) => TextContentPartState;
 
 declare const withSmoothContextProvider: <C extends React.ComponentType<any>>(Component: C) => C;
-declare const useSmoothStatus: () => {
-    type: "running";
-} | {
-    type: "complete";
-} | {
-    type: "incomplete";
-    reason: "cancelled" | "length" | "content-filter" | "other" | "error";
-    error?: unknown;
-} | {
-    type: "requires-action";
-    reason: "tool-calls";
+declare const useSmoothStatus: {
+    (): {
+        type: "running";
+    } | {
+        type: "complete";
+    } | {
+        type: "incomplete";
+        reason: "cancelled" | "length" | "content-filter" | "other" | "error";
+        error?: unknown;
+    } | {
+        type: "requires-action";
+        reason: "tool-calls";
+    };
+    <TSelected>(selector: (state: {
+        type: "running";
+    } | {
+        type: "complete";
+    } | {
+        type: "incomplete";
+        reason: "cancelled" | "length" | "content-filter" | "other" | "error";
+        error?: unknown;
+    } | {
+        type: "requires-action";
+        reason: "tool-calls";
+    }) => TSelected): TSelected;
+    (options: {
+        optional: true;
+    }): {
+        type: "running";
+    } | {
+        type: "complete";
+    } | {
+        type: "incomplete";
+        reason: "cancelled" | "length" | "content-filter" | "other" | "error";
+        error?: unknown;
+    } | {
+        type: "requires-action";
+        reason: "tool-calls";
+    } | null;
+    <TSelected>(options: {
+        optional: true;
+        selector?: (state: {
+            type: "running";
+        } | {
+            type: "complete";
+        } | {
+            type: "incomplete";
+            reason: "cancelled" | "length" | "content-filter" | "other" | "error";
+            error?: unknown;
+        } | {
+            type: "requires-action";
+            reason: "tool-calls";
+        }) => TSelected;
+    }): TSelected | null;
 };
 
 declare const buttonVariants: (props?: ({
@@ -460,6 +510,7 @@ declare class ExternalStoreRuntime extends BaseAssistantRuntime<ExternalStoreThr
     set store(store: ExternalStoreAdapter<any>);
     getModelConfig(): ModelConfig;
     registerModelConfigProvider(provider: ModelConfigProvider): () => void;
+    switchToNewThread(): Promise<void>;
     switchToThread(threadId: string | null): Promise<void>;
 }
 
@@ -548,6 +599,10 @@ type ThreadRuntimeWithSubscribe = {
     subscribe: (callback: () => void) => Unsubscribe;
 };
 type AssistantRuntime = ThreadRuntimeWithSubscribe & {
+    switchToNewThread: () => void;
+    /**
+     * @deprecated Use `switchToNewThread` instead. This will be removed in 0.6.0.
+     */
     switchToThread: (threadId: string | null) => void;
     registerModelConfigProvider: (provider: ModelConfigProvider) => Unsubscribe;
 };
@@ -564,28 +619,121 @@ declare const TextContentPartProvider: FC<PropsWithChildren<TextContentPartProvi
 
 type AssistantActionsState = Readonly<{
     switchToThread: (threadId: string | null) => void;
+    registerModelConfigProvider: (provider: ModelConfigProvider) => Unsubscribe;
     getRuntime: () => AssistantRuntime;
 }>;
 
-type AssistantModelConfigState = Readonly<ModelConfigProvider & {
-    registerModelConfigProvider: (provider: ModelConfigProvider) => () => void;
-}>;
-
 type AssistantToolUIsState = Readonly<{
     getToolUI: (toolName: string) => ToolCallContentPartComponent | null;
     setToolUI: (toolName: string, render: ToolCallContentPartComponent) => () => void;
 }>;
 
 type AssistantContextValue = {
-    useModelConfig: ReadonlyStore<AssistantModelConfigState>;
-    useToolUIs: ReadonlyStore<AssistantToolUIsState>;
-    useAssistantRuntime: ReadonlyStore<AssistantRuntime>;
-    useAssistantActions: ReadonlyStore<AssistantActionsState>;
+    useToolUIs: UseBoundStore<ReadonlyStore<AssistantToolUIsState>>;
+    useAssistantRuntime: UseBoundStore<ReadonlyStore<AssistantRuntime>>;
+    useAssistantActions: UseBoundStore<ReadonlyStore<AssistantActionsState>>;
+};
+declare const useAssistantContext: {
+    (options?: {
+        optional?: false | undefined;
+    } | undefined): AssistantContextValue;
+    (options?: {
+        optional?: boolean | undefined;
+    } | undefined): AssistantContextValue | null;
+};
+declare const useAssistantRuntime: {
+    (): AssistantRuntime;
+    <TSelected>(selector: (state: AssistantRuntime) => TSelected): TSelected;
+    (options: {
+        optional: true;
+    }): AssistantRuntime | null;
+    <TSelected>(options: {
+        optional: true;
+        selector?: (state: AssistantRuntime) => TSelected;
+    }): TSelected | null;
+};
+declare const useAssistantRuntimeStore: {
+    (): ReadonlyStore<AssistantRuntime>;
+    (options: {
+        optional: true;
+    }): ReadonlyStore<AssistantRuntime> | null;
+};
+declare const useToolUIs: {
+    (): Readonly<{
+        getToolUI: (toolName: string) => ToolCallContentPartComponent | null;
+        setToolUI: (toolName: string, render: ToolCallContentPartComponent) => () => void;
+    }>;
+    <TSelected>(selector: (state: Readonly<{
+        getToolUI: (toolName: string) => ToolCallContentPartComponent | null;
+        setToolUI: (toolName: string, render: ToolCallContentPartComponent) => () => void;
+    }>) => TSelected): TSelected;
+    (options: {
+        optional: true;
+    }): Readonly<{
+        getToolUI: (toolName: string) => ToolCallContentPartComponent | null;
+        setToolUI: (toolName: string, render: ToolCallContentPartComponent) => () => void;
+    }> | null;
+    <TSelected>(options: {
+        optional: true;
+        selector?: (state: Readonly<{
+            getToolUI: (toolName: string) => ToolCallContentPartComponent | null;
+            setToolUI: (toolName: string, render: ToolCallContentPartComponent) => () => void;
+        }>) => TSelected;
+    }): TSelected | null;
+};
+declare const useToolUIsStore: {
+    (): ReadonlyStore<Readonly<{
+        getToolUI: (toolName: string) => ToolCallContentPartComponent | null;
+        setToolUI: (toolName: string, render: ToolCallContentPartComponent) => () => void;
+    }>>;
+    (options: {
+        optional: true;
+    }): ReadonlyStore<Readonly<{
+        getToolUI: (toolName: string) => ToolCallContentPartComponent | null;
+        setToolUI: (toolName: string, render: ToolCallContentPartComponent) => () => void;
+    }>> | null;
+};
+declare const useAssistantActions: {
+    (): Readonly<{
+        switchToThread: (threadId: string | null) => void;
+        registerModelConfigProvider: (provider: ModelConfigProvider) => Unsubscribe;
+        getRuntime: () => AssistantRuntime;
+    }>;
+    <TSelected>(selector: (state: Readonly<{
+        switchToThread: (threadId: string | null) => void;
+        registerModelConfigProvider: (provider: ModelConfigProvider) => Unsubscribe;
+        getRuntime: () => AssistantRuntime;
+    }>) => TSelected): TSelected;
+    (options: {
+        optional: true;
+    }): Readonly<{
+        switchToThread: (threadId: string | null) => void;
+        registerModelConfigProvider: (provider: ModelConfigProvider) => Unsubscribe;
+        getRuntime: () => AssistantRuntime;
+    }> | null;
+    <TSelected>(options: {
+        optional: true;
+        selector?: (state: Readonly<{
+            switchToThread: (threadId: string | null) => void;
+            registerModelConfigProvider: (provider: ModelConfigProvider) => Unsubscribe;
+            getRuntime: () => AssistantRuntime;
+        }>) => TSelected;
+    }): TSelected | null;
+};
+declare const useAssistantActionsStore: {
+    (): ReadonlyStore<Readonly<{
+        switchToThread: (threadId: string | null) => void;
+        registerModelConfigProvider: (provider: ModelConfigProvider) => Unsubscribe;
+        getRuntime: () => AssistantRuntime;
+    }>>;
+    (options: {
+        optional: true;
+    }): ReadonlyStore<Readonly<{
+        switchToThread: (threadId: string | null) => void;
+        registerModelConfigProvider: (provider: ModelConfigProvider) => Unsubscribe;
+        getRuntime: () => AssistantRuntime;
+    }>> | null;
 };
-declare function useAssistantContext(): AssistantContextValue;
-declare function useAssistantContext(options: {
-    optional: true;
-}): AssistantContextValue | null;
 
 type ThreadViewportState = Readonly<{
     isAtBottom: boolean;
@@ -596,22 +744,340 @@ type ThreadViewportState = Readonly<{
 type ThreadMessagesState = readonly ThreadMessage[];
 
 type ThreadContextValue = {
-    useThread: ReadonlyStore<ThreadState>;
-    useThreadRuntime: ReadonlyStore<ThreadRuntimeStore>;
-    useThreadMessages: ReadonlyStore<ThreadMessagesState>;
-    useThreadActions: ReadonlyStore<ThreadActionsState>;
-    useComposer: ReadonlyStore<ComposerState>;
-    useViewport: ReadonlyStore<ThreadViewportState>;
-};
-declare function useThreadContext(): ThreadContextValue;
-declare function useThreadContext(options: {
-    optional: true;
-}): ThreadContextValue | null;
+    useThread: UseBoundStore<ReadonlyStore<ThreadState>>;
+    useThreadRuntime: UseBoundStore<ReadonlyStore<ThreadRuntimeStore>>;
+    useThreadMessages: UseBoundStore<ReadonlyStore<ThreadMessagesState>>;
+    useThreadActions: UseBoundStore<ReadonlyStore<ThreadActionsState>>;
+    useComposer: UseBoundStore<ReadonlyStore<ThreadComposerState>>;
+    useViewport: UseBoundStore<ReadonlyStore<ThreadViewportState>>;
+};
+declare const useThreadContext: {
+    (options?: {
+        optional?: false | undefined;
+    } | undefined): ThreadContextValue;
+    (options?: {
+        optional?: boolean | undefined;
+    } | undefined): ThreadContextValue | null;
+};
+declare const useThreadRuntime: {
+    (): ThreadRuntime;
+    <TSelected>(selector: (state: ThreadRuntime) => TSelected): TSelected;
+    (options: {
+        optional: true;
+    }): ThreadRuntime | null;
+    <TSelected>(options: {
+        optional: true;
+        selector?: (state: ThreadRuntime) => TSelected;
+    }): TSelected | null;
+};
+declare const useThreadRuntimeStore: {
+    (): ReadonlyStore<ThreadRuntime>;
+    (options: {
+        optional: true;
+    }): ReadonlyStore<ThreadRuntime> | null;
+};
+declare const useThread: {
+    (): Readonly<{
+        capabilities: Readonly<RuntimeCapabilities>;
+        threadId: string;
+        isRunning: boolean;
+        isDisabled: boolean;
+    }>;
+    <TSelected>(selector: (state: Readonly<{
+        capabilities: Readonly<RuntimeCapabilities>;
+        threadId: string;
+        isRunning: boolean;
+        isDisabled: boolean;
+    }>) => TSelected): TSelected;
+    (options: {
+        optional: true;
+    }): Readonly<{
+        capabilities: Readonly<RuntimeCapabilities>;
+        threadId: string;
+        isRunning: boolean;
+        isDisabled: boolean;
+    }> | null;
+    <TSelected>(options: {
+        optional: true;
+        selector?: (state: Readonly<{
+            capabilities: Readonly<RuntimeCapabilities>;
+            threadId: string;
+            isRunning: boolean;
+            isDisabled: boolean;
+        }>) => TSelected;
+    }): TSelected | null;
+};
+declare const useThreadStore: {
+    (): ReadonlyStore<Readonly<{
+        capabilities: Readonly<RuntimeCapabilities>;
+        threadId: string;
+        isRunning: boolean;
+        isDisabled: boolean;
+    }>>;
+    (options: {
+        optional: true;
+    }): ReadonlyStore<Readonly<{
+        capabilities: Readonly<RuntimeCapabilities>;
+        threadId: string;
+        isRunning: boolean;
+        isDisabled: boolean;
+    }>> | null;
+};
+declare const useThreadMessages: {
+    (): ThreadMessagesState;
+    <TSelected>(selector: (state: ThreadMessagesState) => TSelected): TSelected;
+    (options: {
+        optional: true;
+    }): ThreadMessagesState | null;
+    <TSelected>(options: {
+        optional: true;
+        selector?: (state: ThreadMessagesState) => TSelected;
+    }): TSelected | null;
+};
+declare const useThreadMessagesStore: {
+    (): ReadonlyStore<ThreadMessagesState>;
+    (options: {
+        optional: true;
+    }): ReadonlyStore<ThreadMessagesState> | null;
+};
+declare const useThreadActions: {
+    (): 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;
+    }>;
+    <TSelected>(selector: (state: 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;
+    }>) => TSelected): TSelected;
+    (options: {
+        optional: true;
+    }): 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;
+    }> | null;
+    <TSelected>(options: {
+        optional: true;
+        selector?: (state: 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;
+        }>) => TSelected;
+    }): TSelected | null;
+};
+declare const useThreadActionsStore: {
+    (): ReadonlyStore<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;
+    }>>;
+    (options: {
+        optional: true;
+    }): ReadonlyStore<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;
+    }>> | null;
+};
+declare const useThreadComposer: {
+    (): Readonly<{
+        type: "thread";
+        value: string;
+        setValue: (value: string) => void;
+        attachments: readonly ThreadComposerAttachment[];
+        addAttachment: (file: File) => void;
+        removeAttachment: (attachmentId: string) => void;
+        text: string;
+        setText: (value: string) => void;
+        reset: () => void;
+        canCancel: boolean;
+        isEditing: true;
+        isEmpty: boolean;
+        send: () => void;
+        cancel: () => void;
+        focus: () => void;
+        onFocus: (listener: () => void) => Unsubscribe;
+    }>;
+    <TSelected>(selector: (state: Readonly<{
+        type: "thread";
+        value: string;
+        setValue: (value: string) => void;
+        attachments: readonly ThreadComposerAttachment[];
+        addAttachment: (file: File) => void;
+        removeAttachment: (attachmentId: string) => void;
+        text: string;
+        setText: (value: string) => void;
+        reset: () => void;
+        canCancel: boolean;
+        isEditing: true;
+        isEmpty: boolean;
+        send: () => void;
+        cancel: () => void;
+        focus: () => void;
+        onFocus: (listener: () => void) => Unsubscribe;
+    }>) => TSelected): TSelected;
+    (options: {
+        optional: true;
+    }): Readonly<{
+        type: "thread";
+        value: string;
+        setValue: (value: string) => void;
+        attachments: readonly ThreadComposerAttachment[];
+        addAttachment: (file: File) => void;
+        removeAttachment: (attachmentId: string) => void;
+        text: string;
+        setText: (value: string) => void;
+        reset: () => void;
+        canCancel: boolean;
+        isEditing: true;
+        isEmpty: boolean;
+        send: () => void;
+        cancel: () => void;
+        focus: () => void;
+        onFocus: (listener: () => void) => Unsubscribe;
+    }> | null;
+    <TSelected>(options: {
+        optional: true;
+        selector?: (state: Readonly<{
+            type: "thread";
+            value: string;
+            setValue: (value: string) => void;
+            attachments: readonly ThreadComposerAttachment[];
+            addAttachment: (file: File) => void;
+            removeAttachment: (attachmentId: string) => void;
+            text: string;
+            setText: (value: string) => void;
+            reset: () => void;
+            canCancel: boolean;
+            isEditing: true;
+            isEmpty: boolean;
+            send: () => void;
+            cancel: () => void;
+            focus: () => void;
+            onFocus: (listener: () => void) => Unsubscribe;
+        }>) => TSelected;
+    }): TSelected | null;
+};
+declare const useThreadComposerStore: {
+    (): ReadonlyStore<Readonly<{
+        type: "thread";
+        value: string;
+        setValue: (value: string) => void;
+        attachments: readonly ThreadComposerAttachment[];
+        addAttachment: (file: File) => void;
+        removeAttachment: (attachmentId: string) => void;
+        text: string;
+        setText: (value: string) => void;
+        reset: () => void;
+        canCancel: boolean;
+        isEditing: true;
+        isEmpty: boolean;
+        send: () => void;
+        cancel: () => void;
+        focus: () => void;
+        onFocus: (listener: () => void) => Unsubscribe;
+    }>>;
+    (options: {
+        optional: true;
+    }): ReadonlyStore<Readonly<{
+        type: "thread";
+        value: string;
+        setValue: (value: string) => void;
+        attachments: readonly ThreadComposerAttachment[];
+        addAttachment: (file: File) => void;
+        removeAttachment: (attachmentId: string) => void;
+        text: string;
+        setText: (value: string) => void;
+        reset: () => void;
+        canCancel: boolean;
+        isEditing: true;
+        isEmpty: boolean;
+        send: () => void;
+        cancel: () => void;
+        focus: () => void;
+        onFocus: (listener: () => void) => Unsubscribe;
+    }>> | null;
+};
+declare const useThreadViewport: {
+    (): Readonly<{
+        isAtBottom: boolean;
+        scrollToBottom: () => void;
+        onScrollToBottom: (callback: () => void) => Unsubscribe;
+    }>;
+    <TSelected>(selector: (state: Readonly<{
+        isAtBottom: boolean;
+        scrollToBottom: () => void;
+        onScrollToBottom: (callback: () => void) => Unsubscribe;
+    }>) => TSelected): TSelected;
+    (options: {
+        optional: true;
+    }): Readonly<{
+        isAtBottom: boolean;
+        scrollToBottom: () => void;
+        onScrollToBottom: (callback: () => void) => Unsubscribe;
+    }> | null;
+    <TSelected>(options: {
+        optional: true;
+        selector?: (state: Readonly<{
+            isAtBottom: boolean;
+            scrollToBottom: () => void;
+            onScrollToBottom: (callback: () => void) => Unsubscribe;
+        }>) => TSelected;
+    }): TSelected | null;
+};
+declare const useThreadViewportStore: {
+    (): ReadonlyStore<Readonly<{
+        isAtBottom: boolean;
+        scrollToBottom: () => void;
+        onScrollToBottom: (callback: () => void) => Unsubscribe;
+    }>>;
+    (options: {
+        optional: true;
+    }): ReadonlyStore<Readonly<{
+        isAtBottom: boolean;
+        scrollToBottom: () => void;
+        onScrollToBottom: (callback: () => void) => Unsubscribe;
+    }>> | null;
+};
+
+type MessageState = Readonly<{
+    message: Readonly<ThreadMessage>;
+    parentId: string | null;
+    branches: readonly string[];
+    isLast: boolean;
+}>;
 
 type EditComposerState = Readonly<{
-    /** @deprecated Use `text` instead. */
+    type: "edit";
+    /** @deprecated Use `text` instead. This will be removed in 0.6.0. */
     value: string;
-    /** @deprecated Use `setText` instead. */
+    /** @deprecated Use `setText` instead. This will be removed in 0.6.0. */
     setValue: (value: string) => void;
     text: string;
     setText: (value: string) => void;
@@ -623,19 +1089,6 @@ type EditComposerState = Readonly<{
     cancel: () => void;
 }>;
 
-type ComposerContextValue = {
-    useComposer: ReadonlyStore<EditComposerState | ComposerState>;
-    type: "edit" | "new";
-};
-declare const useComposerContext: () => ComposerContextValue;
-
-type MessageState = Readonly<{
-    message: Readonly<ThreadMessage>;
-    parentId: string | null;
-    branches: readonly string[];
-    isLast: boolean;
-}>;
-
 type MessageUtilsState = Readonly<{
     isCopied: boolean;
     setIsCopied: (value: boolean) => void;
@@ -647,24 +1100,466 @@ type MessageUtilsState = Readonly<{
 }>;
 
 type MessageContextValue = {
-    useMessage: ReadonlyStore<MessageState>;
-    useMessageUtils: ReadonlyStore<MessageUtilsState>;
-    useEditComposer: ReadonlyStore<EditComposerState>;
+    useMessage: UseBoundStore<ReadonlyStore<MessageState>>;
+    useMessageUtils: UseBoundStore<ReadonlyStore<MessageUtilsState>>;
+    useEditComposer: UseBoundStore<ReadonlyStore<EditComposerState>>;
+};
+declare const useMessageContext: {
+    (options?: {
+        optional?: false | undefined;
+    } | undefined): MessageContextValue;
+    (options?: {
+        optional?: boolean | undefined;
+    } | undefined): MessageContextValue | null;
+};
+declare const useMessage: {
+    (): Readonly<{
+        message: Readonly<ThreadMessage>;
+        parentId: string | null;
+        branches: readonly string[];
+        isLast: boolean;
+    }>;
+    <TSelected>(selector: (state: Readonly<{
+        message: Readonly<ThreadMessage>;
+        parentId: string | null;
+        branches: readonly string[];
+        isLast: boolean;
+    }>) => TSelected): TSelected;
+    (options: {
+        optional: true;
+    }): Readonly<{
+        message: Readonly<ThreadMessage>;
+        parentId: string | null;
+        branches: readonly string[];
+        isLast: boolean;
+    }> | null;
+    <TSelected>(options: {
+        optional: true;
+        selector?: (state: Readonly<{
+            message: Readonly<ThreadMessage>;
+            parentId: string | null;
+            branches: readonly string[];
+            isLast: boolean;
+        }>) => TSelected;
+    }): TSelected | null;
+};
+declare const useMessageStore: {
+    (): ReadonlyStore<Readonly<{
+        message: Readonly<ThreadMessage>;
+        parentId: string | null;
+        branches: readonly string[];
+        isLast: boolean;
+    }>>;
+    (options: {
+        optional: true;
+    }): ReadonlyStore<Readonly<{
+        message: Readonly<ThreadMessage>;
+        parentId: string | null;
+        branches: readonly string[];
+        isLast: boolean;
+    }>> | null;
+};
+declare const useMessageUtils: {
+    (): Readonly<{
+        isCopied: boolean;
+        setIsCopied: (value: boolean) => void;
+        isHovering: boolean;
+        setIsHovering: (value: boolean) => void;
+        isSpeaking: boolean;
+        stopSpeaking: () => void;
+        addUtterance: (utterance: SpeechSynthesisAdapter.Utterance) => void;
+    }>;
+    <TSelected>(selector: (state: Readonly<{
+        isCopied: boolean;
+        setIsCopied: (value: boolean) => void;
+        isHovering: boolean;
+        setIsHovering: (value: boolean) => void;
+        isSpeaking: boolean;
+        stopSpeaking: () => void;
+        addUtterance: (utterance: SpeechSynthesisAdapter.Utterance) => void;
+    }>) => TSelected): TSelected;
+    (options: {
+        optional: true;
+    }): Readonly<{
+        isCopied: boolean;
+        setIsCopied: (value: boolean) => void;
+        isHovering: boolean;
+        setIsHovering: (value: boolean) => void;
+        isSpeaking: boolean;
+        stopSpeaking: () => void;
+        addUtterance: (utterance: SpeechSynthesisAdapter.Utterance) => void;
+    }> | null;
+    <TSelected>(options: {
+        optional: true;
+        selector?: (state: Readonly<{
+            isCopied: boolean;
+            setIsCopied: (value: boolean) => void;
+            isHovering: boolean;
+            setIsHovering: (value: boolean) => void;
+            isSpeaking: boolean;
+            stopSpeaking: () => void;
+            addUtterance: (utterance: SpeechSynthesisAdapter.Utterance) => void;
+        }>) => TSelected;
+    }): TSelected | null;
+};
+declare const useMessageUtilsStore: {
+    (): ReadonlyStore<Readonly<{
+        isCopied: boolean;
+        setIsCopied: (value: boolean) => void;
+        isHovering: boolean;
+        setIsHovering: (value: boolean) => void;
+        isSpeaking: boolean;
+        stopSpeaking: () => void;
+        addUtterance: (utterance: SpeechSynthesisAdapter.Utterance) => void;
+    }>>;
+    (options: {
+        optional: true;
+    }): ReadonlyStore<Readonly<{
+        isCopied: boolean;
+        setIsCopied: (value: boolean) => void;
+        isHovering: boolean;
+        setIsHovering: (value: boolean) => void;
+        isSpeaking: boolean;
+        stopSpeaking: () => void;
+        addUtterance: (utterance: SpeechSynthesisAdapter.Utterance) => void;
+    }>> | null;
+};
+declare const useEditComposer: {
+    (): Readonly<{
+        type: "edit";
+        value: string;
+        setValue: (value: string) => void;
+        text: string;
+        setText: (value: string) => void;
+        canCancel: boolean;
+        isEditing: boolean;
+        isEmpty: boolean;
+        edit: () => void;
+        send: () => void;
+        cancel: () => void;
+    }>;
+    <TSelected>(selector: (state: Readonly<{
+        type: "edit";
+        value: string;
+        setValue: (value: string) => void;
+        text: string;
+        setText: (value: string) => void;
+        canCancel: boolean;
+        isEditing: boolean;
+        isEmpty: boolean;
+        edit: () => void;
+        send: () => void;
+        cancel: () => void;
+    }>) => TSelected): TSelected;
+    (options: {
+        optional: true;
+    }): Readonly<{
+        type: "edit";
+        value: string;
+        setValue: (value: string) => void;
+        text: string;
+        setText: (value: string) => void;
+        canCancel: boolean;
+        isEditing: boolean;
+        isEmpty: boolean;
+        edit: () => void;
+        send: () => void;
+        cancel: () => void;
+    }> | null;
+    <TSelected>(options: {
+        optional: true;
+        selector?: (state: Readonly<{
+            type: "edit";
+            value: string;
+            setValue: (value: string) => void;
+            text: string;
+            setText: (value: string) => void;
+            canCancel: boolean;
+            isEditing: boolean;
+            isEmpty: boolean;
+            edit: () => void;
+            send: () => void;
+            cancel: () => void;
+        }>) => TSelected;
+    }): TSelected | null;
+};
+declare const useEditComposerStore: {
+    (): ReadonlyStore<Readonly<{
+        type: "edit";
+        value: string;
+        setValue: (value: string) => void;
+        text: string;
+        setText: (value: string) => void;
+        canCancel: boolean;
+        isEditing: boolean;
+        isEmpty: boolean;
+        edit: () => void;
+        send: () => void;
+        cancel: () => void;
+    }>>;
+    (options: {
+        optional: true;
+    }): ReadonlyStore<Readonly<{
+        type: "edit";
+        value: string;
+        setValue: (value: string) => void;
+        text: string;
+        setText: (value: string) => void;
+        canCancel: boolean;
+        isEditing: boolean;
+        isEmpty: boolean;
+        edit: () => void;
+        send: () => void;
+        cancel: () => void;
+    }>> | null;
 };
-declare function useMessageContext(): MessageContextValue;
-declare function useMessageContext(options: {
-    optional: true;
-}): MessageContextValue | null;
 
 type ContentPartContextValue = {
-    useContentPart: ReadonlyStore<ContentPartState>;
+    useContentPart: UseBoundStore<ReadonlyStore<ContentPartState>>;
+};
+declare const useContentPartContext: {
+    (options?: {
+        optional?: false | undefined;
+    } | undefined): ContentPartContextValue;
+    (options?: {
+        optional?: boolean | undefined;
+    } | undefined): ContentPartContextValue | null;
+};
+declare const useContentPart: {
+    (): Readonly<{
+        status: ContentPartStatus | ToolCallContentPartStatus;
+        part: TextContentPart | ImageContentPart | UIContentPart | ToolCallContentPart;
+    }>;
+    <TSelected>(selector: (state: Readonly<{
+        status: ContentPartStatus | ToolCallContentPartStatus;
+        part: TextContentPart | ImageContentPart | UIContentPart | ToolCallContentPart;
+    }>) => TSelected): TSelected;
+    (options: {
+        optional: true;
+    }): Readonly<{
+        status: ContentPartStatus | ToolCallContentPartStatus;
+        part: TextContentPart | ImageContentPart | UIContentPart | ToolCallContentPart;
+    }> | null;
+    <TSelected>(options: {
+        optional: true;
+        selector?: (state: Readonly<{
+            status: ContentPartStatus | ToolCallContentPartStatus;
+            part: TextContentPart | ImageContentPart | UIContentPart | ToolCallContentPart;
+        }>) => TSelected;
+    }): TSelected | null;
+};
+declare const useContentPartStore: {
+    (): ReadonlyStore<Readonly<{
+        status: ContentPartStatus | ToolCallContentPartStatus;
+        part: TextContentPart | ImageContentPart | UIContentPart | ToolCallContentPart;
+    }>>;
+    (options: {
+        optional: true;
+    }): ReadonlyStore<Readonly<{
+        status: ContentPartStatus | ToolCallContentPartStatus;
+        part: TextContentPart | ImageContentPart | UIContentPart | ToolCallContentPart;
+    }>> | null;
 };
-declare function useContentPartContext(): ContentPartContextValue;
-declare function useContentPartContext(options: {
-    optional: true;
-}): ContentPartContextValue | null;
 
-type ComposerState = Readonly<{
+type ComposerContextValue = {
+    useComposer: ReadonlyStore<EditComposerState | ThreadComposerState>;
+    type: "edit" | "new";
+};
+declare const useComposerContext: () => ComposerContextValue;
+declare const useComposer: {
+    (): Readonly<{
+        type: "edit";
+        value: string;
+        setValue: (value: string) => void;
+        text: string;
+        setText: (value: string) => void;
+        canCancel: boolean;
+        isEditing: boolean;
+        isEmpty: boolean;
+        edit: () => void;
+        send: () => void;
+        cancel: () => void;
+    }> | Readonly<{
+        type: "thread";
+        value: string;
+        setValue: (value: string) => void;
+        attachments: readonly ThreadComposerAttachment[];
+        addAttachment: (file: File) => void;
+        removeAttachment: (attachmentId: string) => void;
+        text: string;
+        setText: (value: string) => void;
+        reset: () => void;
+        canCancel: boolean;
+        isEditing: true;
+        isEmpty: boolean;
+        send: () => void;
+        cancel: () => void;
+        focus: () => void;
+        onFocus: (listener: () => void) => Unsubscribe;
+    }>;
+    <TSelected>(selector: (state: Readonly<{
+        type: "edit";
+        value: string;
+        setValue: (value: string) => void;
+        text: string;
+        setText: (value: string) => void;
+        canCancel: boolean;
+        isEditing: boolean;
+        isEmpty: boolean;
+        edit: () => void;
+        send: () => void;
+        cancel: () => void;
+    }> | Readonly<{
+        type: "thread";
+        value: string;
+        setValue: (value: string) => void;
+        attachments: readonly ThreadComposerAttachment[];
+        addAttachment: (file: File) => void;
+        removeAttachment: (attachmentId: string) => void;
+        text: string;
+        setText: (value: string) => void;
+        reset: () => void;
+        canCancel: boolean;
+        isEditing: true;
+        isEmpty: boolean;
+        send: () => void;
+        cancel: () => void;
+        focus: () => void;
+        onFocus: (listener: () => void) => Unsubscribe;
+    }>) => TSelected): TSelected;
+    (options: {
+        optional: true;
+    }): Readonly<{
+        type: "edit";
+        value: string;
+        setValue: (value: string) => void;
+        text: string;
+        setText: (value: string) => void;
+        canCancel: boolean;
+        isEditing: boolean;
+        isEmpty: boolean;
+        edit: () => void;
+        send: () => void;
+        cancel: () => void;
+    }> | Readonly<{
+        type: "thread";
+        value: string;
+        setValue: (value: string) => void;
+        attachments: readonly ThreadComposerAttachment[];
+        addAttachment: (file: File) => void;
+        removeAttachment: (attachmentId: string) => void;
+        text: string;
+        setText: (value: string) => void;
+        reset: () => void;
+        canCancel: boolean;
+        isEditing: true;
+        isEmpty: boolean;
+        send: () => void;
+        cancel: () => void;
+        focus: () => void;
+        onFocus: (listener: () => void) => Unsubscribe;
+    }> | null;
+    <TSelected>(options: {
+        optional: true;
+        selector?: (state: Readonly<{
+            type: "edit";
+            value: string;
+            setValue: (value: string) => void;
+            text: string;
+            setText: (value: string) => void;
+            canCancel: boolean;
+            isEditing: boolean;
+            isEmpty: boolean;
+            edit: () => void;
+            send: () => void;
+            cancel: () => void;
+        }> | Readonly<{
+            type: "thread";
+            value: string;
+            setValue: (value: string) => void;
+            attachments: readonly ThreadComposerAttachment[];
+            addAttachment: (file: File) => void;
+            removeAttachment: (attachmentId: string) => void;
+            text: string;
+            setText: (value: string) => void;
+            reset: () => void;
+            canCancel: boolean;
+            isEditing: true;
+            isEmpty: boolean;
+            send: () => void;
+            cancel: () => void;
+            focus: () => void;
+            onFocus: (listener: () => void) => Unsubscribe;
+        }>) => TSelected;
+    }): TSelected | null;
+};
+declare const useComposerStore: {
+    (): ReadonlyStore<Readonly<{
+        type: "edit";
+        value: string;
+        setValue: (value: string) => void;
+        text: string;
+        setText: (value: string) => void;
+        canCancel: boolean;
+        isEditing: boolean;
+        isEmpty: boolean;
+        edit: () => void;
+        send: () => void;
+        cancel: () => void;
+    }> | Readonly<{
+        type: "thread";
+        value: string;
+        setValue: (value: string) => void;
+        attachments: readonly ThreadComposerAttachment[];
+        addAttachment: (file: File) => void;
+        removeAttachment: (attachmentId: string) => void;
+        text: string;
+        setText: (value: string) => void;
+        reset: () => void;
+        canCancel: boolean;
+        isEditing: true;
+        isEmpty: boolean;
+        send: () => void;
+        cancel: () => void;
+        focus: () => void;
+        onFocus: (listener: () => void) => Unsubscribe;
+    }>>;
+    (options: {
+        optional: true;
+    }): ReadonlyStore<Readonly<{
+        type: "edit";
+        value: string;
+        setValue: (value: string) => void;
+        text: string;
+        setText: (value: string) => void;
+        canCancel: boolean;
+        isEditing: boolean;
+        isEmpty: boolean;
+        edit: () => void;
+        send: () => void;
+        cancel: () => void;
+    }> | Readonly<{
+        type: "thread";
+        value: string;
+        setValue: (value: string) => void;
+        attachments: readonly ThreadComposerAttachment[];
+        addAttachment: (file: File) => void;
+        removeAttachment: (attachmentId: string) => void;
+        text: string;
+        setText: (value: string) => void;
+        reset: () => void;
+        canCancel: boolean;
+        isEditing: true;
+        isEmpty: boolean;
+        send: () => void;
+        cancel: () => void;
+        focus: () => void;
+        onFocus: (listener: () => void) => Unsubscribe;
+    }>> | null;
+};
+
+type ThreadComposerState = Readonly<{
+    type: "thread";
     /** @deprecated Use `text` instead. */
     value: string;
     /** @deprecated Use `setText` instead. */
@@ -891,10 +1786,10 @@ declare const BranchPickerPrevious: react.ForwardRefExoticComponent<Omit<Omit<re
     asChild?: boolean;
 }, "ref"> & react.RefAttributes<HTMLButtonElement>>;
 
-type BranchPickerPrimitiveCountProps = {};
+type BranchPickerPrimitiveCountProps = Record<string, never>;
 declare const BranchPickerPrimitiveCount: FC<BranchPickerPrimitiveCountProps>;
 
-type BranchPickerPrimitiveNumberProps = {};
+type BranchPickerPrimitiveNumberProps = Record<string, never>;
 declare const BranchPickerPrimitiveNumber: FC<BranchPickerPrimitiveNumberProps>;
 
 type PrimitiveDivProps$3 = ComponentPropsWithoutRef<typeof Primitive.div>;
@@ -987,8 +1882,8 @@ declare const ContentPartPrimitiveImage: react.ForwardRefExoticComponent<Omit<Om
     asChild?: boolean;
 }, "ref"> & react.RefAttributes<HTMLImageElement>>;
 
-type ContentPartPrimitiveDisplayProps = {};
-declare const ContentPartPrimitiveDisplay: FC<ContentPartPrimitiveDisplayProps>;
+type ContentPartPrimitiveDisplayProps = Record<string, never>;
+declare const ContentPartPrimitiveDisplay: FC;
 
 type ContentPartPrimitiveInProgressProps = PropsWithChildren;
 declare const ContentPartPrimitiveInProgress: FC<ContentPartPrimitiveInProgressProps>;
@@ -1010,7 +1905,7 @@ declare const MessagePrimitiveIf: FC<MessagePrimitiveIfProps>;
 
 type MessagePrimitiveContentProps = {
     components?: {
-        Empty?: TextContentPartComponent | undefined;
+        Empty?: EmptyContentPartComponent | undefined;
         Text?: TextContentPartComponent | undefined;
         Image?: ImageContentPartComponent | undefined;
         UI?: UIContentPartComponent | undefined;
@@ -1025,7 +1920,7 @@ declare const MessagePrimitiveContent: FC<MessagePrimitiveContentProps>;
 type PrimitiveSpanProps = ComponentPropsWithoutRef<typeof Primitive.span>;
 type MessagePrimitiveInProgressProps = PrimitiveSpanProps;
 /**
- * @deprecated Define a custom Text renderer via ContentPartPrimitiveInProgress instead.
+ * @deprecated Define a custom Text renderer via ContentPartPrimitiveInProgress instead. This will be removed in 0.6.
  */
 declare const MessagePrimitiveInProgress: FC<MessagePrimitiveInProgressProps>;
 
@@ -1074,14 +1969,20 @@ declare const ThreadPrimitiveViewport: react.ForwardRefExoticComponent<Omit<Omit
 type ThreadPrimitiveMessagesProps = {
     components: {
         Message: ComponentType;
-        UserMessage?: ComponentType | undefined;
         EditComposer?: ComponentType | undefined;
+        UserEditComposer?: ComponentType | undefined;
+        AssistantEditComposer?: ComponentType | undefined;
+        SystemEditComposer?: ComponentType | undefined;
+        UserMessage?: ComponentType | undefined;
         AssistantMessage?: ComponentType | undefined;
         SystemMessage?: ComponentType | undefined;
     } | {
         Message?: ComponentType | undefined;
-        UserMessage: ComponentType;
         EditComposer?: ComponentType | undefined;
+        UserEditComposer?: ComponentType | undefined;
+        AssistantEditComposer?: ComponentType | undefined;
+        SystemEditComposer?: ComponentType | undefined;
+        UserMessage: ComponentType;
         AssistantMessage: ComponentType;
         SystemMessage?: ComponentType | undefined;
     };
@@ -1423,4 +2324,4 @@ declare const exports: {
     Text: FC;
 };
 
-export { index$6 as ActionBarPrimitive, type ActionBarPrimitiveCopyProps, type ActionBarPrimitiveEditProps, type ActionBarPrimitiveReloadProps, type ActionBarPrimitiveRootProps, type ActionBarPrimitiveSpeakProps, type ActionBarPrimitiveStopSpeakingProps, type AddToolResultOptions, AppendMessage, _default$b as AssistantActionBar, type AssistantActionsState, type AssistantContextValue, _default$a as AssistantMessage, type AssistantMessageConfig, type AssistantMessageContentProps, _default$9 as AssistantModal, index$5 as AssistantModalPrimitive, type AssistantModalPrimitiveContentProps, type AssistantModalPrimitiveRootProps, type AssistantModalPrimitiveTriggerProps, type AssistantModelConfigState, type AssistantRuntime, AssistantRuntimeProvider, type AssistantTool, type AssistantToolProps, type AssistantToolUI, type AssistantToolUIProps, type AssistantToolUIsState, type AttachmentAdapter, _default$8 as BranchPicker, index$4 as BranchPickerPrimitive, type BranchPickerPrimitiveCountProps, type BranchPickerPrimitiveNextProps, type BranchPickerPrimitiveNumberProps, type BranchPickerPrimitivePreviousProps, type BranchPickerPrimitiveRootProps, type ChatModelAdapter, type ChatModelRunOptions, type ChatModelRunResult, type ChatModelRunUpdate, _default$7 as Composer, _default$6 as ComposerAttachment, type ComposerContextValue, type ComposerInputProps, index$3 as ComposerPrimitive, type ComposerPrimitiveCancelProps, type ComposerPrimitiveIfProps, type ComposerPrimitiveInputProps, type ComposerPrimitiveRootProps, type ComposerPrimitiveSendProps, type ComposerState, CompositeAttachmentAdapter, exports as ContentPart, type ContentPartContextValue, index$2 as ContentPartPrimitive, type ContentPartPrimitiveDisplayProps, type ContentPartPrimitiveImageProps, type ContentPartPrimitiveInProgressProps, type ContentPartPrimitiveTextProps, type ContentPartState, CoreMessage, type DangerousInBrowserRuntimeOptions, EdgeChatAdapter, type EdgeRuntimeOptions, _default$5 as EditComposer, type EditComposerState, type ExternalStoreAdapter, type ExternalStoreMessageConverter, ExternalStoreRuntime, internal as INTERNAL, ImageContentPart, type ImageContentPartComponent, type ImageContentPartProps, type LocalRuntimeOptions, type MessageContextValue, index$1 as MessagePrimitive, type MessagePrimitiveContentProps, type MessagePrimitiveIfProps, type MessagePrimitiveInProgressProps, type MessagePrimitiveRootProps, type MessageState, MessageStatus, type MessageUtilsState, ModelConfig, ModelConfigProvider, type ReactThreadRuntime, SimpleImageAttachmentAdapter, SimpleTextAttachmentAdapter, SpeechSynthesisAdapter, StreamUtils, type StringsConfig, type SuggestionConfig, TextContentPart, type TextContentPartComponent, type TextContentPartProps, TextContentPartProvider, _default$4 as Thread, type ThreadActionsState, ThreadAssistantContentPart, type ThreadConfig, ThreadConfigProvider, type ThreadConfigProviderProps, type ThreadContextValue, ThreadMessage, type ThreadMessageLike, type ThreadMessagesState, index as ThreadPrimitive, type ThreadPrimitiveEmptyProps, type ThreadPrimitiveIfProps, type ThreadPrimitiveMessagesProps, type ThreadPrimitiveRootProps, type ThreadPrimitiveScrollToBottomProps, type ThreadPrimitiveSuggestionProps, type ThreadPrimitiveViewportProps, type ThreadRootProps, ThreadRuntime, type ThreadState, type ThreadViewportState, _default as ThreadWelcome, type ThreadWelcomeConfig, type ThreadWelcomeMessageProps, type ThreadWelcomeSuggestionProps, Tool, ToolCallContentPart, type ToolCallContentPartComponent, type ToolCallContentPartProps, UIContentPart, type UIContentPartComponent, type UIContentPartProps, type Unsubscribe, type UseActionBarCopyProps, _default$2 as UserActionBar, _default$3 as UserMessage, _default$1 as UserMessageAttachment, type UserMessageConfig, type UserMessageContentProps, WebSpeechSynthesisAdapter, fromCoreMessage, fromCoreMessages, fromLanguageModelMessages, fromLanguageModelTools, getExternalStoreMessage, makeAssistantTool, makeAssistantToolUI, streamUtils, subscribeToMainThread, toCoreMessage, toCoreMessages, toLanguageModelMessages, toLanguageModelTools, useActionBarCopy, useActionBarEdit, useActionBarReload, useActionBarSpeak, useActionBarStopSpeaking, useAppendMessage, useAssistantContext, useAssistantInstructions, useAssistantTool, useAssistantToolUI, useBranchPickerCount, useBranchPickerNext, useBranchPickerNumber, useBranchPickerPrevious, useComposerAddAttachment, useComposerCancel, useComposerContext, useComposerIf, useComposerSend, useContentPartContext, useContentPartDisplay, useContentPartImage, useContentPartText, useDangerousInBrowserRuntime, useEdgeRuntime, useExternalMessageConverter, useExternalStoreRuntime, useLocalRuntime, useMessageContext, useMessageIf, useSwitchToNewThread, useThreadConfig, useThreadContext, useThreadEmpty, useThreadIf, useThreadScrollToBottom, useThreadSuggestion };
+export { index$6 as ActionBarPrimitive, type ActionBarPrimitiveCopyProps, type ActionBarPrimitiveEditProps, type ActionBarPrimitiveReloadProps, type ActionBarPrimitiveRootProps, type ActionBarPrimitiveSpeakProps, type ActionBarPrimitiveStopSpeakingProps, type AddToolResultOptions, AppendMessage, _default$b as AssistantActionBar, type AssistantActionsState, type AssistantContextValue, _default$a as AssistantMessage, type AssistantMessageConfig, type AssistantMessageContentProps, _default$9 as AssistantModal, index$5 as AssistantModalPrimitive, type AssistantModalPrimitiveContentProps, type AssistantModalPrimitiveRootProps, type AssistantModalPrimitiveTriggerProps, type AssistantRuntime, AssistantRuntimeProvider, type AssistantTool, type AssistantToolProps, type AssistantToolUI, type AssistantToolUIProps, type AssistantToolUIsState, type AttachmentAdapter, _default$8 as BranchPicker, index$4 as BranchPickerPrimitive, type BranchPickerPrimitiveCountProps, type BranchPickerPrimitiveNextProps, type BranchPickerPrimitiveNumberProps, type BranchPickerPrimitivePreviousProps, type BranchPickerPrimitiveRootProps, type ChatModelAdapter, type ChatModelRunOptions, type ChatModelRunResult, type ChatModelRunUpdate, _default$7 as Composer, _default$6 as ComposerAttachment, type ComposerContextValue, type ComposerInputProps, index$3 as ComposerPrimitive, type ComposerPrimitiveCancelProps, type ComposerPrimitiveIfProps, type ComposerPrimitiveInputProps, type ComposerPrimitiveRootProps, type ComposerPrimitiveSendProps, CompositeAttachmentAdapter, exports as ContentPart, type ContentPartContextValue, index$2 as ContentPartPrimitive, type ContentPartPrimitiveDisplayProps, type ContentPartPrimitiveImageProps, type ContentPartPrimitiveInProgressProps, type ContentPartPrimitiveTextProps, type ContentPartState, CoreMessage, type DangerousInBrowserRuntimeOptions, EdgeChatAdapter, type EdgeRuntimeOptions, _default$5 as EditComposer, type EditComposerState, type EmptyContentPartComponent, type EmptyContentPartProps, type ExternalStoreAdapter, type ExternalStoreMessageConverter, ExternalStoreRuntime, internal as INTERNAL, ImageContentPart, type ImageContentPartComponent, type ImageContentPartProps, type LocalRuntimeOptions, type MessageContextValue, index$1 as MessagePrimitive, type MessagePrimitiveContentProps, type MessagePrimitiveIfProps, type MessagePrimitiveInProgressProps, type MessagePrimitiveRootProps, type MessageState, MessageStatus, type MessageUtilsState, ModelConfig, ModelConfigProvider, type ReactThreadRuntime, SimpleImageAttachmentAdapter, SimpleTextAttachmentAdapter, SpeechSynthesisAdapter, StreamUtils, type StringsConfig, type SuggestionConfig, TextContentPart, type TextContentPartComponent, type TextContentPartProps, TextContentPartProvider, _default$4 as Thread, type ThreadActionsState, ThreadAssistantContentPart, type ThreadComposerState, type ThreadConfig, ThreadConfigProvider, type ThreadConfigProviderProps, type ThreadContextValue, ThreadMessage, type ThreadMessageLike, type ThreadMessagesState, index as ThreadPrimitive, type ThreadPrimitiveEmptyProps, type ThreadPrimitiveIfProps, type ThreadPrimitiveMessagesProps, type ThreadPrimitiveRootProps, type ThreadPrimitiveScrollToBottomProps, type ThreadPrimitiveSuggestionProps, type ThreadPrimitiveViewportProps, type ThreadRootProps, ThreadRuntime, type ThreadState, type ThreadViewportState, _default as ThreadWelcome, type ThreadWelcomeConfig, type ThreadWelcomeMessageProps, type ThreadWelcomeSuggestionProps, Tool, ToolCallContentPart, type ToolCallContentPartComponent, type ToolCallContentPartProps, UIContentPart, type UIContentPartComponent, type UIContentPartProps, type Unsubscribe, type UseActionBarCopyProps, _default$2 as UserActionBar, _default$3 as UserMessage, _default$1 as UserMessageAttachment, type UserMessageConfig, type UserMessageContentProps, WebSpeechSynthesisAdapter, fromCoreMessage, fromCoreMessages, fromLanguageModelMessages, fromLanguageModelTools, getExternalStoreMessage, makeAssistantTool, makeAssistantToolUI, streamUtils, subscribeToMainThread, toCoreMessage, toCoreMessages, toLanguageModelMessages, toLanguageModelTools, useActionBarCopy, useActionBarEdit, useActionBarReload, useActionBarSpeak, useActionBarStopSpeaking, useAppendMessage, useAssistantActions, useAssistantActionsStore, useAssistantContext, useAssistantInstructions, useAssistantRuntime, useAssistantRuntimeStore, useAssistantTool, useAssistantToolUI, useBranchPickerCount, useBranchPickerNext, useBranchPickerNumber, useBranchPickerPrevious, useComposer, useComposerAddAttachment, useComposerCancel, useComposerContext, useComposerIf, useComposerSend, useComposerStore, useContentPart, useContentPartContext, useContentPartDisplay, useContentPartImage, useContentPartStore, useContentPartText, useDangerousInBrowserRuntime, useEdgeRuntime, useEditComposer, useEditComposerStore, useExternalMessageConverter, useExternalStoreRuntime, useLocalRuntime, useMessage, useMessageContext, useMessageIf, useMessageStore, useMessageUtils, useMessageUtilsStore, useSwitchToNewThread, useThread, useThreadActions, useThreadActionsStore, useThreadComposer, useThreadComposerStore, useThreadConfig, useThreadContext, useThreadEmpty, useThreadIf, useThreadMessages, useThreadMessagesStore, useThreadRuntime, useThreadRuntimeStore, useThreadScrollToBottom, useThreadStore, useThreadSuggestion, useThreadViewport, useThreadViewportStore, useToolUIs, useToolUIsStore };