added user profile session management

.chainlit/config.toml

@@ -82,6 +82,7 @@ custom_css = '/public/stylesheet.css'
 # Specify a Javascript file that can be used to customize the user interface.
 # The Javascript file can be served from the public directory.
 # custom_js = "/public/test.js"
+custom_js = "/public/script.js"
 
 # Specify a custom font url.
 # custom_font = "https://fonts.googleapis.com/css2?family=Inter:wght@400;500;700&display=swap"

chatxbt-assistant.py

@@ -12,6 +12,7 @@ from src.databases.postgres import sqlalchemy_engine
 from src.tools.crypto_swap_toolkit import CryptoSwapTools
 from src.tools.crypto_data_toolkit import CryptoDataTools
 from src.tools.crypto_evm_wallet_toolkit import CryptoEVMWalletTools
+from src.tools.user_profile_toolkit import UserProfileToolkit
 from phi.storage.assistant.postgres import PgAssistantStorage
 from src.knowledge_bases.combined import knowledge_base
 
@@ -29,7 +30,28 @@ def oauth_callback(
   default_user: cl.User,
 ) -> Optional[cl.User]:
     # step-todo: will handle auth from v2 api
-    return default_user
+    return cl.User(
+        identifier=raw_user_data.get('email'),
+        email=raw_user_data.get('email'),
+        name=raw_user_data.get('name'),
+        metadata={**raw_user_data, **({'image':default_user.metadata.get('image')})}
+    )
+
+
+@cl.password_auth_callback
+def auth_callback(username: str, password: str):
+    # Fetch the user matching username from your database
+    # and compare the hashed password with the value stored in the database
+    if (username, password) == ("admin", "admin"):
+        user = {
+            "identifier": "admin", "email": username, "metadata": {"role": "admin", "provider": "credentials"}
+        }
+        cl.user_session.set("user_profile", user)
+        return cl.User(
+            identifier="admin", email=username, metadata={"role": "admin", "provider": "credentials"}
+        )
+    else:
+        return None
 
 
 @cl.set_starters
