@sciol/xyzen 0.3.4 → 0.3.5

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

@@ -0,0 +1,16 @@
+import { default as React } from 'react';
+import { ChartDisplayProps } from '../../types/chartTypes';
+/**
+ * High-level component that decides whether to render data as a chart or JSON
+ */
+export declare const ChartDisplay: React.FC<ChartDisplayProps>;
+/**
+ * Simplified chart display component for cases where you know the data is chartable
+ */
+export declare const SimpleChartDisplay: React.FC<{
+    data: unknown;
+    title?: string;
+    height?: number;
+    className?: string;
+}>;
+export default ChartDisplay;

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

@@ -0,0 +1,6 @@
+import { default as React } from 'react';
+import { ChartRendererProps } from '../../types/chartTypes';
+/**
+ * Core chart rendering component using ECharts
+ */
+export declare const ChartRenderer: React.FC<ChartRendererProps>;

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

@@ -0,0 +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 type { ChartConfig, ChartDataPoint, SeriesData, TimeSeriesPoint, ChartableOutput, ChartDetectionResult, ChartTheme, ChartRendererProps, ChartDisplayProps, ChartableData, DetectionPattern, } from '../../types/chartTypes';

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

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

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

@@ -2,3 +2,4 @@ export { AuthStatus } from './AuthStatus';
 export { SettingsButton } from './SettingsButton';
 export { ThemeToggle } from './ThemeToggle';
 export { LayoutToggle } from './LayoutToggle';
+export { CenteredInput } from './CenteredInput';

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

