@slipstream-ui/ai 0.0.0-stage → 0.4.0

package/LICENSE

@@ -0,0 +1,25 @@
+MIT License
+
+Copyright (c) 2021 Michael McShinsky
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+<<<<<<< HEAD
+SOFTWARE.
+=======
+SOFTWARE.
+>>>>>>> origin/main

package/dist/index.d.mts

@@ -0,0 +1,579 @@
+import * as React from 'react';
+
+/**
+ * AI Component Types
+ *
+ * Shared types for AI interaction components like Message, Conversation, etc.
+ */
+type MessageRole = 'user' | 'assistant' | 'system' | 'tool';
+type Message = {
+    id: string;
+    role: MessageRole;
+    content: string;
+    timestamp?: Date;
+    metadata?: Record<string, unknown>;
+};
+type ToolCall$1 = {
+    id: string;
+    name: string;
+    arguments: Record<string, unknown>;
+    result?: string | number | boolean | Record<string, unknown> | unknown[];
+    status: 'pending' | 'running' | 'completed' | 'failed';
+    /** Error detail rendered when status is failed. */
+    error?: string;
+};
+type ReasoningStep = {
+    id: string;
+    content: string;
+    timestamp?: Date;
+};
+/** A single citation or reference attached to an AI response. */
+type SourceItem = {
+    id: string;
+    title: string;
+    url?: string;
+    snippet?: string;
+};
+
+type MessageProps = {
+    message: Message;
+    className?: string;
+    showAvatar?: boolean;
+    avatarSrc?: string;
+    avatarFallback?: string;
+    /** Display name for the user role; override for localization. */
+    userLabel?: string;
+    /** Display name for the assistant role; override for localization. */
+    assistantLabel?: string;
+    /**
+     * Custom content renderer, e.g. for markdown/code blocks.
+     * When provided, it fully replaces the default plain-text rendering.
+     */
+    renderContent?: (content: string) => React.ReactNode;
+    /**
+     * Marks the response as still being generated: shows a typing cursor
+     * and sets aria-busy so assistive tech knows more content is coming.
+     */
+    isStreaming?: boolean;
+    /** Generation failure text; renders an error card in place of content. */
+    error?: string;
+    /** Called when the user requests a retry after `error`; omit to hide the action. */
+    onRetry?: () => void;
+    labels?: {
+        retry?: string;
+        edit?: string;
+        save?: string;
+        cancel?: string;
+    };
+    /**
+     * Edit-and-resubmit affordance for user messages: renders an Edit action
+     * that swaps content into an inline textarea and calls `onEditContent`.
+     */
+    onEditContent?: (content: string) => void;
+};
+/**
+ * Memoized: during token streaming the parent re-renders on every tick, but
+ * only the streaming message's object identity changes. Memo skips re-render
+ * (and timestamp re-formatting) for every other message in the transcript.
+ * Callback props must be referentially stable for memo to help.
+ */
+declare const MemoizedMessage: React.MemoExoticComponent<React.ForwardRefExoticComponent<MessageProps & React.RefAttributes<HTMLDivElement>>>;
+
+/** User sentiment for an AI response. */
+type FeedbackRating = 'up' | 'down';
+type MessageActionsProps = {
+    /**
+     * Visibility rule:
+     * - 'always': always visible (default)
+     * - 'on-hover': fades in when the parent message is hovered/focused
+     *   (add the `group` class to the parent element)
+     * - 'not-last': like 'on-hover', intended for non-latest messages
+     */
+    autohide?: 'always' | 'on-hover' | 'not-last';
+    /**
+     * Content to copy. Omit to hide the copy action, or pass a getter when
+     * the content lives outside this component.
+     */
+    content?: string;
+    /** Called after the user copies the message; receives the copied text. */
+    onCopy?: (content: string) => void;
+    /** Called with the selected rating; selecting the same rating clears it (passes undefined). */
+    onFeedback?: (rating: FeedbackRating | undefined) => void;
+    /** Called when the user requests a regenerated response; omit to hide the action. */
+    onRegenerate?: () => void;
+    labels?: {
+        copy?: string;
+        copied?: string;
+        thumbUp?: string;
+        thumbDown?: string;
+        regenerate?: string;
+    };
+    className?: string;
+};
+declare const MessageActions: React.ForwardRefExoticComponent<MessageActionsProps & React.RefAttributes<HTMLDivElement>>;
+
+/** A single file attached to a message or prompt. Display-only; upload logic stays consumer-side. */
+type AttachmentItem = {
+    id: string;
+    /** File name, including extension. */
+    name: string;
+    /** Human-readable size, e.g. "2.4 MB". */
+    size?: string;
+    /** MIME type or simple kind used for the chip label. */
+    type?: string;
+    /** Optional image thumbnail URL. */
+    previewUrl?: string;
+    status?: 'uploading' | 'done' | 'error';
+};
+type AttachmentProps = {
+    attachment: AttachmentItem;
+    /** Called when the user removes the attachment; omit to hide the remove control. */
+    onRemove?: (attachment: AttachmentItem) => void;
+    className?: string;
+};
+declare const Attachment: React.ForwardRefExoticComponent<AttachmentProps & React.RefAttributes<HTMLDivElement>>;
+
+type AttachmentListProps = {
+    attachments: AttachmentItem[];
+    /** Passed through to every Attachment; omit to hide remove controls. */
+    onRemove?: (attachment: AttachmentItem) => void;
+    className?: string;
+};
+declare const AttachmentList: React.ForwardRefExoticComponent<AttachmentListProps & React.RefAttributes<HTMLDivElement>>;
+
+type ResponseProps = {
+    /** Markdown content to render. */
+    children: string;
+    /**
+     * Repair unclosed emphasis/inline-code/fences while streaming so partial
+     * chunks render cleanly (default true).
+     */
+    parseIncompleteMarkdown?: boolean;
+    className?: string;
+};
+/**
+ * Streaming-optimized markdown renderer for AI responses.
+ *
+ * Wraps react-markdown with GFM support and routes fenced code blocks to
+ * the CodeBlock component for highlighting + copy.
+ */
+declare const Response: React.ForwardRefExoticComponent<ResponseProps & React.RefAttributes<HTMLDivElement>>;
+
+/**
+ * Repairs markdown that is mid-stream: closes unclosed bold/italic/strikethrough
+ * markers and unterminated inline code / code fences so partial chunks render
+ * without flickering or broken syntax.
+ *
+ * Deliberately conservative — only appends closing characters, never rewrites content.
+ */
+declare function closeIncompleteMarkdown(markdown: string): string;
+
+type CodeBlockProps = {
+    /** Raw code to display (no trailing newline needed). */
+    code: string;
+    /** Language identifier used for Prism highlighting. */
+    language?: string;
+    /** Show a copy-to-clipboard button (default true). */
+    showCopyButton?: boolean;
+    className?: string;
+};
+declare const CodeBlock: React.ForwardRefExoticComponent<CodeBlockProps & React.RefAttributes<HTMLDivElement>>;
+
+type ConfirmationStatus = 'pending' | 'approved' | 'rejected';
+type ConfirmationVariant = 'default' | 'warning' | 'destructive' | 'info' | 'success';
+/** Button variants accepted for the approve/reject actions (Button's variant union). */
+type ConfirmationActionVariant = 'default' | 'destructive' | 'outline' | 'secondary' | 'ghost' | 'link';
+type ConfirmationProps = {
+    /** Human-readable summary of the action requiring approval. */
+    title: string;
+    /** Optional detail: affected resource, arguments preview, risk note. */
+    description?: string;
+    /** Tool or action name shown as a mono chip. */
+    toolName?: string;
+    /** Controlled outcome; omit for fully interactive uncontrolled use. */
+    status?: ConfirmationStatus;
+    /** Accent color of the pending card (outcome chips always follow the result). */
+    variant?: ConfirmationVariant;
+    onApprove?: () => void;
+    onReject?: () => void;
+    /** Button styling for the approve/reject actions. */
+    approveVariant?: ConfirmationActionVariant;
+    rejectVariant?: ConfirmationActionVariant;
+    /** Hide the action buttons (controlled-only gate; status drives the chip). */
+    showActions?: boolean;
+    labels?: {
+        approve?: string;
+        reject?: string;
+        approved?: string;
+        rejected?: string;
+    };
+    className?: string;
+};
+/**
+ * Human-in-the-loop approval gate for agent actions (tool execution,
+ * destructive operations). The agent pauses until the user decides.
+ */
+declare const Confirmation: React.ForwardRefExoticComponent<ConfirmationProps & React.RefAttributes<HTMLDivElement>>;
+
+type BranchProps = {
+    /** Total number of message variants. Renders nothing when count < 2. */
+    count: number;
+    /** Zero-based index of the currently displayed variant. */
+    selected?: number;
+    /** Uncontrolled initial variant when `selected` is omitted. */
+    defaultSelected?: number;
+    onSelect?: (index: number) => void;
+    labels?: {
+        previous?: string;
+        next?: string;
+    };
+    className?: string;
+};
+/**
+ * Variant navigation for branched messages (`‹ 2 / 3 ›`).
+ * Purely presentational + minimal internal state; the consumer swaps content.
+ */
+declare const Branch: React.ForwardRefExoticComponent<BranchProps & React.RefAttributes<HTMLDivElement>>;
+
+type InlineCitationProps = {
+    /** The cited source; powers the hover/focus preview card. */
+    source: SourceItem;
+    /** Citation text to wrap (defaults to the source title). */
+    children?: React.ReactNode;
+    className?: string;
+};
+/**
+ * Perplexity-style inline citation: a superscript chip that reveals the
+ * source snippet on hover or keyboard focus.
+ */
+declare const InlineCitation: React.ForwardRefExoticComponent<InlineCitationProps & React.RefAttributes<HTMLSpanElement>>;
+
+type ConversationProps = {
+    messages: Message[];
+    className?: string;
+    showAvatars?: boolean;
+    userAvatarSrc?: string;
+    userAvatarFallback?: string;
+    assistantAvatarSrc?: string;
+    assistantAvatarFallback?: string;
+    isLoading?: boolean;
+    loadingMessage?: string;
+    /** Custom content renderer applied to every message (e.g. markdown). */
+    renderContent?: (content: string) => React.ReactNode;
+    /** ID of the message still being generated; renders its streaming cursor. */
+    streamingMessageId?: string;
+    /**
+     * Show a floating "scroll to latest" pill when the user has scrolled up.
+     * Default true.
+     */
+    showScrollButton?: boolean;
+    /** Show a download button that exports the transcript as Markdown. Default false. */
+    showDownload?: boolean;
+    /** Per-message generation failures keyed by message id; renders retry cards. */
+    messageErrors?: Record<string, string>;
+    /** Retry handler for failed messages in `messageErrors`. */
+    onRetryMessage?: (message: Message) => void;
+    /** Heading for the empty-transcript welcome state. */
+    welcomeTitle?: string;
+    /** Supporting copy for the welcome state. */
+    welcomeDescription?: string;
+    /** Starter prompts rendered as buttons under the welcome copy. */
+    welcomeSuggestions?: string[];
+    /** Called with the chosen starter prompt text. */
+    onWelcomeSelect?: (prompt: string) => void;
+    /** Older history exists; renders a "load earlier" control at the top. */
+    hasMoreHistory?: boolean;
+    /** Older history request is in flight; shows a loading row. */
+    isLoadingMore?: boolean;
+    /** Called when the user requests older history. */
+    onLoadMore?: () => void;
+};
+declare const Conversation: React.ForwardRefExoticComponent<ConversationProps & React.RefAttributes<HTMLDivElement>>;
+
+type UseAttachmentsOptions = {
+    /** File types to accept, e.g. "image/*" (HTML accept syntax). */
+    accept?: string;
+    /** Maximum number of queued files. */
+    maxFiles?: number;
+    /** Maximum size per file in bytes. */
+    maxFileSize?: number;
+    multiple?: boolean;
+    onError?: (error: {
+        code: 'max_files' | 'max_file_size' | 'accept';
+        message: string;
+    }) => void;
+};
+type UseAttachmentsResult = {
+    files: AttachmentItem[];
+    add: (fileList: FileList | File[]) => void;
+    remove: (id: string) => void;
+    clear: () => void;
+    openFileDialog: () => void;
+    /** Hidden file input element; render it once somewhere in your tree. */
+    input: React.ReactElement;
+};
+/**
+ * Headless attachment queue with constraint validation.
+ * Used internally by PromptInput and exported for custom composers.
+ */
+declare function usePromptInputAttachments(options?: UseAttachmentsOptions): UseAttachmentsResult;
+/** Web Speech API dictation; returns supported=false on unsupported browsers. */
+declare function useSpeechRecognition(onTranscript: (text: string) => void): {
+    supported: boolean;
+    isListening: boolean;
+    toggle: () => void;
+};
+type PromptInputProps = {
+    onSubmit: (value: string) => void;
+    /** Called when the user requests to stop an in-flight generation. */
+    onStop?: () => void;
+    /**
+     * Externally owned attachment queue. When omitted, PromptInput manages its
+     * own queue with drag-and-drop + clipboard-paste support.
+     */
+    attachments?: AttachmentItem[];
+    onRemoveAttachment?: (attachment: AttachmentItem) => void;
+    /** Called whenever the managed attachment queue changes. */
+    onAttachmentsChange?: (attachments: AttachmentItem[]) => void;
+    /** Marks submission as failed; the send control reflects the error state. */
+    hasError?: boolean;
+    accept?: string;
+    multiple?: boolean;
+    maxFiles?: number;
+    maxFileSize?: number;
+    onAttachmentError?: UseAttachmentsOptions['onError'];
+    /** Accept file drops anywhere on the document (default false). */
+    globalDrop?: boolean;
+    placeholder?: string;
+    disabled?: boolean;
+    isLoading?: boolean;
+    className?: string;
+    autoFocus?: boolean;
+    maxLength?: number;
+    showSendButton?: boolean;
+    sendButtonText?: string;
+    stopButtonText?: string;
+    children?: React.ReactNode;
+};
+declare const PromptInputRoot: React.ForwardRefExoticComponent<PromptInputProps & React.RefAttributes<HTMLTextAreaElement>>;
+/** Auto-resizing textarea bound to the prompt state. Accepts standard textarea props. */
+declare const PromptInputTextarea: React.ForwardRefExoticComponent<Omit<React.TextareaHTMLAttributes<HTMLTextAreaElement>, "onChange" | "value"> & React.RefAttributes<HTMLTextAreaElement>>;
+/** Status-aware submit control: send / stop / error icons chosen automatically. */
+declare const PromptInputSubmit: React.ForwardRefExoticComponent<{
+    className?: string;
+} & React.RefAttributes<HTMLButtonElement>>;
+/** Toolbar row under the textarea. */
+declare function PromptInputFooter({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
+/** Left-aligned group of tools inside a footer. */
+declare function PromptInputTools({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
+/** Row above the textarea (attachments, hints). */
+declare function PromptInputHeader({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
+/** Wrapper around the textarea row. */
+declare function PromptInputBody({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
+type PromptInputButtonProps = React.ButtonHTMLAttributes<HTMLButtonElement> & {
+    /** Tooltip content; optionally includes a keyboard shortcut hint. */
+    tooltip?: string | {
+        content: React.ReactNode;
+        shortcut?: string;
+    };
+    active?: boolean;
+};
+/** Small toolbar button with optional tooltip and shortcut hint. */
+declare const PromptInputButton: React.ForwardRefExoticComponent<React.ButtonHTMLAttributes<HTMLButtonElement> & {
+    /** Tooltip content; optionally includes a keyboard shortcut hint. */
+    tooltip?: string | {
+        content: React.ReactNode;
+        shortcut?: string;
+    };
+    active?: boolean;
+} & React.RefAttributes<HTMLButtonElement>>;
+/** Dictation toggle using the Web Speech API; hidden when unsupported. */
+declare function PromptInputActionDictate({ labels }: {
+    labels?: {
+        start?: string;
+        stop?: string;
+    };
+}): React.JSX.Element | null;
+/** Opens the managed file picker with configured constraints. */
+/** Opens the managed file picker with configured constraints. */
+declare function PromptInputActionAddAttachments({ label }: {
+    label?: string;
+}): React.JSX.Element;
+
+type ReasoningProps = {
+    steps: ReasoningStep[];
+    className?: string;
+    collapsible?: boolean;
+    defaultExpanded?: boolean;
+    /** Elapsed thinking time, e.g. 4 (seconds) or "4s"; rendered in the header. */
+    duration?: number | string;
+    /** Marks reasoning as still arriving: animated header state. */
+    isStreaming?: boolean;
+};
+declare const Reasoning: React.ForwardRefExoticComponent<ReasoningProps & React.RefAttributes<HTMLDivElement>>;
+
+type ToolCallProps = {
+    toolCall: ToolCall$1;
+    className?: string;
+    showResult?: boolean;
+};
+/**
+ * Displays a single tool invocation: name, status chip, serialized
+ * arguments, optional result, and an error block on failure.
+ */
+declare const ToolCall: React.ForwardRefExoticComponent<ToolCallProps & React.RefAttributes<HTMLDivElement>>;
+
+type SourceProps = {
+    source: SourceItem;
+    /**
+     * 1-based citation marker rendered as a `[n]` prefix.
+     * Omit to render the citation without numbering.
+     */
+    index?: number;
+    className?: string;
+};
+declare const Source: React.ForwardRefExoticComponent<SourceProps & React.RefAttributes<HTMLDivElement>>;
+
+type SourcesProps = {
+    sources: SourceItem[];
+    className?: string;
+    maxDisplay?: number;
+    /** Heading label; override for localization. */
+    label?: string;
+};
+declare const Sources: React.ForwardRefExoticComponent<SourcesProps & React.RefAttributes<HTMLDivElement>>;
+
+type Suggestion = {
+    id: string;
+    text: string;
+    type?: 'action' | 'query' | 'follow-up';
+};
+type SuggestionsProps = {
+    suggestions: Suggestion[];
+    onSelect?: (suggestion: Suggestion) => void;
+    className?: string;
+    maxDisplay?: number;
+};
+declare const Suggestions: React.ForwardRefExoticComponent<SuggestionsProps & React.RefAttributes<HTMLDivElement>>;
+
+type ChainThoughtStep = {
+    id: string;
+    content: string;
+    status?: 'pending' | 'completed' | 'failed';
+};
+type ChainThoughtProps = {
+    steps: ChainThoughtStep[];
+    className?: string;
+    compact?: boolean;
+};
+declare const ChainThought: React.ForwardRefExoticComponent<ChainThoughtProps & React.RefAttributes<HTMLDivElement>>;
+
+type StreamingIndicatorProps = {
+    isStreaming: boolean;
+    className?: string;
+    text?: string;
+};
+/**
+ * Animated three-dot streaming indicator. Announces the streaming state
+ * to screen readers via role="status" / aria-live so assistive tech
+ * users know generation is in progress.
+ */
+declare const StreamingIndicator: React.ForwardRefExoticComponent<StreamingIndicatorProps & React.RefAttributes<HTMLDivElement>>;
+
+type Command = {
+    id: string;
+    label: string;
+    /** Optional grouping header, e.g. "Navigation". */
+    section?: string;
+    /** Extra lexical search terms. */
+    keywords?: string[];
+    shortcut?: string;
+};
+type CommandPaletteProps = {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    commands: Command[];
+    onSelect: (command: Command) => void;
+    placeholder?: string;
+};
+/**
+ * Cmd+K command palette: combobox + listbox with aria-activedescendant
+ * keyboard navigation, lexical filtering over label/keywords, and
+ * Escape-to-close. No focus leaves the input while navigating.
+ */
+declare function CommandPalette({ open, onOpenChange, commands, onSelect, placeholder, }: CommandPaletteProps): React.JSX.Element | null;
+
+/**
+ * Structural types mirroring the parts of the Vercel AI SDK's chat state the
+ * adapter consumes. Declared locally (instead of importing the SDK) so the
+ * adapter stays runtime-independent: any chat library that produces this
+ * shape can be bridged, and consumers install the SDK themselves.
+ */
+type AiSdkToolInvocation = {
+    toolCallId: string;
+    toolName: string;
+    args?: Record<string, unknown>;
+    /** AI SDK states: 'call' (pending), 'result' (completed), 'error'. */
+    state?: string;
+    result?: unknown;
+    error?: unknown;
+};
+type AiSdkMessage = {
+    id: string;
+    role: 'user' | 'assistant' | 'system' | 'tool';
+    content: string;
+    toolInvocations?: AiSdkToolInvocation[];
+};
+type AiSdkStatus = string;
+
+/** Map one AI SDK tool invocation to a Slipstream ToolCall data object. */
+declare function toSlipstreamToolCall(invocation: AiSdkToolInvocation): ToolCall$1;
+/** Extract every tool call carried by an AI SDK message. */
+declare function toSlipstreamToolCalls(message: AiSdkMessage): ToolCall$1[];
+/**
+ * Map one AI SDK message onto a Slipstream Message. Tool invocations are
+ * preserved under `metadata.toolCalls` (and via toSlipstreamToolCalls) so
+ * ToolCall components can render them.
+ */
+declare function toSlipstreamMessage(message: AiSdkMessage): Message;
+/** Map a useChat/useCompletion message list into Slipstream messages. */
+declare function toSlipstreamMessages(messages: AiSdkMessage[]): Message[];
+
+type UseSlipstreamMessagesOptions = {
+    /** `messages` from the AI SDK's useChat()/useCompletion() state. */
+    messages: AiSdkMessage[];
+};
+type UseSlipstreamMessagesResult = {
+    messages: Message[];
+};
+/**
+ * Bridge AI SDK chat messages to Slipstream `<Conversation>`/`<Message>`
+ * input. Pure derivation of the current state — safe to call from any
+ * runtime that provides the structural message shape.
+ */
+declare function useSlipstreamMessages({ messages }: UseSlipstreamMessagesOptions): UseSlipstreamMessagesResult;
+type UseSlipstreamStreamOptions = {
+    /** `status` from the AI SDK chat state. */
+    status?: AiSdkStatus;
+    /** `error` from the AI SDK chat state. */
+    error?: unknown;
+    /** Retry handler wired to the SDK's reload/retry (e.g. `reload`). */
+    onRetry?: () => void;
+    /** Messages from the SDK chat state; used to locate the streaming id. */
+    messages?: AiSdkMessage[];
+};
+type UseSlipstreamStreamResult = {
+    isLoading: boolean;
+    streamingMessageId?: string;
+    messageErrors?: Record<string, string>;
+    onRetryMessage?: (messageId: string) => void;
+};
+/**
+ * Bridge AI SDK stream status/error to Slipstream Conversation props:
+ * `isLoading` gates the loading row, `streamingMessageId` drives the typing
+ * cursor on the last assistant message, and errors map to retryable
+ * per-message failures (streaming/tool states).
+ */
+declare function useSlipstreamStream({ status, error, onRetry, messages, }: UseSlipstreamStreamOptions): UseSlipstreamStreamResult;
+
+export { type AiSdkMessage, type AiSdkStatus, type AiSdkToolInvocation, Attachment, type AttachmentItem, AttachmentList, type AttachmentListProps, type AttachmentProps, Branch, type BranchProps, ChainThought, type ChainThoughtProps, type ChainThoughtStep, CodeBlock, type CodeBlockProps, type Command, CommandPalette, type CommandPaletteProps, Confirmation, type ConfirmationProps, type ConfirmationStatus, Conversation, type ConversationProps, type FeedbackRating, InlineCitation, type InlineCitationProps, MemoizedMessage as Message, MessageActions, type MessageActionsProps, type Message as MessageData, type MessageProps, type MessageRole, PromptInputRoot as PromptInput, PromptInputActionAddAttachments, PromptInputActionDictate, PromptInputBody, PromptInputButton, type PromptInputButtonProps, PromptInputFooter, PromptInputHeader, type PromptInputProps, PromptInputSubmit, PromptInputTextarea, PromptInputTools, Reasoning, type ReasoningProps, type ReasoningStep, Response, type ResponseProps, Source, type SourceItem, type SourceProps, Sources, type SourcesProps, StreamingIndicator, type StreamingIndicatorProps, type Suggestion, Suggestions, type SuggestionsProps, ToolCall, type ToolCall$1 as ToolCallData, type ToolCallProps, type UseAttachmentsOptions, type UseAttachmentsResult, type UseSlipstreamMessagesOptions, type UseSlipstreamMessagesResult, type UseSlipstreamStreamOptions, type UseSlipstreamStreamResult, closeIncompleteMarkdown, toSlipstreamMessage, toSlipstreamMessages, toSlipstreamToolCall, toSlipstreamToolCalls, usePromptInputAttachments, useSlipstreamMessages, useSlipstreamStream, useSpeechRecognition };