PraisonAI 1.0.1__tar.gz → 1.0.3__tar.gz

{praisonai-1.0.1 → praisonai-1.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PraisonAI
-Version: 1.0.1
+Version: 1.0.3
 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
@@ -34,7 +34,7 @@ Requires-Dist: flaml[automl] (>=2.3.1) ; extra == "call"
 Requires-Dist: flask (>=3.0.0) ; extra == "api"
 Requires-Dist: gradio (>=4.26.0) ; extra == "gradio"
 Requires-Dist: greenlet (>=3.0.3) ; extra == "chat" or extra == "code" or extra == "realtime"
-Requires-Dist: instructor (>=0.4.8) ; extra == "call" or extra == "crewai" or extra == "autogen"
+Requires-Dist: instructor (>=0.4.8) ; extra == "chat" or extra == "call" or extra == "crewai" or extra == "autogen"
 Requires-Dist: langchain-anthropic (>=0.1.13) ; extra == "anthropic"
 Requires-Dist: langchain-cohere (>=0.1.4) ; extra == "cohere"
 Requires-Dist: langchain-google-genai (>=1.0.4) ; extra == "google"
@@ -46,10 +46,11 @@ Requires-Dist: playwright (>=1.47.0) ; extra == "chat" or extra == "code"
 Requires-Dist: plotly (>=5.24.0) ; extra == "realtime"
 Requires-Dist: praisonai-tools (>=0.0.7) ; extra == "crewai" or extra == "autogen"
 Requires-Dist: pyautogen (>=0.2.19) ; extra == "autogen"
+Requires-Dist: pydantic (<=2.10.1) ; extra == "chat" or extra == "code"
 Requires-Dist: pyngrok (>=1.4.0) ; extra == "call"
 Requires-Dist: pyparsing (>=3.0.0)
 Requires-Dist: python-dotenv (>=0.19.0) ; extra == "call"
-Requires-Dist: rich (>=13.7) ; extra == "call"
+Requires-Dist: rich (>=13.7) ; extra == "chat" or extra == "call"
 Requires-Dist: sqlalchemy (>=2.0.36) ; extra == "chat" or extra == "code" or extra == "realtime"
 Requires-Dist: tavily-python (==0.5.0) ; extra == "chat" or extra == "code" or extra == "realtime"
 Requires-Dist: twilio (>=7.0.0) ; extra == "call"
@@ -78,6 +79,8 @@ Description-Content-Type: text/markdown
 
 # Praison AI
 
+<a href="https://trendshift.io/repositories/9130" target="_blank"><img src="https://trendshift.io/api/badge/repositories/9130" alt="MervinPraison%2FPraisonAI | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
+
 </div>
 
 Praison AI, leveraging both AutoGen and CrewAI or any other agent framework, represents a low-code, centralised framework designed to simplify the creation and orchestration of multi-agent systems for various LLM applications, emphasizing ease of use, customization, and human-agent interaction.

{praisonai-1.0.1 → praisonai-1.0.3}/README.md

@@ -16,6 +16,8 @@
 
 # Praison AI
 
+<a href="https://trendshift.io/repositories/9130" target="_blank"><img src="https://trendshift.io/api/badge/repositories/9130" alt="MervinPraison%2FPraisonAI | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
+
 </div>
 
 Praison AI, leveraging both AutoGen and CrewAI or any other agent framework, represents a low-code, centralised framework designed to simplify the creation and orchestration of multi-agent systems for various LLM applications, emphasizing ease of use, customization, and human-agent interaction.

{praisonai-1.0.1 → praisonai-1.0.3}/praisonai/cli.py

@@ -26,7 +26,9 @@ CREWAI_AVAILABLE = False
 AUTOGEN_AVAILABLE = False
 
 try:
-    os.environ["CHAINLIT_APP_ROOT"] = os.path.join(os.path.expanduser("~"), ".praison")
+    # Set CHAINLIT_APP_ROOT only if it doesn't exist
+    if "CHAINLIT_APP_ROOT" not in os.environ:
+        os.environ["CHAINLIT_APP_ROOT"] = os.path.join(os.path.expanduser("~"), ".praison")
     from chainlit.cli import chainlit_run
     CHAINLIT_AVAILABLE = True
 except ImportError:
@@ -389,7 +391,8 @@ class PraisonAI:
             import praisonai
             os.environ["CHAINLIT_PORT"] = "8084"
             root_path = os.path.join(os.path.expanduser("~"), ".praison")
-            os.environ["CHAINLIT_APP_ROOT"] = root_path
+            if "CHAINLIT_APP_ROOT" not in os.environ:
+                os.environ["CHAINLIT_APP_ROOT"] = root_path
             public_folder = os.path.join(os.path.dirname(praisonai.__file__), 'public')
             if not os.path.exists(os.path.join(root_path, "public")):
                 if os.path.exists(public_folder):
@@ -412,7 +415,8 @@ class PraisonAI:
             import praisonai
             os.environ["CHAINLIT_PORT"] = "8086"
             root_path = os.path.join(os.path.expanduser("~"), ".praison")
-            os.environ["CHAINLIT_APP_ROOT"] = root_path
+            if "CHAINLIT_APP_ROOT" not in os.environ:
+                os.environ["CHAINLIT_APP_ROOT"] = root_path
             public_folder = os.path.join(os.path.dirname(__file__), 'public')
             if not os.path.exists(os.path.join(root_path, "public")):
                 if os.path.exists(public_folder):
@@ -481,7 +485,8 @@ class PraisonAI:
             import praisonai
             os.environ["CHAINLIT_PORT"] = "8088"
             root_path = os.path.join(os.path.expanduser("~"), ".praison")
-            os.environ["CHAINLIT_APP_ROOT"] = root_path
+            if "CHAINLIT_APP_ROOT" not in os.environ:
+                os.environ["CHAINLIT_APP_ROOT"] = root_path
             public_folder = os.path.join(os.path.dirname(praisonai.__file__), 'public')
             if not os.path.exists(os.path.join(root_path, "public")):
                 if os.path.exists(public_folder):

{praisonai-1.0.1 → praisonai-1.0.3}/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==1.0.1 gunicorn markdown\n")
+            file.write("RUN pip install flask praisonai==1.0.3 gunicorn markdown\n")
             file.write("EXPOSE 8080\n")
             file.write('CMD ["gunicorn", "-b", "0.0.0.0:8080", "api:app"]\n')
             

{praisonai-1.0.1 → praisonai-1.0.3}/praisonai/ui/chat.py

@@ -1,6 +1,6 @@
 import chainlit as cl
 from chainlit.input_widget import TextInput
-from chainlit.types import ThreadDict  # Change this import
+from chainlit.types import ThreadDict  
 from litellm import acompletion
 import os
 import sqlite3
@@ -9,7 +9,6 @@ from typing import Dict, List, Optional
 from dotenv import load_dotenv
 load_dotenv()
 import chainlit.data as cl_data
-from chainlit.step import StepDict
 from literalai.helper import utc_now
 import logging
 import json
@@ -20,6 +19,8 @@ import asyncio
 from PIL import Image
 import io
 import base64
+from sqlalchemy import text
+from sqlalchemy.exc import DatabaseError
 
 # Set up logging
 logger = logging.getLogger(__name__)
@@ -48,134 +49,225 @@ create_step_counter = 0
 
 DB_PATH = os.path.expanduser("~/.praison/database.sqlite")
 
-def initialize_db():
-    os.makedirs(os.path.dirname(DB_PATH), exist_ok=True)
-    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 UUID PRIMARY KEY,
-            createdAt 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 UUID PRIMARY KEY,
-            name TEXT NOT NULL,
-            type TEXT NOT NULL,
-            threadId UUID NOT NULL,
-            parentId UUID,
-            disableFeedback BOOLEAN NOT NULL DEFAULT 0,
-            streaming BOOLEAN NOT NULL DEFAULT 0,
-            waitForAnswer BOOLEAN DEFAULT 0,
-            isError BOOLEAN NOT NULL DEFAULT 0,
-            metadata JSONB DEFAULT '{}',
-            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,
-            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('''
-        CREATE TABLE IF NOT EXISTS settings (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            key TEXT UNIQUE,
-            value TEXT
-        )
-    ''')
-    conn.commit()
-    conn.close()
-
-def save_setting(key: str, value: str):
-    """Saves a setting to the database.
-
-    Args:
-        key: The setting key.
-        value: The setting value.
-    """
-    conn = sqlite3.connect(DB_PATH)
-    cursor = conn.cursor()
-    cursor.execute(
-        """
-        INSERT OR REPLACE INTO settings (id, key, value)
-        VALUES ((SELECT id FROM settings WHERE key = ?), ?, ?)
-    """,
-        (key, key, value),
-    )
-    conn.commit()
-    conn.close()
-
-def load_setting(key: str) -> str:
-    """Loads a setting from the database.
-
-    Args:
-        key: The setting key.
-
-    Returns:
-        The setting value, or None if the key is not found.
-    """
-    conn = sqlite3.connect(DB_PATH)
-    cursor = conn.cursor()
-    cursor.execute('SELECT value FROM settings WHERE key = ?', (key,))
-    result = cursor.fetchone()
-    conn.close()
-    return result[0] if result else None
-
+async def create_tables(engine):
+    """Create all necessary tables if they don't exist."""
+    try:
+        async with engine.begin() as conn:
+            # Check if we're using PostgreSQL
+            dialect = engine.dialect.name
+            if dialect == 'postgresql':
+                # Create tables with PostgreSQL-specific types
+                await conn.execute(text("""
+                    CREATE TABLE IF NOT EXISTS users (
+                        id UUID PRIMARY KEY,
+                        identifier TEXT NOT NULL UNIQUE,
+                        metadata JSONB NOT NULL,
+                        createdAt TEXT
+                    )
+                """))
+                
+                await conn.execute(text("""
+                    CREATE TABLE IF NOT EXISTS threads (
+                        id UUID PRIMARY KEY,
+                        createdAt TEXT,
+                        name TEXT,
+                        userId UUID,
+                        userIdentifier TEXT,
+                        tags TEXT[],
+                        metadata JSONB NOT NULL DEFAULT '{}',
+                        FOREIGN KEY (userId) REFERENCES users(id) ON DELETE CASCADE
+                    )
+                """))
+                
+                await conn.execute(text("""
+                    CREATE TABLE IF NOT EXISTS steps (
+                        id UUID PRIMARY KEY,
+                        name TEXT NOT NULL,
+                        type TEXT NOT NULL,
+                        threadId UUID NOT NULL,
+                        parentId UUID,
+                        disableFeedback BOOLEAN NOT NULL DEFAULT 0,
+                        streaming BOOLEAN NOT NULL DEFAULT 0,
+                        waitForAnswer BOOLEAN DEFAULT 0,
+                        isError BOOLEAN NOT NULL DEFAULT 0,
+                        metadata JSONB DEFAULT '{}',
+                        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
+                    )
+                """))
+                
+                await conn.execute(text("""
+                    CREATE TABLE IF NOT EXISTS elements (
+                        id UUID PRIMARY KEY,
+                        threadId UUID,
+                        type TEXT,
+                        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
+                    )
+                """))
+                
+                await conn.execute(text("""
+                    CREATE TABLE IF NOT EXISTS feedbacks (
+                        id UUID PRIMARY KEY,
+                        forId UUID NOT NULL,
+                        value INT NOT NULL,
+                        threadId UUID,
+                        comment TEXT
+                    )
+                """))
+                
+                await conn.execute(text("""
+                    CREATE TABLE IF NOT EXISTS settings (
+                        id INTEGER PRIMARY KEY AUTOINCREMENT,
+                        key TEXT UNIQUE,
+                        value TEXT
+                    )
+                """))
+                
+                # Create indexes
+                await conn.execute(text(
+                    "CREATE INDEX IF NOT EXISTS idx_steps_threadId ON steps(threadId)"
+                ))
+                await conn.execute(text(
+                    "CREATE INDEX IF NOT EXISTS idx_threads_createdAt ON threads(createdAt DESC)"
+                ))
+            else:
+                # SQLite tables (existing schema)
+                await conn.execute(text("""
+                    CREATE TABLE IF NOT EXISTS users (
+                        id TEXT PRIMARY KEY,
+                        identifier TEXT NOT NULL UNIQUE,
+                        metadata TEXT NOT NULL,
+                        createdAt TEXT
+                    )
+                """))
+                
+                await conn.execute(text("""
+                    CREATE TABLE IF NOT EXISTS threads (
+                        id TEXT PRIMARY KEY,
+                        createdAt TEXT,
+                        name TEXT,
+                        userId TEXT,
+                        userIdentifier TEXT,
+                        tags TEXT,
+                        metadata TEXT NOT NULL DEFAULT '{}',
+                        FOREIGN KEY (userId) REFERENCES users(id) ON DELETE CASCADE
+                    )
+                """))
+                
+                await conn.execute(text("""
+                    CREATE TABLE IF NOT EXISTS steps (
+                        id TEXT PRIMARY KEY,
+                        name TEXT NOT NULL,
+                        type TEXT NOT NULL,
+                        threadId TEXT NOT NULL,
+                        parentId TEXT,
+                        disableFeedback BOOLEAN NOT NULL DEFAULT 0,
+                        streaming BOOLEAN NOT NULL DEFAULT 0,
+                        waitForAnswer BOOLEAN DEFAULT 0,
+                        isError BOOLEAN NOT NULL DEFAULT 0,
+                        metadata TEXT DEFAULT '{}',
+                        tags TEXT,
+                        input TEXT,
+                        output TEXT,
+                        createdAt TEXT,
+                        start TEXT,
+                        end TEXT,
+                        generation TEXT,
+                        showInput TEXT,
+                        language TEXT,
+                        indent INT,
+                        FOREIGN KEY (threadId) REFERENCES threads (id) ON DELETE CASCADE
+                    )
+                """))
+                
+                await conn.execute(text("""
+                    CREATE TABLE IF NOT EXISTS elements (
+                        id TEXT PRIMARY KEY,
+                        threadId TEXT,
+                        type TEXT,
+                        url TEXT,
+                        chainlitKey TEXT,
+                        name TEXT NOT NULL,
+                        display TEXT,
+                        objectKey TEXT,
+                        size TEXT,
+                        page INT,
+                        language TEXT,
+                        forId TEXT,
+                        mime TEXT,
+                        FOREIGN KEY (threadId) REFERENCES threads (id) ON DELETE CASCADE
+                    )
+                """))
+                
+                await conn.execute(text("""
+                    CREATE TABLE IF NOT EXISTS feedbacks (
+                        id TEXT PRIMARY KEY,
+                        forId TEXT NOT NULL,
+                        value INT NOT NULL,
+                        threadId TEXT,
+                        comment TEXT
+                    )
+                """))
+                
+                await conn.execute(text("""
+                    CREATE TABLE IF NOT EXISTS settings (
+                        id INTEGER PRIMARY KEY AUTOINCREMENT,
+                        key TEXT UNIQUE,
+                        value TEXT
+                    )
+                """))
+                
+                # Create indexes
+                await conn.execute(text(
+                    "CREATE INDEX IF NOT EXISTS idx_steps_threadId ON steps(threadId)"
+                ))
+                await conn.execute(text(
+                    "CREATE INDEX IF NOT EXISTS idx_threads_createdAt ON threads(createdAt DESC)"
+                ))
+        
+        logger.info(f"Successfully created tables for {dialect} database")
+    except Exception as e:
+        logger.error(f"Error creating tables: {str(e)}")
+        raise DatabaseError(f"Failed to create database tables: {str(e)}")
 
 # Initialize the database
-initialize_db()
+async def initialize_db():
+    await create_tables(cl_data._data_layer.engine)
 
-deleted_thread_ids = []  # type: List[str]
+# Get database connection string from environment variable or use SQLite as default
+DB_URL = os.getenv("DATABASE_URL", f"sqlite+aiosqlite:///{DB_PATH}")
+if DB_URL.startswith('postgresql'):
+    # Convert postgresql:// to postgresql+psycopg:// if needed
+    DB_URL = DB_URL.replace('postgresql://', 'postgresql+psycopg://')
 
-cl_data._data_layer = SQLAlchemyDataLayer(conninfo=f"sqlite+aiosqlite:///{DB_PATH}")
+# Initialize SQLAlchemy data layer
+cl_data._data_layer = SQLAlchemyDataLayer(
+    conninfo=DB_URL,
+    ssl_require=bool(os.getenv("DATABASE_SSL", False))
+)
+
+# Create tables if using PostgreSQL
+if DB_URL.startswith('postgresql'):
+    asyncio.run(initialize_db())
 
 # Set Tavily API key
 tavily_api_key = os.getenv("TAVILY_API_KEY")
@@ -236,10 +328,53 @@ tools = [{
     }
 }] if tavily_api_key else []
 
