@vezlo/assistant-chat 1.9.1 → 1.10.0

package/README.md

@@ -102,6 +102,7 @@ npm run dev
 - ✅ **Human agent support** (conversation management, agent handoff)
 - ✅ **Realtime updates** (live message synchronization)
 - ✅ **Database tools** (connect external databases for natural language queries - [docs](./docs/DATABASE_TOOLS.md))
+- ✅ **AI Settings** (customize AI behavior, model, temperature, and prompts per company)
 - ✅ Docker support
 - ✅ Vercel deployment
 

package/lib/contexts/AppContext.d.ts

@@ -0,0 +1,35 @@
+import type { ReactNode } from 'react';
+interface User {
+    name: string;
+    email: string;
+    avatar?: string;
+    id?: string;
+    role?: string;
+    profile?: {
+        company_uuid: string;
+        company_name: string;
+        role: string;
+    };
+}
+interface Workspace {
+    name: string;
+    plan: string;
+    avatar?: string;
+}
+interface AppContextType {
+    user: User | null;
+    workspace: Workspace | null;
+    activeSection: string;
+    isAuthenticated: boolean;
+    token: string | null;
+    setActiveSection: (section: string) => void;
+    setUser: (user: User | null) => void;
+    setWorkspace: (workspace: Workspace | null) => void;
+    login: (token: string, user: User) => void;
+    logout: () => Promise<void>;
+}
+export declare function AppProvider({ children }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useApp(): AppContextType;
+export {};

package/lib/contexts/AppContext.js

@@ -0,0 +1,93 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useState, useEffect } from 'react';
+import { logoutUser } from '@/api';
+import { initializeRealtime } from '@/services/realtime';
+const AppContext = createContext(undefined);
+const TOKEN_KEY = 'vezlo_auth_token';
+const USER_KEY = 'vezlo_user';
+const WORKSPACE_KEY = 'vezlo_workspace';
+export function AppProvider({ children }) {
+    // Initialize from localStorage
+    const [token, setToken] = useState(() => {
+        return localStorage.getItem(TOKEN_KEY);
+    });
+    const [user, setUser] = useState(() => {
+        const storedUser = localStorage.getItem(USER_KEY);
+        return storedUser ? JSON.parse(storedUser) : null;
+    });
+    const [workspace, setWorkspace] = useState(() => {
+        const storedWorkspace = localStorage.getItem(WORKSPACE_KEY);
+        return storedWorkspace ? JSON.parse(storedWorkspace) : null;
+    });
+    const [activeSection, setActiveSection] = useState('widget');
+    const isAuthenticated = !!token && !!user;
+    // Sync token to localStorage
+    useEffect(() => {
+        if (token) {
+            localStorage.setItem(TOKEN_KEY, token);
+        }
+        else {
+            localStorage.removeItem(TOKEN_KEY);
+        }
+    }, [token]);
+    // Sync user to localStorage
+    useEffect(() => {
+        if (user) {
+            localStorage.setItem(USER_KEY, JSON.stringify(user));
+        }
+        else {
+            localStorage.removeItem(USER_KEY);
+        }
+    }, [user]);
+    useEffect(() => {
+        if (workspace) {
+            localStorage.setItem(WORKSPACE_KEY, JSON.stringify(workspace));
+        }
+        else {
+            localStorage.removeItem(WORKSPACE_KEY);
+        }
+    }, [workspace]);
+    const login = (newToken, newUser) => {
+        setToken(newToken);
+        setUser(newUser);
+    };
+    const logout = async () => {
+        if (token) {
+            try {
+                await logoutUser(token);
+            }
+            catch (error) {
+                console.error('[AppContext] Failed to logout via API:', error);
+            }
+        }
+        setToken(null);
+        setUser(null);
+        setWorkspace(null);
+        localStorage.removeItem(TOKEN_KEY);
+        localStorage.removeItem(USER_KEY);
+        localStorage.removeItem(WORKSPACE_KEY);
+    };
+    // Initialize Realtime connection on app load
+    useEffect(() => {
+        initializeRealtime();
+    }, []);
+    return (_jsx(AppContext.Provider, { value: {
+            user,
+            workspace,
+            activeSection,
+            isAuthenticated,
+            token,
+            setActiveSection,
+            setUser,
+            setWorkspace,
+            login,
+            logout,
+        }, children: children }));
+}
+export function useApp() {
+    const context = useContext(AppContext);
+    if (context === undefined) {
+        throw new Error('useApp must be used within an AppProvider');
+    }
+    return context;
+}

