@assistant-ui/react 0.1.11 → 0.2.0

package/dist/index.d.ts

@@ -1,10 +1,10 @@
 import * as react from 'react';
-import { FC, ReactNode, PropsWithChildren, ComponentType, ComponentPropsWithoutRef } from 'react';
+import { FC, PropsWithChildren, ComponentPropsWithoutRef, ReactNode, ComponentType } from 'react';
+import * as PopoverPrimitive from '@radix-ui/react-popover';
 import { TextareaAutosizeProps } from 'react-textarea-autosize';
-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 { Primitive } from '@radix-ui/react-primitive';
-import 'zod';
+import { z } from 'zod';
+import { UseBoundStore, StoreApi } from 'zustand';
 
 type UseActionBarCopyProps = {
     copiedDuration?: number;
@@ -73,63 +73,80 @@ type UseApplyThreadSuggestionProps = {
 };
 declare const useThreadSuggestion: ({ prompt, autoSend, }: UseApplyThreadSuggestionProps) => (() => void) | null;
 
-declare const ThreadRoot: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+type UseActionBarFloatStatusProps = {
+    hideWhenRunning?: boolean | undefined;
+    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"> & {
     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 = {
-    children: ReactNode;
-};
-declare const ThreadEmpty: FC<ThreadEmptyProps>;
+}, "ref"> & UseActionBarFloatStatusProps & react.RefAttributes<HTMLDivElement>>;
 
-type ThreadIfProps = PropsWithChildren<UseThreadIfProps>;
-declare const ThreadIf: FC<ThreadIfProps>;
+declare const ActionBarCopy: 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"> & {
+    copiedDuration?: number;
+} & react.RefAttributes<HTMLButtonElement>>;
 
-type UseThreadViewportAutoScrollProps = {
-    autoScroll?: boolean | undefined;
-};
+declare const ActionBarReload: 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 ThreadViewport: 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;
+declare const ActionBarEdit: 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"> & UseThreadViewportAutoScrollProps & react.RefAttributes<HTMLDivElement>>;
+}, "ref"> & react.RefAttributes<HTMLButtonElement>>;
 
-type ThreadMessagesProps = {
-    components: {
-        Message: ComponentType;
-        UserMessage?: ComponentType;
-        EditComposer?: ComponentType;
-        AssistantMessage?: ComponentType;
-    } | {
-        Message?: ComponentType;
-        UserMessage: ComponentType;
-        EditComposer?: ComponentType;
-        AssistantMessage: ComponentType;
-    };
-};
-declare const ThreadMessages: FC<ThreadMessagesProps>;
+declare namespace index$6 {
+  export { ActionBarCopy as Copy, ActionBarEdit as Edit, ActionBarReload as Reload, ActionBarRoot as Root };
+}
 
-declare const ThreadScrollToBottom: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+type AssistantModalRootProps = PopoverPrimitive.PopoverProps;
+declare const AssistantModalRoot: FC<AssistantModalRootProps>;
+
+declare const AssistantModalTrigger: react.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverTriggerProps & react.RefAttributes<HTMLButtonElement>, "ref"> & react.RefAttributes<HTMLButtonElement>>;
+
+declare const AssistantModalContent: 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 };
+}
+
+declare const BranchPickerNext: 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"> & {
+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;
+
+declare const BranchPickerNumber: FC;
+
+declare const BranchPickerRoot: 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"> & {
-    prompt: string;
-    method: "replace";
-    autoSend?: boolean;
-} & react.RefAttributes<HTMLButtonElement>>;
+    hideWhenSingleBranch?: boolean;
+} & react.RefAttributes<HTMLDivElement>>;
 