@@ -2,7 +2,7 @@ export type Agent = {
     id: string;
     name: string;
     description: string;
-    prompt: string;
+    prompt?: string;
     mcp_servers?: {
         id: string;
     }[];
@@ -10,5 +10,16 @@ export type Agent = {
     user_id: string;
     require_tool_confirmation?: boolean;
     provider_id?: string | null;
+    agent_type: 'regular' | 'graph';
+    avatar?: string | null;
+    tags?: string[] | null;
+    model?: string | null;
+    temperature?: number | null;
+    is_active?: boolean;
+    created_at: string;
+    updated_at: string;
+    state_schema?: any;
+    node_count?: number;
+    edge_count?: number;
 };
 export default function XyzenAgent(): import("react/jsx-runtime").JSX.Element;

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

@@ -4,6 +4,7 @@ interface ChatInputProps {
     disabled?: boolean;
     placeholder?: string;
     height?: number;
+    initialValue?: string;
 }
 export declare const ChatInput: React.FC<ChatInputProps>;
 export default ChatInput;

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

@@ -0,0 +1,11 @@
+import { default as React } from 'react';
+interface JsonDisplayProps {
+    data: unknown;
+    className?: string;
+    compact?: boolean;
+    variant?: 'default' | 'success' | 'error';
+    hideHeader?: boolean;
+    enableCharts?: boolean;
+}
+export declare const JsonDisplay: React.FC<JsonDisplayProps>;
+export default JsonDisplay;

package/dist/main.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -4,11 +4,22 @@ import { XyzenState } from '../types';
 export interface AgentSlice {
     agents: Agent[];
     agentsLoading: boolean;
+    hiddenGraphAgentIds: string[];
     fetchAgents: () => Promise<void>;
     createAgent: (agent: Omit<Agent, "id">) => Promise<void>;
+    createGraphAgent: (graphAgent: GraphAgentCreate) => Promise<void>;
     updateAgent: (agent: Agent) => Promise<void>;
     updateAgentProvider: (agentId: string, providerId: string | null) => Promise<void>;
     deleteAgent: (id: string) => Promise<void>;
+    removeGraphAgentFromSidebar: (id: string) => void;
+    addGraphAgentToSidebar: (id: string) => void;
+    getRegularAgents: () => Agent[];
+    getGraphAgents: () => Agent[];
+}
+export interface GraphAgentCreate {
+    name: string;
+    description: string;
+    state_schema?: any;
 }
 export declare const createAgentSlice: StateCreator<XyzenState, [
     ["zustand/immer", never]

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

@@ -13,6 +13,7 @@ export interface UiSlice {
     activeSettingsCategory: string;
     activeUiSetting: UiSettingType;
     selectedProviderId: string | null;
+    pendingInput: string;
     toggleXyzen: () => void;
     openXyzen: () => void;
     closeXyzen: () => void;
@@ -30,6 +31,8 @@ export interface UiSlice {
     setActiveSettingsCategory: (category: string) => void;
     setActiveUiSetting: (setting: UiSettingType) => void;
     setSelectedProvider: (id: string | null) => void;
+    setPendingInput: (input: string) => void;
+    submitInput: () => void;
 }
 export declare const createUiSlice: StateCreator<XyzenState, [
     ["zustand/immer", never]

package/dist/store/types.d.ts

@@ -5,7 +5,11 @@ export interface ToolCall {
     description?: string;
     arguments: Record<string, unknown>;
     status: "pending" | "waiting_confirmation" | "executing" | "completed" | "failed";
-    result?: string;
+    result?: string | {
+        type: string;
+        content: unknown;
+        raw: string;
+    };
     error?: string;
     timestamp: string;
 }

package/dist/test-charts.d.ts

@@ -0,0 +1,6 @@
+import { default as React } from 'react';
+/**
+ * Test component to verify chart rendering works
+ */
+export declare const ChartTestComponent: React.FC;
+export default ChartTestComponent;

package/dist/types/chartTypes.d.ts

@@ -0,0 +1,78 @@
+import { EChartsOption } from 'echarts';
+export interface ChartDataPoint {
+    x: string | number;
+    y: number;
+    [key: string]: unknown;
+}
+export interface SeriesData {
+    name: string;
+    data: number[] | ChartDataPoint[];
+    type?: 'line' | 'bar' | 'pie' | 'scatter' | 'area';
+}
+export interface TimeSeriesPoint {
+    timestamp: string | Date;
+    value: number;
+    [key: string]: unknown;
+}
+export interface ChartConfig {
+    type: 'line' | 'bar' | 'pie' | 'scatter' | 'area' | 'heatmap';
+    title?: string;
+    data: ChartDataPoint[] | SeriesData[] | TimeSeriesPoint[] | number[];
+    labels?: string[];
+    xAxis?: {
+        type?: 'category' | 'value' | 'time';
+        name?: string;
+    };
+    yAxis?: {
+        type?: 'category' | 'value' | 'log';
+        name?: string;
+    };
+    options?: Partial<EChartsOption>;
+}
+export interface ChartableOutput {
+    echarts?: EChartsOption;
+    chart?: ChartConfig;
+    data?: unknown[];
+    chart_type?: string;
+    visualization?: string;
+    title?: string;
+    description?: string;
+}
+export interface ChartDetectionResult {
+    isChartable: boolean;
+    chartType: ChartConfig['type'] | null;
+    confidence: number;
+    data: ChartConfig | null;
+    reason?: string;
+}
+export interface ChartTheme {
+    backgroundColor: string;
+    textColor: string;
+    axisColor: string;
+    gridColor: string;
+    colorPalette: string[];
+}
+export interface ChartRendererProps {
+    data: ChartConfig | EChartsOption;
+    theme?: 'light' | 'dark';
+    height?: string | number;
+    width?: string | number;
+    className?: string;
+    onChartReady?: (chart: unknown) => void;
+}
+export interface ChartDisplayProps {
+    data: unknown;
+    compact?: boolean;
+    variant?: 'default' | 'success' | 'error';
+    className?: string;
+    fallbackToJson?: boolean;
+}
+export type ChartableData = ChartDataPoint[] | SeriesData[] | TimeSeriesPoint[] | number[] | {
+    [key: string]: number;
+}[] | EChartsOption;
+export type DetectionPattern = {
+    name: string;
+    test: (data: unknown) => boolean;
+    transform: (data: unknown) => ChartConfig | null;
+    confidence: number;
+};

package/dist/utils/chartDetection.d.ts

@@ -0,0 +1,13 @@
+import { ChartDetectionResult, ChartConfig } from '../types/chartTypes';
+/**
+ * Detects if data can be rendered as a chart and transforms it accordingly
+ */
+export declare function detectChart(data: unknown): ChartDetectionResult;
+/**
+ * Validate that chart data is safe to render
+ */
+export declare function validateChartData(config: ChartConfig): boolean;
+/**
+ * Get chart type suggestions based on data characteristics
+ */
+export declare function suggestChartType(data: unknown): ChartConfig['type'][];

package/dist/utils/chartThemes.d.ts

@@ -0,0 +1,18 @@
+import { ChartTheme } from '../types/chartTypes';
+import { EChartsOption } from 'echarts';
+/**
+ * Chart themes matching the application's design system
+ */
+export declare const chartThemes: Record<'light' | 'dark', ChartTheme>;
+/**
+ * Generate ECharts theme configuration
+ */
+export declare function createEChartsTheme(theme: 'light' | 'dark'): Partial<EChartsOption>;
+/**
+ * Hook to detect system theme preference
+ */
+export declare function useSystemTheme(): 'light' | 'dark';
+/**
+ * Detect theme from DOM classes (common pattern in Tailwind apps)
+ */
+export declare function detectThemeFromDOM(): 'light' | 'dark';