PraisonAI 0.0.46__py3-none-any.whl → 0.0.47__py3-none-any.whl

praisonai/deploy.py

@@ -56,7 +56,7 @@ class CloudDeployer:
             file.write("FROM python:3.11-slim\n")
             file.write("WORKDIR /app\n")
             file.write("COPY . .\n")
-            file.write("RUN pip install flask praisonai==0.0.46 gunicorn markdown\n")
+            file.write("RUN pip install flask praisonai==0.0.47 gunicorn markdown\n")
             file.write("EXPOSE 8080\n")
             file.write('CMD ["gunicorn", "-b", "0.0.0.0:8080", "api:app"]\n')
             
@@ -78,8 +78,8 @@ class CloudDeployer:
             file.write("import markdown\n\n")
             file.write("app = Flask(__name__)\n\n")
             file.write("def basic():\n")
-            file.write("    praison_ai = PraisonAI(agent_file=\"agents.yaml\")\n")
-            file.write("    return praison_ai.main()\n\n")
+            file.write("    praisonai = PraisonAI(agent_file=\"agents.yaml\")\n")
+            file.write("    return praisonai.run()\n\n")
             file.write("@app.route('/')\n")
             file.write("def home():\n")
             file.write("    output = basic()\n")

praisonai/ui/chat.py

@@ -12,6 +12,8 @@ import chainlit.data as cl_data
 from chainlit.step import StepDict
 from literalai.helper import utc_now
 import logging
+import json
+from sql_alchemy import SQLAlchemyDataLayer
 
 # Set up logging
 logger = logging.getLogger(__name__)
@@ -38,31 +40,81 @@ now = utc_now()
 
 create_step_counter = 0
 
-import json
-
 DB_PATH = "threads.db"
 
 def initialize_db():
     conn = sqlite3.connect(DB_PATH)
     cursor = conn.cursor()
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS users (
+            id UUID PRIMARY KEY,
+            identifier TEXT NOT NULL UNIQUE,
+            metadata JSONB NOT NULL,
+            createdAt TEXT
+        )
+    ''')
     cursor.execute('''
         CREATE TABLE IF NOT EXISTS threads (
-            id TEXT PRIMARY KEY,
-            name TEXT,
+            id UUID PRIMARY KEY,
             createdAt TEXT,
-            userId TEXT,
-            userIdentifier TEXT
+            name TEXT,
+            userId UUID,
+            userIdentifier TEXT,
+            tags TEXT[],
+            metadata JSONB NOT NULL DEFAULT '{}',
+            FOREIGN KEY (userId) REFERENCES users(id) ON DELETE CASCADE
         )
     ''')
     cursor.execute('''
         CREATE TABLE IF NOT EXISTS steps (
-            id TEXT PRIMARY KEY,
-            threadId TEXT,
-            name TEXT,
+            id UUID PRIMARY KEY,
+            name TEXT NOT NULL,
+            type TEXT NOT NULL,
+            threadId UUID NOT NULL,
+            parentId UUID,
+            disableFeedback BOOLEAN NOT NULL,
+            streaming BOOLEAN NOT NULL,
+            waitForAnswer BOOLEAN,
+            isError BOOLEAN,
+            metadata JSONB,
+            tags TEXT[],
+            input TEXT,
+            output TEXT,
             createdAt TEXT,
+            start TEXT,
+            end TEXT,
+            generation JSONB,
+            showInput TEXT,
+            language TEXT,
+            indent INT,
+            FOREIGN KEY (threadId) REFERENCES threads (id) ON DELETE CASCADE
+        )
+    ''')
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS elements (
+            id UUID PRIMARY KEY,
+            threadId UUID,
             type TEXT,
-            output TEXT,
-            FOREIGN KEY (threadId) REFERENCES threads (id)
+            url TEXT,
+            chainlitKey TEXT,
+            name TEXT NOT NULL,
+            display TEXT,
+            objectKey TEXT,
+            size TEXT,
+            page INT,
+            language TEXT,
+            forId UUID,
+            mime TEXT,
+            FOREIGN KEY (threadId) REFERENCES threads (id) ON DELETE CASCADE
+        )
+    ''')
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS feedbacks (
+            id UUID PRIMARY KEY,
+            forId UUID NOT NULL,
+            value INT NOT NULL,
+            threadId UUID,
+            comment TEXT
         )
     ''')
     cursor.execute('''
@@ -110,210 +162,13 @@ def load_setting(key: str) -> str:
     conn.close()
     return result[0] if result else None
 
