@truefoundry/agent-ui-sdk 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,718 @@
+import * as react from 'react';
+import { ReactNode, ComponentProps, ComponentPropsWithRef, PropsWithChildren } from 'react';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+import { Avatar as Avatar$1, Tooltip as Tooltip$1, Dialog as Dialog$1, Collapsible as Collapsible$1 } from 'radix-ui';
+import { ToolCallMessagePartComponent, MessagePrimitive } from '@assistant-ui/react';
+
+/**
+ * Registry of atom-name -> atom-implementation. Empty by default; each atom module
+ * augments this interface via `declare module "../theme/SlotsProvider"` when it is
+ * introduced, so adding an atom never requires editing this file or any container.
+ */
+interface AtomSlots {
+}
+type SlotOverrides = Partial<AtomSlots>;
+/**
+ * Wrap a subtree to override one or more atoms with a different design system.
+ * Containers never reference concrete atoms directly -- they resolve everything
+ * through `useSlot`, so this is the only thing a design-system swap has to touch.
+ */
+declare function SlotsProvider({ overrides, children, }: {
+    overrides?: SlotOverrides;
+    children: ReactNode;
+}): react.JSX.Element;
+/** Resolves the atom implementation registered for `name` -- default unless overridden. */
+declare function useSlot<K extends keyof AtomSlots>(name: K): AtomSlots[K];
+
+/**
+ * This SDK's default atom implementations, keyed by slot name. Populated
+ * incrementally as atoms are added under `src/atoms/**`; each atom module
+ * augments `AtomSlots` and this object gains the matching entry in the same
+ * milestone.
+ */
+declare const defaultSlots: AtomSlots;
+
+/**
+ * Semantic color roles. Atoms reference these instead of raw hex/HSL values so a
+ * future design-system swap only has to repoint the token values, not the atoms.
+ */
+type ColorToken = "background" | "foreground" | "muted" | "mutedForeground" | "border" | "primary" | "primaryForeground" | "destructive" | "destructiveForeground" | "accent" | "accentForeground";
+type RadiusToken = "none" | "sm" | "md" | "lg" | "full";
+type SpacingToken = "none" | "xs" | "sm" | "md" | "lg" | "xl";
+type TypeRoleToken = "body" | "bodySmall" | "label" | "heading" | "code" | "caption";
+interface TypeRoleValue {
+    fontSize: string;
+    lineHeight: string;
+    fontWeight: string | number;
+}
+interface DesignTokens {
+    colors: Record<ColorToken, string>;
+    radii: Record<RadiusToken, string>;
+    spacing: Record<SpacingToken, string>;
+    typography: Record<TypeRoleToken, TypeRoleValue>;
+}
+/**
+ * Values reference the CSS custom properties already emitted by the shadcn/Tailwind
+ * theme in the ported reference app, so default atoms render identically to today
+ * without requiring every atom to be rewritten to consume tokens in this pass.
+ */
+declare const defaultTokens: DesignTokens;
+declare function TokensProvider({ tokens, children, }: {
+    tokens: DesignTokens;
+    children: ReactNode;
+}): react.FunctionComponentElement<react.ProviderProps<DesignTokens>>;
+/** Atoms may call this for theme-driven values; it is not an assistant-ui/runtime hook. */
+declare function useTokens(): DesignTokens;
+
+declare const buttonVariants: (props?: ({
+    variant?: "default" | "link" | "outline" | "secondary" | "ghost" | "destructive" | null | undefined;
+    size?: "default" | "sm" | "lg" | "xs" | "icon" | "icon-xs" | "icon-sm" | "icon-lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type ButtonProps = ComponentProps<"button"> & VariantProps<typeof buttonVariants> & {
+    asChild?: boolean;
+};
+declare function Button({ className, variant, size, asChild, ...props }: ButtonProps): react.JSX.Element;
+declare module "../../theme/SlotsProvider.js" {
+    interface AtomSlots {
+        Button: typeof Button;
+    }
+}
+
+type IconButtonProps = ComponentPropsWithRef<typeof Button> & {
+    tooltip: string;
+    side?: "top" | "bottom" | "left" | "right";
+};
+declare const IconButton: react.ForwardRefExoticComponent<Omit<IconButtonProps, "ref"> & react.RefAttributes<HTMLButtonElement>>;
+declare module "../../theme/SlotsProvider.js" {
+    interface AtomSlots {
+        IconButton: typeof IconButton;
+    }
+}
+
+type AvatarProps = ComponentProps<typeof Avatar$1.Root> & {
+    size?: "default" | "sm" | "lg";
+};
+declare function Avatar({ className, size, ...props }: AvatarProps): react.JSX.Element;
+type AvatarImageProps = ComponentProps<typeof Avatar$1.Image>;
+declare function AvatarImage({ className, ...props }: AvatarImageProps): react.JSX.Element;
+type AvatarFallbackProps = ComponentProps<typeof Avatar$1.Fallback>;
+declare function AvatarFallback({ className, ...props }: AvatarFallbackProps): react.JSX.Element;
+declare module "../../theme/SlotsProvider.js" {
+    interface AtomSlots {
+        Avatar: typeof Avatar;
+        AvatarImage: typeof AvatarImage;
+        AvatarFallback: typeof AvatarFallback;
+    }
+}
+
+type TooltipProviderProps = ComponentProps<typeof Tooltip$1.Provider>;
+declare function TooltipProvider({ delayDuration, ...props }: TooltipProviderProps): react.JSX.Element;
+type TooltipProps = ComponentProps<typeof Tooltip$1.Root>;
+declare function Tooltip(props: TooltipProps): react.JSX.Element;
+type TooltipTriggerProps = ComponentProps<typeof Tooltip$1.Trigger>;
+declare function TooltipTrigger(props: TooltipTriggerProps): react.JSX.Element;
+type TooltipContentProps = ComponentProps<typeof Tooltip$1.Content>;
+declare function TooltipContent({ className, sideOffset, children, ...props }: TooltipContentProps): react.JSX.Element;
+declare module "../../theme/SlotsProvider.js" {
+    interface AtomSlots {
+        TooltipProvider: typeof TooltipProvider;
+        Tooltip: typeof Tooltip;
+        TooltipTrigger: typeof TooltipTrigger;
+        TooltipContent: typeof TooltipContent;
+    }
+}
+
+type DialogProps = ComponentProps<typeof Dialog$1.Root>;
+declare function Dialog(props: DialogProps): react.JSX.Element;
+type DialogTriggerProps = ComponentProps<typeof Dialog$1.Trigger>;
+declare function DialogTrigger(props: DialogTriggerProps): react.JSX.Element;
+type DialogPortalProps = ComponentProps<typeof Dialog$1.Portal>;
+declare function DialogPortal(props: DialogPortalProps): react.JSX.Element;
+type DialogCloseProps = ComponentProps<typeof Dialog$1.Close>;
+declare function DialogClose(props: DialogCloseProps): react.JSX.Element;
+type DialogOverlayProps = ComponentProps<typeof Dialog$1.Overlay>;
+declare function DialogOverlay({ className, ...props }: DialogOverlayProps): react.JSX.Element;
+type DialogContentProps = ComponentProps<typeof Dialog$1.Content> & {
+    showCloseButton?: boolean;
+};
+declare function DialogContent({ className, children, showCloseButton, ...props }: DialogContentProps): react.JSX.Element;
+type DialogHeaderProps = ComponentProps<"div">;
+declare function DialogHeader({ className, ...props }: DialogHeaderProps): react.JSX.Element;
+type DialogFooterProps = ComponentProps<"div"> & {
+    showCloseButton?: boolean;
+};
+declare function DialogFooter({ className, showCloseButton, children, ...props }: DialogFooterProps): react.JSX.Element;
+type DialogTitleProps = ComponentProps<typeof Dialog$1.Title>;
+declare function DialogTitle({ className, ...props }: DialogTitleProps): react.JSX.Element;
+type DialogDescriptionProps = ComponentProps<typeof Dialog$1.Description>;
+declare function DialogDescription({ className, ...props }: DialogDescriptionProps): react.JSX.Element;
+declare module "../../theme/SlotsProvider.js" {
+    interface AtomSlots {
+        Dialog: typeof Dialog;
+        DialogTrigger: typeof DialogTrigger;
+        DialogPortal: typeof DialogPortal;
+        DialogClose: typeof DialogClose;
+        DialogOverlay: typeof DialogOverlay;
+        DialogContent: typeof DialogContent;
+        DialogHeader: typeof DialogHeader;
+        DialogFooter: typeof DialogFooter;
+        DialogTitle: typeof DialogTitle;
+        DialogDescription: typeof DialogDescription;
+    }
+}
+
+type CollapsibleProps = ComponentProps<typeof Collapsible$1.Root>;
+declare function Collapsible(props: CollapsibleProps): react.JSX.Element;
+type CollapsibleTriggerProps = ComponentProps<typeof Collapsible$1.CollapsibleTrigger>;
+declare function CollapsibleTrigger(props: CollapsibleTriggerProps): react.JSX.Element;
+type CollapsibleContentProps = ComponentProps<typeof Collapsible$1.CollapsibleContent>;
+declare function CollapsibleContent(props: CollapsibleContentProps): react.JSX.Element;
+declare module "../../theme/SlotsProvider.js" {
+    interface AtomSlots {
+        Collapsible: typeof Collapsible;
+        CollapsibleTrigger: typeof CollapsibleTrigger;
+        CollapsibleContent: typeof CollapsibleContent;
+    }
+}
+
+type SkeletonProps = ComponentProps<"div">;
+declare function Skeleton({ className, ...props }: SkeletonProps): react.JSX.Element;
+declare module "../../theme/SlotsProvider.js" {
+    interface AtomSlots {
+        Skeleton: typeof Skeleton;
+    }
+}
+
+type MarkdownProps = {
+    content: string;
+    className?: string;
+    isStreaming?: boolean;
+    onDownloadArtifact?: (path: string) => void | Promise<unknown>;
+};
+declare function Markdown({ content, className, isStreaming, onDownloadArtifact }: MarkdownProps): react.JSX.Element;
+declare module "../theme/SlotsProvider.js" {
+    interface AtomSlots {
+        Markdown: typeof Markdown;
+    }
+}
+
+type ThemeMode = "light" | "dark";
+
+type OpenUIBlockProps = {
+    source: string;
+    isStreaming?: boolean;
+    className?: string;
+    /** Override light/dark mode. Defaults to syncing with a `.dark` class on `<html>`. */
+    mode?: ThemeMode;
+};
+/** Renders an OpenUI Lang fenced code block (```openui ... ```). */
+declare const OpenUIBlock: react.NamedExoticComponent<OpenUIBlockProps>;
+declare module "../theme/SlotsProvider.js" {
+    interface AtomSlots {
+        OpenUIBlock: typeof OpenUIBlock;
+    }
+}
+
+type SandboxArtifactLink = {
+    label: string;
+    path: string;
+};
+type SandboxArtifactListProps = {
+    artifacts: SandboxArtifactLink[];
+    onDownload?: (path: string) => void | Promise<unknown>;
+    className?: string;
+};
+declare function SandboxArtifactList({ artifacts, onDownload, className }: SandboxArtifactListProps): react.JSX.Element;
+declare module "../theme/SlotsProvider.js" {
+    interface AtomSlots {
+        SandboxArtifactList: typeof SandboxArtifactList;
+    }
+}
+
+type CodeBlockHeaderProps = {
+    language: string;
+    code: string;
+};
+declare function CodeBlockHeader({ language, code }: CodeBlockHeaderProps): react.JSX.Element;
+declare module "../theme/SlotsProvider.js" {
+    interface AtomSlots {
+        CodeBlockHeader: typeof CodeBlockHeader;
+    }
+}
+
+type AssistantMessageBubbleProps = {
+    variant: "assistant";
+    children: ReactNode;
+    error?: ReactNode;
+    branchIndicator?: ReactNode;
+    actionBar?: ReactNode;
+    className?: string;
+};
+type UserMessageBubbleProps = {
+    variant: "user";
+    children: ReactNode;
+    attachments?: ReactNode;
+    branchIndicator?: ReactNode;
+    actionBar?: ReactNode;
+    className?: string;
+};
+type MessageBubbleProps = AssistantMessageBubbleProps | UserMessageBubbleProps;
+declare function MessageBubble(props: MessageBubbleProps): react.JSX.Element;
+declare module "../theme/SlotsProvider.js" {
+    interface AtomSlots {
+        MessageBubble: typeof MessageBubble;
+    }
+}
+
+type MessageErrorBannerProps = {
+    message: string;
+    className?: string;
+};
+declare function MessageErrorBanner({ message, className }: MessageErrorBannerProps): react.JSX.Element;
+declare module "../theme/SlotsProvider.js" {
+    interface AtomSlots {
+        MessageErrorBanner: typeof MessageErrorBanner;
+    }
+}
+
+type MessageActionBarProps = {
+    isCopied: boolean;
+    onCopy: () => void;
+    onExportMarkdown: () => void;
+    className?: string;
+};
+declare function MessageActionBar({ isCopied, onCopy, onExportMarkdown, className }: MessageActionBarProps): react.JSX.Element;
+declare module "../theme/SlotsProvider.js" {
+    interface AtomSlots {
+        MessageActionBar: typeof MessageActionBar;
+    }
+}
+
+type UserMessageActionBarProps = {
+    className?: string;
+};
+declare function UserMessageActionBar({ className }: UserMessageActionBarProps): react.JSX.Element;
+declare module "../theme/SlotsProvider.js" {
+    interface AtomSlots {
+        UserMessageActionBar: typeof UserMessageActionBar;
+    }
+}
+
+type BranchIndicatorProps = {
+    index: number;
+    count: number;
+    onPrevious: () => void;
+    onNext: () => void;
+    className?: string;
+};
+declare function BranchIndicator({ index, count, onPrevious, onNext, className }: BranchIndicatorProps): react.JSX.Element | null;
+declare module "../theme/SlotsProvider.js" {
+    interface AtomSlots {
+        BranchIndicator: typeof BranchIndicator;
+    }
+}
+
+type MessageIndicatorProps = {
+    className?: string;
+};
+declare function MessageIndicator({ className }: MessageIndicatorProps): react.JSX.Element;
+declare module "../theme/SlotsProvider.js" {
+    interface AtomSlots {
+        MessageIndicator: typeof MessageIndicator;
+    }
+}
+
+type WelcomeScreenProps = {
+    heading?: string;
+    className?: string;
+};
+declare function WelcomeScreen({ heading, className }: WelcomeScreenProps): react.JSX.Element;
+declare module "../theme/SlotsProvider.js" {
+    interface AtomSlots {
+        WelcomeScreen: typeof WelcomeScreen;
+    }
+}
+
+type MessageListSkeletonProps = {
+    className?: string;
+};
+declare function MessageListSkeleton({ className }: MessageListSkeletonProps): react.JSX.Element;
+declare module "../theme/SlotsProvider.js" {
+    interface AtomSlots {
+        MessageListSkeleton: typeof MessageListSkeleton;
+    }
+}
+
+type ScrollToBottomButtonProps = Omit<IconButtonProps, "tooltip" | "children">;
+declare const ScrollToBottomButton: react.ForwardRefExoticComponent<Omit<ScrollToBottomButtonProps, "ref"> & react.RefAttributes<HTMLButtonElement>>;
+declare module "../theme/SlotsProvider.js" {
+    interface AtomSlots {
+        ScrollToBottomButton: typeof ScrollToBottomButton;
+    }
+}
+
+type ThreadRootShellProps = ComponentPropsWithRef<"div">;
+declare const ThreadRootShell: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+type ThreadViewportShellProps = ComponentPropsWithRef<"div"> & {
+    isEmpty?: boolean;
+};
+declare const ThreadViewportShell: react.ForwardRefExoticComponent<Omit<ThreadViewportShellProps, "ref"> & react.RefAttributes<HTMLDivElement>>;
+type ThreadComposerAreaShellProps = ComponentPropsWithRef<"div"> & {
+    isEmpty?: boolean;
+};
+declare const ThreadComposerAreaShell: react.ForwardRefExoticComponent<Omit<ThreadComposerAreaShellProps, "ref"> & react.RefAttributes<HTMLDivElement>>;
+type MessageGroupProps = ComponentPropsWithRef<"div">;
+declare const MessageGroup: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare module "../theme/SlotsProvider.js" {
+    interface AtomSlots {
+        ThreadRootShell: typeof ThreadRootShell;
+        ThreadViewportShell: typeof ThreadViewportShell;
+        ThreadComposerAreaShell: typeof ThreadComposerAreaShell;
+        MessageGroup: typeof MessageGroup;
+    }
+}
+
+type ToolCallStatus = "running" | "success" | "error";
+type ToolCallCardBaseProps = {
+    variant: "tool" | "sub-agent" | "mcp-listing";
+    name: string;
+    status: ToolCallStatus;
+    expanded: boolean;
+    onToggle: () => void;
+    /** Not in the Section 6 screenshot contract; ported from the reference's live per-call timer. */
+    durationText?: string;
+    className?: string;
+};
+type ToolCallCardToolProps = ToolCallCardBaseProps & {
+    variant: "tool";
+    argsText?: string;
+    result?: string;
+    isError?: boolean;
+    /**
+     * Extends the Section 6 contract: renders the pending tool-approval / ask-user
+     * UI when this call requires action. The reference screenshots didn't include
+     * an in-flight approval state, so this slot was inferred rather than observed.
+     */
+    approvalSlot?: ReactNode;
+};
+type ToolCallCardSubAgentProps = ToolCallCardBaseProps & {
+    variant: "sub-agent";
+    agentName: string;
+    instruction: string;
+    stepCount: number;
+    children?: ReactNode;
+};
+type ToolCallCardMcpProps = ToolCallCardBaseProps & {
+    variant: "mcp-listing";
+    serverName: string;
+    description: string;
+    argsText: string;
+    resultText: string;
+};
+type ToolCallCardProps = ToolCallCardToolProps | ToolCallCardSubAgentProps | ToolCallCardMcpProps;
+declare function ToolCallCard(props: ToolCallCardProps): react.JSX.Element;
+declare module "../theme/SlotsProvider.js" {
+    interface AtomSlots {
+        ToolCallCard: typeof ToolCallCard;
+    }
+}
+
+type ToolApprovalOption = {
+    id: string;
+    label: string;
+    isAllow: boolean;
+    grants?: readonly string[];
+    confirm?: {
+        title?: string;
+        description?: string;
+    };
+};
+type ToolApprovalBarProps = {
+    options: ToolApprovalOption[];
+    onSelectOption: (optionId: string) => void;
+    className?: string;
+};
+declare function ToolApprovalBar({ options, onSelectOption, className }: ToolApprovalBarProps): react.JSX.Element;
+declare module "../theme/SlotsProvider.js" {
+    interface AtomSlots {
+        ToolApprovalBar: typeof ToolApprovalBar;
+    }
+}
+
+type ToolGroupCardProps = {
+    toolCallCount: number;
+    expanded: boolean;
+    active?: boolean;
+    onToggle: () => void;
+    children: ReactNode;
+    className?: string;
+};
+declare function ToolGroupCard({ toolCallCount, expanded, active, onToggle, children, className, }: ToolGroupCardProps): react.JSX.Element;
+declare module "../theme/SlotsProvider.js" {
+    interface AtomSlots {
+        ToolGroupCard: typeof ToolGroupCard;
+    }
+}
+
+type ReasoningCardProps = {
+    streaming: boolean;
+    expanded: boolean;
+    onToggle: () => void;
+    children: ReactNode;
+    className?: string;
+};
+declare function ReasoningCard({ streaming, expanded, onToggle, children, className }: ReasoningCardProps): react.JSX.Element;
+declare module "../theme/SlotsProvider.js" {
+    interface AtomSlots {
+        ReasoningCard: typeof ReasoningCard;
+    }
+}
+
+type ComposerShellProps = {
+    value: string;
+    placeholder: string;
+    disabled: boolean;
+    isRunning?: boolean;
+    attachments?: ReactNode;
+    modelLabel?: string;
+    modelIcon?: ReactNode;
+    connectorStatusLabel?: string;
+    onValueChange: (value: string) => void;
+    onSubmit: () => void;
+    onCancel?: () => void;
+    onAttach?: () => void;
+    className?: string;
+};
+declare function ComposerShell({ value, placeholder, disabled, isRunning, attachments, modelLabel, modelIcon, connectorStatusLabel, onValueChange, onSubmit, onCancel, onAttach, className, }: ComposerShellProps): react.JSX.Element;
+declare module "../theme/SlotsProvider.js" {
+    interface AtomSlots {
+        ComposerShell: typeof ComposerShell;
+    }
+}
+
+type AskUserOption = {
+    id: string;
+    label: string;
+};
+type AskUserPromptProps = {
+    question: string;
+    options: AskUserOption[];
+    allowOther: boolean;
+    selectedOptionId?: string;
+    otherValue: string;
+    disabled: boolean;
+    onSelectOption: (optionId: string) => void;
+    onOtherValueChange: (value: string) => void;
+    onSubmit: () => void;
+    className?: string;
+};
+declare function AskUserPrompt({ question, options, allowOther, selectedOptionId, otherValue, disabled, onSelectOption, onOtherValueChange, onSubmit, className, }: AskUserPromptProps): react.JSX.Element;
+declare module "../theme/SlotsProvider.js" {
+    interface AtomSlots {
+        AskUserPrompt: typeof AskUserPrompt;
+    }
+}
+
+type McpAuthServer = {
+    id: string;
+    name: string;
+    authUrl: string;
+};
+type McpAuthPromptProps = {
+    servers: McpAuthServer[];
+    disabled: boolean;
+    onContinue: () => void;
+    className?: string;
+};
+declare function McpAuthPrompt({ servers, disabled, onContinue, className }: McpAuthPromptProps): react.JSX.Element;
+declare module "../theme/SlotsProvider.js" {
+    interface AtomSlots {
+        McpAuthPrompt: typeof McpAuthPrompt;
+    }
+}
+
+type AttachmentCardSize = "chip" | "preview";
+/** Fixed preview bounds for attachments rendered in user message bubbles. */
+declare const USER_MESSAGE_ATTACHMENT_PREVIEW_REM = 12;
+type AttachmentCardProps = {
+    name: string;
+    contentType?: string;
+    previewSrc?: string;
+    isImage?: boolean;
+    size?: AttachmentCardSize;
+    /** When set, constrains image preview and file chip width to this rem size. */
+    previewRem?: number;
+    onRemove?: () => void;
+    className?: string;
+};
+declare function AttachmentCard({ name, previewSrc, isImage, size, previewRem, onRemove, className, }: AttachmentCardProps): react.JSX.Element;
+declare module "../theme/SlotsProvider.js" {
+    interface AtomSlots {
+        AttachmentCard: typeof AttachmentCard;
+    }
+}
+
+type AttachmentPreviewDialogProps = {
+    previewSrc?: string;
+    children: ReactNode;
+};
+declare function AttachmentPreviewDialog({ previewSrc, children }: AttachmentPreviewDialogProps): react.JSX.Element;
+declare module "../theme/SlotsProvider.js" {
+    interface AtomSlots {
+        AttachmentPreviewDialog: typeof AttachmentPreviewDialog;
+    }
+}
+
+type AttachmentPickerButtonProps = Omit<IconButtonProps, "tooltip" | "children">;
+declare function AttachmentPickerButton(props: AttachmentPickerButtonProps): react.JSX.Element;
+declare module "../theme/SlotsProvider.js" {
+    interface AtomSlots {
+        AttachmentPickerButton: typeof AttachmentPickerButton;
+    }
+}
+
+type ThreadListRowProps = {
+    title: string;
+    active: boolean;
+    onSelect: () => void;
+    onArchive?: () => void;
+    onDelete?: () => void;
+    className?: string;
+};
+declare function ThreadListRow({ title, active, onSelect, onArchive, onDelete, className }: ThreadListRowProps): react.JSX.Element;
+declare module "../theme/SlotsProvider.js" {
+    interface AtomSlots {
+        ThreadListRow: typeof ThreadListRow;
+    }
+}
+
+type ThreadListNewButtonProps = Omit<ButtonProps, "children">;
+declare function ThreadListNewButton({ className, ...rest }: ThreadListNewButtonProps): react.JSX.Element;
+type ThreadListRowSkeletonProps = {
+    count?: number;
+    className?: string;
+};
+declare function ThreadListRowSkeleton({ count, className }: ThreadListRowSkeletonProps): react.JSX.Element;
+type ThreadListEmptyStateProps = {
+    message?: string;
+    className?: string;
+};
+declare function ThreadListEmptyState({ message, className }: ThreadListEmptyStateProps): react.JSX.Element;
+type ThreadListShellProps = {
+    header: ReactNode;
+    children: ReactNode;
+    className?: string;
+};
+declare function ThreadListShell({ header, children, className }: ThreadListShellProps): react.JSX.Element;
+declare module "../theme/SlotsProvider.js" {
+    interface AtomSlots {
+        ThreadListNewButton: typeof ThreadListNewButton;
+        ThreadListRowSkeleton: typeof ThreadListRowSkeleton;
+        ThreadListEmptyState: typeof ThreadListEmptyState;
+        ThreadListShell: typeof ThreadListShell;
+    }
+}
+
+type ToastProps = {
+    title: string;
+    description: string;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    className?: string;
+};
+declare function Toast({ title, description, open, onOpenChange, className }: ToastProps): react.JSX.Element;
+type ToastStackProps = {
+    children: ReactNode;
+    duration?: number;
+};
+declare function ToastStack({ children, duration }: ToastStackProps): react.JSX.Element;
+declare module "../theme/SlotsProvider.js" {
+    interface AtomSlots {
+        Toast: typeof Toast;
+        ToastStack: typeof ToastStack;
+    }
+}
+
+type ThreadContainerProps = {
+    /**
+     * Rendered in the bottom composer area. Left undefined until
+     * `ComposerContainer` exists (milestone 6); the public `<Thread/>` export
+     * wires the two together once it does.
+     */
+    composer?: ReactNode;
+};
+declare function ThreadContainer({ composer }: ThreadContainerProps): react.JSX.Element;
+
+declare function AssistantMessageContainer(): react.JSX.Element;
+
+declare function UserMessageContainer(): react.JSX.Element;
+
+declare function UserEditComposerContainer(): react.JSX.Element;
+
+declare function AssistantTextContainer(): react.JSX.Element;
+
+declare const ToolCallContainer: ToolCallMessagePartComponent;
+
+type ThreadGroupPart = MessagePrimitive.GroupedParts.GroupPart;
+declare function ToolGroupContainer({ group, children }: PropsWithChildren<{
+    group: ThreadGroupPart;
+}>): react.JSX.Element;
+
+declare function ReasoningContainer({ group, children }: PropsWithChildren<{
+    group: ThreadGroupPart;
+}>): react.JSX.Element;
+
+declare function ComposerContainer(): react.JSX.Element;
+
+type ComposerBusyState = {
+    /** True while submitting or while the turn stream is active. */
+    isBusy: boolean;
+    isRunning: boolean;
+    isSubmitting: boolean;
+    send: (sendFn: () => void | Promise<void>) => void;
+    resetBusy: () => void;
+};
+declare function ComposerBusyProvider({ children }: {
+    children: ReactNode;
+}): react.FunctionComponentElement<react.ProviderProps<ComposerBusyState | null>>;
+/**
+ * Optimistic composer busy state shared across the thread. `useThreadIsRunning()`
+ * only becomes true once the turn stream starts; this hook flips to busy
+ * immediately on submit so the send button shows loading before session setup /
+ * turn API work finishes.
+ *
+ * Must be used within `<ComposerBusyProvider>` (wired by default in `<Thread />`).
+ */
+declare function useComposerBusyState(): ComposerBusyState;
+
+declare function AskUserContainer(): react.JSX.Element | null;
+
+declare function McpAuthContainer(): react.JSX.Element | null;
+
+declare function ComposerAttachmentsContainer(): react.JSX.Element;
+declare function MessageAttachmentsContainer(): react.JSX.Element;
+declare function ComposerAttachmentPickerContainer(): react.JSX.Element;
+
+/**
+ * Simplified relative to the reference: renders threads in a single flat list
+ * rather than grouping them by Today/Yesterday/Earlier. Archive/Delete are
+ * wired but no-op against the current thread-list adapter (documented in the
+ * runtime README's unsupported-features table).
+ */
+declare function ThreadListContainer(): react.JSX.Element;
+
+type ErrorToasterContextValue = {
+    showError: (error: unknown) => void;
+};
+declare function ErrorToasterProvider({ children }: {
+    children: ReactNode;
+}): react.JSX.Element;
+declare function useErrorToaster(): ErrorToasterContextValue;
+/** Same as `useErrorToaster`, but returns `null` instead of throwing outside `ErrorToasterProvider`. */
+declare function useErrorToasterOptional(): ErrorToasterContextValue | null;
+
+/** The full assembled thread view: message list + composer. */
+declare function Thread(): react.JSX.Element;
+
+export { AskUserContainer, type AskUserOption, AskUserPrompt, type AskUserPromptProps, type AssistantMessageBubbleProps, AssistantMessageContainer, AssistantTextContainer, type AtomSlots, AttachmentCard, type AttachmentCardProps, type AttachmentCardSize, AttachmentPickerButton, type AttachmentPickerButtonProps, AttachmentPreviewDialog, type AttachmentPreviewDialogProps, Avatar, AvatarFallback, type AvatarFallbackProps, AvatarImage, type AvatarImageProps, type AvatarProps, BranchIndicator, type BranchIndicatorProps, Button, type ButtonProps, CodeBlockHeader, type CodeBlockHeaderProps, Collapsible, CollapsibleContent, type CollapsibleContentProps, type CollapsibleProps, CollapsibleTrigger, type CollapsibleTriggerProps, type ColorToken, ComposerAttachmentPickerContainer, ComposerAttachmentsContainer, ComposerBusyProvider, type ComposerBusyState, ComposerContainer, ComposerShell, type ComposerShellProps, type DesignTokens, Dialog, DialogClose, type DialogCloseProps, DialogContent, type DialogContentProps, DialogDescription, type DialogDescriptionProps, DialogFooter, type DialogFooterProps, DialogHeader, type DialogHeaderProps, DialogOverlay, type DialogOverlayProps, DialogPortal, type DialogPortalProps, type DialogProps, DialogTitle, type DialogTitleProps, DialogTrigger, type DialogTriggerProps, ErrorToasterProvider, IconButton, type IconButtonProps, Markdown, type MarkdownProps, McpAuthContainer, McpAuthPrompt, type McpAuthPromptProps, type McpAuthServer, MessageActionBar, type MessageActionBarProps, MessageAttachmentsContainer, MessageBubble, type MessageBubbleProps, MessageErrorBanner, type MessageErrorBannerProps, MessageGroup, type MessageGroupProps, MessageIndicator, type MessageIndicatorProps, MessageListSkeleton, type MessageListSkeletonProps, OpenUIBlock, type OpenUIBlockProps, type RadiusToken, ReasoningCard, type ReasoningCardProps, ReasoningContainer, type SandboxArtifactLink, SandboxArtifactList, type SandboxArtifactListProps, ScrollToBottomButton, type ScrollToBottomButtonProps, Skeleton, type SkeletonProps, type SlotOverrides, SlotsProvider, type SpacingToken, Thread, ThreadComposerAreaShell, type ThreadComposerAreaShellProps, ThreadContainer, type ThreadContainerProps, type ThreadGroupPart, ThreadListContainer, ThreadListEmptyState, type ThreadListEmptyStateProps, ThreadListNewButton, type ThreadListNewButtonProps, ThreadListRow, type ThreadListRowProps, ThreadListRowSkeleton, type ThreadListRowSkeletonProps, ThreadListShell, type ThreadListShellProps, ThreadRootShell, type ThreadRootShellProps, ThreadViewportShell, type ThreadViewportShellProps, Toast, type ToastProps, ToastStack, type ToastStackProps, TokensProvider, ToolApprovalBar, type ToolApprovalBarProps, type ToolApprovalOption, ToolCallCard, type ToolCallCardMcpProps, type ToolCallCardProps, type ToolCallCardSubAgentProps, type ToolCallCardToolProps, ToolCallContainer, type ToolCallStatus, ToolGroupCard, type ToolGroupCardProps, ToolGroupContainer, Tooltip, TooltipContent, type TooltipContentProps, type TooltipProps, TooltipProvider, type TooltipProviderProps, TooltipTrigger, type TooltipTriggerProps, type TypeRoleToken, type TypeRoleValue, USER_MESSAGE_ATTACHMENT_PREVIEW_REM, UserEditComposerContainer, UserMessageActionBar, type UserMessageActionBarProps, type UserMessageBubbleProps, UserMessageContainer, WelcomeScreen, type WelcomeScreenProps, buttonVariants, defaultSlots, defaultTokens, useComposerBusyState, useErrorToaster, useErrorToasterOptional, useSlot, useTokens };