@sciol/xyzen 0.1.12 → 0.1.14

package/dist/app/LlmProviders.d.ts

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

package/dist/assets/LlmIcon.d.ts

@@ -0,0 +1,6 @@
+import { default as React } from 'react';
+interface LlmIconProps {
+    className?: string;
+}
+declare const LlmIcon: React.FC<LlmIconProps>;
+export default LlmIcon;

package/dist/assets/McpIcon.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+declare const McpIcon: React.FC<React.SVGProps<SVGSVGElement>>;
+export default McpIcon;

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

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+interface BadgeProps {
+    children: React.ReactNode;
+    variant?: "default" | "blue" | "green" | "yellow" | "red" | "gray";
+    size?: "sm" | "md";
+    className?: string;
+}
+export declare const Badge: React.FC<BadgeProps>;
+export {};

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

@@ -0,0 +1,9 @@
+interface EditableTitleProps {
+    title: string;
+    onSave: (newTitle: string) => Promise<void>;
+    className?: string;
+    textClassName?: string;
+    maxLength?: number;
+}
+export default function EditableTitle({ title, onSave, className, textClassName, maxLength, }: EditableTitleProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

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

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

@@ -0,0 +1,9 @@
+import { ReactNode } from 'react';
+interface ModalProps {
+    isOpen: boolean;
+    onClose: () => void;
+    title: string;
+    children: ReactNode;
+}
+export declare function Modal({ isOpen, onClose, title, children }: ModalProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+interface SwitchProps {
+    checked: boolean;
+    onChange: (checked: boolean) => void;
+    className?: string;
+    disabled?: boolean;
+}
+export declare const Switch: React.FC<SwitchProps>;
+export {};

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

@@ -0,0 +1,5 @@
+export interface AuthStatusProps {
+    onTokenInput?: (token: string) => void;
+    className?: string;
+}
+export declare function AuthStatus({ onTokenInput, className }: AuthStatusProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1 @@
+export { AuthStatus } from './AuthStatus';

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

@@ -4,9 +4,9 @@ export type Agent = {
     description: string;
     prompt: string;
     mcp_servers: {
-        id: number;
+        id: string;
     }[];
-    mcp_server_ids?: number[];
+    mcp_server_ids?: string[];
     user_id: string;
 };
 export default function XyzenAgent(): import("react/jsx-runtime").JSX.Element;

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

@@ -3,7 +3,7 @@ interface ChatInputProps {
     onSendMessage: (message: string) => void;
     disabled?: boolean;
     placeholder?: string;
-    onHeightChange?: (height: number) => void;
+    height?: number;
 }
 export declare const ChatInput: React.FC<ChatInputProps>;
 export default ChatInput;

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

@@ -0,0 +1,6 @@
+interface ChatToolbarProps {
+    onShowHistory: () => void;
+    onHeightChange?: (height: number) => void;
+}
+export default function ChatToolbar({ onShowHistory, onHeightChange, }: ChatToolbarProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,7 @@
+interface SessionHistoryProps {
+    isOpen: boolean;
+    onClose: () => void;
+    onSelectTopic?: (topicId: string) => void;
+}
+export default function SessionHistory({ isOpen, onClose, onSelectTopic, }: SessionHistoryProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/modals/AddLlmProviderModal.d.ts

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

package/dist/components/modals/AddMcpServerModal.d.ts

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

package/dist/components/modals/McpServerItem.d.ts

@@ -0,0 +1,9 @@
+import { McpServer } from '../../types/mcp';
+import { default as React } from 'react';
+interface McpServerItemProps {
+    mcp: McpServer;
+    isSelected: boolean;
+    onSelectionChange: (selected: boolean) => void;
+}
+export declare const McpServerItem: React.FC<McpServerItemProps>;
+export {};

package/dist/hooks/useAuth.d.ts

@@ -0,0 +1,14 @@
+import { UserInfo, AuthState } from '../service/authService';
+export interface UseAuthReturn {
+    authState: AuthState;
+    user: UserInfo | undefined;
+    message: string;
+    provider: string | undefined;
+    isLoading: boolean;
+    isAuthenticated: boolean;
+    isConfigured: boolean;
+    login: (token: string) => Promise<void>;
+    logout: () => void;
+    checkAuth: (force?: boolean) => Promise<void>;
+}
+export declare function useAuth(): UseAuthReturn;

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 export { Xyzen, type XyzenProps } from './app/App';
 export { default as useTheme } from './hooks/useTheme';
 export { default as xyzenService } from './service/xyzenService';
-export { useXyzen } from './store/xyzenStore';
+export { useXyzen } from './store';

package/dist/service/authService.d.ts

@@ -0,0 +1,52 @@
+export interface AuthStatus {
+    is_configured: boolean;
+    provider?: string;
+    message: string;
+}
+export interface UserInfo {
+    id: string;
+    username: string;
+    email?: string;
+    display_name?: string;
+    avatar_url?: string;
+    roles?: string[];
+}
+export interface AuthValidationResponse {
+    success: boolean;
+    user_info?: UserInfo;
+    error_message?: string;
+    error_code?: string;
+}
+export declare enum AuthState {
+    NOT_CONFIGURED = "not_configured",
+    NOT_AUTHENTICATED = "not_authenticated",
+    AUTHENTICATED = "authenticated",
+    ERROR = "error"
+}
+export interface AuthResult {
+    state: AuthState;
+    user?: UserInfo;
+    message: string;
+    provider?: string;
+}
+declare class AuthService {
+    private static readonly TOKEN_KEY;
+    private authCheckPromise;
+    private listeners;
+    getToken(): string | null;
+    setToken(token: string): void;
+    removeToken(): void;
+    addAuthStateListener(listener: (result: AuthResult) => void): void;
+    removeAuthStateListener(listener: (result: AuthResult) => void): void;
+    private notifyListeners;
+    getAuthStatus(): Promise<AuthStatus>;
+    validateToken(token?: string): Promise<AuthValidationResponse>;
+    getCurrentUser(): Promise<UserInfo | null>;
+    checkAuthState(force?: boolean): Promise<AuthResult>;
+    private _performAuthCheck;
+    autoLogin(): Promise<AuthResult>;
+    login(token: string): Promise<AuthResult>;
+    logout(): void;
+}
+export declare const authService: AuthService;
+export {};

package/dist/service/llmProviderService.d.ts

@@ -0,0 +1,15 @@
+import { LlmProviderCreate, LlmProviderResponse, SupportedProviderType, SwitchProviderRequest } from '../types/llmProvider';
+declare class LlmProviderService {
+    private getBackendUrl;
+    getLlmProviders(): Promise<LlmProviderResponse[]>;
+    createLlmProvider(provider: LlmProviderCreate): Promise<LlmProviderResponse>;
+    getLlmProvider(id: number): Promise<LlmProviderResponse>;
+    updateLlmProvider(id: number, provider: Partial<LlmProviderCreate>): Promise<LlmProviderResponse>;
+    deleteLlmProvider(id: number): Promise<void>;
+    switchActiveProvider(request: SwitchProviderRequest): Promise<{
+        message: string;
+    }>;
+    getSupportedTypes(): Promise<SupportedProviderType[]>;
+}
+export declare const llmProviderService: LlmProviderService;
+export {};

package/dist/service/mcpService.d.ts

@@ -2,6 +2,6 @@ import { McpServer, McpServerCreate } from '../types/mcp';
 export declare const mcpService: {
     getMcpServers(): Promise<McpServer[]>;
     createMcpServer(server: McpServerCreate): Promise<McpServer>;
-    updateMcpServer(id: number, server: Partial<McpServerCreate>): Promise<McpServer>;
-    deleteMcpServer(id: number): Promise<void>;
+    updateMcpServer(id: string, server: Partial<McpServerCreate>): Promise<McpServer>;
+    deleteMcpServer(id: string): Promise<void>;
 };

package/dist/service/xyzenService.d.ts

@@ -1,4 +1,4 @@
-import { Message } from '../store/xyzenStore';
+import { Message } from '../store/types';
 interface StatusChangePayload {
     connected: boolean;
     error: string | null;

package/dist/store/index.d.ts

@@ -0,0 +1,15 @@
+import { XyzenState } from './types';
+export declare const useXyzen: import('zustand').UseBoundStore<Omit<Omit<import('zustand').StoreApi<XyzenState>, "persist"> & {
+    persist: {
+        setOptions: (options: Partial<import('zustand/middleware').PersistOptions<XyzenState, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: XyzenState) => void) => () => void;
+        onFinishHydration: (fn: (state: XyzenState) => void) => () => void;
+        getOptions: () => Partial<import('zustand/middleware').PersistOptions<XyzenState, unknown>>;
+    };
+}, "setState"> & {
+    setState(nextStateOrUpdater: XyzenState | Partial<XyzenState> | ((state: import('immer').WritableDraft<XyzenState>) => void), shouldReplace?: false): void;
+    setState(nextStateOrUpdater: XyzenState | ((state: import('immer').WritableDraft<XyzenState>) => void), shouldReplace: true): void;
+}>;

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

@@ -0,0 +1,15 @@
+import { Agent } from '../../components/layouts/XyzenAgent';
+import { StateCreator } from 'zustand';
+import { XyzenState } from '../types';
+export interface AgentSlice {
+    agents: Agent[];
+    agentsLoading: boolean;
+    fetchAgents: () => Promise<void>;
+    createAgent: (agent: Omit<Agent, "id">) => Promise<void>;
+    updateAgent: (agent: Agent) => Promise<void>;
+    deleteAgent: (id: string) => Promise<void>;
+}
+export declare const createAgentSlice: StateCreator<XyzenState, [
+    ["zustand/immer", never]
+], [
+], AgentSlice>;

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

@@ -0,0 +1,14 @@
+import { StateCreator } from 'zustand';
+import { User, XyzenState } from '../types';
+export interface AuthSlice {
+    user: User | null;
+    token: string | null;
+    status: "idle" | "loading" | "succeeded" | "failed";
+    login: (token: string) => Promise<void>;
+    logout: () => void;
+    fetchUserByToken: () => Promise<void>;
+}
+export declare const createAuthSlice: StateCreator<XyzenState, [
+    ["zustand/immer", never]
+], [
+], AuthSlice>;

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

@@ -0,0 +1,21 @@
+import { StateCreator } from 'zustand';
+import { ChatChannel, ChatHistoryItem, XyzenState } from '../types';
+export interface ChatSlice {
+    activeChatChannel: string | null;
+    chatHistory: ChatHistoryItem[];
+    chatHistoryLoading: boolean;
+    channels: Record<string, ChatChannel>;
+    setActiveChatChannel: (channelUUID: string | null) => void;
+    fetchChatHistory: () => Promise<void>;
+    togglePinChat: (chatId: string) => void;
+    activateChannel: (topicId: string) => Promise<void>;
+    connectToChannel: (sessionId: string, topicId: string) => void;
+    disconnectFromChannel: () => void;
+    sendMessage: (message: string) => void;
+    createDefaultChannel: (agentId?: string) => Promise<void>;
+    updateTopicName: (topicId: string, newName: string) => Promise<void>;
+}
+export declare const createChatSlice: StateCreator<XyzenState, [
+    ["zustand/immer", never]
+], [
+], ChatSlice>;

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

@@ -0,0 +1,6 @@
+export * from './agentSlice';
+export * from './authSlice';
+export * from './chatSlice';
+export * from './mcpSlice';
+export * from './providerSlice';
+export * from './uiSlice';

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

@@ -0,0 +1,16 @@
+import { McpServer, McpServerCreate } from '../../types/mcp';
+import { StateCreator } from 'zustand';
+import { XyzenState } from '../types';
+export interface McpSlice {
+    mcpServers: McpServer[];
+    mcpServersLoading: boolean;
+    fetchMcpServers: () => Promise<void>;
+    addMcpServer: (server: McpServerCreate) => Promise<void>;
+    editMcpServer: (id: string, server: Partial<McpServerCreate>) => Promise<void>;
+    removeMcpServer: (id: string) => Promise<void>;
+    updateMcpServerInList: (server: McpServer) => void;
+}
+export declare const createMcpSlice: StateCreator<XyzenState, [
+    ["zustand/immer", never]
+], [
+], McpSlice>;

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

@@ -0,0 +1,16 @@
+import { LlmProviderCreate, LlmProviderResponse } from '../../types/llmProvider';
+import { StateCreator } from 'zustand';
+import { XyzenState } from '../types';
+export interface ProviderSlice {
+    llmProviders: LlmProviderResponse[];
+    llmProvidersLoading: boolean;
+    fetchLlmProviders: () => Promise<void>;
+    addLlmProvider: (provider: LlmProviderCreate) => Promise<void>;
+    editLlmProvider: (id: number, provider: Partial<LlmProviderCreate>) => Promise<void>;
+    removeLlmProvider: (id: number) => Promise<void>;
+    switchActiveProvider: (id: number) => Promise<void>;
+}
+export declare const createProviderSlice: StateCreator<XyzenState, [
+    ["zustand/immer", never]
+], [
+], ProviderSlice>;

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

@@ -0,0 +1,26 @@
+import { StateCreator } from 'zustand';
+import { Theme, XyzenState } from '../types';
+export interface UiSlice {
+    backendUrl: string;
+    isXyzenOpen: boolean;
+    panelWidth: number;
+    activeTabIndex: number;
+    theme: Theme;
+    isAddMcpServerModalOpen: boolean;
+    isAddLlmProviderModalOpen: boolean;
+    toggleXyzen: () => void;
+    openXyzen: () => void;
+    closeXyzen: () => void;
+    setPanelWidth: (width: number) => void;
+    setTabIndex: (index: number) => void;
+    setTheme: (theme: Theme) => void;
+    setBackendUrl: (url: string) => void;
+    openAddMcpServerModal: () => void;
+    closeAddMcpServerModal: () => void;
+    openAddLlmProviderModal: () => void;
+    closeAddLlmProviderModal: () => void;
+}
+export declare const createUiSlice: StateCreator<XyzenState, [
+    ["zustand/immer", never]
+], [
+], UiSlice>;

package/dist/store/types.d.ts

@@ -0,0 +1,44 @@
+import { AgentSlice, AuthSlice, ChatSlice, McpSlice, ProviderSlice, UiSlice } from './slices';
+export interface Message {
+    id: string;
+    content: string;
+    role: "user" | "assistant" | "system" | "tool";
+    created_at: string;
+    sender?: "user" | "assistant" | "system";
+    timestamp?: string;
+}
+export interface ChatChannel {
+    id: string;
+    sessionId: string;
+    title: string;
+    messages: Message[];
+    assistantId?: string;
+    connected: boolean;
+    error: string | null;
+}
+export interface ChatHistoryItem {
+    id: string;
+    title: string;
+    updatedAt: string;
+    assistantTitle: string;
+    lastMessage?: string;
+    isPinned: boolean;
+}
+export interface User {
+    id?: string;
+    username: string;
+    avatar: string;
+}
+export type Theme = "light" | "dark" | "system";
+export interface TopicResponse {
+    id: string;
+    name: string;
+    updated_at: string;
+}
+export interface SessionResponse {
+    id: string;
+    name: string;
+    user_id: string;
+    topics: TopicResponse[];
+}
+export type XyzenState = UiSlice & ChatSlice & AgentSlice & McpSlice & ProviderSlice & AuthSlice;

package/dist/types/llmProvider.d.ts

@@ -0,0 +1,34 @@
+export interface LlmProvider {
+    id: number;
+    Name: string;
+    Api: string;
+    Key: string;
+    Model: string;
+    MaxTokens: number | null;
+    Temperature: number | null;
+    Timeout: number | null;
+    is_active?: boolean;
+    is_available?: boolean;
+    provider_type?: string;
+}
+export interface LlmProviderCreate {
+    Name: string;
+    Api: string;
+    Key: string;
+    Model: string;
+    MaxTokens?: number | null;
+    Temperature?: number | null;
+    Timeout?: number | null;
+}
+export interface LlmProviderResponse extends LlmProvider {
+    is_active: boolean;
+    is_available: boolean;
+    provider_type: string;
+}
+export interface SwitchProviderRequest {
+    provider_id: number;
+}
+export interface SupportedProviderType {
+    type: string;
+    description: string;
+}

package/dist/types/mcp.d.ts

@@ -1,5 +1,5 @@
 export interface McpServer {
-    id: number;
+    id: string;
     name: string;
     description?: string;
     url: string;