-def save_thread_to_db(thread):
-    conn = sqlite3.connect(DB_PATH)
-    cursor = conn.cursor()
-    cursor.execute('''
-        INSERT OR REPLACE INTO threads (id, name, createdAt, userId, userIdentifier)
-        VALUES (?, ?, ?, ?, ?)
-    ''', (thread['id'], thread['name'], thread['createdAt'], thread['userId'], thread['userIdentifier']))
-    
-    # No steps to save as steps are empty in the provided thread data
-    conn.commit()
-    conn.close()
-    logger.debug("Thread saved to DB")
-
-def update_thread_in_db(thread):
-    conn = sqlite3.connect(DB_PATH)
-    cursor = conn.cursor()
-
-    # Insert or update the thread
-    cursor.execute('''
-        INSERT OR REPLACE INTO threads (id, name, createdAt, userId, userIdentifier)
-        VALUES (?, ?, ?, ?, ?)
-    ''', (thread['id'], thread['name'], thread['createdAt'], thread['userId'], thread['userIdentifier']))
-
-    # Fetch message_history from metadata
-    message_history = cl.user_session.get("message_history", [])
-
-    # Ensure user messages come first followed by assistant messages
-    user_messages = [msg for msg in message_history if msg['role'] == 'user']
-    assistant_messages = [msg for msg in message_history if msg['role'] == 'assistant']
-    ordered_steps = [val for pair in zip(user_messages, assistant_messages) for val in pair]
-
-    # Generate steps from ordered message_history
-    steps = []
-    for idx, message in enumerate(ordered_steps):
-        step_id = f"{thread['id']}-step-{idx}"
-        step_type = 'user_message' if message['role'] == 'user' else 'assistant_message'
-        step_name = 'user' if message['role'] == 'user' else 'assistant'
-        created_at = message.get('createdAt', thread['createdAt'])  # Use thread's createdAt if no timestamp in message
-        steps.append({
-            'id': step_id,
-            'threadId': thread['id'],
-            'name': step_name,
-            'createdAt': created_at,
-            'type': step_type,
-            'output': message['content']
-        })
-
-    # Insert all steps into the database
-    for step in steps:
-        cursor.execute('''
-            INSERT OR REPLACE INTO steps (id, threadId, name, createdAt, type, output)
-            VALUES (?, ?, ?, ?, ?, ?)
-        ''', (step['id'], step['threadId'], step['name'], step['createdAt'], step['type'], step['output']))
-    
-    conn.commit()
-    conn.close()
-    logger.debug("Thread updated in DB")
-
-def delete_thread_from_db(thread_id: str):
-    """Deletes a thread and its steps from the database.
-
-    Args:
-        thread_id: The ID of the thread to delete.
-    """
-    conn = sqlite3.connect(DB_PATH)
-    cursor = conn.cursor()
-    cursor.execute('DELETE FROM threads WHERE id = ?', (thread_id,))
-    cursor.execute('DELETE FROM steps WHERE threadId = ?', (thread_id,))
-    conn.commit()
-    conn.close()
-
-def load_threads_from_db():
-    conn = sqlite3.connect(DB_PATH)
-    cursor = conn.cursor()
-    cursor.execute('SELECT * FROM threads ORDER BY createdAt ASC')
-    thread_rows = cursor.fetchall()
-    threads = []
-    for thread_row in thread_rows:
-        cursor.execute('SELECT * FROM steps WHERE threadId = ? ORDER BY createdAt ASC', (thread_row[0],))
-        step_rows = cursor.fetchall()
-        steps = []
-        for step_row in step_rows:
-            steps.append({
-                "id": step_row[0],
-                "threadId": step_row[1],
-                "name": step_row[2],
-                "createdAt": step_row[3],
-                "type": step_row[4],
-                "output": step_row[5]
-            })
-        threads.append({
-            "id": thread_row[0],
-            "name": thread_row[1],
-            "createdAt": thread_row[2],
-            "userId": thread_row[3],
-            "userIdentifier": thread_row[4],
-            "steps": steps
-        })
-    conn.close()
-    logger.debug("Threads loaded from DB")
-    return threads
 
 # Initialize the database
 initialize_db()
-thread_history = load_threads_from_db()
 
 deleted_thread_ids = []  # type: List[str]
 
-class TestDataLayer(cl_data.BaseDataLayer): # Implement SQLAlchemyDataLayer
-    async def get_user(self, identifier: str):
-        logger.debug(f"Getting user: {identifier}")
-        return cl.PersistedUser(id="test", createdAt=now, identifier=identifier)
-
-    async def create_user(self, user: cl.User):
-        logger.debug(f"Creating user: {user.identifier}")
-        return cl.PersistedUser(id="test", createdAt=now, identifier=user.identifier)
-
-    async def update_thread(
-        self,
-        thread_id: str,
-        name: Optional[str] = None,
-        user_id: Optional[str] = None,
-        metadata: Optional[Dict] = None,
-        tags: Optional[List[str]] = None,
-    ):
-        logger.debug(f"Updating thread: {thread_id}")
-        thread = next((t for t in thread_history if t["id"] == thread_id), None)
-        if thread:
-            if name:
-                thread["name"] = name
-            if metadata:
-                thread["metadata"] = metadata
-            if tags:
-                thread["tags"] = tags
-            
-            logger.debug(f"Thread: {thread}")
-            cl.user_session.set("message_history", thread['metadata']['message_history'])
-            cl.user_session.set("thread_id", thread["id"])
-            update_thread_in_db(thread)
-            logger.debug(f"Thread updated: {thread_id}")
-            
-        else:
-            thread_history.append(
-                {
-                    "id": thread_id,
-                    "name": name,
-                    "metadata": metadata,
-                    "tags": tags,
-                    "createdAt": utc_now(),
-                    "userId": user_id,
-                    "userIdentifier": "admin",
-                    "steps": [],
-                }
-            )
-            thread = {
-                "id": thread_id,
-                "name": name,
-                "metadata": metadata,
-                "tags": tags,
-                "createdAt": utc_now(),
-                "userId": user_id,
-                "userIdentifier": "admin",
-                "steps": [],
-            }
-            save_thread_to_db(thread)
-            logger.debug(f"Thread created: {thread_id}")
-
-    @cl_data.queue_until_user_message()
-    async def create_step(self, step_dict: StepDict):
-        global create_step_counter
-        create_step_counter += 1
-
-        thread = next(
-            (t for t in thread_history if t["id"] == step_dict.get("threadId")), None
-        )
-        if thread:
-            thread["steps"].append(step_dict)
-
-    async def get_thread_author(self, thread_id: str):
-        logger.debug(f"Getting thread author: {thread_id}")
-        return "admin"
-
-    async def list_threads(
-        self, pagination: cl_data.Pagination, filters: cl_data.ThreadFilter
-    ) -> cl_data.PaginatedResponse[cl_data.ThreadDict]:
-        logger.debug(f"Listing threads")
-        return cl_data.PaginatedResponse(
-            data=[t for t in thread_history if t["id"] not in deleted_thread_ids][::-1],
-            pageInfo=cl_data.PageInfo(
-                hasNextPage=False, startCursor=None, endCursor=None
-            ),
-        )
-
-    async def get_thread(self, thread_id: str):
-        logger.debug(f"Getting thread: {thread_id}")
-        thread_history = load_threads_from_db()
-        return next((t for t in thread_history if t["id"] == thread_id), None)
-
-    async def delete_thread(self, thread_id: str):
-        deleted_thread_ids.append(thread_id)
-        delete_thread_from_db(thread_id)
-        logger.debug(f"Deleted thread: {thread_id}")
-
-cl_data._data_layer = TestDataLayer()
+cl_data._data_layer = SQLAlchemyDataLayer(conninfo=f"sqlite+aiosqlite:///{DB_PATH}")
 
 @cl.on_chat_start
 async def start():
