@assistant-ui/react 0.1.12 → 0.2.2

package/dist/index.d.ts

@@ -1,11 +1,308 @@
 import * as react from 'react';
-import { FC, PropsWithChildren, ComponentPropsWithoutRef, ComponentType, ReactNode } from 'react';
+import { ReactNode, ComponentType, PropsWithChildren, ComponentPropsWithoutRef, FC } from 'react';
+import { z } from 'zod';
+import { UseBoundStore, StoreApi } from 'zustand';
+import { Primitive } from '@radix-ui/react-primitive';
 import * as PopoverPrimitive from '@radix-ui/react-popover';
 import { TextareaAutosizeProps } from 'react-textarea-autosize';
-import { Primitive } from '@radix-ui/react-primitive';
-import { T as TextContentPartComponent, I as ImageContentPartComponent, U as UIContentPartComponent, a as ToolCallContentPartComponent, b as ToolCallContentPartProps, c as ThreadState, d as ThreadActionsState, e as Unsubscribe, M as ModelConfigProvider, f as ThreadMessage, g as ModelConfig, A as AssistantContentPart, h as AppendMessage } from './ThreadActions-BLcKtagX.js';
-export { l as AppendContentPart, i as AssistantMessage, m as TextContentPart, k as UserContentPart, j as UserMessage } from './ThreadActions-BLcKtagX.js';
-import 'zod';
+
+type ToolExecuteFunction<TArgs, TResult> = (args: TArgs) => TResult | Promise<TResult>;
+type Tool<TArgs = unknown, TResult = unknown> = {
+    description?: string;
+    parameters: z.ZodSchema<TArgs>;
+    execute: ToolExecuteFunction<TArgs, TResult>;
+};
+type ModelConfig = {
+    priority?: number;
+    system?: string;
+    tools?: Record<string, Tool<any, any>>;
+};
+type ModelConfigProvider = () => ModelConfig;
+
+type Unsubscribe = () => void;
+
+type TextContentPart = {
+    type: "text";
+    text: string;
+};
+type ImageContentPart = {
+    type: "image";
+    image: string;
+};
+type UIContentPart = {
+    type: "ui";
+    display: ReactNode;
+};
+type ToolCallContentPart<TArgs = unknown, TResult = unknown> = {
+    type: "tool-call";
+    toolCallId: string;
+    toolName: string;
+    args: TArgs;
+    result?: TResult;
+};
+type UserContentPart = TextContentPart | ImageContentPart | UIContentPart;
+type AssistantContentPart = TextContentPart | ToolCallContentPart | UIContentPart;
+type AppendContentPart = TextContentPart | ImageContentPart;
+type BaseMessage = {
+    id: string;
+    createdAt: Date;
+};
+type UserMessage = BaseMessage & {
+    role: "user";
+    content: UserContentPart[];
+};
+type AssistantMessage = BaseMessage & {
+    role: "assistant";
+    content: AssistantContentPart[];
+    status: "in_progress" | "done" | "error";
+};
+type AppendMessage = {
+    parentId: string | null;
+    role: "user";
+    content: AppendContentPart[];
+};
+type ThreadMessage = UserMessage | AssistantMessage;
+
+type ReactThreadRuntime = ThreadRuntime & {
+    unstable_synchronizer?: ComponentType;
+};
+
+type ChatModelRunResult = {
+    content: AssistantContentPart[];
+};
+type ChatModelRunOptions = {
+    messages: ThreadMessage[];
+    abortSignal: AbortSignal;
+    config: ModelConfig;
+    onUpdate: (result: ChatModelRunResult) => void;
+};
+type ChatModelAdapter = {
+    run: (options: ChatModelRunOptions) => Promise<ChatModelRunResult>;
+};
+
+declare abstract class BaseAssistantRuntime<TThreadRuntime extends ReactThreadRuntime> implements AssistantRuntime {
+    private _thread;
+    constructor(_thread: TThreadRuntime);
+    private _unsubscribe;
+    get thread(): TThreadRuntime;
+    set thread(thread: TThreadRuntime);
+    abstract registerModelConfigProvider(provider: ModelConfigProvider): Unsubscribe;
+    abstract switchToThread(threadId: string | null): void;
+    get messages(): readonly ThreadMessage[];
+    get isRunning(): boolean;
+    getBranches(messageId: string): readonly string[];
+    switchToBranch(branchId: string): void;
+    append(message: AppendMessage): void;
+    startRun(parentId: string | null): void;
+    cancelRun(): void;
+    addToolResult(toolCallId: string, result: any): void;
+    private _subscriptions;
+    subscribe(callback: () => void): Unsubscribe;
+    private subscriptionHandler;
+    get unstable_synchronizer(): react.ComponentType | undefined;
+}
+
+declare class LocalRuntime extends BaseAssistantRuntime<LocalThreadRuntime> {
+    private readonly _configProviders;
+    constructor(adapter: ChatModelAdapter);
+    set adapter(adapter: ChatModelAdapter);
+    registerModelConfigProvider(provider: ModelConfigProvider): () => boolean;
+    switchToThread(threadId: string | null): LocalThreadRuntime;
+}
+declare class LocalThreadRuntime implements ThreadRuntime {
+    private _configProviders;
+    adapter: ChatModelAdapter;
+    private _subscriptions;
+    private abortController;
+    private repository;
+    get messages(): ThreadMessage[];
+    get isRunning(): boolean;
+    constructor(_configProviders: Set<ModelConfigProvider>, adapter: ChatModelAdapter);
+    getBranches(messageId: string): string[];
+    switchToBranch(branchId: string): void;
+    append(message: AppendMessage): Promise<void>;
+    startRun(parentId: string | null): Promise<void>;
+    cancelRun(): void;
+    private notifySubscribers;
+    subscribe(callback: () => void): Unsubscribe;
+    addToolResult(): void;
+}
+
+declare const useLocalRuntime: (adapter: ChatModelAdapter) => LocalRuntime;
+
+type ThreadActionsState = Readonly<{
+    getBranches: (messageId: string) => readonly string[];
+    switchToBranch: (branchId: string) => void;
+    append: (message: AppendMessage) => void;
+    startRun: (parentId: string | null) => void;
+    cancelRun: () => void;
+    addToolResult: (toolCallId: string, result: any) => void;
+}>;
+
+type ThreadRuntime = Readonly<ThreadState & ThreadActionsState & {
+    subscribe: (callback: () => void) => Unsubscribe;
+}>;
+
+type AssistantRuntime = ThreadRuntime & {
+    switchToThread: (threadId: string | null) => void;
+    registerModelConfigProvider: (provider: ModelConfigProvider) => Unsubscribe;
+};
+
+type AssistantRuntimeProviderProps = {
+    runtime: AssistantRuntime;
+};
+declare const AssistantRuntimeProvider: react.NamedExoticComponent<PropsWithChildren<AssistantRuntimeProviderProps>>;
+
+type AssistantModelConfigState = Readonly<{
+    getModelConfig: ModelConfigProvider;
+    registerModelConfigProvider: (provider: ModelConfigProvider) => () => void;
+}>;
+
+type ContentPartState = Readonly<{
+    status: "in_progress" | "done" | "error";
+    part: ThreadMessage["content"][number];
+}>;
+
+type MessageState = Readonly<{
+    message: Readonly<ThreadMessage>;
+    parentId: string | null;
+    branches: readonly string[];
+    isLast: boolean;
+}>;
+
+type BaseComposerState = Readonly<{
+    value: string;
+    setValue: (value: string) => void;
+}>;
+
+type ReadonlyStore<T> = UseBoundStore<Omit<StoreApi<T>, "setState" | "destroy">>;
+
+type EditComposerState = BaseComposerState & Readonly<{
+    isEditing: boolean;
+    edit: () => void;
+    send: () => void;
+    cancel: () => boolean;
+}>;
+
+type ThreadState = Readonly<{
+    messages: readonly ThreadMessage[];
+    isRunning: boolean;
+}>;
+
+type ComposerState = BaseComposerState & Readonly<{
+    isEditing: true;
+    send: () => void;
+    cancel: () => boolean;
+    focus: () => void;
+    onFocus: (listener: () => void) => Unsubscribe;
+}>;
+
+type ThreadViewportState = Readonly<{
+    isAtBottom: boolean;
+    scrollToBottom: () => void;
+    onScrollToBottom: (callback: () => void) => Unsubscribe;
+}>;
+
+type ContentPartStatus = "done" | "in_progress" | "error";
+type TextContentPartProps = {
+    part: TextContentPart;
+    status: ContentPartStatus;
+};
+type TextContentPartComponent = ComponentType<TextContentPartProps>;
+type ImageContentPartProps = {
+    part: ImageContentPart;
+    status: ContentPartStatus;
+};
+type ImageContentPartComponent = ComponentType<ImageContentPartProps>;
+type UIContentPartProps = {
+    part: UIContentPart;
+    status: ContentPartStatus;
+};
+type UIContentPartComponent = ComponentType<UIContentPartProps>;
+type ToolCallContentPartProps<TArgs = any, TResult = any> = {
+    part: ToolCallContentPart<TArgs, TResult>;
+    status: ContentPartStatus;
+    addResult: (result: any) => void;
+};
+type ToolCallContentPartComponent<TArgs = any, TResult = any> = ComponentType<ToolCallContentPartProps<TArgs, TResult>>;
+
+type AssistantToolUIsState = Readonly<{
+    getToolUI: (toolName: string) => ToolCallContentPartComponent | null;
+    setToolUI: (toolName: string, render: ToolCallContentPartComponent) => () => void;
+}>;
+
+type AssistantActionsState = Readonly<{
+    switchToThread: (threadId: string | null) => void;
+}>;
+
+type AssistantContextValue = {
+    useModelConfig: ReadonlyStore<AssistantModelConfigState>;
+    useToolUIs: ReadonlyStore<AssistantToolUIsState>;
+    useAssistantActions: ReadonlyStore<AssistantActionsState>;
+};
+declare const useAssistantContext: () => AssistantContextValue;
+
+type ThreadContextValue = {
+    useThread: ReadonlyStore<ThreadState>;
+    useThreadActions: ReadonlyStore<ThreadActionsState>;
+    useComposer: ReadonlyStore<ComposerState>;
+    useViewport: ReadonlyStore<ThreadViewportState>;
+};
+declare const useThreadContext: () => ThreadContextValue;
+
+type ComposerContextValue = {
+    useComposer: ReadonlyStore<EditComposerState | ComposerState>;
+    type: "edit" | "new";
+};
+declare const useComposerContext: () => ComposerContextValue;
+
+type MessageUtilsState = Readonly<{
+    inProgressIndicator: ReactNode | null;
+    setInProgressIndicator: (value: ReactNode | null) => void;
+    isCopied: boolean;
+    setIsCopied: (value: boolean) => void;
+    isHovering: boolean;
+    setIsHovering: (value: boolean) => void;
+}>;
+
+type MessageContextValue = {
+    useMessage: ReadonlyStore<MessageState>;
+    useMessageUtils: ReadonlyStore<MessageUtilsState>;
+    useEditComposer: ReadonlyStore<EditComposerState>;
+};
+declare const useMessageContext: () => MessageContextValue;
+
+type ContentPartContextValue = {
+    useContentPart: ReadonlyStore<ContentPartState>;
+};
+declare const useContentPartContext: () => ContentPartContextValue;
+
+type CreateAppendMessage = string | {
+    parentId?: string | null | undefined;
+    role?: AppendMessage["role"];
+    content: AppendMessage["content"];
+};
+declare const useAppendMessage: () => (message: CreateAppendMessage) => void;
+
+declare const useSwitchToNewThread: () => () => void;
+
+type AssistantToolProps<TArgs, TResult> = Tool<TArgs, TResult> & {
+    toolName: string;
+    render?: ToolCallContentPartComponent<TArgs, TResult>;
+};
+declare const useAssistantTool: <TArgs, TResult>(tool: AssistantToolProps<TArgs, TResult>) => void;
+
+declare const makeAssistantTool: <TArgs, TResult>(tool: AssistantToolProps<TArgs, TResult>) => () => null;
+
+type AssistantToolUIProps<TArgs, TResult> = {
+    toolName: string;
+    render: ToolCallContentPartComponent<TArgs, TResult>;
+};
+declare const useAssistantToolUI: (tool: AssistantToolUIProps<any, any> | null) => void;
+
+declare const makeAssistantToolUI: <TArgs, TResult>(tool: AssistantToolUIProps<TArgs, TResult>) => () => null;
+
+declare const useAssistantInstructions: (instruction: string) => void;
 
 type UseActionBarCopyProps = {
     copiedDuration?: number;
@@ -79,13 +376,20 @@ type UseActionBarFloatStatusProps = {
     autohide?: "always" | "not-last" | "never" | undefined;
     autohideFloat?: "always" | "single-branch" | "never" | undefined;
 };
-declare const ActionBarRoot: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+
+type PrimitiveDivProps$4 = ComponentPropsWithoutRef<typeof Primitive.div>;
+type ActionBarPrimitiveRootProps = PrimitiveDivProps$4 & UseActionBarFloatStatusProps;
+declare const ActionBarPrimitiveRoot: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
     ref?: ((instance: HTMLDivElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLDivElement> | null | undefined;
 } & {
     asChild?: boolean;
 }, "ref"> & UseActionBarFloatStatusProps & react.RefAttributes<HTMLDivElement>>;
 
-declare const ActionBarCopy: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+type PrimitiveButtonProps$1 = ComponentPropsWithoutRef<typeof Primitive.button>;
+type ActionButtonProps<THook> = PrimitiveButtonProps$1 & (THook extends (props: infer TProps) => unknown ? TProps : never);
+
+type ActionBarPrimitiveCopyProps = ActionButtonProps<typeof useActionBarCopy>;
+declare const ActionBarPrimitiveCopy: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
     ref?: ((instance: HTMLButtonElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLButtonElement> | null | undefined;
 } & {
     asChild?: boolean;
@@ -93,52 +397,66 @@ declare const ActionBarCopy: react.ForwardRefExoticComponent<Omit<Omit<react.Det
     copiedDuration?: number;
 } & react.RefAttributes<HTMLButtonElement>>;
 
-declare const ActionBarReload: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+type ActionBarPrimitiveReloadProps = ActionButtonProps<typeof useActionBarReload>;
+declare const ActionBarPrimitiveReload: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
     ref?: ((instance: HTMLButtonElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLButtonElement> | null | undefined;
 } & {
     asChild?: boolean;
 }, "ref"> & react.RefAttributes<HTMLButtonElement>>;
 
-declare const ActionBarEdit: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+type ActionBarPrimitiveEditProps = ActionButtonProps<typeof useActionBarEdit>;
+declare const ActionBarPrimitiveEdit: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
     ref?: ((instance: HTMLButtonElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLButtonElement> | null | undefined;
 } & {
     asChild?: boolean;
 }, "ref"> & react.RefAttributes<HTMLButtonElement>>;
 
 declare namespace index$6 {
-  export { ActionBarCopy as Copy, ActionBarEdit as Edit, ActionBarReload as Reload, ActionBarRoot as Root };
+  export { ActionBarPrimitiveCopy as Copy, ActionBarPrimitiveEdit as Edit, ActionBarPrimitiveReload as Reload, ActionBarPrimitiveRoot as Root };
 }
 
-type AssistantModalRootProps = PopoverPrimitive.PopoverProps;
-declare const AssistantModalRoot: FC<AssistantModalRootProps>;
+type AssistantModalPrimitiveRootProps = PopoverPrimitive.PopoverProps;
+declare const AssistantModalPrimitiveRoot: FC<AssistantModalPrimitiveRootProps>;
 
-declare const AssistantModalTrigger: react.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverTriggerProps & react.RefAttributes<HTMLButtonElement>, "ref"> & react.RefAttributes<HTMLButtonElement>>;
+type AssistantModalPrimitiveTriggerProps = ComponentPropsWithoutRef<typeof PopoverPrimitive.Trigger>;
+declare const AssistantModalPrimitiveTrigger: react.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverTriggerProps & react.RefAttributes<HTMLButtonElement>, "ref"> & react.RefAttributes<HTMLButtonElement>>;
 
-declare const AssistantModalContent: react.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverContentProps & react.RefAttributes<HTMLDivElement>, "ref"> & {
+type AssistantModalPrimitiveContentProps = ComponentPropsWithoutRef<typeof PopoverPrimitive.Content> & {
+    dissmissOnInteractOutside?: boolean;
+};
+declare const AssistantModalPrimitiveContent: react.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverContentProps & react.RefAttributes<HTMLDivElement>, "ref"> & {
     dissmissOnInteractOutside?: boolean;
 } & react.RefAttributes<HTMLDivElement>>;
 
 declare namespace index$5 {
-  export { AssistantModalContent as Content, AssistantModalRoot as Root, AssistantModalTrigger as Trigger };
+  export { AssistantModalPrimitiveContent as Content, AssistantModalPrimitiveRoot as Root, AssistantModalPrimitiveTrigger as Trigger };
 }
 
-declare const BranchPickerNext: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+type BranchPickerPrimitiveNextProps = ActionButtonProps<typeof useBranchPickerNext>;
+declare const BranchPickerPrimitiveNext: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
     ref?: ((instance: HTMLButtonElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLButtonElement> | null | undefined;
 } & {
     asChild?: boolean;
 }, "ref"> & react.RefAttributes<HTMLButtonElement>>;
 
+type BranchPickerPrimitivePreviousProps = ActionButtonProps<typeof useBranchPickerPrevious>;
 declare const BranchPickerPrevious: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
     ref?: ((instance: HTMLButtonElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLButtonElement> | null | undefined;
 } & {
     asChild?: boolean;
 }, "ref"> & react.RefAttributes<HTMLButtonElement>>;
 
-declare const BranchPickerCount: FC;
+type BranchPickerPrimitiveCountProps = {};
+declare const BranchPickerPrimitiveCount: FC<BranchPickerPrimitiveCountProps>;
 
-declare const BranchPickerNumber: FC;
+type BranchPickerPrimitiveNumberProps = {};
+declare const BranchPickerPrimitiveNumber: FC<BranchPickerPrimitiveNumberProps>;
 
-declare const BranchPickerRoot: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+type PrimitiveDivProps$3 = ComponentPropsWithoutRef<typeof Primitive.div>;
+type BranchPickerPrimitiveRootProps = PrimitiveDivProps$3 & {
+    hideWhenSingleBranch?: boolean;
+};
+declare const BranchPickerPrimitiveRoot: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
     ref?: ((instance: HTMLDivElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLDivElement> | null | undefined;
 } & {
     asChild?: boolean;
@@ -147,66 +465,80 @@ declare const BranchPickerRoot: react.ForwardRefExoticComponent<Omit<Omit<react.
 } & react.RefAttributes<HTMLDivElement>>;
 
 declare namespace index$4 {
-  export { BranchPickerCount as Count, BranchPickerNext as Next, BranchPickerNumber as Number, BranchPickerPrevious as Previous, BranchPickerRoot as Root };
+  export { BranchPickerPrimitiveCount as Count, BranchPickerPrimitiveNext as Next, BranchPickerPrimitiveNumber as Number, BranchPickerPrevious as Previous, BranchPickerPrimitiveRoot as Root };
 }
 
-declare const ComposerRoot: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.FormHTMLAttributes<HTMLFormElement>, HTMLFormElement>, "ref"> & {
+type PrimitiveFormProps = ComponentPropsWithoutRef<typeof Primitive.form>;
+type ComposerPrimitiveRootProps = PrimitiveFormProps;
+declare const ComposerPrimitiveRoot: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.FormHTMLAttributes<HTMLFormElement>, HTMLFormElement>, "ref"> & {
     ref?: ((instance: HTMLFormElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLFormElement> | null | undefined;
 } & {
     asChild?: boolean;
 }, "ref"> & react.RefAttributes<HTMLFormElement>>;
 
-declare const ComposerInput: react.ForwardRefExoticComponent<TextareaAutosizeProps & {
+type ComposerPrimitiveInputProps = TextareaAutosizeProps & {
+    asChild?: boolean;
+};
+declare const ComposerPrimitiveInput: react.ForwardRefExoticComponent<TextareaAutosizeProps & {
     asChild?: boolean;
 } & react.RefAttributes<HTMLTextAreaElement>>;
 
-declare const ComposerSend: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+type PrimitiveButtonProps = ComponentPropsWithoutRef<typeof Primitive.button>;
+type ComposerPrimitiveSendProps = PrimitiveButtonProps;
+declare const ComposerPrimitiveSend: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
     ref?: ((instance: HTMLButtonElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLButtonElement> | null | undefined;
 } & {
     asChild?: boolean;
 }, "ref"> & react.RefAttributes<HTMLButtonElement>>;
 
-declare const ComposerCancel: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+type ComposerPrimitiveCancelProps = ActionButtonProps<typeof useComposerCancel>;
+declare const ComposerPrimitiveCancel: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
     ref?: ((instance: HTMLButtonElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLButtonElement> | null | undefined;
 } & {
     asChild?: boolean;
 }, "ref"> & react.RefAttributes<HTMLButtonElement>>;
 
-type ComposerIfProps = PropsWithChildren<UseComposerIfProps>;
-declare const ComposerIf: FC<ComposerIfProps>;
+type ComposerPrimitiveIfProps = PropsWithChildren<UseComposerIfProps>;
+declare const ComposerPrimitiveIf: FC<ComposerPrimitiveIfProps>;
 
 declare namespace index$3 {
-  export { ComposerCancel as Cancel, ComposerIf as If, ComposerInput as Input, ComposerRoot as Root, ComposerSend as Send };
+  export { ComposerPrimitiveCancel as Cancel, ComposerPrimitiveIf as If, ComposerPrimitiveInput as Input, ComposerPrimitiveRoot as Root, ComposerPrimitiveSend as Send };
 }
 
-declare const ContentPartInProgressIndicator: FC;
+type ContentPartPrimitiveInProgressIndicatorProps = {};
+declare const ContentPartPrimitiveInProgressIndicator: FC<ContentPartPrimitiveInProgressIndicatorProps>;
 
-type PrimitiveSpanProps = ComponentPropsWithoutRef<typeof Primitive.span>;
-type ContentPartTextProps = Omit<PrimitiveSpanProps, "children">;
-declare const ContentPartText: react.ForwardRefExoticComponent<ContentPartTextProps & react.RefAttributes<HTMLSpanElement>>;
+type PrimitiveSpanProps$1 = ComponentPropsWithoutRef<typeof Primitive.p>;
+type ContentPartPrimitiveTextProps = Omit<PrimitiveSpanProps$1, "children">;
+declare const ContentPartPrimitiveText: react.ForwardRefExoticComponent<ContentPartPrimitiveTextProps & react.RefAttributes<HTMLParagraphElement>>;
 
-declare const ContentPartImage: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>, "ref"> & {
+type PrimitiveImageProps = ComponentPropsWithoutRef<typeof Primitive.img>;
+type ContentPartPrimitiveImageProps = PrimitiveImageProps;
+declare const ContentPartPrimitiveImage: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>, "ref"> & {
     ref?: ((instance: HTMLImageElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLImageElement> | null | undefined;
 } & {
     asChild?: boolean;
 }, "ref"> & react.RefAttributes<HTMLImageElement>>;
 
-declare const ContentPartDisplay: FC;
+type ContentPartPrimitiveDisplayProps = {};
+declare const ContentPartPrimitiveDisplay: FC<ContentPartPrimitiveDisplayProps>;
 
 declare namespace index$2 {
-  export { ContentPartDisplay as Display, ContentPartImage as Image, ContentPartInProgressIndicator as InProgressIndicator, ContentPartText as Text };
+  export { ContentPartPrimitiveDisplay as Display, ContentPartPrimitiveImage as Image, ContentPartPrimitiveInProgressIndicator as InProgressIndicator, ContentPartPrimitiveText as Text };
 }
 
-declare const MessageRoot: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+type PrimitiveDivProps$2 = ComponentPropsWithoutRef<typeof Primitive.div>;
+type MessagePrimitiveRootProps = PrimitiveDivProps$2;
+declare const MessagePrimitiveRoot: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
     ref?: ((instance: HTMLDivElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLDivElement> | null | undefined;
 } & {
     asChild?: boolean;
 }, "ref"> & react.RefAttributes<HTMLDivElement>>;
 
-type MessageIfProps = PropsWithChildren<UseMessageIfProps>;
-declare const MessageIf: FC<MessageIfProps>;
+type MessagePrimitiveIfProps = PropsWithChildren<UseMessageIfProps>;
+declare const MessagePrimitiveIf: FC<MessagePrimitiveIfProps>;
 
-type MessageContentProps = {
+type MessagePrimitiveContentProps = {
     components?: {
         Text?: TextContentPartComponent;
         Image?: ImageContentPartComponent;
@@ -217,43 +549,49 @@ type MessageContentProps = {
         };
     };
 };
-declare const MessageContent: FC<MessageContentProps>;
+declare const MessagePrimitiveContent: FC<MessagePrimitiveContentProps>;
 
-declare const MessageInProgress: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
+type PrimitiveSpanProps = ComponentPropsWithoutRef<typeof Primitive.span>;
+type MessagePrimitiveInProgressProps = PrimitiveSpanProps;
+declare const MessagePrimitiveInProgress: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
     ref?: ((instance: HTMLSpanElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLSpanElement> | null | undefined;
 } & {
     asChild?: boolean;
 }, "ref"> & react.RefAttributes<HTMLSpanElement>>;
 
 declare namespace index$1 {
-  export { MessageContent as Content, MessageIf as If, MessageInProgress as InProgress, MessageRoot as Root };
+  export { MessagePrimitiveContent as Content, MessagePrimitiveIf as If, MessagePrimitiveInProgress as InProgress, MessagePrimitiveRoot as Root };
 }
 
-declare const ThreadRoot: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+type PrimitiveDivProps$1 = ComponentPropsWithoutRef<typeof Primitive.div>;
+type ThreadPrimitiveRootProps = PrimitiveDivProps$1;
+declare const ThreadPrimitiveRoot: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
     ref?: ((instance: HTMLDivElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLDivElement> | null | undefined;
 } & {
     asChild?: boolean;
 }, "ref"> & react.RefAttributes<HTMLDivElement>>;
 
-type ThreadEmptyProps = {
+type ThreadPrimitiveEmptyProps = {
     children: ReactNode;
 };
-declare const ThreadEmpty: FC<ThreadEmptyProps>;
+declare const ThreadPrimitiveEmpty: FC<ThreadPrimitiveEmptyProps>;
 
-type ThreadIfProps = PropsWithChildren<UseThreadIfProps>;
-declare const ThreadIf: FC<ThreadIfProps>;
+type ThreadPrimitiveIfProps = PropsWithChildren<UseThreadIfProps>;
+declare const ThreadPrimitiveIf: FC<ThreadPrimitiveIfProps>;
 
 type UseThreadViewportAutoScrollProps = {
     autoScroll?: boolean | undefined;
 };
 
-declare const ThreadViewport: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+type PrimitiveDivProps = ComponentPropsWithoutRef<typeof Primitive.div>;
+type ThreadPrimitiveViewportProps = PrimitiveDivProps & UseThreadViewportAutoScrollProps;
+declare const ThreadPrimitiveViewport: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
     ref?: ((instance: HTMLDivElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLDivElement> | null | undefined;
 } & {
     asChild?: boolean;
 }, "ref"> & UseThreadViewportAutoScrollProps & react.RefAttributes<HTMLDivElement>>;
 
-type ThreadMessagesProps = {
+type ThreadPrimitiveMessagesProps = {
     components: {
         Message: ComponentType;
         UserMessage?: ComponentType;
@@ -266,15 +604,17 @@ type ThreadMessagesProps = {
         AssistantMessage: ComponentType;
     };
 };
-declare const ThreadMessages: FC<ThreadMessagesProps>;
+declare const ThreadPrimitiveMessages: FC<ThreadPrimitiveMessagesProps>;
 
-declare const ThreadScrollToBottom: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+type ThreadPrimitiveScrollToBottomProps = ActionButtonProps<typeof useThreadScrollToBottom>;
+declare const ThreadPrimitiveScrollToBottom: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
     ref?: ((instance: HTMLButtonElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLButtonElement> | null | undefined;
 } & {
     asChild?: boolean;
 }, "ref"> & react.RefAttributes<HTMLButtonElement>>;
 
-declare const ThreadSuggestion: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+type ThreadPrimitiveSuggestionProps = ActionButtonProps<typeof useThreadSuggestion>;
+declare const ThreadPrimitiveSuggestion: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
     ref?: ((instance: HTMLButtonElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLButtonElement> | null | undefined;
 } & {
     asChild?: boolean;
@@ -285,61 +625,9 @@ declare const ThreadSuggestion: react.ForwardRefExoticComponent<Omit<Omit<react.
 } & react.RefAttributes<HTMLButtonElement>>;
 
 declare namespace index {
-  export { ThreadEmpty as Empty, ThreadIf as If, ThreadMessages as Messages, ThreadRoot as Root, ThreadScrollToBottom as ScrollToBottom, ThreadSuggestion as Suggestion, ThreadViewport as Viewport };
-}
-
-type ThreadRuntime = Readonly<ThreadState & ThreadActionsState & {
-    subscribe: (callback: () => void) => Unsubscribe;
-}>;
-
-type AssistantRuntime = ThreadRuntime & {
-    registerModelConfigProvider: (provider: ModelConfigProvider) => Unsubscribe;
-};
-
-type ReactThreadRuntime = ThreadRuntime & {
-    unstable_synchronizer?: ComponentType;
-};
-
-type ChatModelRunResult = {
-    content: AssistantContentPart[];
-};
-type ChatModelRunOptions = {
-    messages: ThreadMessage[];
-    abortSignal: AbortSignal;
-    config: ModelConfig;
-    onUpdate: (result: ChatModelRunResult) => void;
-};
-type ChatModelAdapter = {
-    run: (options: ChatModelRunOptions) => Promise<ChatModelRunResult>;
-};
-
-declare class LocalRuntime implements AssistantRuntime {
-    adapter: ChatModelAdapter;
-    private _subscriptions;
-    private _configProviders;
-    private abortController;
-    private repository;
-    get messages(): ThreadMessage[];
-    get isRunning(): boolean;
-    constructor(adapter: ChatModelAdapter);
-    getBranches(messageId: string): string[];
-    switchToBranch(branchId: string): void;
-    append(message: AppendMessage): Promise<void>;
-    startRun(parentId: string | null): Promise<void>;
-    cancelRun(): void;
-    private notifySubscribers;
-    subscribe(callback: () => void): Unsubscribe;
-    registerModelConfigProvider(provider: ModelConfigProvider): () => boolean;
-    addToolResult(): void;
+  export { ThreadPrimitiveEmpty as Empty, ThreadPrimitiveIf as If, ThreadPrimitiveMessages as Messages, ThreadPrimitiveRoot as Root, ThreadPrimitiveScrollToBottom as ScrollToBottom, ThreadPrimitiveSuggestion as Suggestion, ThreadPrimitiveViewport as Viewport };
 }
 
-declare const useLocalRuntime: (adapter: ChatModelAdapter) => LocalRuntime;
-
-type AssistantRuntimeProviderProps = {
-    runtime: AssistantRuntime;
-};
-declare const AssistantRuntimeProvider: react.NamedExoticComponent<PropsWithChildren<AssistantRuntimeProviderProps>>;
-
 declare class ProxyConfigProvider {
     private _providers;
     getModelConfig(): ModelConfig;
@@ -360,12 +648,14 @@ declare class MessageRepository {
     resetHead(messageId: string | null): void;
 }
 
+type internal_BaseAssistantRuntime<TThreadRuntime extends ReactThreadRuntime> = BaseAssistantRuntime<TThreadRuntime>;
+declare const internal_BaseAssistantRuntime: typeof BaseAssistantRuntime;
 type internal_MessageRepository = MessageRepository;
 declare const internal_MessageRepository: typeof MessageRepository;
 type internal_ProxyConfigProvider = ProxyConfigProvider;
 declare const internal_ProxyConfigProvider: typeof ProxyConfigProvider;
 declare namespace internal {
-  export { internal_MessageRepository as MessageRepository, internal_ProxyConfigProvider as ProxyConfigProvider };
+  export { internal_BaseAssistantRuntime as BaseAssistantRuntime, internal_MessageRepository as MessageRepository, internal_ProxyConfigProvider as ProxyConfigProvider };
 }
 
-export { index$6 as ActionBarPrimitive, AppendMessage, AssistantContentPart, index$5 as AssistantModalPrimitive, type AssistantRuntime, AssistantRuntimeProvider, index$4 as BranchPickerPrimitive, type ChatModelAdapter, type ChatModelRunOptions, index$3 as ComposerPrimitive, index$2 as ContentPartPrimitive, internal as INTERNAL, index$1 as MessagePrimitive, type ReactThreadRuntime, ThreadMessage, index as ThreadPrimitive, type ThreadRuntime, Unsubscribe, useActionBarCopy, useActionBarEdit, useActionBarReload, useBranchPickerCount, useBranchPickerNext, useBranchPickerNumber, useBranchPickerPrevious, useComposerCancel, useComposerIf, useComposerSend, useContentPartDisplay, useContentPartImage, useContentPartInProgressIndicator, useContentPartText, useLocalRuntime, useMessageIf, useThreadEmpty, useThreadIf, useThreadScrollToBottom, useThreadSuggestion };
+export { index$6 as ActionBarPrimitive, type ActionBarPrimitiveCopyProps, type ActionBarPrimitiveEditProps, type ActionBarPrimitiveReloadProps, type ActionBarPrimitiveRootProps, type AppendContentPart, type AppendMessage, type AssistantContentPart, type AssistantContextValue, type AssistantMessage, index$5 as AssistantModalPrimitive, type AssistantModalPrimitiveContentProps, type AssistantModalPrimitiveRootProps, type AssistantModalPrimitiveTriggerProps, type AssistantModelConfigState, type AssistantRuntime, AssistantRuntimeProvider, type AssistantToolProps, type AssistantToolUIProps, index$4 as BranchPickerPrimitive, type BranchPickerPrimitiveCountProps, type BranchPickerPrimitiveNextProps, type BranchPickerPrimitiveNumberProps, type BranchPickerPrimitivePreviousProps, type BranchPickerPrimitiveRootProps, type ChatModelAdapter, type ChatModelRunOptions, type ComposerContextValue, index$3 as ComposerPrimitive, type ComposerPrimitiveCancelProps, type ComposerPrimitiveIfProps, type ComposerPrimitiveInputProps, type ComposerPrimitiveRootProps, type ComposerPrimitiveSendProps, type ComposerState, type ContentPartContextValue, index$2 as ContentPartPrimitive, type ContentPartPrimitiveDisplayProps, type ContentPartPrimitiveImageProps, type ContentPartPrimitiveInProgressIndicatorProps, type ContentPartPrimitiveTextProps, type ContentPartState, type EditComposerState, internal as INTERNAL, type ImageContentPart, type ImageContentPartComponent, type ImageContentPartProps, type MessageContextValue, index$1 as MessagePrimitive, type MessagePrimitiveContentProps, type MessagePrimitiveIfProps, type MessagePrimitiveInProgressProps, type MessagePrimitiveRootProps, type MessageState, type ModelConfig, type ModelConfigProvider, type ReactThreadRuntime, type TextContentPart, type TextContentPartComponent, type TextContentPartProps, type ThreadContextValue, type ThreadMessage, index as ThreadPrimitive, type ThreadPrimitiveEmptyProps, type ThreadPrimitiveIfProps, type ThreadPrimitiveMessagesProps, type ThreadPrimitiveRootProps, type ThreadPrimitiveScrollToBottomProps, type ThreadPrimitiveSuggestionProps, type ThreadPrimitiveViewportProps, type ThreadRuntime, type ThreadState, type ThreadViewportState, type ToolCallContentPart, type ToolCallContentPartComponent, type ToolCallContentPartProps, type UIContentPart, type UIContentPartComponent, type UIContentPartProps, type Unsubscribe, type UserContentPart, type UserMessage, makeAssistantTool, makeAssistantToolUI, useActionBarCopy, useActionBarEdit, useActionBarReload, useAppendMessage, useAssistantContext, useAssistantInstructions, useAssistantTool, useAssistantToolUI, useBranchPickerCount, useBranchPickerNext, useBranchPickerNumber, useBranchPickerPrevious, useComposerCancel, useComposerContext, useComposerIf, useComposerSend, useContentPartContext, useContentPartDisplay, useContentPartImage, useContentPartInProgressIndicator, useContentPartText, useLocalRuntime, useMessageContext, useMessageIf, useSwitchToNewThread, useThreadContext, useThreadEmpty, useThreadIf, useThreadScrollToBottom, useThreadSuggestion };