-declare namespace index$5 {
-  export { ThreadEmpty as Empty, ThreadIf as If, ThreadMessages as Messages, ThreadRoot as Root, ThreadScrollToBottom as ScrollToBottom, ThreadSuggestion as Suggestion, ThreadViewport as Viewport };
+declare namespace index$4 {
+  export { BranchPickerCount as Count, BranchPickerNext as Next, BranchPickerNumber as Number, BranchPickerPrevious as Previous, BranchPickerRoot as Root };
 }
 
 declare const ComposerRoot: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.FormHTMLAttributes<HTMLFormElement>, HTMLFormElement>, "ref"> & {
@@ -157,10 +174,28 @@ declare const ComposerCancel: react.ForwardRefExoticComponent<Omit<Omit<react.De
 type ComposerIfProps = PropsWithChildren<UseComposerIfProps>;
 declare const ComposerIf: FC<ComposerIfProps>;
 
-declare namespace index$4 {
+declare namespace index$3 {
   export { ComposerCancel as Cancel, ComposerIf as If, ComposerInput as Input, ComposerRoot as Root, ComposerSend as Send };
 }
 
+declare const ContentPartInProgressIndicator: FC;
+
+type PrimitiveSpanProps = ComponentPropsWithoutRef<typeof Primitive.p>;
+type ContentPartTextProps = Omit<PrimitiveSpanProps, "children">;
+declare const ContentPartText: react.ForwardRefExoticComponent<ContentPartTextProps & react.RefAttributes<HTMLParagraphElement>>;
+
+declare const ContentPartImage: 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;
+
+declare namespace index$2 {
+  export { ContentPartDisplay as Display, ContentPartImage as Image, ContentPartInProgressIndicator as InProgressIndicator, ContentPartText as Text };
+}
+
 declare const MessageRoot: 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;
 } & {
@@ -170,6 +205,71 @@ declare const MessageRoot: react.ForwardRefExoticComponent<Omit<Omit<react.Detai
 type MessageIfProps = PropsWithChildren<UseMessageIfProps>;
 declare const MessageIf: FC<MessageIfProps>;
 
+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 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 MessageContentProps = {
     components?: {
         Text?: TextContentPartComponent;
@@ -189,90 +289,193 @@ declare const MessageInProgress: react.ForwardRefExoticComponent<Omit<Omit<react
     asChild?: boolean;
 }, "ref"> & react.RefAttributes<HTMLSpanElement>>;
 
-declare namespace index$3 {
+declare namespace index$1 {
   export { MessageContent as Content, MessageIf as If, MessageInProgress as InProgress, MessageRoot as Root };
 }
 
-declare const BranchPickerNext: 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;
+declare const ThreadRoot: 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<HTMLButtonElement>>;
+}, "ref"> & react.RefAttributes<HTMLDivElement>>;
 
-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>>;
+type ThreadEmptyProps = {
+    children: ReactNode;
+};
+declare const ThreadEmpty: FC<ThreadEmptyProps>;
 
-declare const BranchPickerCount: FC;
+type ThreadIfProps = PropsWithChildren<UseThreadIfProps>;
+declare const ThreadIf: FC<ThreadIfProps>;
 
-declare const BranchPickerNumber: FC;
+type UseThreadViewportAutoScrollProps = {
+    autoScroll?: boolean | undefined;
+};
 
-declare const BranchPickerRoot: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+declare const ThreadViewport: 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"> & {
-    hideWhenSingleBranch?: boolean;
-} & react.RefAttributes<HTMLDivElement>>;
-
-declare namespace index$2 {
-  export { BranchPickerCount as Count, BranchPickerNext as Next, BranchPickerNumber as Number, BranchPickerPrevious as Previous, BranchPickerRoot as Root };
-}
+}, "ref"> & UseThreadViewportAutoScrollProps & react.RefAttributes<HTMLDivElement>>;
 
-type UseActionBarFloatStatusProps = {
-    hideWhenRunning?: boolean | undefined;
-    autohide?: "always" | "not-last" | "never" | undefined;
-    autohideFloat?: "always" | "single-branch" | "never" | undefined;
+type ThreadMessagesProps = {
+    components: {
+        Message: ComponentType;
+        UserMessage?: ComponentType;
+        EditComposer?: ComponentType;
+        AssistantMessage?: ComponentType;
+    } | {
+        Message?: ComponentType;
+        UserMessage: ComponentType;
+        EditComposer?: ComponentType;
+        AssistantMessage: ComponentType;
+    };
 };
-declare const ActionBarRoot: 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"> & {
-    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"> & {
-    copiedDuration?: number;
-} & react.RefAttributes<HTMLButtonElement>>;
+declare const ThreadMessages: FC<ThreadMessagesProps>;
 
-declare const ActionBarReload: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+declare const ThreadScrollToBottom: 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"> & {
+declare const ThreadSuggestion: 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>>;
+}, "ref"> & {
+    prompt: string;
+    method: "replace";
+    autoSend?: boolean;
+} & react.RefAttributes<HTMLButtonElement>>;
 
-declare namespace index$1 {
-  export { ActionBarCopy as Copy, ActionBarEdit as Edit, ActionBarReload as Reload, ActionBarRoot as Root };
+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 };
 }
 