@@ -357,7 +212,12 @@ async def setup_agent(settings):
         if thread:
             metadata = thread.get("metadata", {})
             metadata["model_name"] = model_name
-            await cl_data.update_thread(thread_id, metadata=metadata)
+            
+            # Always store metadata as a JSON string
+            await cl_data.update_thread(thread_id, metadata=json.dumps(metadata))
+            
+            # Update the user session with the new metadata
+            cl.user_session.set("metadata", metadata)
 
 @cl.on_message
 async def main(message: cl.Message):
@@ -372,9 +232,9 @@ async def main(message: cl.Message):
         model=model_name,
         messages=message_history,
         stream=True,
-        temperature=0.7,
-        max_tokens=500,
-        top_p=1
+        # temperature=0.7,
+        # max_tokens=500,
+        # top_p=1
     )
 
     full_response = ""
@@ -423,6 +283,11 @@ async def on_chat_resume(thread: cl_data.ThreadDict):
     await settings.send()
     thread_id = thread["id"]
     cl.user_session.set("thread_id", thread["id"])
+    
+    # The metadata should now already be a dictionary
+    metadata = thread.get("metadata", {})
+    cl.user_session.set("metadata", metadata)
+    
     message_history = cl.user_session.get("message_history", [])
     steps = thread["steps"]
 
@@ -435,4 +300,4 @@ async def on_chat_resume(thread: cl_data.ThreadDict):
         else:
             logger.warning(f"Message without type: {message}")
 
-        cl.user_session.set("message_history", message_history)
+    cl.user_session.set("message_history", message_history)

praisonai/ui/sql_alchemy.py

