@truefoundry/trueforge-ui 0.0.0 → 0.1.0-rc.0

package/dist/index.d.ts

@@ -0,0 +1,1569 @@
+import * as react from 'react';
+import react__default, { ComponentPropsWithRef, ComponentProps, ComponentType, ReactNode, HTMLAttributes, CSSProperties, FC, SVGProps, ComponentPropsWithoutRef, PropsWithChildren } from 'react';
+import { LucideIcon } from 'lucide-react';
+import { MessagePrimitive, ToolCallMessagePartComponent } from '@assistant-ui/react';
+export { AssistantState, useAui, useAuiState } from '@assistant-ui/react';
+import { UseTrueFoundryAgentRuntimeOptions, TrueFoundryAgentConfig } from '@truefoundry/assistant-ui-runtime';
+export { DraftAgentConfig, NamedAgentConfig, TrueFoundryAgentConfig, UseTrueFoundryAgentRuntimeOptions, mergeAgentSpec, trueFoundryAttachmentAdapter, useTrueFoundryAgentRuntime, useTrueFoundryAgentSpec, useTrueFoundryCancel, useTrueFoundryDownloadSandboxFile, useTrueFoundryHistoryPagination, useTrueFoundryMcpAuth, useTrueFoundryRespondToToolApproval, useTrueFoundryToolResponses, useTrueFoundryTurnId, useTrueFoundryUpdateAgentSpec } from '@truefoundry/assistant-ui-runtime';
+import { AgentSpec, AgentLibraryEntry, CatalogServer, AgentUIServer, AgentBuilderCapabilitiesResponse, ModelSelection, AgentSkill, ConnectorState } from '@truefoundry/assistant-ui-runtime/server';
+export { AgentBuilderCapabilitiesResponse, AgentBuilderServer, AgentChatServer, AgentLibraryEntry, AgentSkill, AgentSpec, AgentUIServer, ApprovalDecision, AuthenticateConnectorRequest, CatalogServer, ConnectorAuth, ConnectorAuthApiKey, ConnectorAuthNone, ConnectorAuthOAuth, ConnectorAuthPublic, ConnectorAuthPublicApiKey, ConnectorAuthPublicNone, ConnectorAuthPublicOAuth, ConnectorAuthType, ConnectorAuthenticationResult, ConnectorBase, ConnectorCatalogEntry, ConnectorCatalogServer, ConnectorConfigBase, ConnectorState, CreateConnectorRequest, CreateModelProviderRequest, CreateSandboxProviderRequest, CreateSessionRequest, CreateSkillRequest, CreateSkillRequestBase, DefinedSkill, GithubSkill, ImportGithubSkillRequest, ListResult, ListSessionsOrder, ListSessionsParams, McpServerMount, Model, ModelCatalogServer, ModelEntry, ModelParams, ModelProperties, ModelProviderBase, ModelProviderCatalogEntry, ModelProviderConfigBase, ModelSelection, ModelSelectorEntry, PageParams, PreviousTurnIdInput, ProviderEntry, ProviderType, RegistrySkill, SandboxCatalogServer, SandboxProviderBase, SandboxProviderCatalogEntry, SandboxProviderConfig, SaveAgentRequest, SaveAgentResult, SearchAgentsParams, SelectRegistrySkillRequest, Session, SessionEventItem, SkillBase, SkillCatalogEntry, SkillCatalogServer, SkillConfigBase, SkillMount, ToolBase, Turn, TurnInputItem, TurnState, TurnStreamData, TurnStreamingEvent, UpdateConnectorRequest, UpdateModelProviderRequest, UpdateSandboxProviderRequest, UpdateSessionRequest, UserMessage, UserMessageContent, UserToolApprovalEvent, UserToolResponseEvent } from '@truefoundry/assistant-ui-runtime/server';
+export { C as CreateTrueFoundryServerOptions, T as TrueFoundryServer, c as createTrueFoundryServer } from './createTrueFoundryServer-B72bU-J7.js';
+import { PartState } from '@assistant-ui/core/react';
+
+/** Configured brand name, or the SDK default. Safe outside a `ThemeProvider`. */
+declare function useBrandName(): string;
+/**
+ * The product mark: `theme.brand.logo` resolved against the active theme mode,
+ * labelled with the brand name, and linked when the config carries an `href`.
+ * Falls back to the default mark when no logo is configured.
+ *
+ * Callers that also want the name as text render it themselves — the SDK layouts
+ * pair this with `useBrandName()` so each one controls its own arrangement.
+ */
+declare function BrandLogo({ className }: {
+    className?: string;
+}): react.JSX.Element;
+declare module './SlotsProvider.js' {
+    interface AtomSlots {
+        BrandLogo: typeof BrandLogo;
+    }
+}
+
+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 HistoryLoaderProps = ComponentPropsWithRef<'div'> & {
+    /** True while an older-history page is being fetched. */
+    isLoading?: boolean;
+};
+/**
+ * Inline status row shown at the top of the message list when older history
+ * pages are available. Doubles as the scroll sentinel observed by
+ * `HistoryLoaderContainer`.
+ */
+declare const HistoryLoader: react.ForwardRefExoticComponent<Omit<HistoryLoaderProps, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare module '../theme/SlotsProvider.js' {
+    interface AtomSlots {
+        HistoryLoader: typeof HistoryLoader;
+    }
+}
+
+type ScrollToBottomButtonProps = Omit<ComponentProps<'button'>, 'children' | 'aria-label'>;
+declare const ScrollToBottomButton: react.ForwardRefExoticComponent<Omit<ScrollToBottomButtonProps, "ref"> & react.RefAttributes<HTMLSpanElement>>;
+declare module '../theme/SlotsProvider.js' {
+    interface AtomSlots {
+        ScrollToBottomButton: typeof ScrollToBottomButton;
+    }
+}
+
+type SyntaxHighlighterProps = {
+    code: string;
+    language?: string;
+    darkTheme?: boolean;
+    className?: string;
+    showLineNumbers?: boolean;
+};
+declare const SyntaxHighlighter: ComponentType<SyntaxHighlighterProps>;
+declare module '../theme/SlotsProvider.js' {
+    interface AtomSlots {
+        SyntaxHighlighter: typeof SyntaxHighlighter;
+    }
+}
+
+type UserMessageEditProps = {
+    /** Timestamp node rendered beside the "User" label. */
+    timestamp?: ReactNode;
+    /** Read-only attachments shown above the input while editing. */
+    attachments?: ReactNode;
+    input: ReactNode;
+    footer: ReactNode;
+    className?: string;
+};
+declare const UserMessageEdit: react.ForwardRefExoticComponent<UserMessageEditProps & HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
+declare module '../theme/SlotsProvider.js' {
+    interface AtomSlots {
+        UserMessageEdit: typeof UserMessageEdit;
+    }
+}
+
+/**
+ * Controlled accordion compatible with prior tfy `expanded` / `onChange` slot usage.
+ */
+type AccordionProps = {
+    expanded?: boolean;
+    onChange?: (event: unknown, expanded: boolean) => void;
+    children?: ReactNode;
+    className?: string;
+    background?: string;
+    sx?: unknown;
+} & Omit<react__default.HTMLAttributes<HTMLDivElement>, 'onChange'>;
+declare function Accordion({ expanded, onChange, children, className, background: _background, sx: _sx, ...rest }: AccordionProps): react__default.JSX.Element;
+type AccordionSummaryProps = {
+    children?: ReactNode;
+    className?: string;
+    expanded?: boolean;
+    onChange?: (event: unknown, expanded: boolean) => void;
+    panelId?: string;
+    hideIcon?: boolean;
+    disableRipple?: boolean;
+    sx?: unknown;
+};
+declare function AccordionSummary({ children, className, expanded, onChange, panelId }: AccordionSummaryProps): react__default.JSX.Element;
+type AccordionDetailsProps = {
+    children?: ReactNode;
+    className?: string;
+    expanded?: boolean;
+    panelId?: string;
+    sx?: unknown;
+};
+declare function AccordionDetails({ children, className, expanded, panelId }: AccordionDetailsProps): react__default.JSX.Element | null;
+declare module '../../theme/SlotsProvider.js' {
+    interface AtomSlots {
+        Accordion: typeof Accordion;
+        AccordionSummary: typeof AccordionSummary;
+        AccordionDetails: typeof AccordionDetails;
+    }
+}
+
+type AgentStepsCardProps = {
+    toolCount: number;
+    thinkingCount: number;
+    expanded: boolean;
+    active?: boolean;
+    onToggle: () => void;
+    children: ReactNode;
+    borderColor?: string;
+    background?: string;
+    dataTestPrefix?: string;
+    className?: string;
+};
+declare function AgentStepsCard({ toolCount, thinkingCount, expanded, active, onToggle, children, borderColor, background, dataTestPrefix, className, }: AgentStepsCardProps): react.JSX.Element;
+declare module '../../theme/SlotsProvider.js' {
+    interface AtomSlots {
+        AgentStepsCard: typeof AgentStepsCard;
+    }
+}
+
+type Question = {
+    id: string;
+    question: string;
+    options: string[];
+};
+type AnsweredQuestion = Question & {
+    answer: string;
+    isCustom: boolean;
+};
+type AskUserAnswerDraft = {
+    radioValue: string;
+    custom: string;
+};
+type AskUserPromptProps = {
+    questions: Question[];
+    answeredQuestions?: AnsweredQuestion[];
+    onSubmit: () => void;
+    currentQuestion?: Question;
+    currentQuestionIndex?: number;
+    currentAnswer?: AskUserAnswerDraft;
+    totalQuestions?: number;
+    isMultiQuestion?: boolean;
+    isLastQuestion?: boolean;
+    allQuestionsAnswered?: boolean;
+    isSubmitDisabled?: boolean;
+    isSubmitAllDisabled?: boolean;
+    onCurrentQuestionIndexChange?: (index: number) => void;
+    onCurrentAnswerChange?: (questionId: string, update: Partial<AskUserAnswerDraft>) => void;
+    readOnly?: boolean;
+    dataTestPrefix?: string;
+    className?: string;
+};
+declare function AskUserPrompt({ questions, answeredQuestions, onSubmit, currentQuestion, currentQuestionIndex, currentAnswer, totalQuestions, isMultiQuestion: isMultiQuestionProp, isLastQuestion: isLastQuestionProp, allQuestionsAnswered, isSubmitDisabled, isSubmitAllDisabled, onCurrentQuestionIndexChange, onCurrentAnswerChange, readOnly, dataTestPrefix, className, }: AskUserPromptProps): react.JSX.Element | null;
+declare module '../../theme/SlotsProvider.js' {
+    interface AtomSlots {
+        AskUserPrompt: typeof AskUserPrompt;
+    }
+}
+
+type McpServer = {
+    id: string;
+    name: string;
+};
+type McpAuthPromptProps = {
+    servers: McpServer[];
+    onConnect: (serverId: string) => void;
+    onContinue?: () => void;
+    readOnly?: boolean;
+    title?: string;
+    dataTestPrefix?: string;
+    className?: string;
+};
+declare function McpAuthPrompt({ servers, onConnect, onContinue, readOnly, title, dataTestPrefix, className, }: McpAuthPromptProps): react.JSX.Element | null;
+declare module '../../theme/SlotsProvider.js' {
+    interface AtomSlots {
+        McpAuthPrompt: typeof McpAuthPrompt;
+    }
+}
+
+type ReasoningCardProps = {
+    content: string;
+    isStreaming?: boolean;
+    expanded?: boolean;
+    onToggle?: () => void;
+    isMultiLine?: boolean;
+    reasoningTimeText?: string | null;
+    previewText?: string;
+    headingText?: string;
+    contentRef?: (node: HTMLDivElement | null) => void;
+    dataTestPrefix?: string;
+    className?: string;
+};
+declare function ReasoningCard({ content, isStreaming, expanded, onToggle, isMultiLine, reasoningTimeText, headingText, contentRef, dataTestPrefix, className, }: ReasoningCardProps): react.JSX.Element;
+declare module '../../theme/SlotsProvider.js' {
+    interface AtomSlots {
+        ReasoningCard: typeof ReasoningCard;
+    }
+}
+
+type ResumeUnavailableProps = {
+    className?: string;
+};
+/**
+ * Inline waiting notice when a response is still generating but this backend
+ * cannot stream it live.
+ */
+declare function ResumeUnavailable({ className }: ResumeUnavailableProps): react.JSX.Element;
+declare module '../theme/SlotsProvider.js' {
+    interface AtomSlots {
+        ResumeUnavailable: typeof ResumeUnavailable;
+    }
+}
+
+type AgentsLibraryProps = {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onSelectAgent?: (agentName: string) => void;
+};
+declare function AgentsLibrary({ open, onOpenChange, onSelectAgent }: AgentsLibraryProps): react.JSX.Element;
+declare module '../theme/SlotsProvider.js' {
+    interface AtomSlots {
+        AgentsLibrary: typeof AgentsLibrary;
+    }
+}
+
+type AgentsLibraryButtonProps = {
+    className?: string;
+    compact?: boolean;
+    onSelectAgent?: (agentName: string) => void;
+};
+declare function AgentsLibraryButton({ className, compact, onSelectAgent }: AgentsLibraryButtonProps): react.JSX.Element | null;
+declare module '../theme/SlotsProvider.js' {
+    interface AtomSlots {
+        AgentsLibraryButton: typeof AgentsLibraryButton;
+    }
+}
+
+type AssistantMessageBubbleProps = {
+    children: ReactNode;
+    error?: ReactNode;
+    actionBar?: ReactNode;
+    className?: string;
+};
+declare function AssistantMessageBubble({ children, error, actionBar, className }: AssistantMessageBubbleProps): react.JSX.Element;
+declare module '../theme/SlotsProvider.js' {
+    interface AtomSlots {
+        AssistantMessageBubble: typeof AssistantMessageBubble;
+    }
+}
+
+/** Fixed preview bounds for attachments rendered in user message bubbles. */
+declare const USER_MESSAGE_ATTACHMENT_PREVIEW_REM = 12;
+
+type AttachmentCardSize = 'chip' | 'preview';
+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 AttachmentPickerButtonProps = Omit<ComponentProps<'button'>, 'children' | 'aria-label'>;
+declare function AttachmentPickerButton({ className, ...props }: AttachmentPickerButtonProps): react.JSX.Element;
+declare module '../theme/SlotsProvider.js' {
+    interface AtomSlots {
+        AttachmentPickerButton: typeof AttachmentPickerButton;
+    }
+}
+
+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 ChatFileDownloadFile = {
+    name: string;
+    path: string;
+};
+type ChatFileDownloadProps = {
+    files: ChatFileDownloadFile[];
+    fileDownloadBaseUrl?: string;
+    onDownloadArtifact?: (path: string, filename: string) => Promise<void>;
+    readOnly?: boolean;
+};
+declare function ChatFileDownload({ files, fileDownloadBaseUrl, onDownloadArtifact, readOnly }: ChatFileDownloadProps): react.JSX.Element;
+declare module '../theme/SlotsProvider.js' {
+    interface AtomSlots {
+        ChatFileDownload: typeof ChatFileDownload;
+    }
+}
+
+declare function ClearChatButton(): react.JSX.Element | null;
+declare module '../theme/SlotsProvider.js' {
+    interface AtomSlots {
+        ClearChatButton: typeof ClearChatButton;
+    }
+}
+
+type MonacoEditorCoreProps = {
+    value: string;
+    language?: string;
+    /** Monaco theme name. Defaults to SDK light/dark themes (`aui-monaco-light` / `aui-monaco-dark`). */
+    theme?: string;
+    options?: Record<string, unknown>;
+    onChange?: (value: string) => void;
+    onMount?: (editor: unknown, monaco: unknown) => void;
+    beforeMount?: (monaco: unknown) => void;
+    onAutoHeightChange?: (height: number) => void;
+    className?: string;
+    /**
+     * Fixed height. Ignored when `autoHeight` is true (except as an initial
+     * fallback before the editor mounts). Use `"100%"` for fill-parent layouts
+     * (e.g. fullscreen dialogs) with `autoHeight={false}`.
+     */
+    height?: string | number;
+    /** Grow/shrink to content height, capped by `maxHeight`. Default false. */
+    autoHeight?: boolean;
+    /** Cap for `autoHeight` (px number or CSS length). Default `10.5rem`. */
+    maxHeight?: string | number;
+    /** Floor for `autoHeight` (px number or CSS length). Default one line. */
+    minHeight?: string | number;
+};
+declare function MonacoEditorCore({ value, language, theme, options, onChange, onMount, beforeMount, onAutoHeightChange, className, height, autoHeight, maxHeight, minHeight, }: MonacoEditorCoreProps): react.JSX.Element;
+declare module '../theme/SlotsProvider.js' {
+    interface AtomSlots {
+        MonacoEditorCore: typeof MonacoEditorCore;
+    }
+}
+
+type CodeEditorProps = Omit<MonacoEditorCoreProps, 'onAutoHeightChange' | 'options'> & {
+    filename?: string;
+    showToolbar?: boolean;
+};
+declare function CodeEditor({ value, language, theme, filename, onChange, onMount, beforeMount, className, height, showToolbar, }: CodeEditorProps): react.JSX.Element;
+declare module '../theme/SlotsProvider.js' {
+    interface AtomSlots {
+        CodeEditor: typeof CodeEditor;
+    }
+}
+
+type ComposerLeftSectionProps = {
+    disabled: boolean;
+    isRunning: boolean;
+    onAttach?: () => void;
+};
+type ComposerRightSectionProps = {
+    disabled: boolean;
+    isRunning: boolean;
+};
+type ComposerSendButtonProps = {
+    disabled: boolean;
+    canSubmit: boolean;
+    isRunning: boolean;
+    onSubmit: () => void;
+    onCancel?: () => void;
+};
+type ComposerLeftSectionSlot = (props: ComposerLeftSectionProps) => ReactNode;
+type ComposerRightSectionSlot = (props: ComposerRightSectionProps) => ReactNode;
+type ComposerSendButtonSlot = (props: ComposerSendButtonProps) => ReactNode;
+declare function ComposerLeftSection({ onAttach }: ComposerLeftSectionProps): react.JSX.Element | null;
+declare function ComposerRightSection(_: ComposerRightSectionProps): ReactNode;
+declare function ComposerSendButton({ canSubmit, isRunning, onSubmit, onCancel }: ComposerSendButtonProps): react.JSX.Element;
+declare module '../theme/SlotsProvider.js' {
+    interface AtomSlots {
+        ComposerLeftSection: ComposerLeftSectionSlot;
+        ComposerRightSection: ComposerRightSectionSlot;
+        ComposerSendButton: ComposerSendButtonSlot;
+    }
+}
+
+type ComposerShellProps = {
+    /** Message input node, supplied by the container (e.g. `<ComposerPrimitive.Input />`). */
+    input: ReactNode;
+    disabled: boolean;
+    canSubmit: boolean;
+    isRunning?: boolean;
+    attachments?: ReactNode;
+    modelLabel?: string;
+    modelIcon?: ReactNode;
+    connectorStatusLabel?: string;
+    onSubmit: () => void;
+    onCancel?: () => void;
+    onAttach?: () => void;
+    className?: string;
+};
+declare function ComposerShell({ input, disabled, canSubmit, isRunning, attachments, modelLabel, modelIcon, connectorStatusLabel, onSubmit, onCancel, onAttach, className, }: ComposerShellProps): react.JSX.Element;
+declare module '../theme/SlotsProvider.js' {
+    interface AtomSlots {
+        ComposerShell: typeof ComposerShell;
+    }
+}
+
+declare function DraftComposerLeftSection({ disabled, isRunning, onAttach }: ComposerLeftSectionProps): react.JSX.Element;
+declare function DraftComposerRightSection({ disabled, isRunning }: ComposerRightSectionProps): react.JSX.Element;
+declare module '../../theme/SlotsProvider.js' {
+    interface AtomSlots {
+        DraftComposerLeftSection: typeof DraftComposerLeftSection;
+        DraftComposerRightSection: typeof DraftComposerRightSection;
+    }
+}
+
+type DraftCompositeSelectorProps = {
+    disabled?: boolean;
+    isRunning?: boolean;
+    onAttach?: () => void;
+};
+declare function DraftCompositeSelector({ disabled, isRunning, onAttach }: DraftCompositeSelectorProps): react.JSX.Element;
+declare module '../../theme/SlotsProvider.js' {
+    interface AtomSlots {
+        DraftCompositeSelector: typeof DraftCompositeSelector;
+    }
+}
+
+type DraftModelSelectorProps = {
+    disabled?: boolean;
+    isRunning?: boolean;
+};
+declare function DraftModelSelector({ disabled, isRunning }: DraftModelSelectorProps): react.JSX.Element;
+declare module '../../theme/SlotsProvider.js' {
+    interface AtomSlots {
+        DraftModelSelector: typeof DraftModelSelector;
+    }
+}
+
+/** Preloads OpenUiFenceBlock so it's ready before the user sees openui content. */
+declare function preloadMarkdownOpenUI(): Promise<unknown>;
+type MarkdownProps = {
+    content: string;
+    isStreaming?: boolean;
+    /** Base URL for resolving sandbox artifact download paths (e.g. gateway file endpoint). */
+    fileDownloadBaseUrl?: string;
+    /** Custom download handler that receives the original sandbox artifact path. */
+    onDownloadArtifact?: (path: string, filename: string) => Promise<void>;
+    /** When true, download actions in sandbox artifact blocks are hidden/disabled. */
+    readOnly?: boolean;
+    className?: string;
+};
+declare function Markdown({ content, isStreaming, fileDownloadBaseUrl, onDownloadArtifact, readOnly, className, }: MarkdownProps): react.JSX.Element;
+declare module '../theme/SlotsProvider.js' {
+    interface AtomSlots {
+        Markdown: typeof Markdown;
+    }
+}
+
+type MessageActionBarProps = {
+    isCopied: boolean;
+    onCopy: () => void;
+    createdAt?: Date | string;
+    className?: string;
+};
+declare function MessageActionBar({ isCopied, onCopy, createdAt, className }: MessageActionBarProps): react.JSX.Element;
+declare module '../theme/SlotsProvider.js' {
+    interface AtomSlots {
+        MessageActionBar: typeof MessageActionBar;
+    }
+}
+
+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 MessageIndicatorProps = {
+    className?: string;
+};
+declare function MessageIndicator({ className }: MessageIndicatorProps): react.JSX.Element;
+declare module '../theme/SlotsProvider.js' {
+    interface AtomSlots {
+        MessageIndicator: typeof MessageIndicator;
+    }
+}
+
+type MessageTimestampProps = {
+    createdAt?: Date | string;
+    className?: string;
+};
+declare function MessageTimestamp({ createdAt, className }: MessageTimestampProps): react.JSX.Element | null;
+declare module '../theme/SlotsProvider.js' {
+    interface AtomSlots {
+        MessageTimestamp: typeof MessageTimestamp;
+    }
+}
+
+type OpenUiFenceBlockProps = {
+    content: string;
+    isStreaming?: boolean;
+    darkTheme?: boolean;
+};
+declare function OpenUiFenceBlock({ content, isStreaming, darkTheme }: OpenUiFenceBlockProps): react.JSX.Element;
+declare module '../theme/SlotsProvider.js' {
+    interface AtomSlots {
+        OpenUiFenceBlock: typeof OpenUiFenceBlock;
+    }
+}
+
+type SandboxArtifactDownloadProps = {
+    code: string;
+    fileDownloadBaseUrl?: string;
+    onDownloadArtifact?: (path: string, filename: string) => Promise<void>;
+    readOnly?: boolean;
+};
+declare function SandboxArtifactDownload({ code, fileDownloadBaseUrl, onDownloadArtifact, readOnly, }: SandboxArtifactDownloadProps): react.JSX.Element | null;
+declare module '../theme/SlotsProvider.js' {
+    interface AtomSlots {
+        SandboxArtifactDownload: typeof SandboxArtifactDownload;
+    }
+}
+
+type ToolCallStatus = 'running' | 'success' | 'error';
+type ToolCallCardProps = {
+    icon?: string;
+    iconClassName?: string;
+    iconVariant?: 'primary' | 'muted';
+    toolName: string;
+    expanded?: boolean;
+    onToggle?: () => void;
+    awaiting?: boolean;
+    awaitingText?: string;
+    status?: ToolCallStatus;
+    exitCode?: number | null;
+    showExpandChevron?: boolean;
+    showResponseLine?: boolean;
+    responseIcon?: ReactNode;
+    approvalSlot?: ReactNode;
+    requestSlot?: ReactNode;
+    responseSlot?: ReactNode;
+    highlightCard?: boolean;
+    className?: string;
+    mcpServerName?: string;
+    dataTestPrefix?: string;
+};
+declare function ToolCallCard({ icon, iconClassName, iconVariant, toolName, expanded, onToggle, awaiting, awaitingText, status: explicitStatus, exitCode, showExpandChevron, showResponseLine, approvalSlot, requestSlot, responseSlot, highlightCard, className, mcpServerName: _mcpServerName, dataTestPrefix, }: ToolCallCardProps): react.JSX.Element;
+declare module '../theme/SlotsProvider.js' {
+    interface AtomSlots {
+        ToolCallCard: typeof ToolCallCard;
+    }
+}
+
+type SandboxToolCallCardProps = {
+    name: string;
+    intent?: string;
+    status: ToolCallStatus;
+    expanded: boolean;
+    onToggle: () => void;
+    command?: string;
+    exitCode?: number | null;
+    argsJson?: string;
+    resultText?: string;
+    resultJson?: string;
+    viewMode?: 'terminal' | 'code';
+    hasContent?: boolean;
+    onViewModeChange?: (viewMode: 'terminal' | 'code') => void;
+    durationText?: string;
+    dataTestPrefix?: string;
+    className?: string;
+};
+declare function SandboxToolCallCard({ name, intent, status, expanded, onToggle, command, exitCode, argsJson, resultText, resultJson, viewMode, hasContent, onViewModeChange, durationText, dataTestPrefix, className, }: SandboxToolCallCardProps): react.JSX.Element;
+declare module '../theme/SlotsProvider.js' {
+    interface AtomSlots {
+        SandboxToolCallCard: typeof SandboxToolCallCard;
+    }
+}
+
+type SaveAgentButtonProps = {
+    disabled?: boolean;
+    className?: string;
+    children?: string;
+};
+declare function SaveAgentButton({ disabled, className, children }: SaveAgentButtonProps): react.JSX.Element;
+declare module '../theme/SlotsProvider.js' {
+    interface AtomSlots {
+        SaveAgentButton: typeof SaveAgentButton;
+    }
+}
+
+/** Empty main pane when AgentLibrary has no agent selected yet. */
+declare function SelectAgentEmptyState(): react.JSX.Element | null;
+declare module '../theme/SlotsProvider.js' {
+    interface AtomSlots {
+        SelectAgentEmptyState: typeof SelectAgentEmptyState;
+    }
+}
+
+/**
+ * Optional host chrome (e.g. logout) to the right of theme + settings in {@link ShellActions}.
+ * Default is empty; override via `overrides.ShellActionsActionSlot`.
+ * Layouts keep {@link ShellActions} mounted while Settings is open so host state is not remounted.
+ */
+declare function ShellActionsActionSlot(): ReactNode;
+declare module '../theme/SlotsProvider.js' {
+    interface AtomSlots {
+        ShellActionsActionSlot: typeof ShellActionsActionSlot;
+    }
+}
+
+type MessageListSkeletonProps = {
+    className?: string;
+};
+declare function MessageListSkeleton({ className }: MessageListSkeletonProps): react.JSX.Element;
+declare module '../theme/SlotsProvider.js' {
+    interface AtomSlots {
+        MessageListSkeleton: typeof MessageListSkeleton;
+    }
+}
+
+type SubAgentCardProps = {
+    agentName: string;
+    instruction: string;
+    stepCount: number;
+    status: ToolCallStatus;
+    expanded: boolean;
+    onToggle: () => void;
+    durationText?: string;
+    children?: ReactNode;
+    renderInstruction?: (instruction: string) => ReactNode;
+    dataTestPrefix?: string;
+    className?: string;
+};
+declare function SubAgentCard({ agentName, instruction, stepCount: _stepCount, status, expanded, onToggle, durationText, children, renderInstruction, dataTestPrefix, className, }: SubAgentCardProps): react.JSX.Element;
+declare module '../theme/SlotsProvider.js' {
+    interface AtomSlots {
+        SubAgentCard: typeof SubAgentCard;
+    }
+}
+
+type ThreadListNewButtonProps = ComponentProps<'button'>;
+declare function ThreadListNewButton({ className, children, style, ...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 ThreadListRowProps = {
+    title: string;
+    active: boolean;
+    onSelect: () => void;
+    /** Named-agent label under the title (from session.agentName). */
+    agentName?: string;
+    /** Shown as compact relative time on the right. */
+    lastMessageAt?: Date;
+    /** Overflow actions (e.g. delete menu) — rendered as a sibling of the title button. */
+    actions?: ReactNode;
+    className?: string;
+};
+declare function ThreadListRow({ title, active, onSelect, agentName, lastMessageAt, actions, className, }: ThreadListRowProps): react.JSX.Element;
+declare module '../theme/SlotsProvider.js' {
+    interface AtomSlots {
+        ThreadListRow: typeof ThreadListRow;
+    }
+}
+
+type ToastProps = {
+    title: string;
+    description: string;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    variant?: 'error' | 'success';
+    className?: string;
+};
+declare function Toast({ title, description, open, onOpenChange, variant, className }: ToastProps): react.JSX.Element | null;
+type ToastStackProps = {
+    children: ReactNode;
+    duration?: number;
+};
+declare function ToastStack({ children, duration: _duration }: ToastStackProps): react.JSX.Element;
+declare module '../theme/SlotsProvider.js' {
+    interface AtomSlots {
+        Toast: typeof Toast;
+        ToastStack: typeof ToastStack;
+    }
+}
+
+type ApprovalOption = {
+    id: string;
+    label: string;
+    variant?: 'primary' | 'secondary' | 'destructive';
+    requiresReason?: boolean;
+    grants?: readonly string[];
+    confirm?: {
+        title?: string;
+        description?: string;
+    };
+};
+type ToolApprovalBarProps = {
+    toolName: string;
+    approveOptions?: ApprovalOption[];
+    denyOptions?: ApprovalOption[];
+    onSelect: (optionId: string, reason?: string) => void;
+    status?: {
+        type: 'approved' | 'denied';
+        label?: string;
+        reason?: string;
+    };
+    selectedDenyOption?: ApprovalOption;
+    denialReason?: string;
+    showReasonError?: boolean;
+    onDenyOptionChange?: (optionId: string | null) => void;
+    onDenialReasonChange?: (reason: string) => void;
+    onReasonSubmit?: () => void;
+    disabled?: boolean;
+    readOnly?: boolean;
+    showLineBelow?: boolean;
+    dataTestPrefix?: string;
+    className?: string;
+};
+declare function ToolApprovalBar({ toolName, approveOptions, denyOptions, onSelect, status, selectedDenyOption, denialReason, showReasonError, onDenyOptionChange, onDenialReasonChange, onReasonSubmit, disabled, readOnly, showLineBelow, dataTestPrefix, className, }: ToolApprovalBarProps): react.JSX.Element;
+declare module '../theme/SlotsProvider.js' {
+    interface AtomSlots {
+        ToolApprovalBar: typeof ToolApprovalBar;
+    }
+}
+
+type ToolCallContentBlockProps = {
+    title: string;
+    content: string;
+    isJson?: boolean;
+    copyValue?: string;
+    maxHeight?: string;
+    resizable?: boolean;
+    fullscreen?: boolean;
+    onFullscreenChange?: (fullscreen: boolean) => void;
+    contentHeightRem?: number;
+    contentRef?: (node: HTMLDivElement | null) => void;
+    onContentHeightChange?: (height: number) => void;
+    dataTestPrefix?: string;
+    className?: string;
+};
+declare function ToolCallContentBlock({ title, content, isJson, copyValue, maxHeight, resizable, fullscreen, onFullscreenChange, contentHeightRem, contentRef, onContentHeightChange, dataTestPrefix, className, }: ToolCallContentBlockProps): react.JSX.Element;
+declare module '../theme/SlotsProvider.js' {
+    interface AtomSlots {
+        ToolCallContentBlock: typeof ToolCallContentBlock;
+    }
+}
+
+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 UserMessageActionBarProps = {
+    isCopied: boolean;
+    editDisabled?: boolean;
+    createdAt?: Date | string;
+    onCopy: () => void;
+    onEdit: () => void;
+    onRetry: () => void;
+    className?: string;
+};
+declare function UserMessageActionBar({ isCopied, editDisabled, createdAt, onCopy, onEdit, onRetry, className, }: UserMessageActionBarProps): react.JSX.Element;
+declare module '../theme/SlotsProvider.js' {
+    interface AtomSlots {
+        UserMessageActionBar: typeof UserMessageActionBar;
+    }
+}
+
+type UserMessageBubbleProps = {
+    text: string;
+    attachments?: ReactNode;
+    editAction?: ReactNode;
+    className?: string;
+};
+declare function UserMessageBubble({ text, attachments, editAction, className }: UserMessageBubbleProps): react.JSX.Element;
+declare module '../theme/SlotsProvider.js' {
+    interface AtomSlots {
+        UserMessageBubble: typeof UserMessageBubble;
+    }
+}
+
+type WelcomeScreenProps = {
+    heading?: string;
+    icon?: ReactNode;
+    className?: string;
+};
+declare function WelcomeScreen({ heading, icon, className }: WelcomeScreenProps): react.JSX.Element;
+declare module '../theme/SlotsProvider.js' {
+    interface AtomSlots {
+        WelcomeScreen: typeof WelcomeScreen;
+    }
+}
+
+/** Default slot implementations. Feature atoms + chrome; primitives via theme/CSS. */
+declare const defaultSlots: {
+    Accordion: typeof Accordion;
+    AccordionSummary: typeof AccordionSummary;
+    AccordionDetails: typeof AccordionDetails;
+    BrandLogo: typeof BrandLogo;
+    ComposerShell: typeof ComposerShell;
+    ComposerLeftSection: typeof ComposerLeftSection;
+    ComposerRightSection: typeof ComposerRightSection;
+    ComposerSendButton: typeof ComposerSendButton;
+    DraftComposerLeftSection: typeof DraftComposerLeftSection;
+    DraftComposerRightSection: typeof DraftComposerRightSection;
+    DraftCompositeSelector: typeof DraftCompositeSelector;
+    DraftModelSelector: typeof DraftModelSelector;
+    AssistantMessageBubble: typeof AssistantMessageBubble;
+    UserMessageBubble: typeof UserMessageBubble;
+    UserMessageEdit: react.ForwardRefExoticComponent<UserMessageEditProps & react.HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
+    UserMessageActionBar: typeof UserMessageActionBar;
+    MessageActionBar: typeof MessageActionBar;
+    MessageErrorBanner: typeof MessageErrorBanner;
+    MessageIndicator: typeof MessageIndicator;
+    MessageTimestamp: typeof MessageTimestamp;
+    Markdown: typeof Markdown;
+    SyntaxHighlighter: react.ComponentType<SyntaxHighlighterProps>;
+    OpenUiFenceBlock: typeof OpenUiFenceBlock;
+    SandboxArtifactDownload: typeof SandboxArtifactDownload;
+    ChatFileDownload: typeof ChatFileDownload;
+    MonacoEditorCore: typeof MonacoEditorCore;
+    CodeEditor: typeof CodeEditor;
+    WelcomeScreen: typeof WelcomeScreen;
+    ToolCallCard: typeof ToolCallCard;
+    ToolCallContentBlock: typeof ToolCallContentBlock;
+    ToolApprovalBar: typeof ToolApprovalBar;
+    ToolGroupCard: typeof ToolGroupCard;
+    SubAgentCard: typeof SubAgentCard;
+    SandboxToolCallCard: typeof SandboxToolCallCard;
+    AgentStepsCard: typeof AgentStepsCard;
+    ReasoningCard: typeof ReasoningCard;
+    AskUserPrompt: typeof AskUserPrompt;
+    McpAuthPrompt: typeof McpAuthPrompt;
+    ResumeUnavailable: typeof ResumeUnavailable;
+    AttachmentCard: typeof AttachmentCard;
+    AttachmentPreviewDialog: typeof AttachmentPreviewDialog;
+    AttachmentPickerButton: typeof AttachmentPickerButton;
+    ScrollToBottomButton: react.ForwardRefExoticComponent<Omit<ScrollToBottomButtonProps, "ref"> & react.RefAttributes<HTMLSpanElement>>;
+    ThreadListRow: typeof ThreadListRow;
+    ThreadListNewButton: typeof ThreadListNewButton;
+    AgentsLibrary: typeof AgentsLibrary;
+    AgentsLibraryButton: typeof AgentsLibraryButton;
+    SaveAgentButton: typeof SaveAgentButton;
+    SelectAgentEmptyState: typeof SelectAgentEmptyState;
+    ClearChatButton: typeof ClearChatButton;
+    ThreadListRowSkeleton: typeof ThreadListRowSkeleton;
+    ThreadListEmptyState: typeof ThreadListEmptyState;
+    ThreadListShell: typeof ThreadListShell;
+    HistoryLoader: react.ForwardRefExoticComponent<Omit<HistoryLoaderProps, "ref"> & react.RefAttributes<HTMLDivElement>>;
+    MessageListSkeleton: typeof MessageListSkeleton;
+    ThreadRootShell: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+    ThreadViewportShell: react.ForwardRefExoticComponent<Omit<ThreadViewportShellProps, "ref"> & react.RefAttributes<HTMLDivElement>>;
+    ThreadComposerAreaShell: react.ForwardRefExoticComponent<Omit<ThreadComposerAreaShellProps, "ref"> & react.RefAttributes<HTMLDivElement>>;
+    MessageGroup: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+    Toast: typeof Toast;
+    ToastStack: typeof ToastStack;
+    ShellActionsActionSlot: typeof ShellActionsActionSlot;
+};
+
+type ThemeMode = 'light' | 'dark' | 'system';
+type ThemePreset = 'trueforge' | 'claude' | 'chatgpt' | 'gemini';
+type SemanticTokens = {
+    sidebarBg: string;
+    topbarBg: string;
+    primaryBg: string;
+    secondaryBg: string;
+    border: string;
+    fontFamily: string;
+    inputBoxBg: string;
+    inputBorder: string;
+    textPrimary: string;
+    textSecondary: string;
+    cardBg: string;
+    dropdownSelectedItemBg: string;
+    dropdownSelectedItemText: string;
+    userMessageBg: string;
+    userMessageText: string;
+    assistantMessageBg: string;
+    assistantMessageText: string;
+    primaryButtonBg: string;
+    primaryButtonHover: string;
+    primaryButtonText: string;
+    secondaryButtonBg: string;
+    secondaryButtonHover: string;
+    secondaryButtonText: string;
+    ghostButtonBg: string;
+    ghostButtonHover: string;
+    ghostButtonText: string;
+    successBg: string;
+    successText: string;
+    failureBg: string;
+    failureText: string;
+    warningBg: string;
+    warningText: string;
+    focusRing: string;
+    radius: string;
+    composerRadius: string;
+    overlay: string;
+    shadowColor: string;
+    scrollbarThumb: string;
+};
+type IconProps$1 = {
+    className?: string;
+    style?: CSSProperties;
+    size?: string | number;
+    'aria-hidden'?: boolean | 'true' | 'false';
+    'aria-label'?: string;
+    'data-testid'?: string;
+};
+type IconComponent = LucideIcon | ((props: IconProps$1) => ReactNode) | FC<SVGProps<SVGSVGElement>>;
+type IconEntry = IconComponent | ReactNode;
+type IconMap = Record<string, IconEntry>;
+/**
+ * Logo sources. `light` / `dark` pick per resolved theme mode and fall back to
+ * each other, then to `src`. `href` wraps the logo in a same-tab link. The logo
+ * is labelled with `name`; replace the mark itself through the slot table when
+ * an image URL is not enough.
+ */
+type BrandLogoConfig = {
+    src?: string;
+    light?: string;
+    dark?: string;
+    href?: string;
+};
+/**
+ * Setting `brand` requires a `name`: it labels the logo, so a logo without one has
+ * no accessible name. `logo` is optional — omit it to pair host text with the stock
+ * mark.
+ */
+type BrandConfig = {
+    /** Display name, and the logo's accessible label. */
+    name: string;
+    /** Image URL, or per-mode sources. Omit to keep the default mark. */
+    logo?: string | BrandLogoConfig;
+};
+type ContentClassNames = {
+    markdown?: string;
+    inlineCode?: string;
+    syntaxHighlighter?: {
+        root?: string;
+        pre?: string;
+        code?: string;
+        lineNumber?: string;
+    };
+    openui?: {
+        root?: string;
+        scope?: string;
+    };
+    monaco?: {
+        root?: string;
+        editor?: string;
+        monacoTheme?: string;
+    };
+};
+type ThemeConfig = {
+    preset?: ThemePreset;
+    mode?: ThemeMode;
+    tokens?: Partial<SemanticTokens>;
+    brand?: BrandConfig;
+    className?: string;
+    icons?: IconMap;
+    classNames?: ContentClassNames;
+};
+type BuiltInLayout = 'sidebar' | 'drawer' | 'dock' | 'widget';
+type LayoutProp = BuiltInLayout | ComponentType<{
+    className?: string;
+}>;
+
+type PresetTokens = {
+    light: SemanticTokens;
+    dark: SemanticTokens;
+};
+declare const PRESETS: Record<ThemePreset, PresetTokens>;
+declare function resolvePresetTokens(preset: ThemePreset | undefined, mode: 'light' | 'dark'): SemanticTokens;
+
+type PublicAtomSlots = typeof defaultSlots;
+type SlotOverrides = Partial<PublicAtomSlots>;
+
+/** Merges `overrides` over parent/default slots. Containers resolve atoms via `useSlot`. */
+declare function SlotsProvider({ overrides, theme, children, }: {
+    overrides?: SlotOverrides;
+    /** Theme config. Pass `mode` for controlled light/dark/system; omit `mode` for uncontrolled. */
+    theme?: ThemeConfig;
+    children: ReactNode;
+}): react.JSX.Element;
+/** Resolves the atom implementation registered for `name` -- default unless overridden. */
+declare function useSlot<K extends keyof PublicAtomSlots>(name: K): PublicAtomSlots[K];
+/** Resolves the light or dark theme mode supplied by the SDK consumer. */
+declare function useThemeMode(): 'light' | 'dark';
+
+type ThemeContextValue = {
+    preset: ThemePreset;
+    /** Resolved light/dark (never `"system"`). */
+    mode: 'light' | 'dark';
+    /** Preference including `"system"` when uncontrolled. */
+    preference: ThemeMode;
+    isDark: boolean;
+    setTheme: (mode: ThemeMode) => void;
+    /** Partial: `theme.brand` is optional, so consumers fall back to SDK defaults. */
+    brand: Partial<BrandConfig>;
+    icons: IconMap;
+    classNames: ContentClassNames;
+    tokens: Partial<SemanticTokens>;
+};
+declare function ThemeProvider({ theme, children }: {
+    theme?: ThemeConfig;
+    children: ReactNode;
+}): react.JSX.Element;
+declare function useTheme(): Pick<ThemeContextValue, 'preset' | 'mode' | 'preference' | 'isDark' | 'setTheme'>;
+/** Configured branding. Fields are optional — `theme.brand` may be omitted entirely. */
+declare function useBrand(): Partial<BrandConfig>;
+declare function useContentClassNames(): ContentClassNames;
+declare function useThemeIcons(): IconMap;
+/** Safe for trees that may sit outside ThemeProvider (falls back to {}). */
+declare function useOptionalContentClassNames(): ContentClassNames;
+
+type BottomSheetProps = {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    children: ReactNode;
+    className?: string;
+    id?: string;
+    'aria-label': string;
+};
+declare function BottomSheet({ open, onOpenChange, children, className, id, 'aria-label': ariaLabel, }: BottomSheetProps): react.JSX.Element;
+
+type AuiButtonVariant = 'default' | 'secondary' | 'ghost' | 'destructive' | 'outline';
+type AuiButtonSize = 'default' | 'sm' | 'lg' | 'icon';
+
+type ButtonVariant = AuiButtonVariant;
+type ButtonSize = AuiButtonSize;
+type ButtonProps = react__default.ButtonHTMLAttributes<HTMLButtonElement> & {
+    variant?: ButtonVariant;
+    size?: ButtonSize;
+    asChild?: never;
+};
+
+type CenteredModalProps = {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    title: string;
+    description?: string;
+    headerIcon?: ReactNode;
+    children: ReactNode;
+    className?: string;
+    contentSized?: boolean;
+    'aria-label'?: string;
+};
+/**
+ * Responsive modal chrome: centered dialog on `md+`, bottom sheet below `md`.
+ * One content tree for both breakpoints (native `<dialog>`).
+ */
+declare function CenteredModal({ open, onOpenChange, title, description, headerIcon, children, className, contentSized, 'aria-label': ariaLabel, }: CenteredModalProps): react.JSX.Element;
+
+type IconButtonProps = Omit<ButtonProps, 'size' | 'children'> & {
+    'aria-label': string;
+    tooltip?: string;
+    children: react__default.ReactNode;
+};
+
+type SwitchSize = 'sm' | 'md';
+type SwitchProps = Omit<ComponentPropsWithoutRef<'button'>, 'aria-checked' | 'children' | 'onClick' | 'role'> & {
+    checked: boolean;
+    onCheckedChange: (checked: boolean) => void;
+    size?: SwitchSize;
+};
+declare function Switch({ checked, onCheckedChange, size, disabled, className, ...props }: SwitchProps): react.JSX.Element;
+
+type IconProps = IconProps$1 & {
+    name: string | readonly string[];
+};
+declare function Icon({ name, className, style, size, ...aria }: IconProps): react.JSX.Element | null;
+
+type AvatarProps = react__default.HTMLAttributes<HTMLDivElement> & {
+    size?: 'default' | 'sm' | 'lg';
+};
+declare function Avatar({ className, size, ...props }: AvatarProps): react__default.JSX.Element;
+type AvatarImageProps = react__default.ImgHTMLAttributes<HTMLImageElement>;
+declare function AvatarImage({ className, src, alt, onError, ...props }: AvatarImageProps): react__default.JSX.Element | null;
+type AvatarFallbackProps = react__default.HTMLAttributes<HTMLDivElement>;
+declare function AvatarFallback({ className, ...props }: AvatarFallbackProps): react__default.JSX.Element;
+
+interface AgentStepsContainerProps {
+    toolCount: number;
+    thinkingCount: number;
+    hasFinal: boolean;
+}
+/**
+ * Container for "Agent steps" section — groups reasoning, intermediate text, and tools
+ * in a collapsible accordion that auto-collapses once final answer is confirmed.
+ */
+declare function AgentStepsContainer({ children, toolCount, thinkingCount, hasFinal, }: PropsWithChildren<AgentStepsContainerProps>): react.JSX.Element;
+
+declare function AskUserContainer(): react.JSX.Element | null;
+
+declare function AssistantMessageContainer(): react.JSX.Element;
+
+declare function AssistantTextContainer(): react.JSX.Element;
+
+declare function ComposerAttachmentsContainer(): react.JSX.Element;
+declare function MessageAttachmentsContainer(): react.JSX.Element;
+declare function ComposerAttachmentPickerContainer(): react.JSX.Element;
+
+type ComposerContainerProps = {
+    placeholder?: string;
+};
+declare function ComposerContainer({ placeholder, }: ComposerContainerProps): react.JSX.Element;
+
+/**
+ * Renders `HistoryLoader` at the top of the message list and fetches
+ * the next older history page when the user scrolls near it. Scroll position
+ * is preserved across the prepend so the list doesn't jump.
+ *
+ * Must be rendered inside `ThreadViewportShell` (it locates the scroll root
+ * via the `aui_thread-viewport` data-slot on its nearest scrollable ancestor).
+ */
+declare function HistoryLoaderContainer(): react.JSX.Element | null;
+
+declare function McpAuthContainer(): react.JSX.Element | null;
+
+declare const PostMcpOauthScreen: () => react.JSX.Element;
+
+type ThreadGroupPart = MessagePrimitive.GroupedParts.GroupPart;
+declare function ToolGroupContainer({ children, group }: PropsWithChildren<{
+    group: ThreadGroupPart;
+}>): react.JSX.Element;
+
+declare function ReasoningContainer({ group }: {
+    group: ThreadGroupPart;
+}): react.JSX.Element;
+
+declare function ResumeUnavailableContainer(): react.JSX.Element | null;
+
+/** The full assembled thread view: message list + composer. */
+declare function Thread(): react.JSX.Element;
+
+type ThreadContainerProps = {
+    /** Composer for the empty-welcome and docked bottom areas. `<Thread />` passes `<ComposerContainer />`. */
+    composer?: ReactNode;
+};
+declare function ThreadContainer({ composer }: ThreadContainerProps): react.JSX.Element;
+
+/**
+ * Simplified relative to the reference: renders threads in a single flat list
+ * rather than grouping them by Today/Yesterday/Earlier.
+ *
+ * Delete uses assistant-ui ThreadListItemPrimitive.Delete / ThreadListItemMorePrimitive
+ * (adapter.delete → server.deleteSession). Mobile/compact keeps a BottomSheet chrome.
+ */
+type ThreadListContainerProps = {
+    /** Called after New chat or selecting a row — used by stack/drawer chrome. */
+    onThreadOpen?: () => void;
+};
+declare function ThreadListContainer({ onThreadOpen }?: ThreadListContainerProps): react.JSX.Element;
+
+type ToastContent = {
+    title: string;
+    description?: string;
+};
+type ToasterContextValue = {
+    showError: (error: unknown) => void;
+    showSuccess: (content: ToastContent) => void;
+};
+declare function ToasterProvider({ children }: {
+    children: ReactNode;
+}): react.JSX.Element;
+declare function useToaster(): ToasterContextValue;
+/** Same as `useToaster`, but returns `null` instead of throwing outside `ToasterProvider`. */
+declare function useToasterOptional(): ToasterContextValue | null;
+
+type ToolApprovalOption = {
+    id: string;
+    label: string;
+    isAllow: boolean;
+    grants?: readonly string[];
+    confirm?: {
+        title?: string;
+        description?: string;
+    };
+};
+type ToolApprovalContainerProps = {
+    toolName?: string;
+    options: ToolApprovalOption[];
+    onSelectOption: (optionId: string, reason?: string) => void;
+};
+declare function ToolApprovalContainer({ toolName, options, onSelectOption }: ToolApprovalContainerProps): react.JSX.Element;
+
+declare const ToolCallContainer: ToolCallMessagePartComponent;
+
+declare function ToolCallContentBlockContainer(props: ToolCallContentBlockProps): react.JSX.Element;
+
+/** Host-facing shell configuration for agent / library / composer chrome. */
+type AgentConfig = {
+    mode: 'SingleAgent';
+    name: string;
+} | {
+    mode: 'AgentLibrary';
+} | {
+    mode: 'AgentComposer';
+    defaultAgentSpec?: AgentSpec;
+} | {
+    mode: 'AgentLibraryWithComposer';
+    defaultAgentSpec?: AgentSpec;
+};
+declare const DEFAULT_AGENT_CONFIG: AgentConfig;
+/**
+ * Active chat binding. Mutability (`isMutable`) decides composer / Save / updateSession —
+ * not a parallel draft|named shell type.
+ */
+type ShellMode = {
+    status: 'idle';
+} | {
+    status: 'active';
+    isMutable: boolean;
+    /** Identity for immutable bind + history filter. */
+    agentId?: string;
+    /** Display / welcome label (often same as agentId). */
+    agentName?: string;
+    /** Seed for mutable (draft) runtime. */
+    agentSpec?: AgentSpec;
+    locked: boolean;
+};
+/** Library / New Chat create intent. */
+type SelectLibraryAgentRequest = {
+    isMutable: boolean;
+    agentId?: string;
+    agentName?: string;
+    agentSpec?: AgentSpec;
+};
+type ShellModeContextValue = {
+    mode: ShellMode;
+    /** Host agentConfig mode (capabilities source). */
+    agentConfigMode: AgentConfig['mode'];
+    /** Agents Library chrome. */
+    isLibraryEnabled: boolean;
+    /** Mutable composer / Save Agent chrome (host capability). */
+    isComposerEnabled: boolean;
+    /** Sidebar / list New Chat control. */
+    isNewChatEnabled: boolean;
+    settingsOpen: boolean;
+    setSettingsOpen: (open: boolean) => void;
+    /**
+     * Bind from the Agents Library (Try = immutable, Edit = mutable + agentSpec).
+     * Prefer this over `selectAgent` / `openDraft` when both fields are available.
+     */
+    selectLibraryAgent: (req: SelectLibraryAgentRequest) => void;
+    /**
+     * Attach identity + agentSpec to the *current* mutable chat without remounting.
+     * Used after `saveAgent` so the same draft session continues as an editable agent.
+     */
+    bindMutableAgent: (req: {
+        agentId: string;
+        agentName: string;
+        agentSpec: AgentSpec;
+    }) => void;
+    /** @deprecated Prefer `selectLibraryAgent({ isMutable: false, agentName })`. */
+    selectAgent: (agentName: string) => void;
+    /** @deprecated Prefer `selectLibraryAgent({ isMutable: true, agentSpec })`. */
+    openDraft: () => void;
+    /**
+     * Open a history session, remounting when mutability/identity changes.
+     * Prefer explicit `isMutable` from the session row; when omitted, agentName
+     * present → immutable and agentName absent → mutable. Immutable rows may omit
+     * `agentName` when the registry agent was deleted.
+     */
+    openHistorySession: (req: {
+        sessionId: string;
+        agentName?: string;
+        isMutable?: boolean;
+    }) => void;
+    /** Reset current chat; no-op when idle. */
+    clearChat: () => void;
+    /** Remount key for the chat runtime when binding changes. */
+    runtimeKey: string;
+    /**
+     * History list filter forwarded as `listSessions({ agentId })`.
+     * `null` = All chats. Only meaningful when `isLibraryEnabled`.
+     */
+    historyAgentFilter: string | null;
+    setHistoryAgentFilter: (agentId: string | null) => void;
+    /** Effective `listSessionsAgentId` for the runtime (SingleAgent locks to name). */
+    listSessionsAgentId: string | undefined;
+    /** Session to open after a binding remount (history click across mutability). */
+    pendingSessionId: string | undefined;
+    /**
+     * Bumped when the Agents Library catalog may have changed (e.g. after saveAgent).
+     * Library chrome should re-fetch when this changes.
+     */
+    agentsListEpoch: number;
+    invalidateAgentsList: () => void;
+};
+declare function libraryAgentId(agent: Pick<AgentLibraryEntry, 'agentId' | 'name'>): string;
+declare function ShellModeProvider({ agentConfig, initialSettingsOpen, children, }: {
+    agentConfig?: AgentConfig;
+    /** Open settings on first paint (e.g. host boot with no models). Does not re-open later. */
+    initialSettingsOpen?: boolean;
+    children: ReactNode;
+}): react.JSX.Element;
+declare function useShellMode(): ShellModeContextValue;
+declare function useOptionalShellMode(): ShellModeContextValue | null;
+/** True when the shell is bound to a mutable (editable) agentSpec. */
+declare function shellIsMutable(mode: ShellMode): boolean;
+
+/**
+ * Built-in backends init inside `<TrueforgeUI />`.
+ * Optional `catalog` is attached onto the resolved `AgentUIServer`.
+ */
+type TrueforgeBuiltInServerConfig = {
+    type: 'truefoundry';
+    apiKey: string;
+    controlPlaneURL: string;
+    gatewayPlaneURL?: string;
+    catalog?: CatalogServer;
+} | {
+    type: 'trueforge';
+    /** Harness API root. Defaults to `'/'` (same-origin / proxied). */
+    baseUrl?: string;
+    /** Bearer token for `@truefoundry/trueforge-sdk` (`Authorization: Bearer …`). */
+    token?: string;
+    /** Custom fetch (cookie sessions, auth interceptors). */
+    fetch?: typeof fetch;
+    catalog?: CatalogServer;
+};
+/**
+ * `server` prop for `<TrueforgeUI />`: a built-in config, or a ready
+ * {@link AgentUIServer} passed directly (no `{ type: "custom" }` wrapper).
+ */
+type TrueforgeServerConfig = TrueforgeBuiltInServerConfig | AgentUIServer;
+
+type ChatLayout = 'sidebar' | 'drawer' | 'dock' | 'widget';
+
+type RuntimeAdapters$1 = NonNullable<UseTrueFoundryAgentRuntimeOptions['adapters']>;
+type TrueforgeUIProps = {
+    server: TrueforgeServerConfig;
+    layout: LayoutProp;
+    overrides?: SlotOverrides;
+    theme?: ThemeConfig;
+    className?: string;
+    initialSessionId?: string;
+    adapters?: RuntimeAdapters$1;
+    onError?: (error: unknown) => void;
+    /**
+     * Agent / library / composer shell mode.
+     * Defaults to `{ mode: "AgentLibraryWithComposer" }`.
+     */
+    agentConfig?: AgentConfig;
+    /** Open settings on first paint only (host boot with no models configured). */
+    initialSettingsOpen?: boolean;
+};
+/**
+ * Quick-start assistant UI: slots + runtime + a built-in or custom layout.
+ * Pass a built-in `server` config, a ready `AgentUIServer`, and optional `agentConfig`.
+ */
+declare function TrueforgeUI(props: TrueforgeUIProps): react.JSX.Element;
+
+type RuntimeAdapters = NonNullable<UseTrueFoundryAgentRuntimeOptions['adapters']>;
+type TrueFoundryChatProviderProps = {
+    server: AgentUIServer;
+    initialSessionId?: string;
+    adapters?: RuntimeAdapters;
+    onError?: (error: unknown) => void;
+    children: ReactNode;
+    /** Discriminated agent source. Prefer over legacy `agentName`. */
+    agent?: TrueFoundryAgentConfig;
+    /** Legacy named-agent shorthand. Prefer `agent: { mode: "named", agentName }`. */
+    agentName?: string;
+    /** Forwarded to `listSessions({ agentId })` for history filtering. */
+    listSessionsAgentId?: string;
+};
+/**
+ * Chat shell: wires `useTrueFoundryAgentRuntime` from `server` and provides
+ * assistant-ui + error toasts.
+ */
+declare function TrueFoundryChatProvider(props: TrueFoundryChatProviderProps): react.JSX.Element;
+
+declare function UserEditComposerContainer(): react.JSX.Element;
+
+declare function UserMessageContainer(): 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;
+
+type ThreadPauseState = {
+    thread: {
+        messages: readonly {
+            role: string;
+            status?: {
+                type: string;
+            };
+            metadata?: {
+                custom?: unknown;
+            };
+        }[];
+    };
+};
+/** Returns true when the latest assistant message is paused for MCP authorization. */
+declare function threadHasPendingMcpAuth(s: ThreadPauseState): boolean;
+type ComposerPauseView = {
+    kind: 'mcp';
+} | {
+    kind: 'ask-user';
+} | {
+    kind: 'compose';
+};
+/** Shared composer pause detection for default and custom composer containers. */
+declare function useComposerPauseView(): ComposerPauseView;
+
+declare const MCP_AUTH_POPUP_CHANNEL = "truefoundry-mcp-auth-popup";
+type McpAuthPopupMessage = {
+    popupUid: string;
+    isSuccess: boolean;
+};
+type McpAuthCallback = (isSuccess: boolean) => void;
+type UseMCPAuthOptions = {
+    callbackPath?: string;
+};
+declare const useMCPAuth: ({ callbackPath }?: UseMCPAuthOptions) => {
+    handleAuthorize: (integrationId: string, callback: McpAuthCallback) => Promise<void>;
+    isOAuthLoading: boolean;
+};
+
+declare function ServerProvider({ server, children }: {
+    server: AgentUIServer;
+    children: ReactNode;
+}): react.JSX.Element;
+declare function useServer(): AgentUIServer;
+declare function useOptionalServer(): AgentUIServer | null;
+declare function useServerCapabilities(): AgentBuilderCapabilitiesResponse['data'] | null;
+declare function useCatalogServer(): CatalogServer;
+declare function useOptionalCatalogServer(): CatalogServer | null;
+
+type AgentStepPart = {
+    type: PartState['type'];
+    text?: string;
+};
+interface AgentStepsSplitResult {
+    cutIndex: number;
+    hasFinal: boolean;
+    toolCount: number;
+    thinkingCount: number;
+}
+declare function computeAgentStepsSplit(parts: readonly AgentStepPart[], isRunning: boolean): AgentStepsSplitResult;
+
+/**
+ * User-facing error text. Prefers HTTP body `{ error: { message } }` when
+ * present (e.g. TrueForgeError), then `error.message` / `error.error.message`,
+ * then `fallback`, then a string form of the value.
+ */
+declare function getErrorMessage(error: unknown, fallback?: string): string;
+
+type DraftCatalogValue = {
+    models: ModelSelection[];
+    skills: AgentSkill[];
+    connectors: ConnectorState[];
+    loading: boolean;
+    error: string | null;
+    /** Kick off catalog fetch (idempotent). Call when a picker opens. */
+    ensureLoaded: () => void;
+    /** Refresh connector auth state without reloading unrelated catalogs. */
+    refreshConnectors: () => Promise<void>;
+};
+declare function DraftCatalogProvider({ children }: {
+    children: ReactNode;
+}): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | react.ReactPortal | react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | react.JSX.Element | null | undefined;
+declare function useDraftCatalog(): DraftCatalogValue;
+
+export { type AgentConfig, type AgentStepPart, AgentStepsCard, type AgentStepsCardProps, AgentStepsContainer, type AgentStepsContainerProps, type AgentStepsSplitResult, AgentsLibrary, AgentsLibraryButton, type AgentsLibraryButtonProps, type AgentsLibraryProps, type AskUserAnswerDraft, type AnsweredQuestion as AskUserAnsweredQuestion, AskUserContainer, type AskUserPromptProps, type Question as AskUserQuestion, type AskUserPromptProps as AskUserQuestionCardProps, AssistantMessageBubble, type AssistantMessageBubbleProps, AssistantMessageContainer, AssistantTextContainer, type PublicAtomSlots as AtomSlots, AttachmentCard, type AttachmentCardProps, type AttachmentCardSize, AttachmentPickerButton, type AttachmentPickerButtonProps, AttachmentPreviewDialog, type AttachmentPreviewDialogProps, Avatar, AvatarFallback, type AvatarFallbackProps, AvatarImage, type AvatarImageProps, type AvatarProps, BottomSheet, type BottomSheetProps, type BrandConfig, BrandLogo, type BrandLogoConfig, type ButtonProps, type ButtonSize, type ButtonVariant, CenteredModal, type CenteredModalProps, ChatFileDownload, type ChatFileDownloadFile, type ChatFileDownloadProps, type ChatLayout, ClearChatButton, CodeEditor, type CodeEditorProps, ComposerAttachmentPickerContainer, ComposerAttachmentsContainer, ComposerBusyProvider, type ComposerBusyState, ComposerContainer, type ComposerContainerProps, ComposerLeftSection, type ComposerLeftSectionProps, type ComposerPauseView, ComposerRightSection, type ComposerRightSectionProps, ComposerSendButton, type ComposerSendButtonProps, ComposerShell, type ComposerShellProps, type ContentClassNames, DEFAULT_AGENT_CONFIG, DraftCatalogProvider, DraftComposerLeftSection, DraftComposerRightSection, DraftCompositeSelector, type DraftCompositeSelectorProps, DraftModelSelector, type DraftModelSelectorProps, HistoryLoader, HistoryLoaderContainer, type HistoryLoaderProps, Icon, type IconButtonProps, type IconMap, type IconProps, type LayoutProp, MCP_AUTH_POPUP_CHANNEL, Markdown, type MarkdownProps, type McpAuthCallback, type McpAuthPromptProps as McpAuthCardProps, McpAuthContainer, type McpAuthPopupMessage, type McpAuthPromptProps, type McpServer as McpAuthServer, MessageActionBar, type MessageActionBarProps, MessageAttachmentsContainer, MessageErrorBanner, type MessageErrorBannerProps, MessageGroup, type MessageGroupProps, MessageIndicator, type MessageIndicatorProps, MessageListSkeleton, type MessageListSkeletonProps, MessageTimestamp, type MessageTimestampProps, MonacoEditorCore, type MonacoEditorCoreProps, OpenUiFenceBlock, type OpenUiFenceBlockProps, PRESETS, PostMcpOauthScreen, type ReasoningCardProps, ReasoningContainer, ResumeUnavailable, ResumeUnavailableContainer, type ResumeUnavailableProps, SandboxArtifactDownload, type SandboxArtifactDownloadProps, SandboxToolCallCard, type SandboxToolCallCardProps, SaveAgentButton, ScrollToBottomButton, type ScrollToBottomButtonProps, SelectAgentEmptyState, type SelectLibraryAgentRequest, type SemanticTokens, ServerProvider, ShellActionsActionSlot, type ShellMode, ShellModeProvider, type SlotOverrides, SlotsProvider, SubAgentCard, type SubAgentCardProps, Switch, type SwitchProps, type SwitchSize, SyntaxHighlighter, type SyntaxHighlighterProps, type ThemeConfig, type IconProps$1 as ThemeIconProps, type ThemeMode, type ThemePreset, ThemeProvider, Thread, ThreadComposerAreaShell, type ThreadComposerAreaShellProps, ThreadContainer, type ThreadContainerProps, type ThreadGroupPart, ThreadListContainer, type ThreadListContainerProps, ThreadListEmptyState, type ThreadListEmptyStateProps, ThreadListNewButton, type ThreadListNewButtonProps, ThreadListRow, type ThreadListRowProps, ThreadListRowSkeleton, type ThreadListRowSkeletonProps, ThreadListShell, type ThreadListShellProps, type ThreadPauseState, ThreadRootShell, type ThreadRootShellProps, ThreadViewportShell, type ThreadViewportShellProps, Toast, type ToastProps, ToastStack, type ToastStackProps, ToasterProvider, ToolApprovalBar, type ToolApprovalBarProps, ToolApprovalContainer, type ToolApprovalOption, ToolCallCard, type ToolCallCardProps, ToolCallContainer, ToolCallContentBlock, ToolCallContentBlockContainer, type ToolCallContentBlockProps, type ToolCallStatus, ToolGroupCard, type ToolGroupCardProps, ToolGroupContainer, TrueFoundryChatProvider, type TrueFoundryChatProviderProps, type TrueforgeBuiltInServerConfig, type TrueforgeServerConfig, TrueforgeUI, type TrueforgeUIProps, USER_MESSAGE_ATTACHMENT_PREVIEW_REM, type UseMCPAuthOptions, UserEditComposerContainer, UserMessageActionBar, type UserMessageActionBarProps, UserMessageBubble, type UserMessageBubbleProps, UserMessageContainer, UserMessageEdit, type UserMessageEditProps, WelcomeScreen, type WelcomeScreenProps, computeAgentStepsSplit, defaultSlots, getErrorMessage, libraryAgentId, preloadMarkdownOpenUI, resolvePresetTokens, shellIsMutable, threadHasPendingMcpAuth, useBrand, useBrandName, useCatalogServer, useComposerBusyState, useComposerPauseView, useContentClassNames, useDraftCatalog, useMCPAuth, useOptionalCatalogServer, useOptionalContentClassNames, useOptionalServer, useOptionalShellMode, useServer, useServerCapabilities, useShellMode, useSlot, useTheme, useThemeIcons, useThemeMode, useToaster, useToasterOptional };