package/lib/services/realtime.d.ts

@@ -0,0 +1,13 @@
+type AuthBroadcastPayload = {
+    uuid: string;
+    name: string;
+    email: string;
+    role: string;
+};
+/**
+ * Initialize Supabase Realtime client connection
+ * Call this on app load to establish the WebSocket connection
+ */
+export declare function initializeRealtime(): boolean;
+export declare function listenForAuthBroadcast(onPayload: (payload: AuthBroadcastPayload) => void): () => void;
+export {};

package/lib/services/realtime.js

@@ -0,0 +1,79 @@
+import { createClient } from '@supabase/supabase-js';
+const SUPABASE_URL = import.meta.env.VITE_SUPABASE_URL;
+const SUPABASE_ANON_KEY = import.meta.env.VITE_SUPABASE_ANON_KEY;
+let client = null;
+function getClient() {
+    if (!SUPABASE_URL || !SUPABASE_ANON_KEY) {
+        console.error('[Realtime] Missing VITE_SUPABASE_URL or VITE_SUPABASE_ANON_KEY environment variables');
+        return null;
+    }
+    if (!client) {
+        try {
+            client = createClient(SUPABASE_URL, SUPABASE_ANON_KEY, {
+                realtime: { params: { eventsPerSecond: 2 } },
+            });
+        }
+        catch (error) {
+            console.error('[Realtime] Failed to initialize client:', error instanceof Error ? error.message : 'Unknown error');
+            return null;
+        }
+    }
+    return client;
+}
+/**
+ * Initialize Supabase Realtime client connection
+ * Call this on app load to establish the WebSocket connection
+ */
+export function initializeRealtime() {
+    try {
+        const realtimeClient = getClient();
+        if (realtimeClient) {
+            console.info('[Realtime] Initialized and connected');
+            return true;
+        }
+        return false;
+    }
+    catch (error) {
+        console.error('[Realtime] Initialization failed:', error instanceof Error ? error.message : 'Unknown error');
+        return false;
+    }
+}
+export function listenForAuthBroadcast(onPayload) {
+    try {
+        const realtimeClient = getClient();
+        if (!realtimeClient) {
+            return () => { };
+        }
+        const channel = realtimeClient.channel('vezlo_authenticated', {
+            config: {
+                broadcast: { self: true, ack: false }
+            }
+        });
+        channel.on('broadcast', { event: 'me_payload' }, ({ payload }) => {
+            onPayload(payload);
+        });
+        channel.subscribe((status, err) => {
+            if (err) {
+                console.error('[Realtime] Subscription failed:', err.message || err);
+            }
+            else if (status === 'SUBSCRIBED') {
+                console.info('[Realtime] Subscribed to channel: vezlo_authenticated');
+            }
+            else if (status === 'CLOSED' || status === 'CHANNEL_ERROR') {
+                console.error('[Realtime] Channel connection failed:', status);
+            }
+        });
+        return () => {
+            try {
+                channel.unsubscribe();
+            }
+            catch (error) {
+                console.error('[Realtime] Unsubscribe error:', error instanceof Error ? error.message : 'Unknown error');
+            }
+        };
+    }
+    catch (error) {
+        console.error('[Realtime] Failed to setup broadcast listener:', error instanceof Error ? error.message : 'Unknown error');
+        return () => { };
+    }
+}

package/lib/utils/useIsAdmin.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Hook to check if the current user is an admin
+ * @returns true if user role is 'admin', false otherwise
+ */
+export declare function useIsAdmin(): boolean;

package/lib/utils/useIsAdmin.js

@@ -0,0 +1,9 @@
+import { useApp } from '@/contexts/AppContext';
+/**
+ * Hook to check if the current user is an admin
+ * @returns true if user role is 'admin', false otherwise
+ */
+export function useIsAdmin() {
+    const { user } = useApp();
+    return user?.profile?.role === 'admin';
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vezlo/assistant-chat",
-  "version": "1.9.1",
+  "version": "1.10.0",
   "description": "React component library for AI-powered chat widgets with RAG knowledge base integration, realtime updates, and human agent support",
   "type": "module",
   "main": "lib/index.js",
@@ -38,6 +38,7 @@
     "lucide-react": "^0.544.0",
     "marked": "^17.0.1",
     "react-hot-toast": "^2.6.0",
+    "react-markdown": "^10.1.0",
     "react-router-dom": "^7.9.3",
     "tailwindcss": "^4.1.14"
   },