@@ -0,0 +1,638 @@
+import json
+import ssl
+import uuid
+from dataclasses import asdict
+from datetime import datetime
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
+
+import aiofiles
+import aiohttp
+from chainlit.context import context
+from chainlit.data import BaseDataLayer, BaseStorageClient, queue_until_user_message
+from chainlit.element import ElementDict
+from chainlit.logger import logger
+from chainlit.step import StepDict
+from chainlit.types import (
+    Feedback,
+    FeedbackDict,
+    PageInfo,
+    PaginatedResponse,
+    Pagination,
+    ThreadDict,
+    ThreadFilter,
+)
+from chainlit.user import PersistedUser, User
+from sqlalchemy import text
+from sqlalchemy.exc import SQLAlchemyError
+from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession, create_async_engine
+from sqlalchemy.orm import sessionmaker
+import chainlit as cl
+from literalai.helper import utc_now
+now = utc_now()
+
+if TYPE_CHECKING:
+    from chainlit.element import Element, ElementDict
+    from chainlit.step import StepDict
+
+
+class SQLAlchemyDataLayer(BaseDataLayer):
+    def __init__(
+        self,
+        conninfo: str,
+        ssl_require: bool = False,
+        storage_provider: Optional[BaseStorageClient] = None,
+        user_thread_limit: Optional[int] = 1000,
+        show_logger: Optional[bool] = False,
+    ):
+        self._conninfo = conninfo
+        self.user_thread_limit = user_thread_limit
+        self.show_logger = show_logger
+        ssl_args = {}
+        if ssl_require:
+            # Create an SSL context to require an SSL connection
+            ssl_context = ssl.create_default_context()
+            ssl_context.check_hostname = False
+            ssl_context.verify_mode = ssl.CERT_NONE
+            ssl_args["ssl"] = ssl_context
+        self.engine: AsyncEngine = create_async_engine(
+            self._conninfo, connect_args=ssl_args
+        )
+        self.async_session = sessionmaker(bind=self.engine, expire_on_commit=False, class_=AsyncSession)  # type: ignore
+        if storage_provider:
+            self.storage_provider: Optional[BaseStorageClient] = storage_provider
+            if self.show_logger:
+                logger.info("SQLAlchemyDataLayer storage client initialized")
+        else:
+            self.storage_provider = None
+            logger.warn(
+                "SQLAlchemyDataLayer storage client is not initialized and elements will not be persisted!"
+            )
+
+    async def build_debug_url(self) -> str:
+        return ""
+
+    ###### SQL Helpers ######
+    async def execute_sql(
+        self, query: str, parameters: dict
+    ) -> Union[List[Dict[str, Any]], int, None]:
+        parameterized_query = text(query)
+        async with self.async_session() as session:
+            try:
+                await session.begin()
+                result = await session.execute(parameterized_query, parameters)
+                await session.commit()
+                if result.returns_rows:
+                    json_result = [dict(row._mapping) for row in result.fetchall()]
+                    clean_json_result = self.clean_result(json_result)
+                    return clean_json_result
+                else:
+                    return result.rowcount
+            except SQLAlchemyError as e:
+                await session.rollback()
+                logger.warn(f"An error occurred: {e}")
+                return None
+            except Exception as e:
+                await session.rollback()
+                logger.warn(f"An unexpected error occurred: {e}")
+                return None
+
+    async def get_current_timestamp(self) -> str:
+        return datetime.now().isoformat() + "Z"
+
+    def clean_result(self, obj):
+        """Recursively change UUID -> str and serialize dictionaries"""
+        if isinstance(obj, dict):
+            return {k: self.clean_result(v) for k, v in obj.items()}
+        elif isinstance(obj, list):
+            return [self.clean_result(item) for item in obj]
+        elif isinstance(obj, uuid.UUID):
+            return str(obj)
+        return obj
+
+    ###### User ######
+    async def get_user(self, identifier: str) -> Optional[PersistedUser]:
+        logger.debug(f"Getting user: {identifier}")
+        return cl.PersistedUser(id="test", createdAt=now, identifier=identifier)
+        if self.show_logger:
+            logger.info(f"SQLAlchemy: get_user, identifier={identifier}")
+        query = "SELECT * FROM users WHERE identifier = :identifier"
+        parameters = {"identifier": identifier}
+        result = await self.execute_sql(query=query, parameters=parameters)
+        if result and isinstance(result, list):
+            user_data = result[0]
+            return PersistedUser(**user_data)
+        return None
+
+    async def create_user(self, user: User) -> Optional[PersistedUser]:
+        logger.debug(f"Creating user: {user.identifier}")
+        return cl.PersistedUser(id="test", createdAt=now, identifier=user.identifier)
+        if self.show_logger:
+            logger.info(f"SQLAlchemy: create_user, user_identifier={user.identifier}")
+        existing_user: Optional["PersistedUser"] = await self.get_user(user.identifier)
+        user_dict: Dict[str, Any] = {
+            "identifier": str(user.identifier),
+            "metadata": json.dumps(user.metadata) or {},
+        }
+        if not existing_user:  # create the user
+            if self.show_logger:
+                logger.info("SQLAlchemy: create_user, creating the user")
+            user_dict["id"] = str(uuid.uuid4())
+            user_dict["createdAt"] = await self.get_current_timestamp()
+            query = """INSERT INTO users ("id", "identifier", "createdAt", "metadata") VALUES (:id, :identifier, :createdAt, :metadata)"""
+            await self.execute_sql(query=query, parameters=user_dict)
+        else:  # update the user
+            if self.show_logger:
+                logger.info("SQLAlchemy: update user metadata")
+            query = """UPDATE users SET "metadata" = :metadata WHERE "identifier" = :identifier"""
+            await self.execute_sql(
+                query=query, parameters=user_dict
+            )  # We want to update the metadata
+        return await self.get_user(user.identifier)
+
+    ###### Threads ######
+    async def get_thread_author(self, thread_id: str) -> str:
+        logger.debug(f"Getting thread author: {thread_id}")
+        return "admin"
+        if self.show_logger:
+            logger.info(f"SQLAlchemy: get_thread_author, thread_id={thread_id}")
+        query = """SELECT "userIdentifier" FROM threads WHERE "id" = :id"""
+        parameters = {"id": thread_id}
+        result = await self.execute_sql(query=query, parameters=parameters)
+        if isinstance(result, list) and result:
+            author_identifier = result[0].get("userIdentifier")
+            if author_identifier is not None:
+                return author_identifier
+        raise ValueError(f"Author not found for thread_id {thread_id}")
+
+    async def get_thread(self, thread_id: str) -> Optional[ThreadDict]:
+        if self.show_logger:
+            logger.info(f"SQLAlchemy: get_thread, thread_id={thread_id}")
+        user_threads: Optional[List[ThreadDict]] = await self.get_all_user_threads(
+            thread_id=thread_id
+        )
+        if user_threads:
+            thread = user_threads[0]
+            # Parse the metadata here
+            if isinstance(thread['metadata'], str):
+                try:
+                    thread['metadata'] = json.loads(thread['metadata'])
+                except json.JSONDecodeError:
+                    thread['metadata'] = {}
+            elif thread['metadata'] is None:
+                thread['metadata'] = {}
+            return thread
+        else:
+            return None
+
+    async def update_thread(
+        self,
+        thread_id: str,
+        name: Optional[str] = None,
+        user_id: Optional[str] = None,
+        metadata: Optional[Dict] = None,
+        tags: Optional[List[str]] = None,
+    ):
+        if self.show_logger:
+            logger.info(f"SQLAlchemy: update_thread, thread_id={thread_id}")
+        if context.session.user is not None:
+            user_identifier = context.session.user.identifier
+        else:
+            raise ValueError("User not found in session context")
+        data = {
+            "id": thread_id,
+            "createdAt": (
+                await self.get_current_timestamp() if metadata is None else None
+            ),
+            "name": (
+                name
+                if name is not None
+                else (metadata.get("name") if metadata and "name" in metadata else None)
+            ),
+            "userId": user_id,
+            "userIdentifier": user_identifier,
+            "tags": tags,
+            "metadata": json.dumps(metadata) if metadata else None,
+        }
+        parameters = {
+            key: value for key, value in data.items() if value is not None
+        }  # Remove keys with None values
+        columns = ", ".join(f'"{key}"' for key in parameters.keys())
+        values = ", ".join(f":{key}" for key in parameters.keys())
+        updates = ", ".join(
+            f'"{key}" = EXCLUDED."{key}"' for key in parameters.keys() if key != "id"
+        )
+        query = f"""
+            INSERT INTO threads ({columns})
+            VALUES ({values})
+            ON CONFLICT ("id") DO UPDATE
+            SET {updates};
+        """
+        await self.execute_sql(query=query, parameters=parameters)
+
+    async def delete_thread(self, thread_id: str):
+        if self.show_logger:
+            logger.info(f"SQLAlchemy: delete_thread, thread_id={thread_id}")
+        # Delete feedbacks/elements/steps/thread
+        feedbacks_query = """DELETE FROM feedbacks WHERE "forId" IN (SELECT "id" FROM steps WHERE "threadId" = :id)"""
+        elements_query = """DELETE FROM elements WHERE "threadId" = :id"""
+        steps_query = """DELETE FROM steps WHERE "threadId" = :id"""
+        thread_query = """DELETE FROM threads WHERE "id" = :id"""
+        parameters = {"id": thread_id}
+        await self.execute_sql(query=feedbacks_query, parameters=parameters)
+        await self.execute_sql(query=elements_query, parameters=parameters)
+        await self.execute_sql(query=steps_query, parameters=parameters)
+        await self.execute_sql(query=thread_query, parameters=parameters)
+
+    async def list_threads(
+        self, pagination: Pagination, filters: ThreadFilter
+    ) -> PaginatedResponse:
+        if self.show_logger:
+            logger.info(
+                f"SQLAlchemy: list_threads, pagination={pagination}, filters={filters}"
+            )
+        if not filters.userId:
+            raise ValueError("userId is required")
+        all_user_threads: List[ThreadDict] = (
+            await self.get_all_user_threads(user_id=filters.userId) or []
+        )
+
+        search_keyword = filters.search.lower() if filters.search else None
+        feedback_value = int(filters.feedback) if filters.feedback else None
+
+        filtered_threads = []
+        for thread in all_user_threads:
+            keyword_match = True
+            feedback_match = True
+            if search_keyword or feedback_value is not None:
+                if search_keyword:
+                    keyword_match = any(
+                        search_keyword in step["output"].lower()
+                        for step in thread["steps"]
+                        if "output" in step
+                    )
+                if feedback_value is not None:
+                    feedback_match = False  # Assume no match until found
+                    for step in thread["steps"]:
+                        feedback = step.get("feedback")
+                        if feedback and feedback.get("value") == feedback_value:
+                            feedback_match = True
+                            break
+            if keyword_match and feedback_match:
+                filtered_threads.append(thread)
+
+        start = 0
+        if pagination.cursor:
+            for i, thread in enumerate(filtered_threads):
+                if (
+                    thread["id"] == pagination.cursor
+                ):  # Find the start index using pagination.cursor
+                    start = i + 1
+                    break
+        end = start + pagination.first
+        paginated_threads = filtered_threads[start:end] or []
+
+        has_next_page = len(filtered_threads) > end
+        start_cursor = paginated_threads[0]["id"] if paginated_threads else None
+        end_cursor = paginated_threads[-1]["id"] if paginated_threads else None
+
+        return PaginatedResponse(
+            pageInfo=PageInfo(
+                hasNextPage=has_next_page,
+                startCursor=start_cursor,
+                endCursor=end_cursor,
+            ),
+            data=paginated_threads,
+        )
+
+    ###### Steps ######
+    @queue_until_user_message()
+    async def create_step(self, step_dict: "StepDict"):
+        if self.show_logger:
+            logger.info(f"SQLAlchemy: create_step, step_id={step_dict.get('id')}")
+        if not getattr(context.session.user, "id", None):
+            raise ValueError("No authenticated user in context")
+        step_dict["showInput"] = (
+            str(step_dict.get("showInput", "")).lower()
+            if "showInput" in step_dict
+            else None
+        )
+        parameters = {
+            key: value
+            for key, value in step_dict.items()
+            if value is not None and not (isinstance(value, dict) and not value)
+        }
+        parameters["metadata"] = json.dumps(step_dict.get("metadata", {}))
+        parameters["generation"] = json.dumps(step_dict.get("generation", {}))
+        columns = ", ".join(f'"{key}"' for key in parameters.keys())
+        values = ", ".join(f":{key}" for key in parameters.keys())
+        updates = ", ".join(
+            f'"{key}" = :{key}' for key in parameters.keys() if key != "id"
+        )
+        query = f"""
+            INSERT INTO steps ({columns})
+            VALUES ({values})
+            ON CONFLICT (id) DO UPDATE
+            SET {updates};
+        """
+        await self.execute_sql(query=query, parameters=parameters)
+
+    @queue_until_user_message()
+    async def update_step(self, step_dict: "StepDict"):
+        if self.show_logger:
+            logger.info(f"SQLAlchemy: update_step, step_id={step_dict.get('id')}")
+        await self.create_step(step_dict)
+
+    @queue_until_user_message()
+    async def delete_step(self, step_id: str):
+        if self.show_logger:
+            logger.info(f"SQLAlchemy: delete_step, step_id={step_id}")
+        # Delete feedbacks/elements/steps
+        feedbacks_query = """DELETE FROM feedbacks WHERE "forId" = :id"""
+        elements_query = """DELETE FROM elements WHERE "forId" = :id"""
+        steps_query = """DELETE FROM steps WHERE "id" = :id"""
+        parameters = {"id": step_id}
+        await self.execute_sql(query=feedbacks_query, parameters=parameters)
+        await self.execute_sql(query=elements_query, parameters=parameters)
+        await self.execute_sql(query=steps_query, parameters=parameters)
+
+    ###### Feedback ######
+    async def upsert_feedback(self, feedback: Feedback) -> str:
+        if self.show_logger:
+            logger.info(f"SQLAlchemy: upsert_feedback, feedback_id={feedback.id}")
+        feedback.id = feedback.id or str(uuid.uuid4())
+        feedback_dict = asdict(feedback)
+        parameters = {
+            key: value for key, value in feedback_dict.items() if value is not None
+        }
+
+        columns = ", ".join(f'"{key}"' for key in parameters.keys())
+        values = ", ".join(f":{key}" for key in parameters.keys())
+        updates = ", ".join(
+            f'"{key}" = :{key}' for key in parameters.keys() if key != "id"
+        )
+        query = f"""
+            INSERT INTO feedbacks ({columns})
+            VALUES ({values})
+            ON CONFLICT (id) DO UPDATE
+            SET {updates};
+        """
+        await self.execute_sql(query=query, parameters=parameters)
+        return feedback.id
+
+    async def delete_feedback(self, feedback_id: str) -> bool:
+        if self.show_logger:
+            logger.info(f"SQLAlchemy: delete_feedback, feedback_id={feedback_id}")
+        query = """DELETE FROM feedbacks WHERE "id" = :feedback_id"""
+        parameters = {"feedback_id": feedback_id}
+        await self.execute_sql(query=query, parameters=parameters)
+        return True
+
+    ###### Elements ######
+    @queue_until_user_message()
+    async def create_element(self, element: "Element"):
+        if self.show_logger:
+            logger.info(f"SQLAlchemy: create_element, element_id = {element.id}")
+        if not getattr(context.session.user, "id", None):
+            raise ValueError("No authenticated user in context")
+        if not self.storage_provider:
+            logger.warn(
+                f"SQLAlchemy: create_element error. No blob_storage_client is configured!"
+            )
+            return
+        if not element.for_id:
+            return
+
+        content: Optional[Union[bytes, str]] = None
+
+        if element.path:
+            async with aiofiles.open(element.path, "rb") as f:
+                content = await f.read()
+        elif element.url:
+            async with aiohttp.ClientSession() as session:
+                async with session.get(element.url) as response:
+                    if response.status == 200:
+                        content = await response.read()
+                    else:
+                        content = None
+        elif element.content:
+            content = element.content
+        else:
+            raise ValueError("Element url, path or content must be provided")
+        if content is None:
+            raise ValueError("Content is None, cannot upload file")
+
+        context_user = context.session.user
+
+        user_folder = getattr(context_user, "id", "unknown")
+        file_object_key = f"{user_folder}/{element.id}" + (
+            f"/{element.name}" if element.name else ""
+        )
+
+        if not element.mime:
+            element.mime = "application/octet-stream"
+
+        uploaded_file = await self.storage_provider.upload_file(
+            object_key=file_object_key, data=content, mime=element.mime, overwrite=True
+        )
+        if not uploaded_file:
+            raise ValueError(
+                "SQLAlchemy Error: create_element, Failed to persist data in storage_provider"
+            )
+
+        element_dict: ElementDict = element.to_dict()
+
+        element_dict["url"] = uploaded_file.get("url")
+        element_dict["objectKey"] = uploaded_file.get("object_key")
+        element_dict_cleaned = {k: v for k, v in element_dict.items() if v is not None}
+
+        columns = ", ".join(f'"{column}"' for column in element_dict_cleaned.keys())
+        placeholders = ", ".join(f":{column}" for column in element_dict_cleaned.keys())
+        query = f"INSERT INTO elements ({columns}) VALUES ({placeholders})"
+        await self.execute_sql(query=query, parameters=element_dict_cleaned)
+
+    @queue_until_user_message()
+    async def delete_element(self, element_id: str, thread_id: Optional[str] = None):
+        if self.show_logger:
+            logger.info(f"SQLAlchemy: delete_element, element_id={element_id}")
+        query = """DELETE FROM elements WHERE "id" = :id"""
+        parameters = {"id": element_id}
+        await self.execute_sql(query=query, parameters=parameters)
+
+    async def delete_user_session(self, id: str) -> bool:
+        return False  # Not sure why documentation wants this
+
+    async def get_all_user_threads(
+        self, user_id: Optional[str] = None, thread_id: Optional[str] = None
+    ) -> Optional[List[ThreadDict]]:
+        """Fetch all user threads up to self.user_thread_limit, or one thread by id if thread_id is provided."""
+        if self.show_logger:
+            logger.info(f"SQLAlchemy: get_all_user_threads")
+        user_threads_query = """
+            SELECT
+                "id" AS thread_id,
+                "createdAt" AS thread_createdat,
+                "name" AS thread_name,
+                "userId" AS user_id,
+                "userIdentifier" AS user_identifier,
+                "tags" AS thread_tags,
+                "metadata" AS thread_metadata
+            FROM threads
+            WHERE "userId" = :user_id OR "id" = :thread_id
+            ORDER BY "createdAt" DESC
+            LIMIT :limit
+        """
+        user_threads = await self.execute_sql(
+            query=user_threads_query,
+            parameters={
+                "user_id": user_id,
+                "limit": self.user_thread_limit,
+                "thread_id": thread_id,
+            },
+        )
+        if not isinstance(user_threads, list):
+            return None
+        if not user_threads:
+            return []
+        else:
+            thread_ids = (
+                "('"
+                + "','".join(map(str, [thread["thread_id"] for thread in user_threads]))
+                + "')"
+            )
+
+        steps_feedbacks_query = f"""
+            SELECT
+                s."id" AS step_id,
+                s."name" AS step_name,
+                s."type" AS step_type,
+                s."threadId" AS step_threadid,
+                s."parentId" AS step_parentid,
+                s."streaming" AS step_streaming,
+                s."waitForAnswer" AS step_waitforanswer,
+                s."isError" AS step_iserror,
+                s."metadata" AS step_metadata,
+                s."tags" AS step_tags,
+                s."input" AS step_input,
+                s."output" AS step_output,
+                s."createdAt" AS step_createdat,
+                s."start" AS step_start,
+                s."end" AS step_end,
+                s."generation" AS step_generation,
+                s."showInput" AS step_showinput,
+                s."language" AS step_language,
+                s."indent" AS step_indent,
+                f."value" AS feedback_value,
+                f."comment" AS feedback_comment
+            FROM steps s LEFT JOIN feedbacks f ON s."id" = f."forId"
+            WHERE s."threadId" IN {thread_ids}
+            ORDER BY s."createdAt" ASC
+        """
+        steps_feedbacks = await self.execute_sql(
+            query=steps_feedbacks_query, parameters={}
+        )
+
+        elements_query = f"""
+            SELECT
+                e."id" AS element_id,
+                e."threadId" as element_threadid,
+                e."type" AS element_type,
+                e."chainlitKey" AS element_chainlitkey,
+                e."url" AS element_url,
+                e."objectKey" as element_objectkey,
+                e."name" AS element_name,
+                e."display" AS element_display,
+                e."size" AS element_size,
+                e."language" AS element_language,
+                e."page" AS element_page,
+                e."forId" AS element_forid,
+                e."mime" AS element_mime
+            FROM elements e
+            WHERE e."threadId" IN {thread_ids}
+        """
+        elements = await self.execute_sql(query=elements_query, parameters={})
+
+        thread_dicts = {}
+        for thread in user_threads:
+            thread_id = thread["thread_id"]
+            if thread_id is not None:
+                thread_dicts[thread_id] = ThreadDict(
+                    id=thread_id,
+                    createdAt=thread["thread_createdat"],
+                    name=thread["thread_name"],
+                    userId=thread["user_id"],
+                    userIdentifier=thread["user_identifier"],
+                    tags=thread["thread_tags"],
+                    metadata=thread["thread_metadata"],
+                    steps=[],
+                    elements=[],
+                )
+        # Process steps_feedbacks to populate the steps in the corresponding ThreadDict
+        if isinstance(steps_feedbacks, list):
+            for step_feedback in steps_feedbacks:
+                thread_id = step_feedback["step_threadid"]
+                if thread_id is not None:
+                    feedback = None
+                    if step_feedback["feedback_value"] is not None:
+                        feedback = FeedbackDict(
+                            forId=step_feedback["step_id"],
+                            id=step_feedback.get("feedback_id"),
+                            value=step_feedback["feedback_value"],
+                            comment=step_feedback.get("feedback_comment"),
+                        )
+                    step_dict = StepDict(
+                        id=step_feedback["step_id"],
+                        name=step_feedback["step_name"],
+                        type=step_feedback["step_type"],
+                        threadId=thread_id,
+                        parentId=step_feedback.get("step_parentid"),
+                        streaming=step_feedback.get("step_streaming", False),
+                        waitForAnswer=step_feedback.get("step_waitforanswer"),
+                        isError=step_feedback.get("step_iserror"),
+                        metadata=(
+                            step_feedback["step_metadata"]
+                            if step_feedback.get("step_metadata") is not None
+                            else {}
+                        ),
+                        tags=step_feedback.get("step_tags"),
+                        input=(
+                            step_feedback.get("step_input", "")
+                            if step_feedback["step_showinput"] == "true"
+                            else None
+                        ),
+                        output=step_feedback.get("step_output", ""),
+                        createdAt=step_feedback.get("step_createdat"),
+                        start=step_feedback.get("step_start"),
+                        end=step_feedback.get("step_end"),
+                        generation=step_feedback.get("step_generation"),
+                        showInput=step_feedback.get("step_showinput"),
+                        language=step_feedback.get("step_language"),
+                        indent=step_feedback.get("step_indent"),
+                        feedback=feedback,
+                    )
+                    # Append the step to the steps list of the corresponding ThreadDict
+                    thread_dicts[thread_id]["steps"].append(step_dict)
+
+        if isinstance(elements, list):
+            for element in elements:
+                thread_id = element["element_threadid"]
+                if thread_id is not None:
+                    element_dict = ElementDict(
+                        id=element["element_id"],
+                        threadId=thread_id,
+                        type=element["element_type"],
+                        chainlitKey=element.get("element_chainlitkey"),
+                        url=element.get("element_url"),
+                        objectKey=element.get("element_objectkey"),
+                        name=element["element_name"],
+                        display=element["element_display"],
+                        size=element.get("element_size"),
+                        language=element.get("element_language"),
+                        autoPlay=element.get("element_autoPlay"),
+                        playerConfig=element.get("element_playerconfig"),
+                        page=element.get("element_page"),
+                        forId=element.get("element_forid"),
+                        mime=element.get("element_mime"),
+                    )
+                    thread_dicts[thread_id]["elements"].append(element_dict)  # type: ignore
+
+        return list(thread_dicts.values())

