@sciol/xyzen 0.3.5 → 0.3.7

package/dist/app/App.d.ts

@@ -2,4 +2,4 @@ export interface XyzenProps {
     backendUrl?: string;
     showLlmProvider?: boolean;
 }
-export declare function Xyzen({ backendUrl, showLlmProvider, }: XyzenProps): import("react/jsx-runtime").JSX.Element;
+export declare function Xyzen({ backendUrl, showLlmProvider, }: XyzenProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/app/AppFullscreen.d.ts

@@ -2,4 +2,4 @@ export interface AppFullscreenProps {
     backendUrl?: string;
     showLlmProvider?: boolean;
 }
-export declare function AppFullscreen({ backendUrl, showLlmProvider, }: AppFullscreenProps): import('react').ReactPortal | null;
+export declare function AppFullscreen({ backendUrl, }: AppFullscreenProps): import('react').ReactPortal | null;

package/dist/app/AppSide.d.ts

@@ -0,0 +1,6 @@
+export interface AppSideProps {
+    backendUrl?: string;
+    showLlmProvider?: boolean;
+    isMobile?: boolean;
+}
+export declare function AppSide({ backendUrl, showLlmProvider, isMobile, }: AppSideProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/app/explore/AgentExploreContent.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+declare const AgentExploreContent: React.FC;
+export default AgentExploreContent;

package/dist/app/explore/AgentExploreTab.d.ts

@@ -0,0 +1,2 @@
+declare const AgentExploreTab: React.FC;
+export default AgentExploreTab;

package/dist/app/explore/McpExploreContent.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+declare const McpExploreContent: React.FC;
+export default McpExploreContent;

package/dist/app/explore/McpExploreTab.d.ts

@@ -0,0 +1,2 @@
+declare const McpExploreTab: React.FC;
+export default McpExploreTab;

package/dist/app/explore/page.d.ts

@@ -0,0 +1 @@
+export default function Explorer(): import("react/jsx-runtime").JSX.Element;

package/dist/components/animate-ui/components/buttons/button.d.ts

@@ -0,0 +1,9 @@
+import { VariantProps } from 'class-variance-authority';
+import { ButtonProps as ButtonPrimitiveProps } from '../../primitives/buttons/button';
+declare const buttonVariants: (props?: ({
+    variant?: "link" | "default" | "outline" | "destructive" | "secondary" | "ghost" | "accent" | null | undefined;
+    size?: "default" | "sm" | "lg" | "icon" | "icon-sm" | "icon-lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+type ButtonProps = ButtonPrimitiveProps & VariantProps<typeof buttonVariants>;
+declare function Button({ className, variant, size, ...props }: ButtonProps): import("react/jsx-runtime").JSX.Element;
+export { Button, buttonVariants, type ButtonProps };

package/dist/components/animate-ui/components/buttons/github-stars.d.ts

@@ -0,0 +1,10 @@
+import { VariantProps } from 'class-variance-authority';
+import { GithubStarsProps } from '../../primitives/animate/github-stars';
+import { ButtonProps as ButtonPrimitiveProps } from '../../primitives/buttons/button';
+declare const buttonVariants: (props?: ({
+    variant?: "default" | "outline" | "ghost" | "accent" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+type GitHubStarsButtonProps = Omit<ButtonPrimitiveProps & GithubStarsProps, "asChild" | "children"> & VariantProps<typeof buttonVariants>;
+declare function GitHubStarsButton({ className, username, repo, value, delay, inView, inViewMargin, inViewOnce, variant, size, ...props }: GitHubStarsButtonProps): import("react/jsx-runtime").JSX.Element;
+export { GitHubStarsButton, type GitHubStarsButtonProps };

package/dist/components/animate-ui/components/headless/checkbox.d.ts

@@ -0,0 +1,11 @@
+import { motion } from 'motion/react';
+import { CheckboxProps as CheckboxPrimitiveProps } from '../../primitives/headless/checkbox';
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+declare const checkboxVariants: (props?: ({
+    variant?: "default" | "accent" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+type CheckboxProps<TTag extends React.ElementType = typeof motion.button> = CheckboxPrimitiveProps<TTag> & VariantProps<typeof checkboxVariants>;
+declare function Checkbox<TTag extends React.ElementType = typeof motion.button>({ className, children, variant, size, ...props }: CheckboxProps<TTag>): import("react/jsx-runtime").JSX.Element;
+export { Checkbox, type CheckboxProps };

package/dist/components/animate-ui/components/radix/dropdown-menu.d.ts

@@ -0,0 +1,37 @@
+import { DropdownMenuCheckboxItemProps as DropdownMenuCheckboxItemPrimitiveProps, DropdownMenuContentProps as DropdownMenuContentPrimitiveProps, DropdownMenuGroupProps as DropdownMenuGroupPrimitiveProps, DropdownMenuItemProps as DropdownMenuItemPrimitiveProps, DropdownMenuLabelProps as DropdownMenuLabelPrimitiveProps, DropdownMenuProps as DropdownMenuPrimitiveProps, DropdownMenuRadioGroupProps as DropdownMenuRadioGroupPrimitiveProps, DropdownMenuRadioItemProps as DropdownMenuRadioItemPrimitiveProps, DropdownMenuSeparatorProps as DropdownMenuSeparatorPrimitiveProps, DropdownMenuShortcutProps as DropdownMenuShortcutPrimitiveProps, DropdownMenuSubContentProps as DropdownMenuSubContentPrimitiveProps, DropdownMenuSubProps as DropdownMenuSubPrimitiveProps, DropdownMenuSubTriggerProps as DropdownMenuSubTriggerPrimitiveProps, DropdownMenuTriggerProps as DropdownMenuTriggerPrimitiveProps } from '../../primitives/radix/dropdown-menu';
+type DropdownMenuProps = DropdownMenuPrimitiveProps;
+declare function DropdownMenu(props: DropdownMenuProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuTriggerProps = DropdownMenuTriggerPrimitiveProps;
+declare function DropdownMenuTrigger(props: DropdownMenuTriggerProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuContentProps = DropdownMenuContentPrimitiveProps;
+declare function DropdownMenuContent({ sideOffset, className, children, ...props }: DropdownMenuContentProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuGroupProps = DropdownMenuGroupPrimitiveProps;
+declare function DropdownMenuGroup({ ...props }: DropdownMenuGroupProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuItemProps = DropdownMenuItemPrimitiveProps & {
+    inset?: boolean;
+    variant?: "default" | "destructive";
+};
+declare function DropdownMenuItem({ className, inset, variant, disabled, ...props }: DropdownMenuItemProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuCheckboxItemProps = DropdownMenuCheckboxItemPrimitiveProps;
+declare function DropdownMenuCheckboxItem({ className, children, checked, disabled, ...props }: DropdownMenuCheckboxItemProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuRadioGroupProps = DropdownMenuRadioGroupPrimitiveProps;
+declare function DropdownMenuRadioGroup(props: DropdownMenuRadioGroupProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuRadioItemProps = DropdownMenuRadioItemPrimitiveProps;
+declare function DropdownMenuRadioItem({ className, children, disabled, ...props }: DropdownMenuRadioItemProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuLabelProps = DropdownMenuLabelPrimitiveProps & {
+    inset?: boolean;
+};
+declare function DropdownMenuLabel({ className, inset, ...props }: DropdownMenuLabelProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuSeparatorProps = DropdownMenuSeparatorPrimitiveProps;
+declare function DropdownMenuSeparator({ className, ...props }: DropdownMenuSeparatorProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuShortcutProps = DropdownMenuShortcutPrimitiveProps;
+declare function DropdownMenuShortcut({ className, ...props }: DropdownMenuShortcutProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuSubProps = DropdownMenuSubPrimitiveProps;
+declare function DropdownMenuSub(props: DropdownMenuSubProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuSubTriggerProps = DropdownMenuSubTriggerPrimitiveProps & {
+    inset?: boolean;
+};
+declare function DropdownMenuSubTrigger({ disabled, className, inset, children, ...props }: DropdownMenuSubTriggerProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuSubContentProps = DropdownMenuSubContentPrimitiveProps;
+declare function DropdownMenuSubContent({ className, ...props }: DropdownMenuSubContentProps): import("react/jsx-runtime").JSX.Element;
+export { DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, type DropdownMenuCheckboxItemProps, type DropdownMenuContentProps, type DropdownMenuGroupProps, type DropdownMenuItemProps, type DropdownMenuLabelProps, type DropdownMenuProps, type DropdownMenuRadioGroupProps, type DropdownMenuRadioItemProps, type DropdownMenuSeparatorProps, type DropdownMenuShortcutProps, type DropdownMenuSubContentProps, type DropdownMenuSubProps, type DropdownMenuSubTriggerProps, type DropdownMenuTriggerProps, };

package/dist/components/animate-ui/components/radix/tooltip.d.ts

@@ -0,0 +1,10 @@
+import { TooltipContentProps as TooltipContentPrimitiveProps, TooltipProps as TooltipPrimitiveProps, TooltipTriggerProps as TooltipTriggerPrimitiveProps } from '../../primitives/radix/tooltip';
+type TooltipProps = TooltipPrimitiveProps & {
+    delayDuration?: TooltipPrimitiveProps["delayDuration"];
+};
+declare function Tooltip({ delayDuration, ...props }: TooltipProps): import("react/jsx-runtime").JSX.Element;
+type TooltipTriggerProps = TooltipTriggerPrimitiveProps;
+declare function TooltipTrigger({ ...props }: TooltipTriggerProps): import("react/jsx-runtime").JSX.Element;
+type TooltipContentProps = TooltipContentPrimitiveProps;
+declare function TooltipContent({ className, sideOffset, children, ...props }: TooltipContentProps): import("react/jsx-runtime").JSX.Element;
+export { Tooltip, TooltipContent, TooltipTrigger, type TooltipContentProps, type TooltipProps, type TooltipTriggerProps, };

package/dist/components/animate-ui/primitives/animate/github-stars.d.ts

@@ -0,0 +1,40 @@
+import { HTMLMotionProps } from 'motion/react';
+import { UseIsInViewOptions } from '../../../../hooks/use-is-in-view';
+import { WithAsChild } from './slot';
+import { SlidingNumberProps } from '../texts/sliding-number';
+import { ParticlesEffectProps } from '../effects/particles';
+import * as React from "react";
+type GithubStarsContextType = {
+    stars: number;
+    setStars: (stars: number) => void;
+    currentStars: number;
+    setCurrentStars: (stars: number) => void;
+    isCompleted: boolean;
+    isLoading: boolean;
+};
+declare const useGithubStars: () => GithubStarsContextType;
+type GithubStarsProps = WithAsChild<{
+    children: React.ReactNode;
+    username?: string;
+    repo?: string;
+    value?: number;
+    delay?: number;
+} & UseIsInViewOptions & HTMLMotionProps<"div">>;
+declare function GithubStars({ ref, children, username, repo, value, delay, inView, inViewMargin, inViewOnce, asChild, ...props }: GithubStarsProps): import("react/jsx-runtime").JSX.Element;
+type GithubStarsNumberProps = Omit<SlidingNumberProps, "number" | "fromNumber">;
+declare function GithubStarsNumber({ padStart, ...props }: GithubStarsNumberProps): import("react/jsx-runtime").JSX.Element;
+type GithubStarsIconProps<T extends React.ElementType> = {
+    icon: React.ReactElement<T>;
+    color?: string;
+    activeClassName?: string;
+} & React.ComponentProps<T>;
+declare function GithubStarsIcon<T extends React.ElementType>({ icon: Icon, color, activeClassName, className, ...props }: GithubStarsIconProps<T>): import("react/jsx-runtime").JSX.Element;
+type GithubStarsParticlesProps = ParticlesEffectProps & {
+    children: React.ReactElement;
+    size?: number;
+};
+declare function GithubStarsParticles({ children, size, style, ...props }: GithubStarsParticlesProps): import("react/jsx-runtime").JSX.Element;
+type GithubStarsLogoProps = React.SVGProps<SVGSVGElement>;
+declare function GithubStarsLogo(props: GithubStarsLogoProps): import("react/jsx-runtime").JSX.Element;
+export { GithubStars, GithubStarsNumber, GithubStarsIcon, GithubStarsParticles, GithubStarsLogo, useGithubStars, //eslint-disable-line
+type GithubStarsProps, type GithubStarsNumberProps, type GithubStarsIconProps, type GithubStarsParticlesProps, type GithubStarsLogoProps, type GithubStarsContextType, };

package/dist/components/animate-ui/primitives/animate/slot.d.ts

@@ -0,0 +1,17 @@
+import { HTMLMotionProps } from 'motion/react';
+import * as React from "react";
+type AnyProps = Record<string, unknown>;
+type DOMMotionProps<T extends HTMLElement = HTMLElement> = Omit<HTMLMotionProps<keyof HTMLElementTagNameMap>, "ref"> & {
+    ref?: React.Ref<T>;
+};
+type WithAsChild<Base extends object> = (Base & {
+    asChild: true;
+    children: React.ReactElement;
+}) | (Base & {
+    asChild?: false | undefined;
+});
+type SlotProps<T extends HTMLElement = HTMLElement> = {
+    children?: any;
+} & DOMMotionProps<T>;
+declare function Slot<T extends HTMLElement = HTMLElement>({ children, ref, ...props }: SlotProps<T>): import("react/jsx-runtime").JSX.Element | null;
+export { Slot, type SlotProps, type WithAsChild, type DOMMotionProps, type AnyProps, };

package/dist/components/animate-ui/primitives/buttons/button.d.ts

@@ -0,0 +1,8 @@
+import { HTMLMotionProps } from 'motion/react';
+import { WithAsChild } from '../animate/slot';
+type ButtonProps = WithAsChild<HTMLMotionProps<"button"> & {
+    hoverScale?: number;
+    tapScale?: number;
+}>;
+declare function Button({ hoverScale, tapScale, asChild, ...props }: ButtonProps): import("react/jsx-runtime").JSX.Element;
+export { Button, type ButtonProps };

package/dist/components/animate-ui/primitives/buttons/liquid.d.ts

@@ -0,0 +1,10 @@
+import { HTMLMotionProps } from 'motion/react';
+import { WithAsChild } from '../animate/slot';
+type LiquidButtonProps = WithAsChild<HTMLMotionProps<"button"> & {
+    delay?: string;
+    fillHeight?: string;
+    hoverScale?: number;
+    tapScale?: number;
+}>;
+declare function LiquidButton({ delay, fillHeight, hoverScale, tapScale, asChild, ...props }: LiquidButtonProps): import("react/jsx-runtime").JSX.Element;
+export { LiquidButton, type LiquidButtonProps };

package/dist/components/animate-ui/primitives/effects/auto-height.d.ts

@@ -0,0 +1,11 @@
+import { HTMLMotionProps, LegacyAnimationControls, TargetAndTransition, Transition } from 'motion/react';
+import { WithAsChild } from '../animate/slot';
+import * as React from "react";
+type AutoHeightProps = WithAsChild<{
+    children: React.ReactNode;
+    deps?: React.DependencyList;
+    animate?: TargetAndTransition | LegacyAnimationControls;
+    transition?: Transition;
+} & Omit<HTMLMotionProps<"div">, "animate">>;
+declare function AutoHeight({ children, deps, transition, style, animate, asChild, ...props }: AutoHeightProps): import("react/jsx-runtime").JSX.Element;
+export { AutoHeight, type AutoHeightProps };

package/dist/components/animate-ui/primitives/effects/highlight.d.ts

@@ -0,0 +1,92 @@
+import { Transition } from 'motion/react';
+import * as React from "react";
+type HighlightMode = "children" | "parent";
+type Bounds = {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+};
+type HighlightContextType<T extends string> = {
+    as?: keyof HTMLElementTagNameMap;
+    mode: HighlightMode;
+    activeValue: T | null;
+    setActiveValue: (value: T | null) => void;
+    setBounds: (bounds: DOMRect) => void;
+    clearBounds: () => void;
+    id: string;
+    hover: boolean;
+    click: boolean;
+    className?: string;
+    style?: React.CSSProperties;
+    activeClassName?: string;
+    setActiveClassName: (className: string) => void;
+    transition?: Transition;
+    disabled?: boolean;
+    enabled?: boolean;
+    exitDelay?: number;
+    forceUpdateBounds?: boolean;
+};
+declare function useHighlight<T extends string>(): HighlightContextType<T>;
+type BaseHighlightProps<T extends React.ElementType = "div"> = {
+    as?: T;
+    ref?: React.Ref<HTMLDivElement>;
+    mode?: HighlightMode;
+    value?: string | null;
+    defaultValue?: string | null;
+    onValueChange?: (value: string | null) => void;
+    className?: string;
+    style?: React.CSSProperties;
+    transition?: Transition;
+    hover?: boolean;
+    click?: boolean;
+    disabled?: boolean;
+    enabled?: boolean;
+    exitDelay?: number;
+};
+type ParentModeHighlightProps = {
+    boundsOffset?: Partial<Bounds>;
+    containerClassName?: string;
+    forceUpdateBounds?: boolean;
+};
+type ControlledParentModeHighlightProps<T extends React.ElementType = "div"> = BaseHighlightProps<T> & ParentModeHighlightProps & {
+    mode: "parent";
+    controlledItems: true;
+    children: React.ReactNode;
+};
+type ControlledChildrenModeHighlightProps<T extends React.ElementType = "div"> = BaseHighlightProps<T> & {
+    mode?: "children" | undefined;
+    controlledItems: true;
+    children: React.ReactNode;
+};
+type UncontrolledParentModeHighlightProps<T extends React.ElementType = "div"> = BaseHighlightProps<T> & ParentModeHighlightProps & {
+    mode: "parent";
+    controlledItems?: false;
+    itemsClassName?: string;
+    children: React.ReactElement | React.ReactElement[];
+};
+type UncontrolledChildrenModeHighlightProps<T extends React.ElementType = "div"> = BaseHighlightProps<T> & {
+    mode?: "children";
+    controlledItems?: false;
+    itemsClassName?: string;
+    children: React.ReactElement | React.ReactElement[];
+};
+type HighlightProps<T extends React.ElementType = "div"> = ControlledParentModeHighlightProps<T> | ControlledChildrenModeHighlightProps<T> | UncontrolledParentModeHighlightProps<T> | UncontrolledChildrenModeHighlightProps<T>;
+declare function Highlight<T extends React.ElementType = "div">({ ref, ...props }: HighlightProps<T>): import("react/jsx-runtime").JSX.Element;
+type HighlightItemProps<T extends React.ElementType = "div"> = React.ComponentProps<T> & {
+    as?: T;
+    children: React.ReactElement;
+    id?: string;
+    value?: string;
+    className?: string;
+    style?: React.CSSProperties;
+    transition?: Transition;
+    activeClassName?: string;
+    disabled?: boolean;
+    exitDelay?: number;
+    asChild?: boolean;
+    forceUpdateBounds?: boolean;
+};
+declare function HighlightItem<T extends React.ElementType>({ ref, as, children, id, value, className, style, transition, disabled, activeClassName, exitDelay, asChild, forceUpdateBounds, ...props }: HighlightItemProps<T>): any;
+export { Highlight, HighlightItem, useHighlight, //eslint-disable-line
+type HighlightItemProps, type HighlightProps, };

package/dist/components/animate-ui/primitives/effects/particles.d.ts

@@ -0,0 +1,25 @@
+import { HTMLMotionProps } from 'motion/react';
+import { WithAsChild } from '../animate/slot';
+import { UseIsInViewOptions } from '../../../../hooks/use-is-in-view';
+import * as React from "react";
+type Side = "top" | "bottom" | "left" | "right";
+type Align = "start" | "center" | "end";
+type ParticlesProps = WithAsChild<Omit<HTMLMotionProps<"div">, "children"> & {
+    animate?: boolean;
+    children: React.ReactNode;
+} & UseIsInViewOptions>;
+declare function Particles({ ref, animate, asChild, inView, inViewMargin, inViewOnce, children, style, ...props }: ParticlesProps): import("react/jsx-runtime").JSX.Element;
+type ParticlesEffectProps = Omit<HTMLMotionProps<"div">, "children"> & {
+    side?: Side;
+    align?: Align;
+    count?: number;
+    radius?: number;
+    spread?: number;
+    duration?: number;
+    holdDelay?: number;
+    sideOffset?: number;
+    alignOffset?: number;
+    delay?: number;
+};
+declare function ParticlesEffect({ side, align, count, radius, spread, duration, holdDelay, sideOffset, alignOffset, delay, transition, style, ...props }: ParticlesEffectProps): import("react/jsx-runtime").JSX.Element;
+export { Particles, ParticlesEffect, type ParticlesProps, type ParticlesEffectProps, };

package/dist/components/animate-ui/primitives/headless/checkbox.d.ts

@@ -0,0 +1,16 @@
+import { CheckboxProps as CheckboxPrimitiveProps } from '@headlessui/react';
+import { motion, HTMLMotionProps, SVGMotionProps } from 'motion/react';
+import * as React from "react";
+type CheckboxContextType = {
+    isChecked: boolean;
+    isIndeterminate: boolean;
+};
+declare const useCheckbox: () => CheckboxContextType;
+type CheckboxProps<TTag extends React.ElementType = typeof motion.button> = CheckboxPrimitiveProps<TTag> & Omit<HTMLMotionProps<"button">, "checked" | "onChange" | "defaultChecked" | "children"> & {
+    as?: TTag;
+};
+declare function Checkbox<TTag extends React.ElementType = typeof motion.button>({ children, ...props }: CheckboxProps<TTag>): import("react/jsx-runtime").JSX.Element;
+type CheckboxIndicatorProps = SVGMotionProps<SVGSVGElement>;
+declare function CheckboxIndicator(props: CheckboxIndicatorProps): import("react/jsx-runtime").JSX.Element;
+export { Checkbox, CheckboxIndicator, useCheckbox, //eslint-disable-line
+type CheckboxContextType, type CheckboxIndicatorProps, type CheckboxProps, };

package/dist/components/animate-ui/primitives/headless/dialog.d.ts

@@ -0,0 +1,42 @@
+import { Description as DialogDescriptionPrimitive, DialogProps as DialogPrimitiveProps, DialogBackdropProps as DialogBackdropPrimitiveProps, DialogPanelProps as DialogPanelPrimitiveProps, DialogTitleProps as DialogTitlePrimitiveProps, CloseButtonProps } from '@headlessui/react';
+import { motion, Transition, HTMLMotionProps } from 'motion/react';
+import * as React from "react";
+type DialogProps<TTag extends React.ElementType = "div"> = Omit<DialogPrimitiveProps<TTag>, "static"> & {
+    className?: string;
+    as?: TTag;
+};
+declare function Dialog<TTag extends React.ElementType = "div">({ className, ...props }: DialogProps<TTag>): import("react/jsx-runtime").JSX.Element;
+type DialogBackdropProps<TTag extends React.ElementType = typeof motion.div> = Omit<DialogBackdropPrimitiveProps<TTag>, "transition"> & HTMLMotionProps<"div"> & {
+    as?: TTag;
+};
+declare function DialogBackdrop<TTag extends React.ElementType = typeof motion.div>(props: DialogBackdropProps<TTag>): import("react/jsx-runtime").JSX.Element;
+type DialogFlipDirection = "top" | "bottom" | "left" | "right";
+type DialogPanelProps<TTag extends React.ElementType = typeof motion.div> = Omit<DialogPanelPrimitiveProps<TTag>, "transition"> & Omit<HTMLMotionProps<"div">, "children"> & {
+    from?: DialogFlipDirection;
+    transition?: Transition;
+    as?: TTag;
+};
+declare function DialogPanel<TTag extends React.ElementType = typeof motion.div>(props: DialogPanelProps<TTag>): import("react/jsx-runtime").JSX.Element;
+type DialogCloseProps<TTag extends React.ElementType = "div"> = CloseButtonProps<TTag> & {
+    as?: TTag;
+};
+declare function DialogClose<TTag extends React.ElementType = "button">(props: DialogCloseProps<TTag>): import("react/jsx-runtime").JSX.Element;
+type DialogHeaderProps<TTag extends React.ElementType = "div"> = React.ComponentProps<TTag> & {
+    as?: TTag;
+};
+declare function DialogHeader<TTag extends React.ElementType = "div">({ as: Component, ...props }: DialogHeaderProps<TTag>): import("react/jsx-runtime").JSX.Element;
+type DialogFooterProps<TTag extends React.ElementType = "div"> = React.ComponentProps<TTag> & {
+    as?: TTag;
+};
+declare function DialogFooter({ as: Component, ...props }: DialogFooterProps): import("react/jsx-runtime").JSX.Element;
+type DialogTitleProps<TTag extends React.ElementType = "h2"> = DialogTitlePrimitiveProps<TTag> & {
+    as?: TTag;
+    className?: string;
+};
+declare function DialogTitle<TTag extends React.ElementType = "h2">(props: DialogTitleProps<TTag>): import("react/jsx-runtime").JSX.Element;
+type DialogDescriptionProps<TTag extends React.ElementType = "div"> = React.ComponentProps<typeof DialogDescriptionPrimitive<TTag>> & {
+    as?: TTag;
+    className?: string;
+};
+declare function DialogDescription<TTag extends React.ElementType = "div">(props: DialogDescriptionProps<TTag>): import("react/jsx-runtime").JSX.Element;
+export { Dialog, DialogBackdrop, DialogPanel, DialogClose, DialogTitle, DialogDescription, DialogHeader, DialogFooter, type DialogProps, type DialogBackdropProps, type DialogPanelProps, type DialogCloseProps, type DialogTitleProps, type DialogDescriptionProps, type DialogHeaderProps, type DialogFooterProps, type DialogFlipDirection, };

package/dist/components/{base/Modal.d.ts → animate-ui/primitives/headless/modal.d.ts}

@@ -2,7 +2,7 @@ import { ReactNode } from 'react';
 interface ModalProps {
     isOpen: boolean;
     onClose: () => void;
-    title: string;
+    title?: string;
     children: ReactNode;
     maxWidth?: string;
     minWidth?: string;

package/dist/components/animate-ui/primitives/radix/dropdown-menu.d.ts

@@ -0,0 +1,57 @@
+import { HTMLMotionProps } from 'motion/react';
+import { DropdownMenu as DropdownMenuPrimitive } from 'radix-ui';
+import { HighlightItemProps, HighlightProps } from '../effects/highlight';
+import * as React from "react";
+type DropdownMenuContextType = {
+    isOpen: boolean;
+    setIsOpen: (o: boolean) => void;
+    highlightedValue: string | null;
+    setHighlightedValue: (value: string | null) => void;
+};
+type DropdownMenuSubContextType = {
+    isOpen: boolean;
+    setIsOpen: (o: boolean) => void;
+};
+declare const useDropdownMenu: () => DropdownMenuContextType;
+declare const useDropdownMenuSub: () => DropdownMenuSubContextType;
+type DropdownMenuProps = React.ComponentProps<typeof DropdownMenuPrimitive.Root>;
+declare function DropdownMenu(props: DropdownMenuProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuTriggerProps = React.ComponentProps<typeof DropdownMenuPrimitive.Trigger>;
+declare function DropdownMenuTrigger(props: DropdownMenuTriggerProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuPortalProps = React.ComponentProps<typeof DropdownMenuPrimitive.Portal>;
+declare function DropdownMenuPortal(props: DropdownMenuPortalProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuGroupProps = React.ComponentProps<typeof DropdownMenuPrimitive.Group>;
+declare function DropdownMenuGroup(props: DropdownMenuGroupProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuSubProps = React.ComponentProps<typeof DropdownMenuPrimitive.Sub>;
+declare function DropdownMenuSub(props: DropdownMenuSubProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuRadioGroupProps = React.ComponentProps<typeof DropdownMenuPrimitive.RadioGroup>;
+declare function DropdownMenuRadioGroup(props: DropdownMenuRadioGroupProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuSubTriggerProps = Omit<React.ComponentProps<typeof DropdownMenuPrimitive.SubTrigger>, "asChild"> & HTMLMotionProps<"div">;
+declare function DropdownMenuSubTrigger({ disabled, textValue, ...props }: DropdownMenuSubTriggerProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuSubContentProps = Omit<React.ComponentProps<typeof DropdownMenuPrimitive.SubContent>, "forceMount" | "asChild"> & Omit<React.ComponentProps<typeof DropdownMenuPrimitive.Portal>, "forceMount"> & HTMLMotionProps<"div">;
+declare function DropdownMenuSubContent({ loop, onEscapeKeyDown, onPointerDownOutside, onFocusOutside, onInteractOutside, sideOffset, alignOffset, avoidCollisions, collisionBoundary, collisionPadding, arrowPadding, sticky, hideWhenDetached, transition, style, container, ...props }: DropdownMenuSubContentProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuHighlightProps = Omit<HighlightProps, "controlledItems" | "enabled" | "hover"> & {
+    animateOnHover?: boolean;
+};
+declare function DropdownMenuHighlight({ transition, ...props }: DropdownMenuHighlightProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuContentProps = Omit<React.ComponentProps<typeof DropdownMenuPrimitive.Content>, "forceMount" | "asChild"> & Omit<React.ComponentProps<typeof DropdownMenuPrimitive.Portal>, "forceMount"> & HTMLMotionProps<"div">;
+declare function DropdownMenuContent({ loop, onCloseAutoFocus, onEscapeKeyDown, onPointerDownOutside, onFocusOutside, onInteractOutside, side, sideOffset, align, alignOffset, avoidCollisions, collisionBoundary, collisionPadding, arrowPadding, sticky, hideWhenDetached, transition, style, container, ...props }: DropdownMenuContentProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuHighlightItemProps = HighlightItemProps;
+declare function DropdownMenuHighlightItem(props: DropdownMenuHighlightItemProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuItemProps = Omit<React.ComponentProps<typeof DropdownMenuPrimitive.Item>, "asChild"> & HTMLMotionProps<"div">;
+declare function DropdownMenuItem({ disabled, onSelect, textValue, ...props }: DropdownMenuItemProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuCheckboxItemProps = Omit<React.ComponentProps<typeof DropdownMenuPrimitive.CheckboxItem>, "asChild"> & HTMLMotionProps<"div">;
+declare function DropdownMenuCheckboxItem({ checked, onCheckedChange, disabled, onSelect, textValue, ...props }: DropdownMenuCheckboxItemProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuRadioItemProps = Omit<React.ComponentProps<typeof DropdownMenuPrimitive.RadioItem>, "asChild"> & HTMLMotionProps<"div">;
+declare function DropdownMenuRadioItem({ value, disabled, onSelect, textValue, ...props }: DropdownMenuRadioItemProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuLabelProps = React.ComponentProps<typeof DropdownMenuPrimitive.Label>;
+declare function DropdownMenuLabel(props: DropdownMenuLabelProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuSeparatorProps = React.ComponentProps<typeof DropdownMenuPrimitive.Separator>;
+declare function DropdownMenuSeparator(props: DropdownMenuSeparatorProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuShortcutProps = React.ComponentProps<"span">;
+declare function DropdownMenuShortcut(props: DropdownMenuShortcutProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuItemIndicatorProps = Omit<React.ComponentProps<typeof DropdownMenuPrimitive.ItemIndicator>, "asChild"> & HTMLMotionProps<"div">;
+declare function DropdownMenuItemIndicator(props: DropdownMenuItemIndicatorProps): import("react/jsx-runtime").JSX.Element;
+export { DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuHighlight, DropdownMenuHighlightItem, DropdownMenuItem, DropdownMenuItemIndicator, DropdownMenuLabel, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, useDropdownMenu, //eslint-disable-line
+useDropdownMenuSub, //eslint-disable-line
+type DropdownMenuCheckboxItemProps, type DropdownMenuContentProps, type DropdownMenuContextType, type DropdownMenuGroupProps, type DropdownMenuHighlightItemProps, type DropdownMenuHighlightProps, type DropdownMenuItemIndicatorProps, type DropdownMenuItemProps, type DropdownMenuLabelProps, type DropdownMenuPortalProps, type DropdownMenuProps, type DropdownMenuRadioGroupProps, type DropdownMenuRadioItemProps, type DropdownMenuSeparatorProps, type DropdownMenuShortcutProps, type DropdownMenuSubContentProps, type DropdownMenuSubContextType, type DropdownMenuSubProps, type DropdownMenuSubTriggerProps, type DropdownMenuTriggerProps, };

package/dist/components/animate-ui/primitives/radix/tabs.d.ts

@@ -0,0 +1,32 @@
+import { Tabs as TabsPrimitive } from 'radix-ui';
+import { HTMLMotionProps, Transition } from 'motion/react';
+import { HighlightProps, HighlightItemProps } from '../effects/highlight';
+import { AutoHeightProps } from '../effects/auto-height';
+import * as React from "react";
+type TabsProps = React.ComponentProps<typeof TabsPrimitive.Root>;
+declare function Tabs(props: TabsProps): import("react/jsx-runtime").JSX.Element;
+type TabsHighlightProps = Omit<HighlightProps, "controlledItems" | "value">;
+declare function TabsHighlight({ transition, ...props }: TabsHighlightProps): import("react/jsx-runtime").JSX.Element;
+type TabsListProps = React.ComponentProps<typeof TabsPrimitive.List>;
+declare function TabsList(props: TabsListProps): import("react/jsx-runtime").JSX.Element;
+type TabsHighlightItemProps = HighlightItemProps & {
+    value: string;
+};
+declare function TabsHighlightItem(props: TabsHighlightItemProps): import("react/jsx-runtime").JSX.Element;
+type TabsTriggerProps = React.ComponentProps<typeof TabsPrimitive.Trigger>;
+declare function TabsTrigger(props: TabsTriggerProps): import("react/jsx-runtime").JSX.Element;
+type TabsContentProps = React.ComponentProps<typeof TabsPrimitive.Content> & HTMLMotionProps<"div">;
+declare function TabsContent({ value, forceMount, transition, ...props }: TabsContentProps): import("react/jsx-runtime").JSX.Element;
+type TabsContentsAutoProps = AutoHeightProps & {
+    mode?: "auto-height";
+    children: React.ReactNode;
+    transition?: Transition;
+};
+type TabsContentsLayoutProps = Omit<HTMLMotionProps<"div">, "transition"> & {
+    mode: "layout";
+    children: React.ReactNode;
+    transition?: Transition;
+};
+type TabsContentsProps = TabsContentsAutoProps | TabsContentsLayoutProps;
+declare function TabsContents(props: TabsContentsProps): import("react/jsx-runtime").JSX.Element;
+export { Tabs, TabsHighlight, TabsHighlightItem, TabsList, TabsTrigger, TabsContent, TabsContents, type TabsProps, type TabsHighlightProps, type TabsHighlightItemProps, type TabsListProps, type TabsTriggerProps, type TabsContentProps, type TabsContentsProps, };

package/dist/components/animate-ui/primitives/radix/tooltip.d.ts

@@ -0,0 +1,21 @@
+import { HTMLMotionProps } from 'motion/react';
+import { Tooltip as TooltipPrimitive } from 'radix-ui';
+import * as React from "react";
+type TooltipContextType = {
+    isOpen: boolean;
+    setIsOpen: (isOpen: boolean) => void;
+};
+declare const useTooltip: () => TooltipContextType;
+type TooltipProviderProps = React.ComponentProps<typeof TooltipPrimitive.Provider>;
+declare function TooltipProvider(props: TooltipProviderProps): import("react/jsx-runtime").JSX.Element;
+type TooltipProps = React.ComponentProps<typeof TooltipPrimitive.Root>;
+declare function Tooltip(props: TooltipProps): import("react/jsx-runtime").JSX.Element;
+type TooltipTriggerProps = React.ComponentProps<typeof TooltipPrimitive.Trigger>;
+declare function TooltipTrigger(props: TooltipTriggerProps): import("react/jsx-runtime").JSX.Element;
+type TooltipPortalProps = Omit<React.ComponentProps<typeof TooltipPrimitive.Portal>, "forceMount">;
+declare function TooltipPortal(props: TooltipPortalProps): import("react/jsx-runtime").JSX.Element;
+type TooltipContentProps = Omit<React.ComponentProps<typeof TooltipPrimitive.Content>, "forceMount" | "asChild"> & HTMLMotionProps<"div">;
+declare function TooltipContent({ onEscapeKeyDown, onPointerDownOutside, side, sideOffset, align, alignOffset, avoidCollisions, collisionBoundary, collisionPadding, arrowPadding, sticky, hideWhenDetached, transition, ...props }: TooltipContentProps): import("react/jsx-runtime").JSX.Element;
+type TooltipArrowProps = React.ComponentProps<typeof TooltipPrimitive.Arrow>;
+declare function TooltipArrow(props: TooltipArrowProps): import("react/jsx-runtime").JSX.Element;
+export { Tooltip, TooltipArrow, TooltipContent, TooltipPortal, TooltipProvider, TooltipTrigger, useTooltip, type TooltipArrowProps, type TooltipContentProps, type TooltipContextType, type TooltipPortalProps, type TooltipProps, type TooltipProviderProps, type TooltipTriggerProps, };

package/dist/components/animate-ui/primitives/texts/sliding-number.d.ts

@@ -0,0 +1,16 @@
+import { SpringOptions, HTMLMotionProps } from 'motion/react';
+import { UseIsInViewOptions } from '../../../../hooks/use-is-in-view';
+type SlidingNumberProps = Omit<HTMLMotionProps<"span">, "children"> & {
+    number: number;
+    fromNumber?: number;
+    onNumberChange?: (number: number) => void;
+    padStart?: boolean;
+    decimalSeparator?: string;
+    decimalPlaces?: number;
+    thousandSeparator?: string;
+    transition?: SpringOptions;
+    delay?: number;
+    initiallyStable?: boolean;
+} & UseIsInViewOptions;
+declare function SlidingNumber({ ref, number, fromNumber, onNumberChange, inView, inViewMargin, inViewOnce, padStart, decimalSeparator, decimalPlaces, thousandSeparator, transition, delay, initiallyStable, ...props }: SlidingNumberProps): import("react/jsx-runtime").JSX.Element;
+export { SlidingNumber, type SlidingNumberProps };

package/dist/components/base/Badge.d.ts

@@ -1,7 +1,7 @@
 import { default as React } from 'react';
 interface BadgeProps {
     children: React.ReactNode;
-    variant?: "default" | "blue" | "green" | "yellow" | "red" | "gray";
+    variant?: "default" | "blue" | "green" | "yellow" | "red" | "gray" | "purple";
     size?: "sm" | "md";
     className?: string;
 }

package/dist/components/charts/index.d.ts

@@ -1,5 +1,5 @@
 export { ChartRenderer } from './ChartRenderer';
 export { ChartDisplay, SimpleChartDisplay } from './ChartDisplay';
-export { detectChart, validateChartData, suggestChartType } from '../../utils/chartDetection';
-export { createEChartsTheme, detectThemeFromDOM } from '../../utils/chartThemes';
+export { detectChart, validateChartData, suggestChartType, } from '../../utils/chartDetection';
+export { createEChartsTheme, detectThemeFromDOM, } from '../../utils/chartThemes';
 export type { ChartConfig, ChartDataPoint, SeriesData, TimeSeriesPoint, ChartableOutput, ChartDetectionResult, ChartTheme, ChartRendererProps, ChartDisplayProps, ChartableData, DetectionPattern, } from '../../types/chartTypes';

package/dist/components/features/ExploreMcpCard.d.ts

@@ -0,0 +1,6 @@
+import { BuiltinMcpData, ExplorableMcpServer } from '../../types/mcp';
+import { default as React } from 'react';
+declare const ExplorerMcpCard: React.FC<{
+    mcp: ExplorableMcpServer<BuiltinMcpData>;
+}>;
+export default ExplorerMcpCard;

package/dist/components/features/ExploreMcpListItem.d.ts

@@ -0,0 +1,6 @@
+import { BuiltinMcpData, ExplorableMcpServer } from '../../types/mcp';
+import { default as React } from 'react';
+declare const ExploreMcpListItem: React.FC<{
+    mcp: ExplorableMcpServer<BuiltinMcpData>;
+}>;
+export default ExploreMcpListItem;

package/dist/components/layouts/ActivityBar.d.ts

@@ -0,0 +1,8 @@
+export type ActivityPanel = "chat" | "explorer" | "workshop";
+interface ActivityBarProps {
+    activePanel: ActivityPanel;
+    onPanelChange: (panel: ActivityPanel) => void;
+    className?: string;
+}
+export declare const ActivityBar: React.FC<ActivityBarProps>;
+export default ActivityBar;

package/dist/components/layouts/AgentExplorer.d.ts

@@ -0,0 +1 @@
+export default function AgentExplorer(): import("react/jsx-runtime").JSX.Element;

package/dist/components/layouts/McpListModal.d.ts

@@ -0,0 +1 @@
+export declare function McpListModal(): import("react/jsx-runtime").JSX.Element;

package/dist/components/layouts/Workshop.d.ts

@@ -0,0 +1 @@
+export default function Workshop(): import("react/jsx-runtime").JSX.Element;

package/dist/components/layouts/WorkshopChat.d.ts

@@ -0,0 +1 @@
+export default function WorkshopChat(): import("react/jsx-runtime").JSX.Element;