@assistant-ui/react 0.0.19 → 0.0.21

package/dist/index.d.ts

@@ -2,10 +2,22 @@ import * as react from 'react';
 import { FC, ReactNode, PropsWithChildren, ComponentType } from 'react';
 import { TextareaAutosizeProps } from 'react-textarea-autosize';
 import { UseChatHelpers, UseAssistantHelpers } from 'ai/react';
+import { Message, LanguageModel } from 'ai';
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import { LanguageModel, Message } from 'ai';
 import { UseBoundStore, StoreApi } from 'zustand';
 
+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;
 } & {
@@ -103,16 +115,23 @@ declare namespace index$4 {
   export { ComposerCancel as Cancel, ComposerIf as If, ComposerInput as Input, ComposerRoot as Root, ComposerSend as Send };
 }
 
-type BaseComposerState = Readonly<{
-    value: string;
-    setValue: (value: string) => void;
-}>;
-type MessageComposerState = BaseComposerState & Readonly<{
-    isEditing: boolean;
-    edit: () => void;
-    send: () => void;
-    cancel: () => boolean;
-}>;
+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 TextContentPart = {
     type: "text";
@@ -154,30 +173,6 @@ type AppendMessage = {
 };
 type ThreadMessage = UserMessage | AssistantMessage;
 
-type MessageProviderProps = PropsWithChildren<{
-    message: ThreadMessage;
-    parentId: string | null;
-}>;
-declare const MessageProvider: FC<MessageProviderProps>;
-
-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?: ComponentType<{
@@ -201,14 +196,14 @@ type MessageContentProps = {
 };
 declare const MessageContent: FC<MessageContentProps>;
 
-declare const MessageInProgress: react.ForwardRefExoticComponent<Pick<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
-    ref?: ((instance: HTMLDivElement | null) => void) | react.RefObject<HTMLDivElement> | null | undefined;
+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" | keyof react.HTMLAttributes<HTMLDivElement> | "asChild"> & react.RefAttributes<HTMLDivElement>>;
+}, "key" | "asChild" | keyof react.HTMLAttributes<HTMLSpanElement>> & react.RefAttributes<HTMLSpanElement>>;
 
 declare namespace index$3 {
-  export { MessageContent as Content, MessageIf as If, MessageInProgress as InProgress, MessageProvider as Provider, MessageRoot as Root };
+  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"> & {
@@ -274,64 +269,124 @@ declare namespace index$1 {
   export { ActionBarCopy as Copy, ActionBarEdit as Edit, ActionBarReload as Reload, ActionBarRoot as Root };
 }
 
-type ContentPartProviderProps = PropsWithChildren<{
-    part: ThreadMessage["content"][number];
-    status: "in_progress" | "done" | "error";
-}>;
-declare const ContentPartProvider: FC<ContentPartProviderProps>;
-
 declare const ContentPartInProgressIndicator: FC;
 
 declare namespace index {
-  export { ContentPartInProgressIndicator as InProgressIndicator, ContentPartProvider as Provider };
+  export { ContentPartInProgressIndicator as InProgressIndicator };
 }
 
-type VercelAIAssistantProviderProps = PropsWithChildren<{
-    chat: UseChatHelpers;
-} | {
-    assistant: UseAssistantHelpers;
-}>;
-declare const VercelAIAssistantProvider: FC<VercelAIAssistantProviderProps>;
-
 type VercelRSCMessage = {
     id: string;
     role: "user" | "assistant";
     display: ReactNode;
     createdAt?: Date;
 };
-type VercelRSCAssistantProviderBaseProps<T> = PropsWithChildren<{
+
+type RSCMessageConverter<T> = {
+    convertMessage: (message: T) => VercelRSCMessage;
+};
+type VercelRSCAdapterBase<T> = {
     messages: T[];
     append: (message: AppendMessage) => Promise<void>;
     edit?: (message: AppendMessage) => Promise<void>;
     reload?: (parentId: string | null) => Promise<void>;
     convertMessage?: (message: T) => VercelRSCMessage;
-}>;
-type RSCMessageConverter<T> = {
-    convertMessage: (message: T) => VercelRSCMessage;
 };
-type VercelRSCAssistantProviderProps<T = VercelRSCMessage> = VercelRSCAssistantProviderBaseProps<T> & (T extends VercelRSCMessage ? object : RSCMessageConverter<T>);
-declare const VercelRSCAssistantProvider: <T extends WeakKey = VercelRSCMessage>({ children, convertMessage, messages: vercelMessages, append: appendCallback, edit, reload, }: VercelRSCAssistantProviderProps<T>) => react_jsx_runtime.JSX.Element;
+type VercelRSCAdapter<T = VercelRSCMessage> = VercelRSCAdapterBase<T> & (T extends VercelRSCMessage ? object : RSCMessageConverter<T>);
 
-type MessageUpdateCallback = (parentId: string | null, message: ThreadMessage) => void;
-type StatusUpdateCallback = (isRunning: boolean) => void;
-type Unsubscribe = () => void;
-type ThreadRuntime = {
-    append(message: AppendMessage): Promise<{
-        parentId: string;
-        id: string;
-    }>;
-    startRun(parentId: string | null): Promise<{
-        id: string;
-    }>;
-    cancelRun(): void;
-    subscribeToMessageUpdates(callback: MessageUpdateCallback): Unsubscribe;
-    subscribeToStatusUpdates(callback: StatusUpdateCallback): Unsubscribe;
+type ThreadState = {
+    messages: ThreadMessage[];
+    isRunning: boolean;
+    getBranches: (messageId: string) => readonly string[];
+    switchToBranch: (branchId: string) => void;
+    append: (message: AppendMessage) => void;
+    startRun: (parentId: string | null) => void;
+    cancelRun: () => void;
 };
 
-type AssistantProviderProps = {
-    runtime: ThreadRuntime;
+type Unsubscribe = () => void;
+type ThreadRuntime = Readonly<ThreadState> & {
+    subscribe: (callback: () => void) => Unsubscribe;
+};
+type ReactThreadRuntime = Readonly<ThreadState> & {
+    unstable_synchronizer?: ComponentType;
 };
-declare const AssistantProvider: FC<PropsWithChildren<AssistantProviderProps>>;
+
+type AssistantRuntime = ThreadRuntime;
+
+declare class VercelRSCRuntime<T extends WeakKey = VercelRSCMessage> implements AssistantRuntime, ReactThreadRuntime {
+    adapter: VercelRSCAdapter<T>;
+    private useAdapter;
+    private _subscriptions;
+    isRunning: boolean;
+    messages: ThreadMessage[];
+    constructor(adapter: VercelRSCAdapter<T>);
+    private withRunning;
+    getBranches(): readonly string[];
+    switchToBranch(): void;
+    append(message: AppendMessage): Promise<void>;
+    startRun(parentId: string | null): Promise<void>;
+    cancelRun(): void;
+    subscribe(callback: () => void): Unsubscribe;
+    onAdapterUpdated(): void;
+    private updateData;
+    unstable_synchronizer: () => null;
+}
+
+declare const useVercelRSCRuntime: <T extends WeakKey>(adapter: VercelRSCAdapter<T>) => VercelRSCRuntime<T>;
+
+declare const getVercelRSCMessage: <T>(message: ThreadMessage) => T | undefined;
+
+type VercelHelpers = UseChatHelpers | UseAssistantHelpers;
+
+declare class VercelAIRuntime implements AssistantRuntime, ReactThreadRuntime {
+    vercel: VercelHelpers;
+    private _subscriptions;
+    private repository;
+    private assistantOptimisticId;
+    private useVercel;
+    messages: ThreadMessage[];
+    isRunning: boolean;
+    constructor(vercel: VercelHelpers);
+    getBranches(messageId: string): string[];
+    switchToBranch(branchId: string): void;
+    append(message: AppendMessage): Promise<void>;
+    startRun(parentId: string | null): Promise<void>;
+    cancelRun(): void;
+    subscribe(callback: () => void): Unsubscribe;
+    private updateVercelMessages;
+    onVercelUpdated(): void;
+    private updateData;
+    unstable_synchronizer: () => null;
+}
+
+declare const useVercelUseChatRuntime: (chatHelpers: UseChatHelpers) => VercelAIRuntime;
+
+declare const useVercelUseAssistantRuntime: (assistantHelpers: UseAssistantHelpers) => VercelAIRuntime;
+
+declare const getVercelAIMessage: (message: ThreadMessage) => Message | undefined;
+
+/**
+ * @deprecated Will be removed in 0.1.0.
+ */
+type VercelAIAssistantProviderProps = PropsWithChildren<{
+    chat: UseChatHelpers;
+} | {
+    assistant: UseAssistantHelpers;
+}>;
+/**
+ * @deprecated `const runtime = useVercelUseChatRuntime(chat)` and `<AssistantRuntimeProvider runtime={...} />`. Will be removed in 0.1.0.
+ */
+declare const VercelAIAssistantProvider: FC<VercelAIAssistantProviderProps>;
+
+/**
+ * @deprecated Will be removed in 0.1.0.
+ */
+type VercelRSCAssistantProviderProps<T> = PropsWithChildren<VercelRSCAdapter<T>>;
+/**
+ * @deprecated Replaced with `const runtime = useVercelRSCRuntime({ messages, append })` and `<AssistantRuntimeProvider runtime={runtime} />`. Will be removed in 0.1.0.
+ */
+declare const VercelRSCAssistantProvider: <T extends WeakKey = VercelRSCMessage>({ children, ...adapter }: VercelRSCAssistantProviderProps<T>) => react_jsx_runtime.JSX.Element;
 
 type ChatModelRunResult = {
     content: AssistantContentPart[];
@@ -345,25 +400,21 @@ type ChatModelAdapter = {
     run: (options: ChatModelRunOptions) => Promise<ChatModelRunResult>;
 };
 
-declare class LocalRuntime implements ThreadRuntime {
+declare class LocalRuntime implements AssistantRuntime {
     adapter: ChatModelAdapter;
-    private _messageUpdateCallbacks;
-    private _statusUpdateCallbacks;
+    private _subscriptions;
     private abortController;
     private repository;
+    get messages(): ThreadMessage[];
+    get isRunning(): boolean;
     constructor(adapter: ChatModelAdapter);
-    append(message: AppendMessage): Promise<{
-        parentId: string;
-        id: string;
-    }>;
-    startRun(parentId: string | null): Promise<{
-        id: string;
-    }>;
-    private addOrUpdateMessage;
-    private run;
+    getBranches(messageId: string): string[];
+    switchToBranch(branchId: string): void;
+    append(message: AppendMessage): Promise<void>;
+    startRun(parentId: string | null): Promise<void>;
     cancelRun(): void;
-    subscribeToMessageUpdates(callback: MessageUpdateCallback): Unsubscribe;
-    subscribeToStatusUpdates(callback: StatusUpdateCallback): Unsubscribe;
+    private notifySubscribers;
+    subscribe(callback: () => void): Unsubscribe;
 }
 
 declare const useLocalRuntime: (adapter: ChatModelAdapter) => LocalRuntime;
@@ -376,8 +427,15 @@ declare class VercelModelAdapter implements ChatModelAdapter {
     }>;
 }
 
-declare const getVercelMessage: (message: ThreadMessage) => Message | undefined;
-declare const getVercelRSCMessage: <T>(message: ThreadMessage) => T | undefined;
+type AssistantRuntimeProviderProps = {
+    runtime: AssistantRuntime;
+};
+declare const AssistantRuntimeProvider: react.NamedExoticComponent<PropsWithChildren<AssistantRuntimeProviderProps>>;
+
+type ContentPartState = Readonly<{
+    status: "in_progress" | "done" | "error";
+    part: ThreadMessage["content"][number];
+}>;
 
 type MessageState = Readonly<{
     message: Readonly<ThreadMessage>;
@@ -391,23 +449,53 @@ type MessageState = Readonly<{
     isHovering: boolean;
     setIsHovering: (value: boolean) => void;
 }>;
-type MessageStore = {
-    useMessage: UseBoundStore<StoreApi<MessageState>>;
-    useComposer: UseBoundStore<StoreApi<MessageComposerState>>;
-};
 
-declare const useMessageContext: () => MessageStore;
+type BaseComposerState = Readonly<{
+    value: string;
+    setValue: (value: string) => void;
+}>;
 
-declare const useCopyMessage: ({ copiedDuration }: {
-    copiedDuration?: number | undefined;
-}) => (() => void) | null;
+type EditComposerState = BaseComposerState & Readonly<{
+    isEditing: boolean;
+    edit: () => void;
+    send: () => void;
+    cancel: () => boolean;
+}>;
 
-declare const useReloadMessage: () => (() => void) | null;
+type ComposerState = BaseComposerState & Readonly<{
+    isEditing: true;
+    send: () => void;
+    cancel: () => boolean;
+}>;
 
-declare const useBeginMessageEdit: () => (() => void) | null;
+type ThreadViewportState = {
+    isAtBottom: boolean;
+    scrollToBottom: () => void;
+    onScrollToBottom: (callback: () => void) => () => void;
+};
 
-declare const useGoToNextBranch: () => (() => void) | null;
+type ThreadContextValue = {
+    useThread: UseBoundStore<StoreApi<ThreadState>>;
+    useComposer: UseBoundStore<StoreApi<ComposerState>>;
+    useViewport: UseBoundStore<StoreApi<ThreadViewportState>>;
+};
+declare const useThreadContext: () => ThreadContextValue;
 
-declare const useGoToPreviousBranch: () => (() => void) | null;
+type ComposerContextValue = {
+    useComposer: UseBoundStore<StoreApi<EditComposerState | ComposerState>>;
+    type: "edit" | "new";
+};
+declare const useComposerContext: () => ComposerContextValue;
+
+type MessageContextValue = {
+    useMessage: UseBoundStore<StoreApi<MessageState>>;
+    useComposer: UseBoundStore<StoreApi<EditComposerState>>;
+};
+declare const useMessageContext: () => MessageContextValue;
+
+type ContentPartContextValue = {
+    useContentPart: UseBoundStore<StoreApi<ContentPartState>>;
+};
+declare const useContentPartContext: () => ContentPartContextValue;
 
-export { index$1 as ActionBarPrimitive, type AppendContentPart, type AppendMessage, index$2 as BranchPickerPrimitive, index$4 as ComposerPrimitive, index as ContentPartPrimitive, type ImageContentPart, index$3 as MessagePrimitive, type VercelRSCMessage as RSCMessage, type TextContentPart, index$5 as ThreadPrimitive, VercelAIAssistantProvider, type VercelAIAssistantProviderProps, VercelRSCAssistantProvider, type VercelRSCAssistantProviderProps, AssistantProvider as unstable_AssistantProvider, type ChatModelAdapter as unstable_ChatModelAdapter, type ChatModelRunOptions as unstable_ChatModelRunOptions, VercelModelAdapter as unstable_VercelModelAdapter, getVercelMessage as unstable_getVercelMessage, getVercelRSCMessage as unstable_getVercelRSCMessage, useLocalRuntime as unstable_useLocalRuntime, useMessageContext as unstable_useMessageContext, useBeginMessageEdit, useCopyMessage, useGoToNextBranch, useGoToPreviousBranch, useReloadMessage };
+export { index$1 as ActionBarPrimitive, type AppendContentPart, type AppendMessage, type AssistantContentPart, type AssistantMessage, AssistantRuntimeProvider, index$2 as BranchPickerPrimitive, index$4 as ComposerPrimitive, index as ContentPartPrimitive, index$3 as MessagePrimitive, type VercelRSCMessage as RSCMessage, type TextContentPart, type ThreadMessage, index$5 as ThreadPrimitive, type UserContentPart, type UserMessage, VercelAIAssistantProvider, type VercelAIAssistantProviderProps, type VercelRSCAdapter, VercelRSCAssistantProvider, type VercelRSCAssistantProviderProps, type VercelRSCMessage, getVercelAIMessage, getVercelRSCMessage, type ChatModelAdapter as unstable_ChatModelAdapter, type ChatModelRunOptions as unstable_ChatModelRunOptions, type ComposerContextValue as unstable_ComposerContextValue, type ComposerState as unstable_ComposerState, type ContentPartContextValue as unstable_ContentPartContextValue, type ContentPartState as unstable_ContentPartState, type EditComposerState as unstable_EditComposerState, type ImageContentPart as unstable_ImageContentPart, type MessageContextValue as unstable_MessageContextValue, type MessageState as unstable_MessageState, type ThreadContextValue as unstable_ThreadContextValue, type ThreadState as unstable_ThreadState, type ThreadViewportState as unstable_ThreadViewportState, type ToolCallContentPart as unstable_ToolCallContentPart, type UIContentPart as unstable_UIContentPart, VercelModelAdapter as unstable_VercelModelAdapter, useComposerContext as unstable_useComposerContext, useContentPartContext as unstable_useContentPartContext, useLocalRuntime as unstable_useLocalRuntime, useMessageContext as unstable_useMessageContext, useThreadContext as unstable_useThreadContext, useBeginMessageEdit, useCopyMessage, useGoToNextBranch, useGoToPreviousBranch, useReloadMessage, useVercelRSCRuntime, useVercelUseAssistantRuntime, useVercelUseChatRuntime };