{praisonai-0.0.46.dist-info → praisonai-0.0.47.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PraisonAI
-Version: 0.0.46
+Version: 0.0.47
 Summary: PraisonAI application combines AutoGen and CrewAI or similar frameworks into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customization, and efficient human-agent collaboration.
 Author: Mervin Praison
 Requires-Python: >=3.10,<3.13
@@ -255,10 +255,10 @@ roles:
 """
 
 # Create a PraisonAI instance with the agent_yaml content
-praison_ai = PraisonAI(agent_yaml=agent_yaml)
+praisonai = PraisonAI(agent_yaml=agent_yaml)
 
 # Run PraisonAI
-result = praison_ai.main()
+result = praisonai.run()
 
 # Print the result
 print(result)
@@ -273,8 +273,8 @@ Note: Please create agents.yaml file before hand.
 from praisonai import PraisonAI
 
 def basic(): # Basic Mode
-    praison_ai = PraisonAI(agent_file="agents.yaml")
-    praison_ai.main()
+    praisonai = PraisonAI(agent_file="agents.yaml")
+    praisonai.run()
 
 if __name__ == "__main__":
     basic()

{praisonai-0.0.46.dist-info → praisonai-0.0.47.dist-info}/RECORD

@@ -4,7 +4,7 @@ praisonai/agents_generator.py,sha256=8d1WRbubvEkBrW1HZ7_xnGyqgJi0yxmXa3MgTIqef1c
 praisonai/auto.py,sha256=9spTXqj47Hmmqv5QHRYE_RzSVHH_KoPbaZjskUj2UcE,7895
 praisonai/chainlit_ui.py,sha256=bNR7s509lp0I9JlJNvwCZRUZosC64qdvlFCt8NmFamQ,12216
 praisonai/cli.py,sha256=JBI3JjI7RB0QQipuy-utJpP3jxj8gnG5roMLW2Zjq6A,12851
-praisonai/deploy.py,sha256=UmebXvdSfKGk4A-nQeOkbj2bieEOcMK9VZMTn2z1AOY,6031
+praisonai/deploy.py,sha256=4lahg-H78WZXKbJynxA1IvSOUPyV8USS5QFvFGTPGro,6028
 praisonai/inbuilt_tools/__init__.py,sha256=mUKnbL6Gram9c9f2m8wJwEzURBLmPEOcHzwySBH89YA,74
 praisonai/inbuilt_tools/autogen_tools.py,sha256=svYkM2N7DVFvbiwgoAS7U_MqTOD8rHf8VD3BaFUV5_Y,14907
 praisonai/inc/__init__.py,sha256=sPDlYBBwdk0VlWzaaM_lG0_LD07lS2HRGvPdxXJFiYg,62
@@ -22,16 +22,17 @@ praisonai/public/logo_light.png,sha256=8cQRti_Ysa30O3_7C3ku2w40LnVUUlUok47H-3ZZH
 praisonai/public/movie.svg,sha256=aJ2EQ8vXZusVsF2SeuAVxP4RFJzQ14T26ejrGYdBgzk,1289
 praisonai/public/thriller.svg,sha256=2dYY72EcgbEyTxS4QzjAm37Y4srtPWEW4vCMFki98ZI,3163
 praisonai/test.py,sha256=RZKq3UEFb6AnFFiHER3zBXfNmlteSLBlrTmOvnpnZLo,4092
-praisonai/ui/chat.py,sha256=Gx0SmnE5P6f8csS--gfnInJVmLF-5bWyOBLu1o4AXgc,14643
+praisonai/ui/chat.py,sha256=S3a5u0mI7RO5QFbKckz4z8b32gRTiX8kauSHvQBTMco,9238
 praisonai/ui/public/fantasy.svg,sha256=4Gs3kIOux-pjGtw6ogI_rv5_viVJxnE5gRwGilsSg0o,1553
 praisonai/ui/public/game.svg,sha256=y2QMaA01m8XzuDjTOBWzupOC3-TpnUl9ah89mIhviUw,2406
 praisonai/ui/public/logo_dark.png,sha256=frHz1zkrnivGssJgk9iy1cabojkVgm8B4MllFwL_CnI,17050
 praisonai/ui/public/logo_light.png,sha256=8cQRti_Ysa30O3_7C3ku2w40LnVUUlUok47H-3ZZHSU,19656
 praisonai/ui/public/movie.svg,sha256=aJ2EQ8vXZusVsF2SeuAVxP4RFJzQ14T26ejrGYdBgzk,1289
 praisonai/ui/public/thriller.svg,sha256=2dYY72EcgbEyTxS4QzjAm37Y4srtPWEW4vCMFki98ZI,3163
+praisonai/ui/sql_alchemy.py,sha256=HsyeRq-G9qbQobHWpTJHHKQiT4FvYw_7iuv-2PNh0IU,27419
 praisonai/version.py,sha256=ugyuFliEqtAwQmH4sTlc16YXKYbFWDmfyk87fErB8-8,21
-praisonai-0.0.46.dist-info/LICENSE,sha256=kqvFysVlnFxYOu0HxCe2HlmZmJtdmNGOxWRRkT9TsWc,1035
-praisonai-0.0.46.dist-info/METADATA,sha256=HFsoACSl5CZakd3MXJtl4pFGB3_6fV-6jBEYyY07wR8,9307
-praisonai-0.0.46.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-praisonai-0.0.46.dist-info/entry_points.txt,sha256=Qg41eW3A1-dvdV5tF7LqChfYof8Rihk2rN1fiEE3vnk,53
-praisonai-0.0.46.dist-info/RECORD,,
+praisonai-0.0.47.dist-info/LICENSE,sha256=kqvFysVlnFxYOu0HxCe2HlmZmJtdmNGOxWRRkT9TsWc,1035
+praisonai-0.0.47.dist-info/METADATA,sha256=FH2jJ9hDTdpt4pNpl4hR8Pige1GuzlISpLBs45F-FK0,9301
+praisonai-0.0.47.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+praisonai-0.0.47.dist-info/entry_points.txt,sha256=Qg41eW3A1-dvdV5tF7LqChfYof8Rihk2rN1fiEE3vnk,53
+praisonai-0.0.47.dist-info/RECORD,,