-declare const ContentPartInProgressIndicator: FC;
+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 PrimitiveSpanProps = ComponentPropsWithoutRef<typeof Primitive.span>;
-type ContentPartTextProps = Omit<PrimitiveSpanProps, "children">;
-declare const ContentPartText: react.ForwardRefExoticComponent<ContentPartTextProps & react.RefAttributes<HTMLSpanElement>>;
+type Unsubscribe = () => void;
 
-declare const ContentPartImage: 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>>;
+type AssistantRuntimeProviderProps = {
+    runtime: AssistantRuntime;
+};
+declare const AssistantRuntimeProvider: react.NamedExoticComponent<PropsWithChildren<AssistantRuntimeProviderProps>>;
 
-declare const ContentPartDisplay: FC;
+type AssistantModelConfigState = Readonly<{
+    getModelConfig: ModelConfigProvider;
+    registerModelConfigProvider: (provider: ModelConfigProvider) => () => void;
+}>;
 
-declare namespace index {
-  export { ContentPartDisplay as Display, ContentPartImage as Image, ContentPartInProgressIndicator as InProgressIndicator, ContentPartText as Text };
-}
+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 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 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 AssistantToolUIsState = Readonly<{
+    getToolUI: (toolName: string) => ToolCallContentPartComponent | null;
+    setToolUI: (toolName: string, render: ToolCallContentPartComponent) => () => void;
+}>;
+
+type AssistantContextValue = {
+    useModelConfig: ReadonlyStore<AssistantModelConfigState>;
+    useToolUIs: ReadonlyStore<AssistantToolUIsState>;
+};
+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 ThreadRuntime = Readonly<ThreadState & ThreadActionsState & {
     subscribe: (callback: () => void) => Unsubscribe;
@@ -321,10 +524,23 @@ declare class LocalRuntime implements AssistantRuntime {
 
 declare const useLocalRuntime: (adapter: ChatModelAdapter) => LocalRuntime;
 
-type AssistantRuntimeProviderProps = {
-    runtime: AssistantRuntime;
+type AssistantToolProps<TArgs, TResult> = Tool<TArgs, TResult> & {
+    toolName: string;
+    render?: ToolCallContentPartComponent<TArgs, TResult>;
 };
-declare const AssistantRuntimeProvider: react.NamedExoticComponent<PropsWithChildren<AssistantRuntimeProviderProps>>;
+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;
 
 declare class ProxyConfigProvider {
     private _providers;
@@ -354,4 +570,4 @@ declare namespace internal {
   export { internal_MessageRepository as MessageRepository, internal_ProxyConfigProvider as ProxyConfigProvider };
 }
 
-export { index$1 as ActionBarPrimitive, AppendMessage, AssistantContentPart, type AssistantRuntime, AssistantRuntimeProvider, index$2 as BranchPickerPrimitive, type ChatModelAdapter, type ChatModelRunOptions, index$4 as ComposerPrimitive, index as ContentPartPrimitive, internal as INTERNAL, index$3 as MessagePrimitive, type ReactThreadRuntime, ThreadMessage, index$5 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 AppendContentPart, type AppendMessage, type AssistantContentPart, type AssistantContextValue, type AssistantMessage, index$5 as AssistantModalPrimitive, type AssistantModelConfigState, type AssistantRuntime, AssistantRuntimeProvider, type AssistantToolProps, type AssistantToolUIProps, index$4 as BranchPickerPrimitive, type ChatModelAdapter, type ChatModelRunOptions, type ComposerContextValue, index$3 as ComposerPrimitive, type ComposerState, type ContentPartContextValue, index$2 as ContentPartPrimitive, type ContentPartState, type EditComposerState, internal as INTERNAL, type ImageContentPart, type ImageContentPartComponent, type ImageContentPartProps, type MessageContextValue, index$1 as MessagePrimitive, type MessageState, type ModelConfig, type ReactThreadRuntime, type TextContentPart, type TextContentPartComponent, type TextContentPartProps, type ThreadContextValue, type ThreadMessage, index as ThreadPrimitive, 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, useAssistantContext, useAssistantInstructions, useAssistantTool, useAssistantToolUI, useBranchPickerCount, useBranchPickerNext, useBranchPickerNumber, useBranchPickerPrevious, useComposerCancel, useComposerContext, useComposerIf, useComposerSend, useContentPartContext, useContentPartDisplay, useContentPartImage, useContentPartInProgressIndicator, useContentPartText, useLocalRuntime, useMessageContext, useMessageIf, useThreadContext, useThreadEmpty, useThreadIf, useThreadScrollToBottom, useThreadSuggestion };