+async def save_setting(key: str, value: str):
+    """Saves a setting to the database.
+
+    Args:
+        key: The setting key.
+        value: The setting value.
+    """
+    try:
+        async with cl_data._data_layer.engine.begin() as conn:
+            await conn.execute(
+                text("""
+                INSERT INTO settings (key, value)
+                VALUES (:key, :value)
+                ON CONFLICT (key) DO UPDATE SET value = :value
+                """),
+                {"key": key, "value": value}
+            )
+        logger.debug(f"Saved setting {key}={value}")
+    except Exception as e:
+        logger.error(f"Error saving setting {key}: {str(e)}")
+        raise DatabaseError(f"Failed to save setting: {str(e)}")
+
+async def load_setting(key: str) -> str:
+    """Loads a setting from the database.
+
+    Args:
+        key: The setting key.
+
+    Returns:
+        The setting value, or None if the key is not found.
+    """
+    try:
+        async with cl_data._data_layer.engine.connect() as conn:
+            result = await conn.execute(
+                text("SELECT value FROM settings WHERE key = :key"),
+                {"key": key}
+            )
+            row = result.fetchone()
+            return row[0] if row else None
+    except Exception as e:
+        logger.error(f"Error loading setting {key}: {str(e)}")
+        return None
+
 @cl.on_chat_start
 async def start():
