@sciol/xyzen 0.3.5 → 0.3.6

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/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/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" | "accent" | "destructive" | "secondary" | "ghost" | 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/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 react-refresh/only-export-components
+type HighlightItemProps, type HighlightProps, };

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/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/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/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/Explorer.d.ts

@@ -0,0 +1 @@
+export default function Explorer(): 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;

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

@@ -10,7 +10,7 @@ export type Agent = {
     user_id: string;
     require_tool_confirmation?: boolean;
     provider_id?: string | null;
-    agent_type: 'regular' | 'graph';
+    agent_type: "regular" | "graph" | "builtin";
     avatar?: string | null;
     tags?: string[] | null;
     model?: string | null;
@@ -18,8 +18,12 @@ export type Agent = {
     is_active?: boolean;
     created_at: string;
     updated_at: string;
-    state_schema?: any;
+    state_schema?: Record<string, unknown>;
     node_count?: number;
     edge_count?: number;
 };
-export default function XyzenAgent(): import("react/jsx-runtime").JSX.Element;
+interface XyzenAgentProps {
+    systemAgentType?: "chat" | "workshop" | "all";
+}
+export default function XyzenAgent({ systemAgentType, }: XyzenAgentProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/shared/JsonDisplay.d.ts

@@ -3,7 +3,7 @@ interface JsonDisplayProps {
     data: unknown;
     className?: string;
     compact?: boolean;
-    variant?: 'default' | 'success' | 'error';
+    variant?: "default" | "success" | "error";
     hideHeader?: boolean;
     enableCharts?: boolean;
 }

package/dist/configs/chatThemes.d.ts

@@ -0,0 +1,9 @@
+import { XyzenChatConfig } from '../hooks/useXyzenChat';
+import { WorkShopChatConfig } from '../hooks/useWorkShopChat';
+export declare const XYZEN_CHAT_CONFIG: XyzenChatConfig;
+export declare const WORKSHOP_CHAT_CONFIG: WorkShopChatConfig;
+export declare const CHAT_THEMES: {
+    readonly xyzen: XyzenChatConfig;
+    readonly workshop: WorkShopChatConfig;
+};
+export type ChatThemeKey = keyof typeof CHAT_THEMES;

package/dist/hooks/use-auto-height.d.ts

@@ -0,0 +1,10 @@
+import * as React from "react";
+type AutoHeightOptions = {
+    includeParentBox?: boolean;
+    includeSelfBox?: boolean;
+};
+export declare function useAutoHeight<T extends HTMLElement = HTMLDivElement>(deps?: React.DependencyList, options?: AutoHeightOptions): {
+    readonly ref: React.RefObject<T | null>;
+    readonly height: number;
+};
+export {};

package/dist/hooks/use-controlled-state.d.ts

@@ -0,0 +1,8 @@
+interface CommonControlledStateProps<T> {
+    value?: T;
+    defaultValue?: T;
+}
+export declare function useControlledState<T, Rest extends any[] = []>(props: CommonControlledStateProps<T> & {
+    onChange?: (value: T, ...args: Rest) => void;
+}): readonly [T, (next: T, ...args: Rest) => void];
+export {};

package/dist/hooks/useWorkShopChat.d.ts

@@ -0,0 +1,69 @@
+import { Message } from '../store/types';
+export interface WorkShopChatConfig {
+    theme: "indigo" | "purple";
+    systemAgentId: string;
+    storageKeys: {
+        inputHeight: string;
+        historyPinned?: string;
+    };
+    defaultTitle: string;
+    placeholders: {
+        responding: string;
+        default: string;
+    };
+    connectionMessages: {
+        connecting: string;
+        retrying: string;
+    };
+    responseMessages: {
+        generating: string;
+        creating: string;
+    };
+    emptyState: {
+        title: string;
+        description: string;
+        icon: string;
+        features?: string[];
+    };
+    welcomeMessage?: {
+        title: string;
+        description: string;
+        icon: string;
+        tags?: string[];
+    };
+}
+export declare function useWorkShopChat(config: WorkShopChatConfig): {
+    autoScroll: boolean;
+    isRetrying: boolean;
+    showHistory: boolean;
+    inputHeight: number;
+    sendBlocked: boolean;
+    currentChannel: import('../store/types').ChatChannel | null;
+    currentAgent: import('../components/layouts/XyzenAgent').Agent | null | undefined;
+    messages: Message[];
+    connected: boolean;
+    error: string | null;
+    responding: boolean;
+    messagesEndRef: import('react').RefObject<HTMLDivElement | null>;
+    messagesContainerRef: import('react').RefObject<HTMLDivElement | null>;
+    handleSendMessage: (inputMessage: string) => void;
+    handleToggleHistory: () => void;
+    handleCloseHistory: () => void;
+    handleSelectTopic: (_topicId: string) => void;
+    handleInputHeightChange: (height: number) => void;
+    handleRetryConnection: () => void;
+    handleScrollToBottom: () => void;
+    handleScroll: () => void;
+    activeChatChannel: string | null;
+    notification: {
+        isOpen: boolean;
+        title: string;
+        message: string;
+        type: "info" | "warning" | "error" | "success";
+        actionLabel?: string;
+        onAction?: () => void;
+    } | null;
+    closeNotification: () => void;
+    pendingInput: string;
+    updateTopicName: (topicId: string, newName: string) => Promise<void>;
+};

package/dist/hooks/useXyzenChat.d.ts

@@ -0,0 +1,69 @@
+import { Message } from '../store/types';
+export interface XyzenChatConfig {
+    theme: "indigo" | "purple";
+    systemAgentId: string;
+    storageKeys: {
+        inputHeight: string;
+        historyPinned?: string;
+    };
+    defaultTitle: string;
+    placeholders: {
+        responding: string;
+        default: string;
+    };
+    connectionMessages: {
+        connecting: string;
+        retrying: string;
+    };
+    responseMessages: {
+        generating: string;
+        creating: string;
+    };
+    emptyState: {
+        title: string;
+        description: string;
+        icon: string;
+        features?: string[];
+    };
+    welcomeMessage?: {
+        title: string;
+        description: string;
+        icon: string;
+        tags?: string[];
+    };
+}
+export declare function useXyzenChat(config: XyzenChatConfig): {
+    autoScroll: boolean;
+    isRetrying: boolean;
+    showHistory: boolean;
+    inputHeight: number;
+    sendBlocked: boolean;
+    currentChannel: import('../store/types').ChatChannel | null;
+    currentAgent: import('../components/layouts/XyzenAgent').Agent | null | undefined;
+    messages: Message[];
+    connected: boolean;
+    error: string | null;
+    responding: boolean;
+    messagesEndRef: import('react').RefObject<HTMLDivElement | null>;
+    messagesContainerRef: import('react').RefObject<HTMLDivElement | null>;
+    handleSendMessage: (inputMessage: string) => void;
+    handleToggleHistory: () => void;
+    handleCloseHistory: () => void;
+    handleSelectTopic: (_topicId: string) => void;
+    handleInputHeightChange: (height: number) => void;
+    handleRetryConnection: () => void;
+    handleScrollToBottom: () => void;
+    handleScroll: () => void;
+    activeChatChannel: string | null;
+    notification: {
+        isOpen: boolean;
+        title: string;
+        message: string;
+        type: "info" | "warning" | "error" | "success";
+        actionLabel?: string;
+        onAction?: () => void;
+    } | null;
+    closeNotification: () => void;
+    pendingInput: string;
+    updateTopicName: (topicId: string, newName: string) => Promise<void>;
+};

package/dist/lib/get-strict-context.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+declare function getStrictContext<T>(name?: string): readonly [
+    ({ value, children, }: {
+        value: T;
+        children?: React.ReactNode;
+    }) => React.JSX.Element,
+    () => T
+];
+export { getStrictContext };

package/dist/lib/utils.d.ts

@@ -0,0 +1,2 @@
+import { ClassValue } from 'clsx';
+export declare function cn(...inputs: ClassValue[]): string;

package/dist/store/slices/agentSlice.d.ts

@@ -5,7 +5,12 @@ export interface AgentSlice {
     agents: Agent[];
     agentsLoading: boolean;
     hiddenGraphAgentIds: string[];
+    systemAgents: Agent[];
+    systemAgentsLoading: boolean;
     fetchAgents: () => Promise<void>;
+    fetchSystemAgents: () => Promise<void>;
+    getSystemChatAgent: () => Promise<Agent>;
+    getSystemWorkshopAgent: () => Promise<Agent>;
     createAgent: (agent: Omit<Agent, "id">) => Promise<void>;
     createGraphAgent: (graphAgent: GraphAgentCreate) => Promise<void>;
     updateAgent: (agent: Agent) => Promise<void>;
@@ -15,11 +20,12 @@ export interface AgentSlice {
     addGraphAgentToSidebar: (id: string) => void;
     getRegularAgents: () => Agent[];
     getGraphAgents: () => Agent[];
+    getSystemAgents: () => Agent[];
 }
 export interface GraphAgentCreate {
     name: string;
     description: string;
-    state_schema?: any;
+    state_schema?: Record<string, unknown>;
 }
 export declare const createAgentSlice: StateCreator<XyzenState, [
     ["zustand/immer", never]

package/dist/store/slices/uiSlice.d.ts

@@ -1,12 +1,16 @@
 import { StateCreator } from 'zustand';
 import { Theme, XyzenState, LayoutStyle, UiSettingType } from '../types';
+export type ActivityPanel = "chat" | "explorer" | "workshop";
 export interface UiSlice {
     backendUrl: string;
     isXyzenOpen: boolean;
     panelWidth: number;
     activeTabIndex: number;
+    activePanel: ActivityPanel;
     theme: Theme;
     layoutStyle: LayoutStyle;
+    isMcpListModalOpen: boolean;
+    isLlmProvidersModalOpen: boolean;
     isAddMcpServerModalOpen: boolean;
     isAddLlmProviderModalOpen: boolean;
     isSettingsModalOpen: boolean;
@@ -19,9 +23,14 @@ export interface UiSlice {
     closeXyzen: () => void;
     setPanelWidth: (width: number) => void;
     setTabIndex: (index: number) => void;
+    setActivePanel: (panel: ActivityPanel) => void;
     setTheme: (theme: Theme) => void;
     setLayoutStyle: (style: LayoutStyle) => void;
     setBackendUrl: (url: string) => void;
+    openMcpListModal: () => void;
+    closeMcpListModal: () => void;
+    openLlmProvidersModal: () => void;
+    closeLlmProvidersModal: () => void;
     openAddMcpServerModal: () => void;
     closeAddMcpServerModal: () => void;
     openAddLlmProviderModal: () => void;

package/dist/types/chartTypes.d.ts

@@ -7,7 +7,7 @@ export interface ChartDataPoint {
 export interface SeriesData {
     name: string;
     data: number[] | ChartDataPoint[];
-    type?: 'line' | 'bar' | 'pie' | 'scatter' | 'area';
+    type?: "line" | "bar" | "pie" | "scatter" | "area";
 }
 export interface TimeSeriesPoint {
     timestamp: string | Date;
@@ -15,16 +15,16 @@ export interface TimeSeriesPoint {
     [key: string]: unknown;
 }
 export interface ChartConfig {
-    type: 'line' | 'bar' | 'pie' | 'scatter' | 'area' | 'heatmap';
+    type: "line" | "bar" | "pie" | "scatter" | "area" | "heatmap";
     title?: string;
     data: ChartDataPoint[] | SeriesData[] | TimeSeriesPoint[] | number[];
     labels?: string[];
     xAxis?: {
-        type?: 'category' | 'value' | 'time';
+        type?: "category" | "value" | "time";
         name?: string;
     };
     yAxis?: {
-        type?: 'category' | 'value' | 'log';
+        type?: "category" | "value" | "log";
         name?: string;
     };
     options?: Partial<EChartsOption>;
@@ -40,7 +40,7 @@ export interface ChartableOutput {
 }
 export interface ChartDetectionResult {
     isChartable: boolean;
-    chartType: ChartConfig['type'] | null;
+    chartType: ChartConfig["type"] | null;
     confidence: number;
     data: ChartConfig | null;
     reason?: string;
@@ -54,7 +54,7 @@ export interface ChartTheme {
 }
 export interface ChartRendererProps {
     data: ChartConfig | EChartsOption;
-    theme?: 'light' | 'dark';
+    theme?: "light" | "dark";
     height?: string | number;
     width?: string | number;
     className?: string;
@@ -63,7 +63,7 @@ export interface ChartRendererProps {
 export interface ChartDisplayProps {
     data: unknown;
     compact?: boolean;
-    variant?: 'default' | 'success' | 'error';
+    variant?: "default" | "success" | "error";
     className?: string;
     fallbackToJson?: boolean;
 }

package/dist/utils/chartDetection.d.ts

@@ -10,4 +10,4 @@ export declare function validateChartData(config: ChartConfig): boolean;
 /**
  * Get chart type suggestions based on data characteristics
  */
-export declare function suggestChartType(data: unknown): ChartConfig['type'][];
+export declare function suggestChartType(data: unknown): ChartConfig["type"][];