@assistant-ui/react 0.1.4 → 0.1.6

package/dist/index.d.ts

@@ -0,0 +1,319 @@
+import * as react from 'react';
+import { FC, ReactNode, PropsWithChildren, ComponentType } from 'react';
+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 Unsubscribe, M as ModelConfigProvider, e as ThreadMessage, f as ModelConfig, A as AssistantContentPart, g as AppendMessage } from './Thread-ZUDFhMtm.js';
+export { k as AppendContentPart, h as AssistantMessage, l as TextContentPart, j as UserContentPart, i as UserMessage } from './Thread-ZUDFhMtm.js';
+import { ComponentPropsWithoutRef, Primitive } from '@radix-ui/react-primitive';
+import 'zod';
+
+declare const useCopyMessage: ({ copiedDuration }: {
+    copiedDuration?: number | undefined;
+}) => (() => void) | null;
+
+declare const useReloadMessage: () => (() => void) | null;
+
+declare const useBeginMessageEdit: () => (() => void) | null;
+
+declare const useGoToNextBranch: () => (() => void) | null;
+
+declare const useGoToPreviousBranch: () => (() => void) | null;
+
+declare const ThreadRoot: react.ForwardRefExoticComponent<Pick<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void) | react.RefObject<HTMLDivElement> | null | undefined;
+} & {
+    asChild?: boolean;
+}, "key" | keyof react.HTMLAttributes<HTMLDivElement> | "asChild"> & react.RefAttributes<HTMLDivElement>>;
+
+type ThreadEmptyProps = {
+    children: ReactNode;
+};
+declare const ThreadEmpty: FC<ThreadEmptyProps>;
+
+type RequireAtLeastOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> & {
+    [K in Keys]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<Keys, K>>>;
+}[Keys];
+
+type ThreadIfFilters = {
+    empty: boolean | undefined;
+    running: boolean | undefined;
+};
+type ThreadIfProps = PropsWithChildren<RequireAtLeastOne<ThreadIfFilters>>;
+declare const ThreadIf: FC<ThreadIfProps>;
+
+declare const ThreadViewport: react.ForwardRefExoticComponent<Pick<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void) | react.RefObject<HTMLDivElement> | null | undefined;
+} & {
+    asChild?: boolean;
+}, "key" | keyof react.HTMLAttributes<HTMLDivElement> | "asChild"> & {
+    autoScroll?: boolean;
+} & react.RefAttributes<HTMLDivElement>>;
+
+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 const ThreadScrollToBottom: react.ForwardRefExoticComponent<Pick<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+    ref?: ((instance: HTMLButtonElement | null) => void) | react.RefObject<HTMLButtonElement> | null | undefined;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof react.ButtonHTMLAttributes<HTMLButtonElement>> & react.RefAttributes<HTMLButtonElement>>;
+
+declare const ThreadSuggestion: react.ForwardRefExoticComponent<Pick<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+    ref?: ((instance: HTMLButtonElement | null) => void) | react.RefObject<HTMLButtonElement> | null | undefined;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof react.ButtonHTMLAttributes<HTMLButtonElement>> & {
+    prompt: string;
+    method: "replace";
+    autoSend?: boolean;
+} & react.RefAttributes<HTMLButtonElement>>;
+
+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 const ComposerRoot: react.ForwardRefExoticComponent<Pick<Omit<react.DetailedHTMLProps<react.FormHTMLAttributes<HTMLFormElement>, HTMLFormElement>, "ref"> & {
+    ref?: ((instance: HTMLFormElement | null) => void) | react.RefObject<HTMLFormElement> | null | undefined;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof react.FormHTMLAttributes<HTMLFormElement>> & react.RefAttributes<HTMLFormElement>>;
+
+declare const ComposerInput: react.ForwardRefExoticComponent<TextareaAutosizeProps & {
+    asChild?: boolean;
+} & react.RefAttributes<HTMLTextAreaElement>>;
+
+declare const ComposerSend: react.ForwardRefExoticComponent<Pick<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+    ref?: ((instance: HTMLButtonElement | null) => void) | react.RefObject<HTMLButtonElement> | null | undefined;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof react.ButtonHTMLAttributes<HTMLButtonElement>> & react.RefAttributes<HTMLButtonElement>>;
+
+declare const ComposerCancel: react.ForwardRefExoticComponent<Pick<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+    ref?: ((instance: HTMLButtonElement | null) => void) | react.RefObject<HTMLButtonElement> | null | undefined;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof react.ButtonHTMLAttributes<HTMLButtonElement>> & react.RefAttributes<HTMLButtonElement>>;
+
+type ComposerIfFilters = {
+    editing: boolean | undefined;
+};
+type ComposerIfProps = PropsWithChildren<RequireAtLeastOne<ComposerIfFilters>>;
+declare const ComposerIf: FC<ComposerIfProps>;
+
+declare namespace index$4 {
+  export { ComposerCancel as Cancel, ComposerIf as If, ComposerInput as Input, ComposerRoot as Root, ComposerSend as Send };
+}
+
+declare const MessageRoot: react.ForwardRefExoticComponent<Pick<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void) | react.RefObject<HTMLDivElement> | null | undefined;
+} & {
+    asChild?: boolean;
+}, "key" | keyof react.HTMLAttributes<HTMLDivElement> | "asChild"> & react.RefAttributes<HTMLDivElement>>;
+
+type MessageIfFilters = {
+    user: boolean | undefined;
+    assistant: boolean | undefined;
+    hasBranches: boolean | undefined;
+    copied: boolean | undefined;
+    lastOrHover: boolean | undefined;
+};
+type MessageIfProps = RequireAtLeastOne<MessageIfFilters> & {
+    children: ReactNode;
+};
+declare const MessageIf: FC<MessageIfProps>;
+
+type MessageContentProps = {
+    components?: {
+        Text?: TextContentPartComponent;
+        Image?: ImageContentPartComponent;
+        UI?: UIContentPartComponent;
+        tools?: {
+            by_name?: Record<string, ToolCallContentPartComponent>;
+            Fallback?: ComponentType<ToolCallContentPartProps>;
+        };
+    };
+};
+declare const MessageContent: FC<MessageContentProps>;
+
+declare const MessageInProgress: react.ForwardRefExoticComponent<Pick<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
+    ref?: ((instance: HTMLSpanElement | null) => void) | react.RefObject<HTMLSpanElement> | null | undefined;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof react.HTMLAttributes<HTMLSpanElement>> & react.RefAttributes<HTMLSpanElement>>;
+
+declare namespace index$3 {
+  export { MessageContent as Content, MessageIf as If, MessageInProgress as InProgress, MessageRoot as Root };
+}
+
+declare const BranchPickerNext: react.ForwardRefExoticComponent<Pick<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+    ref?: ((instance: HTMLButtonElement | null) => void) | react.RefObject<HTMLButtonElement> | null | undefined;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof react.ButtonHTMLAttributes<HTMLButtonElement>> & react.RefAttributes<HTMLButtonElement>>;
+
+declare const BranchPickerPrevious: react.ForwardRefExoticComponent<Pick<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+    ref?: ((instance: HTMLButtonElement | null) => void) | react.RefObject<HTMLButtonElement> | null | undefined;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof react.ButtonHTMLAttributes<HTMLButtonElement>> & react.RefAttributes<HTMLButtonElement>>;
+
+declare const BranchPickerCount: FC;
+
+declare const BranchPickerNumber: FC;
+
+declare const BranchPickerRoot: react.ForwardRefExoticComponent<Pick<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void) | react.RefObject<HTMLDivElement> | null | undefined;
+} & {
+    asChild?: boolean;
+}, "key" | keyof react.HTMLAttributes<HTMLDivElement> | "asChild"> & {
+    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 };
+}
+
+declare const ActionBarRoot: react.ForwardRefExoticComponent<Pick<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void) | react.RefObject<HTMLDivElement> | null | undefined;
+} & {
+    asChild?: boolean;
+}, "key" | keyof react.HTMLAttributes<HTMLDivElement> | "asChild"> & {
+    hideWhenRunning?: boolean;
+    autohide?: "always" | "not-last" | "never";
+    autohideFloat?: "always" | "single-branch" | "never";
+} & react.RefAttributes<HTMLDivElement>>;
+
+type ActionBarCopyProps = {
+    copiedDuration?: number;
+};
+declare const ActionBarCopy: react.ForwardRefExoticComponent<Pick<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+    ref?: ((instance: HTMLButtonElement | null) => void) | react.RefObject<HTMLButtonElement> | null | undefined;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof react.ButtonHTMLAttributes<HTMLButtonElement>> & ActionBarCopyProps & react.RefAttributes<HTMLButtonElement>>;
+
+declare const ActionBarReload: react.ForwardRefExoticComponent<Pick<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+    ref?: ((instance: HTMLButtonElement | null) => void) | react.RefObject<HTMLButtonElement> | null | undefined;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof react.ButtonHTMLAttributes<HTMLButtonElement>> & react.RefAttributes<HTMLButtonElement>>;
+
+declare const ActionBarEdit: react.ForwardRefExoticComponent<Pick<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+    ref?: ((instance: HTMLButtonElement | null) => void) | react.RefObject<HTMLButtonElement> | null | undefined;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof react.ButtonHTMLAttributes<HTMLButtonElement>> & react.RefAttributes<HTMLButtonElement>>;
+
+declare namespace index$1 {
+  export { ActionBarCopy as Copy, ActionBarEdit as Edit, ActionBarReload as Reload, ActionBarRoot as Root };
+}
+
+declare const ContentPartInProgressIndicator: FC;
+
+type PrimitiveSpanProps = ComponentPropsWithoutRef<typeof Primitive.span>;
+type ContentPartTextProps = Omit<PrimitiveSpanProps, "children">;
+declare const ContentPartText: react.ForwardRefExoticComponent<ContentPartTextProps & react.RefAttributes<HTMLSpanElement>>;
+
+declare const ContentPartImage: react.ForwardRefExoticComponent<Pick<Omit<react.DetailedHTMLProps<react.ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>, "ref"> & {
+    ref?: ((instance: HTMLImageElement | null) => void) | react.RefObject<HTMLImageElement> | null | undefined;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof react.ImgHTMLAttributes<HTMLImageElement>> & react.RefAttributes<HTMLImageElement>>;
+
+declare const ContentPartDisplay: FC;
+
+declare namespace index {
+  export { ContentPartDisplay as Display, ContentPartImage as Image, ContentPartInProgressIndicator as InProgressIndicator, ContentPartText as Text };
+}
+
+type ThreadRuntime = Readonly<ThreadState & {
+    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;
+}
+
+declare const useLocalRuntime: (adapter: ChatModelAdapter) => LocalRuntime;
+
+type AssistantRuntimeProviderProps = {
+    runtime: AssistantRuntime;
+};
+declare const AssistantRuntimeProvider: react.NamedExoticComponent<PropsWithChildren<AssistantRuntimeProviderProps>>;
+
+declare class ProxyConfigProvider {
+    private _providers;
+    getModelConfig(): ModelConfig;
+    registerModelConfigProvider(provider: ModelConfigProvider): () => void;
+}
+
+declare class MessageRepository {
+    private messages;
+    private head;
+    private root;
+    private performOp;
+    getMessages(): ThreadMessage[];
+    addOrUpdateMessage(parentId: string | null, message: ThreadMessage): void;
+    appendOptimisticMessage(parentId: string | null, message: Omit<ThreadMessage, "id" | "createdAt">): string;
+    deleteMessage(messageId: string, replacementId?: string | null | undefined): void;
+    getBranches(messageId: string): string[];
+    switchToBranch(messageId: string): void;
+    resetHead(messageId: string | null): void;
+}
+
+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 { 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, useBeginMessageEdit, useCopyMessage, useGoToNextBranch, useGoToPreviousBranch, useLocalRuntime, useReloadMessage };