@@ -66,13 +88,14 @@ async def start():
     cxbt_assistant = Assistant(
         llm=OpenAIChat(model="gpt-4o"),
         tools=[
+            UserProfileToolkit(),
             DuckDuckGo(),
             CryptoDataTools(),
             CryptoSwapTools(),
             CryptoEVMWalletTools(),
             YFinanceTools(stock_price=True)
         ],
-        show_tool_calls= is_dev_mode,
+        show_tool_calls=is_dev_mode,
         markdown=True,
         knowledge_base=knowledge_base,
         storage=storage,

node_modules/.yarn-integrity

@@ -0,0 +1,10 @@
+{
+  "systemParams": "darwin-x64-115",
+  "modulesFolders": [],
+  "flags": [],
+  "linkedModules": [],
+  "topLevelPatterns": [],
+  "lockfileEntries": {},
+  "files": [],
+  "artifacts": {}
+}

public/script.js

@@ -0,0 +1,113 @@
+document.addEventListener('DOMContentLoaded', () => {
+    const items = { ...localStorage };
+    const isAuthed = items?.token;
+
+    const wdgt = {
+        idBox: 'wdgt',
+        url_widget: 'https://next-starter.thirdweb-example.com/',
+        url_style: 'http://localhost:8080/css/widget.css',
+
+        init: function (identifier, byClass = false) {
+            console.log("Begin Widget initialization");
+
+            const observer = new MutationObserver((mutations, observer) => {
+                let elements = [];
+                if (byClass) {
+                    elements = document.querySelectorAll(`.${identifier}`);
+                    console.log(`Looking for elements by class: .${identifier}`);
+                } else {
+                    const element = document.getElementById(identifier || this.idBox);
+                    if (element) {
+                        elements.push(element);
+                    }
+                    console.log(`Looking for element by ID: #${identifier || this.idBox}`);
+                }
+
+                console.log(`Found elements:`, elements);
+
+                if (elements.length > 0 && elements[0] != null) {
+                    observer.disconnect(); // Stop observing once elements are found
+                    try {
+                        const XHR = ("onload" in new XMLHttpRequest()) ? XMLHttpRequest : XDomainRequest;
+                        const xhr = new XHR();
+                        xhr.open('GET', this.url_widget, true);
+
+                        xhr.onload = function () {
+                            if (this.status >= 200 && this.status < 300) {
+                                elements.forEach(element => {
+                                    element.innerHTML = this.responseText;
+                                });
+                            } else {
+                                console.error('Failed to load widget content. Status:', this.status);
+                            }
+                        };
+
+                        xhr.onerror = function () {
+                            console.error('onerror', this.status);
+                        };
+
+                        xhr.send();
+                    } catch (error) {
+                        console.error('Error loading widget:', error);
+                    }
+                }
+            });
+
+            // Start observing the document body for changes
+            observer.observe(document.body, { childList: true, subtree: true });
+
+            // Initial check in case the elements are already present
+            let elements = [];
+            if (byClass) {
+                elements = document.querySelectorAll(`.${identifier}`);
+            } else {
+                const element = document.getElementById(identifier || this.idBox);
+                if (element) {
+                    elements.push(element);
+                }
+            }
+
+            if (elements.length > 0 && elements[0] != null) {
+                observer.disconnect(); // Stop observing if elements are found initially
+                try {
+                    const XHR = ("onload" in new XMLHttpRequest()) ? XMLHttpRequest : XDomainRequest;
+                    const xhr = new XHR();
+                    xhr.open('GET', this.url_widget, true);
+
+                    xhr.onload = function () {
+                        if (this.status >= 200 && this.status < 300) {
+                            elements.forEach(element => {
+                                element.innerHTML = this.responseText;
+                            });
+                        } else {
+                            console.error('Failed to load widget content. Status:', this.status);
+                        }
+                    };
+
+                    xhr.onerror = function () {
+                        console.error('onerror', this.status);
+                    };
+
+                    xhr.send();
+                } catch (error) {
+                    console.error('Error loading widget:', error);
+                }
+            }
+        },
+
+        addStyle: function () {
+            const style = document.createElement('link');
+            style.rel = 'stylesheet';
+            style.type = 'text/css';
+            style.href = this.url_style;
+            document.head.appendChild(style);
+        }
+    };
+
+    if (isAuthed) {
+//        alert('You are authed');
+    } else {
+        // alert('You are not authed');
+        // wdgt.init('root', false); // Change 'true' to 'false' if you want to use an ID instead of class
+    }
+});

src/tools/user_profile_toolkit.py

@@ -0,0 +1,185 @@
+import chainlit as cl
+from phi.tools import Toolkit
+from phi.utils.log import logger
+
+
+class UserProfileToolkit(Toolkit):
+    def __init__(self):
+        super().__init__(name="user_profile_toolkit")
+
+        # Registering methods to make them accessible via the toolkit
+        self.register(self.get_user_name)
+        self.register(self.get_user_email)
+        self.register(self.get_user_picture)
+        self.register(self.get_all_user_info)
+        self.register(self.update_user_info)
+        self.register(self.update_user_name)
+        self.register(self.update_user_email)
+        self.register(self.update_user_picture)
+
+    @cl.on_chat_start
+    def get_user_info(self, info_type: str) -> str:
+        """
+        Fetches user information from the Chainlit user session.
+
+        Args:
+        info_type (str): The type of information to fetch ('name', 'email', 'picture').
+
+        Returns:
+        str: The requested user information.
+
+        Example:
+        >>> get_user_info('name')
+        """
+        logger.info(f"Fetching user info: {info_type}")
+        try:
+            # Fetch user session data
+            user_session = cl.user_session.get("user").metadata
+            if not user_session:
+                raise ValueError("User session not found")
+
+            response = user_session[info_type]
+            return f"{response}"
+        except Exception as e:
+            logger.warning(f"Failed to get user info: {e}")
+            return f"Error: {e}"
+
+    def get_all_user_info(self) -> str:
+        """
+        Fetches all user information from the Chainlit user session.
+
+        Returns:
+        dict: A dictionary containing all user information.
+
+        Example:
+        >>> get_all_user_info()
+        """
+        logger.info("Fetching all user info")
+        try:
+            # Fetch user session data
+            user_session = cl.user_session.get("user").metadata
+            if not user_session:
+                raise ValueError("User session not found")
+
+            response = user_session
+            return f"{response}"
+        except Exception as e:
+            logger.warning(f"Failed to get all user info: {e}")
+            # return {"error": str(e)}
+            return f"Error: {e}"
+
+    def update_user_info(self, info_type: str, value: str) -> str:
+        """
+        Updates user information in the Chainlit user session.
+
+        Args:
+        info_type (str): The type of information to update ('name', 'email', 'picture').
+        value (str): The new value to set.
+
+        Returns:
+        str: Confirmation message.
+
+        Example:
+        >>> update_user_info('name', 'Jane Doe')
+        """
+        logger.info(f"Updating user info: {info_type} to {value}")
+        try:
+            # Fetch user session data
+            user_session = cl.user_session.get("user").metadata
+            if not user_session:
+                raise ValueError("User session not found")
+
+            # Update the user session data
+            user_session[info_type] = value
+            cl.user_session.set("user", user_session)
+            return f"{info_type} updated to {value}"
+        except Exception as e:
+            logger.warning(f"Failed to update user info: {e}")
+            return f"Error: {e}"
+
+    def get_user_name(self) -> str:
+        """
+        Fetches the user's name from the Chainlit user session.
+
+        Returns:
+        str: The user's name.
+
+        Example:
+        >>> get_user_name()
+        """
+        response = self.get_user_info('name')
+        return f"{response}"
+
+    def get_user_email(self) -> str:
+        """
+        Fetches the user's email from the Chainlit user session.
+
+        Returns:
+        str: The user's email.
+
+        Example:
+        >>> get_user_email()
+        """
+        response = self.get_user_info('email')
+        return f"{response}"
+
+    def get_user_picture(self) -> str:
+        """
+        Fetches the user's picture URL from the Chainlit user session.
+
+        Returns:
+        str: The user's picture URL.
+
+        Example:
+        >>> get_user_picture()
+        """
+        response = self.get_user_info('picture')
+        return f"{response}"
+
+    def update_user_name(self, name: str) -> str:
+        """
+        Updates the user's name in the Chainlit user session.
+
+        Args:
+        name (str): The new name to set.
+
+        Returns:
+        str: Confirmation message.
+
+        Example:
+        >>> update_user_name('Jane Doe')
+        """
+        response = self.update_user_info('name', name)
+        return f"{response}"
+
+    def update_user_email(self, email: str) -> str:
+        """
+        Updates the user's email in the Chainlit user session.
+
+        Args:
+        email (str): The new email to set.
+
+        Returns:
+        str: Confirmation message.
+
+        Example:
+        >>> update_user_email('jane.doe@example.com')
+        """
+        response = self.update_user_info('email', email)
+        return f"{response}"
+
+    def update_user_picture(self, picture: str) -> str:
+        """
+        Updates the user's picture URL in the Chainlit user session.
+
+        Args:
+        picture (str): The new picture URL to set.
+
+        Returns:
+        str: Confirmation message.
+
+        Example:
+        >>> update_user_picture('https://example.com/new_picture.jpg')
+        """
+        response = self.update_user_info('picture', picture)
+        return f"{response}"

yarn.lock

@@ -0,0 +1,4 @@
+# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+# yarn lockfile v1
+
+