-    initialize_db()
-    model_name = load_setting("model_name") 
+    await initialize_db()
+    model_name = await load_setting("model_name") 
 
     if model_name:
         cl.user_session.set("model_name", model_name)
@@ -269,7 +404,7 @@ async def setup_agent(settings):
     cl.user_session.set("model_name", model_name)
     
     # Save in settings table
-    save_setting("model_name", model_name)
+    await save_setting("model_name", model_name)
     
     # Save in thread metadata
     thread_id = cl.user_session.get("thread_id")
@@ -287,7 +422,7 @@ async def setup_agent(settings):
 
 @cl.on_message
 async def main(message: cl.Message):
-    model_name = load_setting("model_name") or os.getenv("MODEL_NAME") or "gpt-4o-mini"
+    model_name = await load_setting("model_name") or os.getenv("MODEL_NAME") or "gpt-4o-mini"
     message_history = cl.user_session.get("message_history", [])
     now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
     
@@ -469,7 +604,7 @@ async def send_count():
 @cl.on_chat_resume
 async def on_chat_resume(thread: ThreadDict):
     logger.info(f"Resuming chat: {thread['id']}")
-    model_name = load_setting("model_name") or os.getenv("MODEL_NAME") or "gpt-4o-mini"
+    model_name = await load_setting("model_name") or os.getenv("MODEL_NAME") or "gpt-4o-mini"
     logger.debug(f"Model name: {model_name}")
     settings = cl.ChatSettings(
         [

{praisonai-1.0.1 → praisonai-1.0.3}/praisonai/ui/code.py

@@ -1,7 +1,6 @@
 import chainlit as cl
 from chainlit.input_widget import TextInput
-from chainlit.types import ThreadDict
-from litellm import acompletion, completion
+from chainlit.types import ThreadDict, StepDict
 import os
 import sqlite3
 from datetime import datetime
@@ -9,8 +8,6 @@ from typing import Dict, List, Optional
 from dotenv import load_dotenv
 load_dotenv()
 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
@@ -43,7 +40,7 @@ if not CHAINLIT_AUTH_SECRET:
     os.environ["CHAINLIT_AUTH_SECRET"] = "p8BPhQChpg@J>jBz$wGxqLX2V>yTVgP*7Ky9H$aV:axW~ANNX-7_T:o@lnyCBu^U"
     CHAINLIT_AUTH_SECRET = os.getenv("CHAINLIT_AUTH_SECRET")
 
-now = utc_now()
+now = datetime.now()
 
 create_step_counter = 0
 

{praisonai-1.0.1 → praisonai-1.0.3}/praisonai/ui/sql_alchemy.py

@@ -12,6 +12,7 @@ from chainlit.data.base import BaseDataLayer, BaseStorageClient
 from chainlit.data.utils import queue_until_user_message
 from chainlit.element import ElementDict
 from chainlit.logger import logger
+from chainlit.message import Message
 from chainlit.step import StepDict
 from chainlit.types import (
     Feedback,
@@ -204,9 +205,10 @@ class SQLAlchemyDataLayer(BaseDataLayer):
     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
+        user_threads: Optional[List[ThreadDict]] = (
+            await self.get_all_user_threads(thread_id=thread_id) or []
         )
+
         if user_threads:
             return user_threads[0]
         else:
@@ -335,7 +337,7 @@ class SQLAlchemyDataLayer(BaseDataLayer):
 
     ###### Steps ######
     @queue_until_user_message()
-    async def create_step(self, step_dict: "StepDict"):
+    async def create_step(self, step_dict: dict):
         if self.show_logger:
             logger.info(f"SQLAlchemy: create_step, step_id={step_dict.get('id')}")
 
@@ -365,7 +367,7 @@ class SQLAlchemyDataLayer(BaseDataLayer):
         await self.execute_sql(query=query, parameters=parameters)
 
     @queue_until_user_message()
-    async def update_step(self, step_dict: "StepDict"):
+    async def update_step(self, step_dict: dict):
         if self.show_logger:
             logger.info(f"SQLAlchemy: update_step, step_id={step_dict.get('id')}")
         await self.create_step(step_dict)
@@ -646,37 +648,37 @@ class SQLAlchemyDataLayer(BaseDataLayer):
                             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_dict = {
+                        "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=(
+                        "tags": step_feedback.get("step_tags"),
+                        "input": (
                             step_feedback.get("step_input", "")
                             if step_feedback.get("step_showinput")
                             not in [None, "false"]
                             else ""
                         ),
-                        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,
-                    )
+                        "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)
 

{praisonai-1.0.1 → praisonai-1.0.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "PraisonAI"
-version = "1.0.1"
+version = "1.0.3"
 description = "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."
 authors = ["Mervin Praison"]
 license = ""
@@ -48,6 +48,7 @@ pyngrok = {version = ">=1.4.0", optional = true}
 sqlalchemy = {version = ">=2.0.36", optional = true}
 playwright = {version = ">=1.47.0", optional = true}
 openai = {version = ">=1.54.0", optional = true}
+pydantic = {version = "<=2.10.1", optional = true}
 
 [tool.poetry.group.docs.dependencies]
 mkdocs = "*"
@@ -125,7 +126,10 @@ chat = [
     "tavily-python", 
     "crawl4ai",
     "sqlalchemy",
-    "playwright"
+    "playwright",
+    "rich",
+    "instructor",
+    "pydantic"
 ]
 code = [
     "chainlit", 
@@ -135,7 +139,8 @@ code = [
     "tavily-python", 
     "crawl4ai",
     "sqlalchemy",
-    "playwright"
+    "playwright",
+    "pydantic"
 ]
 train = ["setup-conda-env"]
 realtime = [