@leanspec/ui 0.2.23 → 0.2.25

package/dist/lib/components/library/ai-elements/persona.d.ts

@@ -0,0 +1,48 @@
+import { RiveParameters } from '@rive-app/react-webgl2';
+import { FC } from 'react';
+export type PersonaState = "idle" | "listening" | "thinking" | "speaking" | "asleep";
+interface PersonaProps {
+    state: PersonaState;
+    onLoad?: RiveParameters["onLoad"];
+    onLoadError?: RiveParameters["onLoadError"];
+    onReady?: () => void;
+    onPause?: RiveParameters["onPause"];
+    onPlay?: RiveParameters["onPlay"];
+    onStop?: RiveParameters["onStop"];
+    className?: string;
+    variant?: keyof typeof sources;
+}
+declare const sources: {
+    obsidian: {
+        source: string;
+        dynamicColor: boolean;
+        hasModel: boolean;
+    };
+    mana: {
+        source: string;
+        dynamicColor: boolean;
+        hasModel: boolean;
+    };
+    opal: {
+        source: string;
+        dynamicColor: boolean;
+        hasModel: boolean;
+    };
+    halo: {
+        source: string;
+        dynamicColor: boolean;
+        hasModel: boolean;
+    };
+    glint: {
+        source: string;
+        dynamicColor: boolean;
+        hasModel: boolean;
+    };
+    command: {
+        source: string;
+        dynamicColor: boolean;
+        hasModel: boolean;
+    };
+};
+export declare const Persona: FC<PersonaProps>;
+export {};

package/dist/lib/components/library/ai-elements/plan.d.ts

@@ -0,0 +1,25 @@
+import { CardAction, CardContent, CardDescription, CardHeader, CardTitle } from '../ui/card';
+import { Collapsible, CollapsibleTrigger } from '../ui/collapsible';
+import { ComponentProps } from 'react';
+export type PlanProps = ComponentProps<typeof Collapsible> & {
+    isStreaming?: boolean;
+};
+export declare const Plan: ({ className, isStreaming, children, ...props }: PlanProps) => import("react/jsx-runtime").JSX.Element;
+export type PlanHeaderProps = ComponentProps<typeof CardHeader>;
+export declare const PlanHeader: ({ className, ...props }: PlanHeaderProps) => import("react/jsx-runtime").JSX.Element;
+export type PlanTitleProps = Omit<ComponentProps<typeof CardTitle>, "children"> & {
+    children: string;
+};
+export declare const PlanTitle: ({ children, ...props }: PlanTitleProps) => import("react/jsx-runtime").JSX.Element;
+export type PlanDescriptionProps = Omit<ComponentProps<typeof CardDescription>, "children"> & {
+    children: string;
+};
+export declare const PlanDescription: ({ className, children, ...props }: PlanDescriptionProps) => import("react/jsx-runtime").JSX.Element;
+export type PlanActionProps = ComponentProps<typeof CardAction>;
+export declare const PlanAction: (props: PlanActionProps) => import("react/jsx-runtime").JSX.Element;
+export type PlanContentProps = ComponentProps<typeof CardContent>;
+export declare const PlanContent: (props: PlanContentProps) => import("react/jsx-runtime").JSX.Element;
+export type PlanFooterProps = ComponentProps<"div">;
+export declare const PlanFooter: (props: PlanFooterProps) => import("react/jsx-runtime").JSX.Element;
+export type PlanTriggerProps = ComponentProps<typeof CollapsibleTrigger>;
+export declare const PlanTrigger: ({ className, ...props }: PlanTriggerProps) => import("react/jsx-runtime").JSX.Element;

package/dist/lib/components/library/ai-elements/prompt-input.d.ts

@@ -0,0 +1,137 @@
+import { Command, CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList, CommandSeparator } from '../ui/command';
+import { DropdownMenu, DropdownMenuContent, DropdownMenuItem } from '../ui/dropdown-menu';
+import { HoverCard, HoverCardContent, HoverCardTrigger } from '../ui/hover-card';
+import { InputGroupAddon, InputGroupButton, InputGroupTextarea } from '../ui/input-group';
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '../ui/select';
+import { ChatStatus, FileUIPart, SourceDocumentUIPart } from 'ai';
+import { ComponentProps, FormEvent, HTMLAttributes, PropsWithChildren, RefObject } from 'react';
+export interface AttachmentsContext {
+    files: (FileUIPart & {
+        id: string;
+    })[];
+    add: (files: File[] | FileList) => void;
+    remove: (id: string) => void;
+    clear: () => void;
+    openFileDialog: () => void;
+    fileInputRef: RefObject<HTMLInputElement | null>;
+}
+export interface TextInputContext {
+    value: string;
+    setInput: (v: string) => void;
+    clear: () => void;
+}
+export interface PromptInputControllerProps {
+    textInput: TextInputContext;
+    attachments: AttachmentsContext;
+    /** INTERNAL: Allows PromptInput to register its file textInput + "open" callback */
+    __registerFileInput: (ref: RefObject<HTMLInputElement | null>, open: () => void) => void;
+}
+export declare const usePromptInputController: () => PromptInputControllerProps;
+export declare const useProviderAttachments: () => AttachmentsContext;
+export type PromptInputProviderProps = PropsWithChildren<{
+    initialInput?: string;
+}>;
+/**
+ * Optional global provider that lifts PromptInput state outside of PromptInput.
+ * If you don't use it, PromptInput stays fully self-managed.
+ */
+export declare function PromptInputProvider({ initialInput: initialTextInput, children, }: PromptInputProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare const usePromptInputAttachments: () => AttachmentsContext;
+export interface ReferencedSourcesContext {
+    sources: (SourceDocumentUIPart & {
+        id: string;
+    })[];
+    add: (sources: SourceDocumentUIPart[] | SourceDocumentUIPart) => void;
+    remove: (id: string) => void;
+    clear: () => void;
+}
+export declare const LocalReferencedSourcesContext: import('react').Context<ReferencedSourcesContext | null>;
+export declare const usePromptInputReferencedSources: () => ReferencedSourcesContext;
+export type PromptInputActionAddAttachmentsProps = ComponentProps<typeof DropdownMenuItem> & {
+    label?: string;
+};
+export declare const PromptInputActionAddAttachments: ({ label, ...props }: PromptInputActionAddAttachmentsProps) => import("react/jsx-runtime").JSX.Element;
+export interface PromptInputMessage {
+    text: string;
+    files: FileUIPart[];
+    referencedSources: SourceDocumentUIPart[];
+}
+export type PromptInputProps = Omit<HTMLAttributes<HTMLFormElement>, "onSubmit" | "onError"> & {
+    accept?: string;
+    multiple?: boolean;
+    globalDrop?: boolean;
+    syncHiddenInput?: boolean;
+    maxFiles?: number;
+    maxFileSize?: number;
+    onError?: (err: {
+        code: "max_files" | "max_file_size" | "accept";
+        message: string;
+    }) => void;
+    onSubmit: (message: PromptInputMessage, event: FormEvent<HTMLFormElement>) => void | Promise<void>;
+};
+export declare const PromptInput: ({ className, accept, multiple, globalDrop, syncHiddenInput, maxFiles, maxFileSize, onError, onSubmit, children, ...props }: PromptInputProps) => import("react/jsx-runtime").JSX.Element;
+export type PromptInputBodyProps = HTMLAttributes<HTMLDivElement>;
+export declare const PromptInputBody: ({ className, ...props }: PromptInputBodyProps) => import("react/jsx-runtime").JSX.Element;
+export type PromptInputTextareaProps = ComponentProps<typeof InputGroupTextarea>;
+export declare const PromptInputTextarea: ({ onChange, onKeyDown, className, placeholder, ...props }: PromptInputTextareaProps) => import("react/jsx-runtime").JSX.Element;
+export type PromptInputHeaderProps = Omit<ComponentProps<typeof InputGroupAddon>, "align">;
+export declare const PromptInputHeader: ({ className, ...props }: PromptInputHeaderProps) => import("react/jsx-runtime").JSX.Element;
+export type PromptInputFooterProps = Omit<ComponentProps<typeof InputGroupAddon>, "align">;
+export declare const PromptInputFooter: ({ className, ...props }: PromptInputFooterProps) => import("react/jsx-runtime").JSX.Element;
+export type PromptInputToolsProps = HTMLAttributes<HTMLDivElement>;
+export declare const PromptInputTools: ({ className, ...props }: PromptInputToolsProps) => import("react/jsx-runtime").JSX.Element;
+export type PromptInputButtonProps = ComponentProps<typeof InputGroupButton>;
+export declare const PromptInputButton: ({ variant, className, size, ...props }: PromptInputButtonProps) => import("react/jsx-runtime").JSX.Element;
+export type PromptInputActionMenuProps = ComponentProps<typeof DropdownMenu>;
+export declare const PromptInputActionMenu: (props: PromptInputActionMenuProps) => import("react/jsx-runtime").JSX.Element;
+export type PromptInputActionMenuTriggerProps = PromptInputButtonProps;
+export declare const PromptInputActionMenuTrigger: ({ className, children, ...props }: PromptInputActionMenuTriggerProps) => import("react/jsx-runtime").JSX.Element;
+export type PromptInputActionMenuContentProps = ComponentProps<typeof DropdownMenuContent>;
+export declare const PromptInputActionMenuContent: ({ className, ...props }: PromptInputActionMenuContentProps) => import("react/jsx-runtime").JSX.Element;
+export type PromptInputActionMenuItemProps = ComponentProps<typeof DropdownMenuItem>;
+export declare const PromptInputActionMenuItem: ({ className, ...props }: PromptInputActionMenuItemProps) => import("react/jsx-runtime").JSX.Element;
+export type PromptInputSubmitProps = ComponentProps<typeof InputGroupButton> & {
+    status?: ChatStatus;
+    onStop?: () => void;
+};
+export declare const PromptInputSubmit: ({ className, variant, size, status, onStop, onClick, children, ...props }: PromptInputSubmitProps) => import("react/jsx-runtime").JSX.Element;
+export type PromptInputSelectProps = ComponentProps<typeof Select>;
+export declare const PromptInputSelect: (props: PromptInputSelectProps) => import("react/jsx-runtime").JSX.Element;
+export type PromptInputSelectTriggerProps = ComponentProps<typeof SelectTrigger>;
+export declare const PromptInputSelectTrigger: ({ className, ...props }: PromptInputSelectTriggerProps) => import("react/jsx-runtime").JSX.Element;
+export type PromptInputSelectContentProps = ComponentProps<typeof SelectContent>;
+export declare const PromptInputSelectContent: ({ className, ...props }: PromptInputSelectContentProps) => import("react/jsx-runtime").JSX.Element;
+export type PromptInputSelectItemProps = ComponentProps<typeof SelectItem>;
+export declare const PromptInputSelectItem: ({ className, ...props }: PromptInputSelectItemProps) => import("react/jsx-runtime").JSX.Element;
+export type PromptInputSelectValueProps = ComponentProps<typeof SelectValue>;
+export declare const PromptInputSelectValue: ({ className, ...props }: PromptInputSelectValueProps) => import("react/jsx-runtime").JSX.Element;
+export type PromptInputHoverCardProps = ComponentProps<typeof HoverCard>;
+export declare const PromptInputHoverCard: ({ openDelay, closeDelay, ...props }: PromptInputHoverCardProps) => import("react/jsx-runtime").JSX.Element;
+export type PromptInputHoverCardTriggerProps = ComponentProps<typeof HoverCardTrigger>;
+export declare const PromptInputHoverCardTrigger: (props: PromptInputHoverCardTriggerProps) => import("react/jsx-runtime").JSX.Element;
+export type PromptInputHoverCardContentProps = ComponentProps<typeof HoverCardContent>;
+export declare const PromptInputHoverCardContent: ({ align, ...props }: PromptInputHoverCardContentProps) => import("react/jsx-runtime").JSX.Element;
+export type PromptInputTabsListProps = HTMLAttributes<HTMLDivElement>;
+export declare const PromptInputTabsList: ({ className, ...props }: PromptInputTabsListProps) => import("react/jsx-runtime").JSX.Element;
+export type PromptInputTabProps = HTMLAttributes<HTMLDivElement>;
+export declare const PromptInputTab: ({ className, ...props }: PromptInputTabProps) => import("react/jsx-runtime").JSX.Element;
+export type PromptInputTabLabelProps = HTMLAttributes<HTMLHeadingElement>;
+export declare const PromptInputTabLabel: ({ className, ...props }: PromptInputTabLabelProps) => import("react/jsx-runtime").JSX.Element;
+export type PromptInputTabBodyProps = HTMLAttributes<HTMLDivElement>;
+export declare const PromptInputTabBody: ({ className, ...props }: PromptInputTabBodyProps) => import("react/jsx-runtime").JSX.Element;
+export type PromptInputTabItemProps = HTMLAttributes<HTMLDivElement>;
+export declare const PromptInputTabItem: ({ className, ...props }: PromptInputTabItemProps) => import("react/jsx-runtime").JSX.Element;
+export type PromptInputCommandProps = ComponentProps<typeof Command>;
+export declare const PromptInputCommand: ({ className, ...props }: PromptInputCommandProps) => import("react/jsx-runtime").JSX.Element;
+export type PromptInputCommandInputProps = ComponentProps<typeof CommandInput>;
+export declare const PromptInputCommandInput: ({ className, ...props }: PromptInputCommandInputProps) => import("react/jsx-runtime").JSX.Element;
+export type PromptInputCommandListProps = ComponentProps<typeof CommandList>;
+export declare const PromptInputCommandList: ({ className, ...props }: PromptInputCommandListProps) => import("react/jsx-runtime").JSX.Element;
+export type PromptInputCommandEmptyProps = ComponentProps<typeof CommandEmpty>;
+export declare const PromptInputCommandEmpty: ({ className, ...props }: PromptInputCommandEmptyProps) => import("react/jsx-runtime").JSX.Element;
+export type PromptInputCommandGroupProps = ComponentProps<typeof CommandGroup>;
+export declare const PromptInputCommandGroup: ({ className, ...props }: PromptInputCommandGroupProps) => import("react/jsx-runtime").JSX.Element;
+export type PromptInputCommandItemProps = ComponentProps<typeof CommandItem>;
+export declare const PromptInputCommandItem: ({ className, ...props }: PromptInputCommandItemProps) => import("react/jsx-runtime").JSX.Element;
+export type PromptInputCommandSeparatorProps = ComponentProps<typeof CommandSeparator>;
+export declare const PromptInputCommandSeparator: ({ className, ...props }: PromptInputCommandSeparatorProps) => import("react/jsx-runtime").JSX.Element;

package/dist/lib/components/library/ai-elements/queue.d.ts

@@ -0,0 +1,61 @@
+import { Button } from '../ui/button';
+import { Collapsible, CollapsibleContent } from '../ui/collapsible';
+import { ScrollArea } from '../ui/scroll-area';
+import { ComponentProps } from 'react';
+export interface QueueMessagePart {
+    type: string;
+    text?: string;
+    url?: string;
+    filename?: string;
+    mediaType?: string;
+}
+export interface QueueMessage {
+    id: string;
+    parts: QueueMessagePart[];
+}
+export interface QueueTodo {
+    id: string;
+    title: string;
+    description?: string;
+    status?: "pending" | "completed";
+}
+export type QueueItemProps = ComponentProps<"li">;
+export declare const QueueItem: ({ className, ...props }: QueueItemProps) => import("react/jsx-runtime").JSX.Element;
+export type QueueItemIndicatorProps = ComponentProps<"span"> & {
+    completed?: boolean;
+};
+export declare const QueueItemIndicator: ({ completed, className, ...props }: QueueItemIndicatorProps) => import("react/jsx-runtime").JSX.Element;
+export type QueueItemContentProps = ComponentProps<"span"> & {
+    completed?: boolean;
+};
+export declare const QueueItemContent: ({ completed, className, ...props }: QueueItemContentProps) => import("react/jsx-runtime").JSX.Element;
+export type QueueItemDescriptionProps = ComponentProps<"div"> & {
+    completed?: boolean;
+};
+export declare const QueueItemDescription: ({ completed, className, ...props }: QueueItemDescriptionProps) => import("react/jsx-runtime").JSX.Element;
+export type QueueItemActionsProps = ComponentProps<"div">;
+export declare const QueueItemActions: ({ className, ...props }: QueueItemActionsProps) => import("react/jsx-runtime").JSX.Element;
+export type QueueItemActionProps = Omit<ComponentProps<typeof Button>, "variant" | "size">;
+export declare const QueueItemAction: ({ className, ...props }: QueueItemActionProps) => import("react/jsx-runtime").JSX.Element;
+export type QueueItemAttachmentProps = ComponentProps<"div">;
+export declare const QueueItemAttachment: ({ className, ...props }: QueueItemAttachmentProps) => import("react/jsx-runtime").JSX.Element;
+export type QueueItemImageProps = ComponentProps<"img">;
+export declare const QueueItemImage: ({ className, ...props }: QueueItemImageProps) => import("react/jsx-runtime").JSX.Element;
+export type QueueItemFileProps = ComponentProps<"span">;
+export declare const QueueItemFile: ({ children, className, ...props }: QueueItemFileProps) => import("react/jsx-runtime").JSX.Element;
+export type QueueListProps = ComponentProps<typeof ScrollArea>;
+export declare const QueueList: ({ children, className, ...props }: QueueListProps) => import("react/jsx-runtime").JSX.Element;
+export type QueueSectionProps = ComponentProps<typeof Collapsible>;
+export declare const QueueSection: ({ className, defaultOpen, ...props }: QueueSectionProps) => import("react/jsx-runtime").JSX.Element;
+export type QueueSectionTriggerProps = ComponentProps<"button">;
+export declare const QueueSectionTrigger: ({ children, className, ...props }: QueueSectionTriggerProps) => import("react/jsx-runtime").JSX.Element;
+export type QueueSectionLabelProps = ComponentProps<"span"> & {
+    count?: number;
+    label: string;
+    icon?: React.ReactNode;
+};
+export declare const QueueSectionLabel: ({ count, label, icon, className, ...props }: QueueSectionLabelProps) => import("react/jsx-runtime").JSX.Element;
+export type QueueSectionContentProps = ComponentProps<typeof CollapsibleContent>;
+export declare const QueueSectionContent: ({ className, ...props }: QueueSectionContentProps) => import("react/jsx-runtime").JSX.Element;
+export type QueueProps = ComponentProps<"div">;
+export declare const Queue: ({ className, ...props }: QueueProps) => import("react/jsx-runtime").JSX.Element;

package/dist/lib/components/library/ai-elements/reasoning.d.ts

@@ -0,0 +1,26 @@
+import { Collapsible, CollapsibleContent, CollapsibleTrigger } from '../ui/collapsible';
+import { ComponentProps, ReactNode } from 'react';
+interface ReasoningContextValue {
+    isStreaming: boolean;
+    isOpen: boolean;
+    setIsOpen: (open: boolean) => void;
+    duration: number | undefined;
+}
+export declare const useReasoning: () => ReasoningContextValue;
+export type ReasoningProps = ComponentProps<typeof Collapsible> & {
+    isStreaming?: boolean;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    duration?: number;
+};
+export declare const Reasoning: import('react').MemoExoticComponent<({ className, isStreaming, open, defaultOpen, onOpenChange, duration: durationProp, children, ...props }: ReasoningProps) => import("react/jsx-runtime").JSX.Element>;
+export type ReasoningTriggerProps = ComponentProps<typeof CollapsibleTrigger> & {
+    getThinkingMessage?: (isStreaming: boolean, duration?: number) => ReactNode;
+};
+export declare const ReasoningTrigger: import('react').MemoExoticComponent<({ className, children, getThinkingMessage, ...props }: ReasoningTriggerProps) => import("react/jsx-runtime").JSX.Element>;
+export type ReasoningContentProps = ComponentProps<typeof CollapsibleContent> & {
+    children: string;
+};
+export declare const ReasoningContent: import('react').MemoExoticComponent<({ className, children, ...props }: ReasoningContentProps) => import("react/jsx-runtime").JSX.Element>;
+export {};

package/dist/lib/components/library/ai-elements/runner-logo.d.ts

@@ -0,0 +1,33 @@
+import { ComponentProps } from 'react';
+/**
+ * Known runner IDs with dedicated icons.
+ * Falls back to Terminal icon for unknown runners.
+ */
+export type KnownRunnerId = "claude" | "copilot" | "codex" | "opencode" | "aider" | "cline" | "gemini" | "cursor" | "windsurf" | "droid" | "kiro" | "kimi" | "qodo" | "amp" | "trae" | "qwen-code" | "goose" | "openhands" | "continue" | "crush" | "roo" | "codebuddy" | "kilo" | "augment" | "antigravity" | (string & {});
+export type RunnerLogoProps = ComponentProps<"div"> & {
+    /**
+     * Runner ID (e.g., "claude", "cursor", "aider")
+     */
+    runnerId: KnownRunnerId;
+    /**
+     * Size of the logo container in pixels (default: 40)
+     */
+    size?: number;
+    /**
+     * Show fallback icon if runner logo is not found
+     */
+    showFallback?: boolean;
+};
+/**
+ * RunnerLogo displays a branded logo for AI coding agents/runners.
+ * Uses SVG icons when available, falling back to letter-based avatars.
+ */
+export declare const RunnerLogo: ({ runnerId, size, showFallback, className, ...props }: RunnerLogoProps) => import("react/jsx-runtime").JSX.Element | null;
+export type RunnerLogoSmallProps = ComponentProps<"span"> & {
+    runnerId: KnownRunnerId;
+    size?: number;
+};
+/**
+ * Small inline runner logo for use in badges, lists, etc.
+ */
+export declare const RunnerLogoSmall: ({ runnerId, size, className, ...props }: RunnerLogoSmallProps) => import("react/jsx-runtime").JSX.Element;

package/dist/lib/components/library/ai-elements/sandbox.d.ts

@@ -0,0 +1,24 @@
+import { Collapsible, CollapsibleContent } from '../ui/collapsible';
+import { Tabs, TabsContent, TabsList, TabsTrigger } from '../ui/tabs';
+import { ToolUIPart } from 'ai';
+import { ComponentProps } from 'react';
+export type SandboxRootProps = ComponentProps<typeof Collapsible>;
+export declare const Sandbox: ({ className, ...props }: SandboxRootProps) => import("react/jsx-runtime").JSX.Element;
+export interface SandboxHeaderProps {
+    title?: string;
+    state: ToolUIPart["state"];
+    className?: string;
+}
+export declare const SandboxHeader: ({ className, title, state, ...props }: SandboxHeaderProps) => import("react/jsx-runtime").JSX.Element;
+export type SandboxContentProps = ComponentProps<typeof CollapsibleContent>;
+export declare const SandboxContent: ({ className, ...props }: SandboxContentProps) => import("react/jsx-runtime").JSX.Element;
+export type SandboxTabsProps = ComponentProps<typeof Tabs>;
+export declare const SandboxTabs: ({ className, ...props }: SandboxTabsProps) => import("react/jsx-runtime").JSX.Element;
+export type SandboxTabsBarProps = ComponentProps<"div">;
+export declare const SandboxTabsBar: ({ className, ...props }: SandboxTabsBarProps) => import("react/jsx-runtime").JSX.Element;
+export type SandboxTabsListProps = ComponentProps<typeof TabsList>;
+export declare const SandboxTabsList: ({ className, ...props }: SandboxTabsListProps) => import("react/jsx-runtime").JSX.Element;
+export type SandboxTabsTriggerProps = ComponentProps<typeof TabsTrigger>;
+export declare const SandboxTabsTrigger: ({ className, ...props }: SandboxTabsTriggerProps) => import("react/jsx-runtime").JSX.Element;
+export type SandboxTabContentProps = ComponentProps<typeof TabsContent>;
+export declare const SandboxTabContent: ({ className, ...props }: SandboxTabContentProps) => import("react/jsx-runtime").JSX.Element;

package/dist/lib/components/library/ai-elements/schema-display.d.ts

@@ -0,0 +1,55 @@
+import { Badge } from '../ui/badge';
+import { Collapsible } from '../ui/collapsible';
+import { ComponentProps, HTMLAttributes } from 'react';
+type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+interface SchemaParameter {
+    name: string;
+    type: string;
+    required?: boolean;
+    description?: string;
+    location?: "path" | "query" | "header";
+}
+interface SchemaProperty {
+    name: string;
+    type: string;
+    required?: boolean;
+    description?: string;
+    properties?: SchemaProperty[];
+    items?: SchemaProperty;
+}
+export type SchemaDisplayProps = HTMLAttributes<HTMLDivElement> & {
+    method: HttpMethod;
+    path: string;
+    description?: string;
+    parameters?: SchemaParameter[];
+    requestBody?: SchemaProperty[];
+    responseBody?: SchemaProperty[];
+};
+export declare const SchemaDisplay: ({ method, path, description, parameters, requestBody, responseBody, className, children, ...props }: SchemaDisplayProps) => import("react/jsx-runtime").JSX.Element;
+export type SchemaDisplayHeaderProps = HTMLAttributes<HTMLDivElement>;
+export declare const SchemaDisplayHeader: ({ className, children, ...props }: SchemaDisplayHeaderProps) => import("react/jsx-runtime").JSX.Element;
+export type SchemaDisplayMethodProps = ComponentProps<typeof Badge>;
+export declare const SchemaDisplayMethod: ({ className, children, ...props }: SchemaDisplayMethodProps) => import("react/jsx-runtime").JSX.Element;
+export type SchemaDisplayPathProps = HTMLAttributes<HTMLSpanElement>;
+export declare const SchemaDisplayPath: ({ className, children, ...props }: SchemaDisplayPathProps) => import("react/jsx-runtime").JSX.Element;
+export type SchemaDisplayDescriptionProps = HTMLAttributes<HTMLParagraphElement>;
+export declare const SchemaDisplayDescription: ({ className, children, ...props }: SchemaDisplayDescriptionProps) => import("react/jsx-runtime").JSX.Element;
+export type SchemaDisplayContentProps = HTMLAttributes<HTMLDivElement>;
+export declare const SchemaDisplayContent: ({ className, children, ...props }: SchemaDisplayContentProps) => import("react/jsx-runtime").JSX.Element;
+export type SchemaDisplayParametersProps = ComponentProps<typeof Collapsible>;
+export declare const SchemaDisplayParameters: ({ className, children, ...props }: SchemaDisplayParametersProps) => import("react/jsx-runtime").JSX.Element;
+export type SchemaDisplayParameterProps = HTMLAttributes<HTMLDivElement> & SchemaParameter;
+export declare const SchemaDisplayParameter: ({ name, type, required, description, location, className, ...props }: SchemaDisplayParameterProps) => import("react/jsx-runtime").JSX.Element;
+export type SchemaDisplayRequestProps = ComponentProps<typeof Collapsible>;
+export declare const SchemaDisplayRequest: ({ className, children, ...props }: SchemaDisplayRequestProps) => import("react/jsx-runtime").JSX.Element;
+export type SchemaDisplayResponseProps = ComponentProps<typeof Collapsible>;
+export declare const SchemaDisplayResponse: ({ className, children, ...props }: SchemaDisplayResponseProps) => import("react/jsx-runtime").JSX.Element;
+export type SchemaDisplayBodyProps = HTMLAttributes<HTMLDivElement>;
+export declare const SchemaDisplayBody: ({ className, children, ...props }: SchemaDisplayBodyProps) => import("react/jsx-runtime").JSX.Element;
+export type SchemaDisplayPropertyProps = HTMLAttributes<HTMLDivElement> & SchemaProperty & {
+    depth?: number;
+};
+export declare const SchemaDisplayProperty: ({ name, type, required, description, properties, items, depth, className, ...props }: SchemaDisplayPropertyProps) => import("react/jsx-runtime").JSX.Element;
+export type SchemaDisplayExampleProps = HTMLAttributes<HTMLPreElement>;
+export declare const SchemaDisplayExample: ({ className, children, ...props }: SchemaDisplayExampleProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/lib/components/library/ai-elements/shimmer.d.ts

@@ -0,0 +1,9 @@
+import { ElementType } from 'react';
+export interface TextShimmerProps {
+    children: string;
+    as?: ElementType;
+    className?: string;
+    duration?: number;
+    spread?: number;
+}
+export declare const Shimmer: import('react').MemoExoticComponent<({ children, as: Component, className, duration, spread, }: TextShimmerProps) => import("react/jsx-runtime").JSX.Element>;

package/dist/lib/components/library/ai-elements/snippet.d.ts

@@ -0,0 +1,18 @@
+import { InputGroup, InputGroupAddon, InputGroupButton, InputGroupInput, InputGroupText } from '../ui/input-group';
+import { ComponentProps } from 'react';
+export type SnippetProps = ComponentProps<typeof InputGroup> & {
+    code: string;
+};
+export declare const Snippet: ({ code, className, children, ...props }: SnippetProps) => import("react/jsx-runtime").JSX.Element;
+export type SnippetAddonProps = ComponentProps<typeof InputGroupAddon>;
+export declare const SnippetAddon: (props: SnippetAddonProps) => import("react/jsx-runtime").JSX.Element;
+export type SnippetTextProps = ComponentProps<typeof InputGroupText>;
+export declare const SnippetText: ({ className, ...props }: SnippetTextProps) => import("react/jsx-runtime").JSX.Element;
+export type SnippetInputProps = Omit<ComponentProps<typeof InputGroupInput>, "readOnly" | "value">;
+export declare const SnippetInput: ({ className, ...props }: SnippetInputProps) => import("react/jsx-runtime").JSX.Element;
+export type SnippetCopyButtonProps = ComponentProps<typeof InputGroupButton> & {
+    onCopy?: () => void;
+    onError?: (error: Error) => void;
+    timeout?: number;
+};
+export declare const SnippetCopyButton: ({ onCopy, onError, timeout, children, className, ...props }: SnippetCopyButtonProps) => import("react/jsx-runtime").JSX.Element;

package/dist/lib/components/library/ai-elements/sources.d.ts

@@ -0,0 +1,12 @@
+import { CollapsibleContent, CollapsibleTrigger } from '../ui/collapsible';
+import { ComponentProps } from 'react';
+export type SourcesProps = ComponentProps<"div">;
+export declare const Sources: ({ className, ...props }: SourcesProps) => import("react/jsx-runtime").JSX.Element;
+export type SourcesTriggerProps = ComponentProps<typeof CollapsibleTrigger> & {
+    count: number;
+};
+export declare const SourcesTrigger: ({ className, count, children, ...props }: SourcesTriggerProps) => import("react/jsx-runtime").JSX.Element;
+export type SourcesContentProps = ComponentProps<typeof CollapsibleContent>;
+export declare const SourcesContent: ({ className, ...props }: SourcesContentProps) => import("react/jsx-runtime").JSX.Element;
+export type SourceProps = ComponentProps<"a">;
+export declare const Source: ({ href, title, children, ...props }: SourceProps) => import("react/jsx-runtime").JSX.Element;

package/dist/lib/components/library/ai-elements/speech-input.d.ts

@@ -0,0 +1,58 @@
+import { Button } from '../ui/button';
+import { ComponentProps } from 'react';
+interface SpeechRecognition extends EventTarget {
+    continuous: boolean;
+    interimResults: boolean;
+    lang: string;
+    start(): void;
+    stop(): void;
+    onstart: ((this: SpeechRecognition, ev: Event) => void) | null;
+    onend: ((this: SpeechRecognition, ev: Event) => void) | null;
+    onresult: ((this: SpeechRecognition, ev: SpeechRecognitionEvent) => void) | null;
+    onerror: ((this: SpeechRecognition, ev: SpeechRecognitionErrorEvent) => void) | null;
+}
+interface SpeechRecognitionEvent extends Event {
+    results: SpeechRecognitionResultList;
+    resultIndex: number;
+}
+interface SpeechRecognitionResultList {
+    readonly length: number;
+    item(index: number): SpeechRecognitionResult;
+    [index: number]: SpeechRecognitionResult;
+}
+interface SpeechRecognitionResult {
+    readonly length: number;
+    item(index: number): SpeechRecognitionAlternative;
+    [index: number]: SpeechRecognitionAlternative;
+    isFinal: boolean;
+}
+interface SpeechRecognitionAlternative {
+    transcript: string;
+    confidence: number;
+}
+interface SpeechRecognitionErrorEvent extends Event {
+    error: string;
+}
+declare global {
+    interface Window {
+        SpeechRecognition: {
+            new (): SpeechRecognition;
+        };
+        webkitSpeechRecognition: {
+            new (): SpeechRecognition;
+        };
+    }
+}
+export type SpeechInputProps = ComponentProps<typeof Button> & {
+    onTranscriptionChange?: (text: string) => void;
+    /**
+     * Callback for when audio is recorded using MediaRecorder fallback.
+     * This is called in browsers that don't support the Web Speech API (Firefox, Safari).
+     * The callback receives an audio Blob that should be sent to a transcription service.
+     * Return the transcribed text, which will be passed to onTranscriptionChange.
+     */
+    onAudioRecorded?: (audioBlob: Blob) => Promise<string>;
+    lang?: string;
+};
+export declare const SpeechInput: ({ className, onTranscriptionChange, onAudioRecorded, lang, ...props }: SpeechInputProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/lib/components/library/ai-elements/stack-trace.d.ts

@@ -0,0 +1,37 @@
+import { Button } from '../ui/button';
+import { CollapsibleContent, CollapsibleTrigger } from '../ui/collapsible';
+import { ComponentProps } from 'react';
+export type StackTraceProps = ComponentProps<"div"> & {
+    trace: string;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    onFilePathClick?: (filePath: string, line?: number, column?: number) => void;
+};
+export declare const StackTrace: import('react').MemoExoticComponent<({ trace, className, open, defaultOpen, onOpenChange, onFilePathClick, children, ...props }: StackTraceProps) => import("react/jsx-runtime").JSX.Element>;
+export type StackTraceHeaderProps = ComponentProps<typeof CollapsibleTrigger>;
+export declare const StackTraceHeader: import('react').MemoExoticComponent<({ className, children, ...props }: StackTraceHeaderProps) => import("react/jsx-runtime").JSX.Element>;
+export type StackTraceErrorProps = ComponentProps<"div">;
+export declare const StackTraceError: import('react').MemoExoticComponent<({ className, children, ...props }: StackTraceErrorProps) => import("react/jsx-runtime").JSX.Element>;
+export type StackTraceErrorTypeProps = ComponentProps<"span">;
+export declare const StackTraceErrorType: import('react').MemoExoticComponent<({ className, children, ...props }: StackTraceErrorTypeProps) => import("react/jsx-runtime").JSX.Element>;
+export type StackTraceErrorMessageProps = ComponentProps<"span">;
+export declare const StackTraceErrorMessage: import('react').MemoExoticComponent<({ className, children, ...props }: StackTraceErrorMessageProps) => import("react/jsx-runtime").JSX.Element>;
+export type StackTraceActionsProps = ComponentProps<"div">;
+export declare const StackTraceActions: import('react').MemoExoticComponent<({ className, children, ...props }: StackTraceActionsProps) => import("react/jsx-runtime").JSX.Element>;
+export type StackTraceCopyButtonProps = ComponentProps<typeof Button> & {
+    onCopy?: () => void;
+    onError?: (error: Error) => void;
+    timeout?: number;
+};
+export declare const StackTraceCopyButton: import('react').MemoExoticComponent<({ onCopy, onError, timeout, className, children, ...props }: StackTraceCopyButtonProps) => import("react/jsx-runtime").JSX.Element>;
+export type StackTraceExpandButtonProps = ComponentProps<"div">;
+export declare const StackTraceExpandButton: import('react').MemoExoticComponent<({ className, ...props }: StackTraceExpandButtonProps) => import("react/jsx-runtime").JSX.Element>;
+export type StackTraceContentProps = ComponentProps<typeof CollapsibleContent> & {
+    maxHeight?: number;
+};
+export declare const StackTraceContent: import('react').MemoExoticComponent<({ className, maxHeight, children, ...props }: StackTraceContentProps) => import("react/jsx-runtime").JSX.Element>;
+export type StackTraceFramesProps = ComponentProps<"div"> & {
+    showInternalFrames?: boolean;
+};
+export declare const StackTraceFrames: import('react').MemoExoticComponent<({ className, showInternalFrames, ...props }: StackTraceFramesProps) => import("react/jsx-runtime").JSX.Element>;

package/dist/lib/components/library/ai-elements/suggestion.d.ts

@@ -0,0 +1,10 @@
+import { Button } from '../ui/button';
+import { ScrollArea } from '../ui/scroll-area';
+import { ComponentProps } from 'react';
+export type SuggestionsProps = ComponentProps<typeof ScrollArea>;
+export declare const Suggestions: ({ className, children, ...props }: SuggestionsProps) => import("react/jsx-runtime").JSX.Element;
+export type SuggestionProps = Omit<ComponentProps<typeof Button>, "onClick"> & {
+    suggestion: string;
+    onClick?: (suggestion: string) => void;
+};
+export declare const Suggestion: ({ suggestion, onClick, className, variant, size, children, ...props }: SuggestionProps) => import("react/jsx-runtime").JSX.Element;

package/dist/lib/components/library/ai-elements/task.d.ts

@@ -0,0 +1,14 @@
+import { Collapsible, CollapsibleContent, CollapsibleTrigger } from '../ui/collapsible';
+import { ComponentProps } from 'react';
+export type TaskItemFileProps = ComponentProps<"div">;
+export declare const TaskItemFile: ({ children, className, ...props }: TaskItemFileProps) => import("react/jsx-runtime").JSX.Element;
+export type TaskItemProps = ComponentProps<"div">;
+export declare const TaskItem: ({ children, className, ...props }: TaskItemProps) => import("react/jsx-runtime").JSX.Element;
+export type TaskProps = ComponentProps<typeof Collapsible>;
+export declare const Task: ({ defaultOpen, className, ...props }: TaskProps) => import("react/jsx-runtime").JSX.Element;
+export type TaskTriggerProps = ComponentProps<typeof CollapsibleTrigger> & {
+    title: string;
+};
+export declare const TaskTrigger: ({ children, className, title, ...props }: TaskTriggerProps) => import("react/jsx-runtime").JSX.Element;
+export type TaskContentProps = ComponentProps<typeof CollapsibleContent>;
+export declare const TaskContent: ({ children, className, ...props }: TaskContentProps) => import("react/jsx-runtime").JSX.Element;

package/dist/lib/components/library/ai-elements/terminal.d.ts

@@ -0,0 +1,27 @@
+import { Button } from '../ui/button';
+import { ComponentProps, HTMLAttributes } from 'react';
+export type TerminalProps = HTMLAttributes<HTMLDivElement> & {
+    output: string;
+    isStreaming?: boolean;
+    autoScroll?: boolean;
+    onClear?: () => void;
+};
+export declare const Terminal: ({ output, isStreaming, autoScroll, onClear, className, children, ...props }: TerminalProps) => import("react/jsx-runtime").JSX.Element;
+export type TerminalHeaderProps = HTMLAttributes<HTMLDivElement>;
+export declare const TerminalHeader: ({ className, children, ...props }: TerminalHeaderProps) => import("react/jsx-runtime").JSX.Element;
+export type TerminalTitleProps = HTMLAttributes<HTMLDivElement>;
+export declare const TerminalTitle: ({ className, children, ...props }: TerminalTitleProps) => import("react/jsx-runtime").JSX.Element;
+export type TerminalStatusProps = HTMLAttributes<HTMLDivElement>;
+export declare const TerminalStatus: ({ className, children, ...props }: TerminalStatusProps) => import("react/jsx-runtime").JSX.Element | null;
+export type TerminalActionsProps = HTMLAttributes<HTMLDivElement>;
+export declare const TerminalActions: ({ className, children, ...props }: TerminalActionsProps) => import("react/jsx-runtime").JSX.Element;
+export type TerminalCopyButtonProps = ComponentProps<typeof Button> & {
+    onCopy?: () => void;
+    onError?: (error: Error) => void;
+    timeout?: number;
+};
+export declare const TerminalCopyButton: ({ onCopy, onError, timeout, children, className, ...props }: TerminalCopyButtonProps) => import("react/jsx-runtime").JSX.Element;
+export type TerminalClearButtonProps = ComponentProps<typeof Button>;
+export declare const TerminalClearButton: ({ children, className, ...props }: TerminalClearButtonProps) => import("react/jsx-runtime").JSX.Element | null;
+export type TerminalContentProps = HTMLAttributes<HTMLDivElement>;
+export declare const TerminalContent: ({ className, children, ...props }: TerminalContentProps) => import("react/jsx-runtime").JSX.Element;