Merge pull request #264 from MervinPraison/develop

bug fix ui load

Dockerfile

@@ -1,6 +1,6 @@
 FROM python:3.11-slim
 WORKDIR /app
 COPY . .
-RUN pip install flask praisonai==2.0.24 gunicorn markdown
+RUN pip install flask praisonai==2.0.28 gunicorn markdown
 EXPOSE 8080
 CMD ["gunicorn", "-b", "0.0.0.0:8080", "api:app"]

agents.yaml

@@ -7,12 +7,8 @@ roles:
       information.
     goal: Gather information about Mars and cats
     role: Researcher
-    llm:
-      model: "gpt-4o"
-    reflect_llm:
-      model: "gpt-4o"
-    min_reflect: 2
-    max_reflect: 4
+    min_reflect: 1
+    max_reflect: 2
     tasks:
       research_task:
         description: Research about Mars, its environment, and the feasibility of
@@ -25,8 +21,6 @@ roles:
       stories.
     goal: Create a story concept for a movie about a cat in Mars
     role: Narrative Designer
-    llm:
-      model: "gpt-4o"
     tasks:
       story_concept_development:
         description: Use the research findings to craft a unique story concept for
@@ -39,8 +33,6 @@ roles:
       scripts.
     goal: Write a movie script about a cat in Mars
     role: Scriptwriter
-    llm:
-      model: "gpt-4o"
     tasks:
       scriptwriting_task:
         description: Turn the story concept into a production-ready movie script,

agents/example_callback.py

@@ -1,4 +1,12 @@
-from praisonaiagents import Agent, Task, PraisonAIAgents, error_logs, register_display_callback
+from praisonaiagents import (
+    Agent, 
+    Task, 
+    PraisonAIAgents, 
+    error_logs, 
+    register_display_callback,
+    sync_display_callbacks,
+    async_display_callbacks
+)
 from duckduckgo_search import DDGS
 from rich.console import Console
 import json

agents/praisonaiagents/__init__.py

@@ -17,7 +17,8 @@ from .main import (
     clean_triple_backticks,
     error_logs,
     register_display_callback,
-    display_callbacks,
+    sync_display_callbacks,
+    async_display_callbacks,
 )
 
 __all__ = [
@@ -35,5 +36,6 @@ __all__ = [
     'clean_triple_backticks',
     'error_logs',
     'register_display_callback',
-    'display_callbacks',
+    'sync_display_callbacks',
+    'async_display_callbacks',
 ] 

agents/praisonaiagents/main.py

@@ -12,6 +12,7 @@ from rich.text import Text
 from rich.markdown import Markdown
 from rich.logging import RichHandler
 from rich.live import Live
+import asyncio
 
 LOGLEVEL = os.environ.get('LOGLEVEL', 'INFO').upper()
 
@@ -25,12 +26,49 @@ logging.basicConfig(
 # Global list to store error logs
 error_logs = []
 
-# Global callback registry
-display_callbacks = {}
+# Separate registries for sync and async callbacks
+sync_display_callbacks = {}
+async_display_callbacks = {}
 
-def register_display_callback(display_type: str, callback_fn):
-    """Register a callback function for a specific display type."""
-    display_callbacks[display_type] = callback_fn
+# At the top of the file, add display_callbacks to __all__
+__all__ = [
+    'error_logs',
+    'register_display_callback',
+    'sync_display_callbacks',
+    'async_display_callbacks',
+    # ... other exports
+]
+
+def register_display_callback(display_type: str, callback_fn, is_async: bool = False):
+    """Register a synchronous or asynchronous callback function for a specific display type.
+    
+    Args:
+        display_type (str): Type of display event ('interaction', 'self_reflection', etc.)
+        callback_fn: The callback function to register
+        is_async (bool): Whether the callback is asynchronous
+    """
+    if is_async:
+        async_display_callbacks[display_type] = callback_fn
+    else:
+        sync_display_callbacks[display_type] = callback_fn
+
+async def execute_callback(display_type: str, **kwargs):
+    """Execute both sync and async callbacks for a given display type.
+    
+    Args:
+        display_type (str): Type of display event
+        **kwargs: Arguments to pass to the callback functions
+    """
+    # Execute synchronous callback if registered
+    if display_type in sync_display_callbacks:
+        callback = sync_display_callbacks[display_type]
+        loop = asyncio.get_event_loop()
+        await loop.run_in_executor(None, lambda: callback(**kwargs))
+    
+    # Execute asynchronous callback if registered
+    if display_type in async_display_callbacks:
+        callback = async_display_callbacks[display_type]
+        await callback(**kwargs)
 
 def _clean_display_content(content: str, max_length: int = 20000) -> str:
     """Helper function to clean and truncate content for display."""
@@ -53,11 +91,10 @@ def _clean_display_content(content: str, max_length: int = 20000) -> str:
     return content.strip()
 
 def display_interaction(message, response, markdown=True, generation_time=None, console=None):
-    """Display the interaction between user and assistant."""
+    """Synchronous version of display_interaction."""
     if console is None:
         console = Console()
     
-    # Handle multimodal content (list)
     if isinstance(message, list):
         text_content = next((item["text"] for item in message if item["type"] == "text"), "")
         message = text_content
@@ -65,16 +102,16 @@ def display_interaction(message, response, markdown=True, generation_time=None,
     message = _clean_display_content(str(message))
     response = _clean_display_content(str(response))
 
-    # Execute callback if registered
-    if 'interaction' in display_callbacks:
-        display_callbacks['interaction'](
+    # Execute synchronous callback if registered
+    if 'interaction' in sync_display_callbacks:
+        sync_display_callbacks['interaction'](
             message=message,
             response=response,
             markdown=markdown,
             generation_time=generation_time
         )
 
-    # Existing display logic...
+    # Rest of the display logic...
     if generation_time:
         console.print(Text(f"Response generated in {generation_time:.1f}s", style="dim"))
 
@@ -93,8 +130,8 @@ def display_self_reflection(message: str, console=None):
     message = _clean_display_content(str(message))
     
     # Execute callback if registered
-    if 'self_reflection' in display_callbacks:
-        display_callbacks['self_reflection'](message=message)
+    if 'self_reflection' in sync_display_callbacks:
+        sync_display_callbacks['self_reflection'](message=message)
     
     console.print(Panel.fit(Text(message, style="bold yellow"), title="Self Reflection", border_style="magenta"))
 
@@ -106,8 +143,8 @@ def display_instruction(message: str, console=None):
     message = _clean_display_content(str(message))
     
     # Execute callback if registered
-    if 'instruction' in display_callbacks:
-        display_callbacks['instruction'](message=message)
+    if 'instruction' in sync_display_callbacks:
+        sync_display_callbacks['instruction'](message=message)
     
     console.print(Panel.fit(Text(message, style="bold blue"), title="Instruction", border_style="cyan"))
 
@@ -119,8 +156,8 @@ def display_tool_call(message: str, console=None):
     message = _clean_display_content(str(message))
     
     # Execute callback if registered
-    if 'tool_call' in display_callbacks:
-        display_callbacks['tool_call'](message=message)
+    if 'tool_call' in sync_display_callbacks:
+        sync_display_callbacks['tool_call'](message=message)
     
     console.print(Panel.fit(Text(message, style="bold cyan"), title="Tool Call", border_style="green"))
 
@@ -132,8 +169,8 @@ def display_error(message: str, console=None):
     message = _clean_display_content(str(message))
     
     # Execute callback if registered
-    if 'error' in display_callbacks:
-        display_callbacks['error'](message=message)
+    if 'error' in sync_display_callbacks:
+        sync_display_callbacks['error'](message=message)
     
     console.print(Panel.fit(Text(message, style="bold red"), title="Error", border_style="red"))
     error_logs.append(message)
@@ -150,8 +187,114 @@ def display_generating(content: str = "", start_time: Optional[float] = None):
     content = _clean_display_content(str(content))
     
     # Execute callback if registered
-    if 'generating' in display_callbacks:
-        display_callbacks['generating'](
+    if 'generating' in sync_display_callbacks:
+        sync_display_callbacks['generating'](
+            content=content,
+            elapsed_time=elapsed_str.strip() if elapsed_str else None
+        )
+    
+    return Panel(Markdown(content), title=f"Generating...{elapsed_str}", border_style="green")
+
+# Async versions with 'a' prefix
+async def adisplay_interaction(message, response, markdown=True, generation_time=None, console=None):
+    """Async version of display_interaction."""
+    if console is None:
+        console = Console()
+    
+    if isinstance(message, list):
+        text_content = next((item["text"] for item in message if item["type"] == "text"), "")
+        message = text_content
+
+    message = _clean_display_content(str(message))
+    response = _clean_display_content(str(response))
+
+    # Execute callbacks
+    await execute_callback(
+        'interaction',
+        message=message,
+        response=response,
+        markdown=markdown,
+        generation_time=generation_time
+    )
+
+    # Rest of the display logic...
+    if generation_time:
+        console.print(Text(f"Response generated in {generation_time:.1f}s", style="dim"))
+
+    if markdown:
+        console.print(Panel.fit(Markdown(message), title="Message", border_style="cyan"))
+        console.print(Panel.fit(Markdown(response), title="Response", border_style="cyan"))
+    else:
+        console.print(Panel.fit(Text(message, style="bold green"), title="Message", border_style="cyan"))
+        console.print(Panel.fit(Text(response, style="bold blue"), title="Response", border_style="cyan"))
+
+async def adisplay_self_reflection(message: str, console=None):
+    """Async version of display_self_reflection."""
+    if not message or not message.strip():
+        return
+    if console is None:
+        console = Console()
+    message = _clean_display_content(str(message))
+    
+    if 'self_reflection' in async_display_callbacks:
+        await async_display_callbacks['self_reflection'](message=message)
+    
+    console.print(Panel.fit(Text(message, style="bold yellow"), title="Self Reflection", border_style="magenta"))
+
+async def adisplay_instruction(message: str, console=None):
+    """Async version of display_instruction."""
+    if not message or not message.strip():
+        return
+    if console is None:
+        console = Console()
+    message = _clean_display_content(str(message))
+    
+    if 'instruction' in async_display_callbacks:
+        await async_display_callbacks['instruction'](message=message)
+    
+    console.print(Panel.fit(Text(message, style="bold blue"), title="Instruction", border_style="cyan"))
+
+async def adisplay_tool_call(message: str, console=None):
+    """Async version of display_tool_call."""
+    if not message or not message.strip():
+        return
+    if console is None:
+        console = Console()
+    message = _clean_display_content(str(message))
+    
+    if 'tool_call' in async_display_callbacks:
+        await async_display_callbacks['tool_call'](message=message)
+    
+    console.print(Panel.fit(Text(message, style="bold cyan"), title="Tool Call", border_style="green"))
+
+async def adisplay_error(message: str, console=None):
+    """Async version of display_error."""
+    if not message or not message.strip():
+        return
+    if console is None:
+        console = Console()
+    message = _clean_display_content(str(message))
+    
+    if 'error' in async_display_callbacks:
+        await async_display_callbacks['error'](message=message)
+    
+    console.print(Panel.fit(Text(message, style="bold red"), title="Error", border_style="red"))
+    error_logs.append(message)
+
+async def adisplay_generating(content: str = "", start_time: Optional[float] = None):
+    """Async version of display_generating."""
+    if not content or not str(content).strip():
+        return Panel("", title="", border_style="green")
+    
+    elapsed_str = ""
+    if start_time is not None:
+        elapsed = time.time() - start_time
+        elapsed_str = f" {elapsed:.1f}s"
+    
+    content = _clean_display_content(str(content))
+    
+    if 'generating' in async_display_callbacks:
+        await async_display_callbacks['generating'](
             content=content,
             elapsed_time=elapsed_str.strip() if elapsed_str else None
         )

agents/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "praisonaiagents"
-version = "0.0.18"
+version = "0.0.20"
 description = "Praison AI agents for completing complex tasks with Self Reflection Agents"
 authors = [
     { name="Mervin Praison" }

agents/uv.lock

@@ -186,7 +186,7 @@ wheels = [
 
 [[package]]
 name = "praisonaiagents"
-version = "0.0.18"
+version = "0.0.20"
 source = { editable = "." }
 dependencies = [
     { name = "openai" },

chainlit.md

@@ -1 +0,0 @@
-# Welcome to Praison AI! 🚀🤖

docs/api/praisonai/deploy.html

@@ -110,7 +110,7 @@ Loads environment variables from .env file or system and sets them.</p>
             file.write(&#34;FROM python:3.11-slim\n&#34;)
             file.write(&#34;WORKDIR /app\n&#34;)
             file.write(&#34;COPY . .\n&#34;)
-            file.write(&#34;RUN pip install flask praisonai==2.0.24 gunicorn markdown\n&#34;)
+            file.write(&#34;RUN pip install flask praisonai==2.0.28 gunicorn markdown\n&#34;)
             file.write(&#34;EXPOSE 8080\n&#34;)
             file.write(&#39;CMD [&#34;gunicorn&#34;, &#34;-b&#34;, &#34;0.0.0.0:8080&#34;, &#34;api:app&#34;]\n&#39;)
             

docs/features/callbacks.mdx

@@ -40,8 +40,17 @@ icon: "bell"
         print(f"Received message: {message}")
         print(f"Got response: {response}")
     
-    # Register the callback
-    register_display_callback('interaction', simple_callback)
+    # Register as synchronous callback
+    register_display_callback('interaction', simple_callback, is_async=False)
+
+    # For async callbacks
+    async def async_simple_callback(message=None, response=None, **kwargs):
+        await asyncio.sleep(0)  # Non-blocking pause
+        print(f"Received message: {message}")
+        print(f"Got response: {response}")
+    
+    # Register as async callback
+    register_display_callback('interaction', async_simple_callback, is_async=True)
     ```
   </Step>
 
@@ -75,6 +84,10 @@ icon: "bell"
   </Step>
 </Steps>
 
+<Note>
+  PraisonAI Agents supports both synchronous and asynchronous callbacks. When registering a callback, specify `is_async=True` for async callbacks. Both sync and async callbacks for the same display type can be executed simultaneously.
+</Note>
+
 ## Understanding Callbacks
 
 <Card title="What are Callbacks?" icon="question">
@@ -124,8 +137,16 @@ logging.basicConfig(level=logging.INFO)
 def log_callback(message=None, **kwargs):
     logging.info(f"Agent message: {message}")
 
-# Register callback
-register_display_callback('interaction', log_callback)
+# Register synchronous callback
+register_display_callback('interaction', log_callback, is_async=False)
+
+# Register asynchronous callback
+async def async_log_callback(message=None, **kwargs):
+    await asyncio.sleep(0)
+    logging.info(f"Agent message: {message}")
+
+# Register as async callback
+register_display_callback('interaction', async_log_callback, is_async=True)
 ```
 
 ```python Advanced
@@ -475,8 +496,260 @@ def main():
 if __name__ == "__main__":
     main()
 
+## Async Callbacks
+
+Async callbacks allow you to handle events asynchronously, which is particularly useful for long-running operations or when dealing with multiple agents simultaneously.
+
+### Basic Async Callback Implementation
+
+```python
+import asyncio
+from praisonaiagents import register_display_callback
+
+async def async_interaction_callback(message=None, response=None, **kwargs):
+    """Async callback for handling interactions"""
+    await asyncio.sleep(0)  # Non-blocking pause
+    print(f"Async processing - Message: {message}")
+    print(f"Response: {response}")
+
+# Register the async callback
+register_display_callback('interaction', async_interaction_callback)
 ```
 
+### Complete Async Example
+
+```python
+import asyncio
+from praisonaiagents import Agent, Task, PraisonAIAgents, register_display_callback
+import logging
+from datetime import datetime
+
+# Setup async logging
+async def setup_async_logging():
+    logging.basicConfig(
+        filename='async_ai_interactions.log',
+        level=logging.INFO,
+        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    )
+
+# Async callbacks
+async def async_interaction_callback(message=None, response=None, markdown=None, generation_time=None):
+    await asyncio.sleep(0)
+    logging.info(f"""
+    === ASYNC INTERACTION ===
+    Time: {datetime.now()}
+    Generation Time: {generation_time}s
+    Message: {message}
+    Response: {response}
+    """)
+
+async def async_error_callback(message=None):
+    await asyncio.sleep(0)
+    logging.error(f"""
+    === ASYNC ERROR ===
+    Time: {datetime.now()}
+    Message: {message}
+    """)
+
+# Register async callbacks
+register_display_callback('interaction', async_interaction_callback, is_async=True)
+register_display_callback('error', async_error_callback, is_async=True)
+
+# Create async task callback
+async def async_task_callback(output):
+    await asyncio.sleep(0)
+    logging.info(f"""
+    === ASYNC TASK COMPLETED ===
+    Time: {datetime.now()}
+    Description: {output.description}
+    Agent: {output.agent}
+    Output: {output.raw[:200]}...
+    """)
+
+async def main():
+    await setup_async_logging()
+    
+    # Create agent with async capabilities
+    agent = Agent(
+        name="AsyncAgent",
+        role="Assistant",
+        goal="Demonstrate async callbacks",
+        backstory="I am an async-capable assistant",
+        verbose=True
+    )
+
+    # Create task with async callback
+    task = Task(
+        name="async_task",
+        description="Demonstrate async callbacks",
+        agent=agent,
+        expected_output="Async demonstration complete",
+        callback=async_task_callback
+    )
+
+    # Create and run agents with async support
+    agents = PraisonAIAgents(
+        agents=[agent],
+        tasks=[task],
+        verbose=True
+    )
+
+    await agents.start_async()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+### Available Async Functions
+
+PraisonAI Agents provides several async versions of display functions, prefixed with 'a'. Here's the complete list:
+
+<CardGroup cols={2}>
+  <Card title="adisplay_interaction" icon="comments">
+    ```python
+    async def adisplay_interaction(
+        message, 
+        response, 
+        markdown=True, 
+        generation_time=None, 
+        console=None
+    )
+    ```
+    Async version of display_interaction for showing conversations.
+  </Card>
+  
+  <Card title="adisplay_self_reflection" icon="brain">
+    ```python
+    async def adisplay_self_reflection(
+        message: str, 
+        console=None
+    )
+    ```
+    Async version for displaying agent's self-reflection moments.
+  </Card>
+
+  <Card title="adisplay_instruction" icon="list-check">
+    ```python
+    async def adisplay_instruction(
+        message: str, 
+        console=None
+    )
+    ```
+    Async version for showing instructions.
+  </Card>
+
+  <Card title="adisplay_tool_call" icon="wrench">
+    ```python
+    async def adisplay_tool_call(
+        message: str, 
+        console=None
+    )
+    ```
+    Async version for displaying tool calls.
+  </Card>
+
+  <Card title="adisplay_error" icon="triangle-exclamation">
+    ```python
+    async def adisplay_error(
+        message: str, 
+        console=None
+    )
+    ```
+    Async version for error messages.
+  </Card>
+
+  <Card title="adisplay_generating" icon="spinner">
+    ```python
+    async def adisplay_generating(
+        content: str = "", 
+        start_time: Optional[float] = None
+    )
+    ```
+    Async version for showing generation progress.
+  </Card>
+</CardGroup>
+
+#### Example Usage
+
+```python
+import asyncio
+from praisonaiagents import (
+    adisplay_interaction,
+    adisplay_error,
+    adisplay_tool_call
+)
+
+async def main():
+    # Display an interaction
+    await adisplay_interaction(
+        message="What's the weather?",
+        response="Let me check that for you.",
+        generation_time=0.5
+    )
+
+    # Display a tool call
+    await adisplay_tool_call(
+        "Calling weather API for location data..."
+    )
+
+    # Handle an error
+    try:
+        raise Exception("API connection failed")
+    except Exception as e:
+        await adisplay_error(str(e))
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+### Best Practices for Async Callbacks
+
+<AccordionGroup>
+  <Accordion title="Error Handling">
+    Implement proper error handling in async callbacks:
+    ```python
+    async def safe_async_callback(message=None, **kwargs):
+        try:
+            await asyncio.sleep(0)
+            # Process the callback
+            await process_message(message)
+        except Exception as e:
+            logging.error(f"Async callback error: {e}")
+    ```
+  </Accordion>
+
+  <Accordion title="Performance">
+    Optimize async callbacks for better performance:
+    ```python
+    async def optimized_async_callback(message=None, **kwargs):
+        # Use asyncio.gather for concurrent operations
+        results = await asyncio.gather(
+            process_message(message),
+            update_status(),
+            log_interaction(message)
+        )
+        return results
+    ```
+  </Accordion>
+</AccordionGroup>
+
+### Key Considerations
+
+<CardGroup cols={2}>
+  <Card title="Concurrency" icon="arrows-split-up-and-left">
+    - Use asyncio.gather for parallel operations
+    - Avoid blocking calls in async callbacks
+    - Handle concurrent access to shared resources
+  </Card>
+  <Card title="Resource Management" icon="server">
+    - Implement proper cleanup in async contexts
+    - Use async context managers when appropriate
+    - Monitor memory usage in long-running callbacks
+  </Card>
+</CardGroup>
+
+<Note>
+  When using async callbacks, ensure all dependent operations are also async-compatible to prevent blocking the event loop.
+</Note>
 
 ## Troubleshooting
 

praisonai.rb

@@ -3,7 +3,7 @@ class Praisonai < Formula
   
     desc "AI tools for various AI applications"
     homepage "https://github.com/MervinPraison/PraisonAI"
-    url "https://github.com/MervinPraison/PraisonAI/archive/refs/tags/2.0.24.tar.gz"
+    url "https://github.com/MervinPraison/PraisonAI/archive/refs/tags/2.0.28.tar.gz"
     sha256 "1828fb9227d10f991522c3f24f061943a254b667196b40b1a3e4a54a8d30ce32"  # Replace with actual SHA256 checksum
     license "MIT"
   

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

praisonai/ui/callbacks.py

@@ -0,0 +1,57 @@
+import logging
+from typing import Dict, Any, Callable, Optional, Union
+import asyncio
+
+logger = logging.getLogger(__name__)
+
+class CallbackManager:
+    """Manages callbacks for the PraisonAI UI"""
+    
+    def __init__(self):
+        self._callbacks: Dict[str, Dict[str, Union[Callable, bool]]] = {}
+    
+    def register(self, name: str, callback: Callable, is_async: bool = False) -> None:
+        """Register a callback function"""
+        self._callbacks[name] = {
+            'func': callback,
+            'is_async': is_async
+        }
+    
+    async def call(self, name: str, **kwargs) -> None:
+        """Call a registered callback"""
+        if name not in self._callbacks:
+            logger.warning(f"No callback registered for {name}")
+            return
+            
+        callback_info = self._callbacks[name]
+        func = callback_info['func']
+        is_async = callback_info['is_async']
+        
+        try:
+            if is_async:
+                await func(**kwargs)
+            else:
+                if asyncio.iscoroutinefunction(func):
+                    await func(**kwargs)
+                else:
+                    await asyncio.get_event_loop().run_in_executor(None, lambda: func(**kwargs))
+        except Exception as e:
+            logger.error(f"Error in callback {name}: {str(e)}")
+
+# Global callback manager instance
+callback_manager = CallbackManager()
+
+def register_callback(name: str, callback: Callable, is_async: bool = False) -> None:
+    """Register a callback with the global callback manager"""
+    callback_manager.register(name, callback, is_async)
+
+async def trigger_callback(name: str, **kwargs) -> None:
+    """Trigger a callback from the global callback manager"""
+    await callback_manager.call(name, **kwargs)
+
+# Decorator for registering callbacks
+def callback(name: str, is_async: bool = False):
+    def decorator(func):
+        register_callback(name, func, is_async)
+        return func
+    return decorator 

praisonai/ui/colab.py

@@ -0,0 +1,474 @@
+from praisonaiagents import Agent, Task, PraisonAIAgents
+import os
+import importlib
+import inspect
+import yaml
+import logging
+from .callbacks import trigger_callback
+import asyncio
+import chainlit as cl
+from queue import Queue
+
+logger = logging.getLogger(__name__)
+agent_file = "agents.yaml"
+
+with open(agent_file, 'r') as f:
+    config = yaml.safe_load(f)
+
+topic = "get from the message content from the chainlit user message"
+
+# Create a message queue
+message_queue = Queue()
+
+async def process_message_queue():
+    """Process messages in the queue and send them to Chainlit"""
+    while True:
+        try:
+            if not message_queue.empty():
+                msg_data = message_queue.get()
+                await cl.Message(**msg_data).send()
+            await asyncio.sleep(0.1)  # Small delay to prevent busy waiting
+        except Exception as e:
+            logger.error(f"Error processing message queue: {e}")
+
+def load_tools_from_tools_py():
+    """
+    Imports and returns all contents from tools.py file.
+    Also adds the tools to the global namespace.
+
+    Returns:
+        list: A list of callable functions with proper formatting
+    """
+    tools_list = []
+    try:
+        # Try to import tools.py from current directory
+        spec = importlib.util.spec_from_file_location("tools", "tools.py")
+        logger.info(f"Spec: {spec}")
+        if spec is None:
+            logger.info("tools.py not found in current directory")
+            return tools_list
+
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+
+        # Get all module attributes except private ones and classes
+        for name, obj in inspect.getmembers(module):
+            if (not name.startswith('_') and 
+                callable(obj) and 
+                not inspect.isclass(obj)):
+                # Add the function to global namespace
+                globals()[name] = obj
+                # Format the tool as an OpenAI function
+                tool = {
+                    "type": "function",
+                    "function": {
+                        "name": name,
+                        "description": obj.__doc__ or f"Function to {name.replace('_', ' ')}",
+                        "parameters": {
+                            "type": "object",
+                            "properties": {
+                                "query": {
+                                    "type": "string",
+                                    "description": "The search query to look up information about"
+                                }
+                            },
+                            "required": ["query"]
+                        }
+                    }
+                }
+                # Add formatted tool to tools list
+                tools_list.append(tool)
+                logger.info(f"Loaded and globalized tool function: {name}")
+
+        logger.info(f"Loaded {len(tools_list)} tool functions from tools.py")
+        logger.info(f"Tools list: {tools_list}")
+        
+    except Exception as e:
+        logger.warning(f"Error loading tools from tools.py: {e}")
+        
+    return tools_list
+
+async def step_callback(step_details):
+    """Callback for agent steps"""
+    logger.info(f"[CALLBACK DEBUG] Step callback triggered with details: {step_details}")
+    try:
+        # Queue message for agent response
+        if step_details.get("response"):
+            message_queue.put({
+                "content": f"Agent Response: {step_details.get('response')}",
+                "author": step_details.get("agent_name", "Agent")
+            })
+            logger.info("[CALLBACK DEBUG] Queued agent response message")
+        
+        # Queue message for tool usage
+        if step_details.get("tool_name"):
+            message_queue.put({
+                "content": f"🛠️ Using tool: {step_details.get('tool_name')}",
+                "author": "System"
+            })
+            logger.info("[CALLBACK DEBUG] Queued tool usage message")
+            
+    except Exception as e:
+        logger.error(f"[CALLBACK DEBUG] Error in step callback: {str(e)}", exc_info=True)
+
+async def task_callback(task_output):
+    """Callback for task completion"""
+    logger.info(f"[CALLBACK DEBUG] Task callback triggered with output: {task_output}")
+    try:
+        # Create message content
+        if hasattr(task_output, 'raw'):
+            content = task_output.raw
+        elif hasattr(task_output, 'content'):
+            content = task_output.content
+        else:
+            content = str(task_output)
+            
+        # Queue the message
+        message_queue.put({
+            "content": f"Task Output: {content}",
+            "author": "Task"
+        })
+        logger.info("[CALLBACK DEBUG] Queued task completion message")
+        
+    except Exception as e:
+        logger.error(f"[CALLBACK DEBUG] Error in task callback: {str(e)}", exc_info=True)
+
+async def step_callback_wrapper(step_details):
+    logger.info(f"[CALLBACK DEBUG] Step callback wrapper triggered with details: {step_details}")
+    try:
+        # Check if we have a Chainlit context
+        if not cl.context.context_var.get():
+            logger.warning("[CALLBACK DEBUG] No Chainlit context available in wrapper")
+            return
+        logger.info("[CALLBACK DEBUG] Chainlit context found in wrapper")
+
+        # Create a message for the agent's response
+        if step_details.get("response"):
+            logger.info(f"[CALLBACK DEBUG] Sending agent response from wrapper: {step_details.get('response')}")
+            try:
+                await cl.Message(
+                    content=f"{role_name}: {step_details.get('response')}",
+                    author=role_name,
+                ).send()
+                logger.info("[CALLBACK DEBUG] Successfully sent agent response message from wrapper")
+            except Exception as e:
+                logger.error(f"[CALLBACK DEBUG] Error sending agent response message from wrapper: {str(e)}")
+
+        # Create a message for any tool usage
+        if step_details.get("tool_name"):
+            logger.info(f"[CALLBACK DEBUG] Sending tool usage from wrapper: {step_details.get('tool_name')}")
+            try:
+                await cl.Message(
+                    content=f"🛠️ {role_name} is using tool: {step_details.get('tool_name')}",
+                    author="System",
+                ).send()
+                logger.info("[CALLBACK DEBUG] Successfully sent tool usage message from wrapper")
+            except Exception as e:
+                logger.error(f"[CALLBACK DEBUG] Error sending tool usage message from wrapper: {str(e)}")
+
+        # Create a message for any thoughts or reasoning
+        if step_details.get("thought"):
+            logger.info(f"[CALLBACK DEBUG] Sending thought from wrapper: {step_details.get('thought')}")
+            try:
+                await cl.Message(
+                    content=f"💭 {role_name}'s thought: {step_details.get('thought')}",
+                    author=role_name,
+                ).send()
+                logger.info("[CALLBACK DEBUG] Successfully sent thought message from wrapper")
+            except Exception as e:
+                logger.error(f"[CALLBACK DEBUG] Error sending thought message from wrapper: {str(e)}")
+
+    except Exception as e:
+        logger.error(f"[CALLBACK DEBUG] Error in step callback wrapper: {str(e)}", exc_info=True)
+        try:
+            await cl.Message(
+                content=f"Error in step callback: {str(e)}",
+                author="System",
+            ).send()
+        except Exception as send_error:
+            logger.error(f"[CALLBACK DEBUG] Error sending error message: {str(send_error)}")
+
+async def task_callback_wrapper(task_output):
+    logger.info(f"[CALLBACK DEBUG] Task callback wrapper triggered with output type: {type(task_output)}")
+    try:
+        # Check if we have a Chainlit context
+        if not cl.context.context_var.get():
+            logger.warning("[CALLBACK DEBUG] No Chainlit context available in task wrapper")
+            return
+        logger.info("[CALLBACK DEBUG] Chainlit context found in task wrapper")
+
+        # Create a message for task completion
+        if hasattr(task_output, 'raw'):
+            content = task_output.raw
+            logger.info("[CALLBACK DEBUG] Using raw output")
+        elif hasattr(task_output, 'content'):
+            content = task_output.content
+            logger.info("[CALLBACK DEBUG] Using content output")
+        else:
+            content = str(task_output)
+            logger.info("[CALLBACK DEBUG] Using string representation of output")
+            
+        logger.info(f"[CALLBACK DEBUG] Sending task completion message from wrapper: {content[:100]}...")
+        try:
+            await cl.Message(
+                content=f"✅ {role_name} completed task:\n{content}",
+                author=role_name,
+            ).send()
+            logger.info("[CALLBACK DEBUG] Successfully sent task completion message from wrapper")
+        except Exception as e:
+            logger.error(f"[CALLBACK DEBUG] Error sending task completion message from wrapper: {str(e)}")
+
+        # If there are any additional task details
+        if hasattr(task_output, 'details'):
+            logger.info("[CALLBACK DEBUG] Task has additional details")
+            try:
+                await cl.Message(
+                    content=f"📝 Additional details:\n{task_output.details}",
+                    author=role_name,
+                ).send()
+                logger.info("[CALLBACK DEBUG] Successfully sent additional details message")
+            except Exception as e:
+                logger.error(f"[CALLBACK DEBUG] Error sending additional details message: {str(e)}")
+
+    except Exception as e:
+        logger.error(f"[CALLBACK DEBUG] Error in task callback wrapper: {str(e)}", exc_info=True)
+        try:
+            await cl.Message(
+                content=f"Error in task callback: {str(e)}",
+                author="System",
+            ).send()
+        except Exception as send_error:
+            logger.error(f"[CALLBACK DEBUG] Error sending error message: {str(send_error)}")
+
+def sync_task_callback_wrapper(task_output):
+    logger.info("[CALLBACK DEBUG] Sync task callback wrapper triggered")
+    try:
+        # Create a new event loop for this thread if there isn't one
+        try:
+            loop = asyncio.get_event_loop()
+            logger.info("[CALLBACK DEBUG] Got existing event loop")
+        except RuntimeError:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            logger.info("[CALLBACK DEBUG] Created new event loop")
+        
+        if loop.is_running():
+            # If loop is running, schedule the callback
+            logger.info("[CALLBACK DEBUG] Loop is running, scheduling callback")
+            asyncio.run_coroutine_threadsafe(
+                task_callback_wrapper(task_output),
+                loop
+            )
+        else:
+            # If loop is not running, run it directly
+            logger.info("[CALLBACK DEBUG] Loop is not running, running callback directly")
+            loop.run_until_complete(task_callback_wrapper(task_output))
+            
+    except Exception as e:
+        logger.error(f"[CALLBACK DEBUG] Error in sync task callback: {str(e)}", exc_info=True)
+
+def sync_step_callback_wrapper(step_details):
+    logger.info("[CALLBACK DEBUG] Sync step callback wrapper triggered")
+    try:
+        # Create a new event loop for this thread if there isn't one
+        try:
+            loop = asyncio.get_event_loop()
+            logger.info("[CALLBACK DEBUG] Got existing event loop")
+        except RuntimeError:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            logger.info("[CALLBACK DEBUG] Created new event loop")
+        
+        if loop.is_running():
+            # If loop is running, schedule the callback
+            logger.info("[CALLBACK DEBUG] Loop is running, scheduling callback")
+            asyncio.run_coroutine_threadsafe(
+                step_callback_wrapper(step_details),
+                loop
+            )
+        else:
+            # If loop is not running, run it directly
+            logger.info("[CALLBACK DEBUG] Loop is not running, running callback directly")
+            loop.run_until_complete(step_callback_wrapper(step_details))
+            
+    except Exception as e:
+        logger.error(f"[CALLBACK DEBUG] Error in sync step callback: {str(e)}", exc_info=True)
+
+async def ui_run_praisonai(config, topic, tools_dict):
+    """Run PraisonAI with the given configuration and topic."""
+    logger = logging.getLogger(__name__)
+    logger.setLevel(logging.DEBUG)
+    agents = {}
+    tasks = []
+    tasks_dict = {}
+
+    try:
+        # Start message queue processor
+        queue_processor = asyncio.create_task(process_message_queue())
+        
+        # Create agents for each role
+        for role, details in config['roles'].items():
+            # Format the role name and other details
+            role_name = details.get('name', role).format(topic=topic)
+            role_filled = details.get('role', role).format(topic=topic)
+            goal_filled = details['goal'].format(topic=topic)
+            backstory_filled = details['backstory'].format(topic=topic)
+
+            # Test message to verify Chainlit is working
+            await cl.Message(
+                content=f"[DEBUG] Creating agent: {role_name}",
+                author="System"
+            ).send()
+
+            # Create a sync wrapper for the step callback
+            def step_callback_sync(step_details):
+                try:
+                    # Create a new event loop for this thread
+                    loop = asyncio.new_event_loop()
+                    asyncio.set_event_loop(loop)
+                    
+                    # Add agent name to step details
+                    step_details["agent_name"] = role_name
+                    
+                    # Run the callback
+                    loop.run_until_complete(step_callback(step_details))
+                    loop.close()
+                except Exception as e:
+                    logger.error(f"[CALLBACK DEBUG] Error in step callback: {str(e)}", exc_info=True)
+
+            agent = Agent(
+                name=role_name,
+                role=role_filled,
+                goal=goal_filled,
+                backstory=backstory_filled,
+                llm=details.get('llm', 'gpt-4o'),
+                verbose=True,
+                allow_delegation=details.get('allow_delegation', False),
+                max_iter=details.get('max_iter', 15),
+                max_rpm=details.get('max_rpm'),
+                max_execution_time=details.get('max_execution_time'),
+                cache=details.get('cache', True),
+                step_callback=step_callback_sync
+            )
+            agents[role] = agent
+
+        # Create tasks for each role
+        for role, details in config['roles'].items():
+            agent = agents[role]
+            tools_list = []
+            
+            # Get tools for this role
+            for tool_name in details.get('tools', []):
+                if tool_name in tools_dict:
+                    tool_func = tools_dict[tool_name]
+                    tools_list.append(tool_func)
+
+            # Create tasks for the agent
+            for task_name, task_details in details.get('tasks', {}).items():
+                description_filled = task_details['description'].format(topic=topic)
+                expected_output_filled = task_details['expected_output'].format(topic=topic)
+
+                # Test message to verify task creation
+                await cl.Message(
+                    content=f"[DEBUG] Created task: {task_name} for agent {role_name}",
+                    author="System"
+                ).send()
+
+                # Create a sync wrapper for the task callback
+                def task_callback_sync(task_output):
+                    try:
+                        # Create a new event loop for this thread
+                        loop = asyncio.new_event_loop()
+                        asyncio.set_event_loop(loop)
+                        
+                        # Run the callback
+                        loop.run_until_complete(task_callback(task_output))
+                        loop.close()
+                    except Exception as e:
+                        logger.error(f"[CALLBACK DEBUG] Error in task callback: {str(e)}", exc_info=True)
+
+                task = Task(
+                    description=description_filled,
+                    expected_output=expected_output_filled,
+                    agent=agent,
+                    tools=tools_list,
+                    async_execution=True,
+                    context=[],
+                    config=task_details.get('config', {}),
+                    output_json=task_details.get('output_json'),
+                    output_pydantic=task_details.get('output_pydantic'),
+                    output_file=task_details.get('output_file', ""),
+                    callback=task_callback_sync,
+                    create_directory=task_details.get('create_directory', False)
+                )
+
+                tasks.append(task)
+                tasks_dict[task_name] = task
+
+        # Set up task contexts
+        for role, details in config['roles'].items():
+            for task_name, task_details in details.get('tasks', {}).items():
+                task = tasks_dict[task_name]
+                context_tasks = [tasks_dict[ctx] for ctx in task_details.get('context', []) 
+                            if ctx in tasks_dict]
+                task.context = context_tasks
+
+        # Send the start message
+        await cl.Message(
+            content="Starting PraisonAI agents execution...",
+            author="System"
+        ).send()
+
+        # Create and run the PraisonAI agents
+        if config.get('process') == 'hierarchical':
+            crew = PraisonAIAgents(
+                agents=list(agents.values()),
+                tasks=tasks,
+                verbose=True,
+                process="hierarchical",
+                manager_llm=config.get('manager_llm', 'gpt-4o')
+            )
+        else:
+            crew = PraisonAIAgents(
+                agents=list(agents.values()),
+                tasks=tasks,
+                verbose=2
+            )
+
+        # Store the crew in the user session
+        cl.user_session.set("crew", crew)
+
+        # Run the agents in a separate thread
+        loop = asyncio.get_event_loop()
+        response = await loop.run_in_executor(None, crew.start)
+        
+        logger.debug(f"[CALLBACK DEBUG] Result: {response}")
+        
+        # Convert response to string if it's not already
+        if hasattr(response, 'raw'):
+            result = response.raw
+        elif hasattr(response, 'content'):
+            result = response.content
+        else:
+            result = str(response)
+        
+        # Send the completion message
+        await cl.Message(
+            content="PraisonAI agents execution completed.",
+            author="System"
+        ).send()
+        
+        # After getting the response, wait a bit for remaining messages
+        await asyncio.sleep(1)  # Give time for final messages to be processed
+        queue_processor.cancel()  # Stop the queue processor
+        
+        return result
+        
+    except Exception as e:
+        error_msg = f"Error in ui_run_praisonai: {str(e)}"
+        logger.error(error_msg, exc_info=True)
+        await cl.Message(
+            content=error_msg,
+            author="System"
+        ).send()
+        raise

praisonai/ui/colab_chainlit.py

@@ -0,0 +1,81 @@
+import os
+import logging
+from dotenv import load_dotenv
+import chainlit as cl
+from chainlit.types import ThreadDict
+import yaml
+import sys
+import os
+from datetime import datetime
+
+# Add the parent directory to sys.path to allow imports
+sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
+
+from praisonai.ui.colab import ui_run_praisonai, load_tools_from_tools_py
+from praisonai.ui.callbacks import callback, trigger_callback
+
+# Load environment variables
+load_dotenv()
+
+# Set up logging
+logger = logging.getLogger(__name__)
+log_level = os.getenv("LOGLEVEL", "INFO").upper()
+logger.setLevel(log_level)
+
+# Load agent configuration
+agent_file = "agents.yaml"
+with open(agent_file, 'r') as f:
+    config = yaml.safe_load(f)
+
+# Load tools
+tools_dict = load_tools_from_tools_py()
+
+@cl.on_message
+async def main(message: cl.Message):
+    """Main message handler for Chainlit"""
+    try:
+        logger.info(f"Processing message: {message.content}")
+        await cl.Message(
+            content=f"🔄 Processing your request about: {message.content}...",
+            author="System"
+        ).send()
+
+        await cl.Message(
+            content="Using Running PraisonAI Agents...",
+            author="System"
+        ).send()
+
+        # Run PraisonAI with the message content as the topic
+        result = await ui_run_praisonai(config, message.content, tools_dict)
+        
+        # Send the final result
+        await cl.Message(
+            content=result,
+            author="System"
+        ).send()
+
+    except Exception as e:
+        error_msg = f"Error running PraisonAI agents: {str(e)}"
+        logger.error(error_msg, exc_info=True)
+        await cl.Message(
+            content=error_msg,
+            author="System"
+        ).send()
+
+@cl.on_chat_start
+async def start():
+    """Handler for chat start"""
+    await cl.Message(
+        content="👋 Welcome! I'm your AI assistant. What would you like to work on?",
+        author="System"
+    ).send()
+
+# Authentication setup (optional)
+if os.getenv("CHAINLIT_AUTH_SECRET"):
+    @cl.password_auth_callback
+    def auth_callback(username: str, password: str) -> cl.User:
+        # Replace with your authentication logic
+        if username == os.getenv("CHAINLIT_USERNAME", "admin") and \
+           password == os.getenv("CHAINLIT_PASSWORD", "admin"):
+            return cl.User(identifier=username, metadata={"role": "user"})
+        return None 

praisonai/ui/config/chainlit.md

@@ -1 +1 @@
-# Welcome to Praison AI! 🚀🤖
+# Welcome to PraisonAI! 🚀

praisonai/ui/tools.md

@@ -0,0 +1,133 @@
+# Understanding Tool Integration in AI Agents - A Beginner's Guide
+
+## Overview
+This guide explains how to properly integrate tools (functions) that an AI agent can use, making them both understandable to the OpenAI API and executable by your code.
+
+## Key Components
+
+### 1. Tool Definition Structure
+```python
+# Example tool definition in tools.py
+def search_tool(query: str) -> list:
+    """
+    Perform a web search using DuckDuckGo.
+
+    Args:
+        query (str): The search query string.
+
+    Returns:
+        list: Search results with title, url, and snippet.
+    """
+    # Function implementation...
+```
+
+### 2. Tool Dictionary Format
+```python
+tools_dict = {
+    'search_tool': {
+        'type': 'function',
+        'function': {
+            'name': 'search_tool',
+            'description': '...', 
+            'parameters': {
+                'type': 'object',
+                'properties': {
+                    'query': {'type': 'string'}
+                }
+            }
+        },
+        'callable': search_tool  # The actual Python function
+    }
+}
+```
+
+## The Two-Part System
+
+### Part 1: OpenAI API Communication
+```python
+# task_tools: What OpenAI understands
+task_tools = []
+tool_def = tools_dict[tool_name].copy()
+callable_func = tool_def.pop("callable")  # Remove the Python function
+task_tools.append(tool_def)  # Add clean JSON-serializable definition
+```
+
+### Part 2: Function Execution
+```python
+# role_tools: What your code executes
+role_tools = []
+role_tools.append(callable_func)  # Store the actual function
+agent.tools = role_tools  # Give agent access to executable functions
+```
+
+## Putting It All Together
+
+```python
+# Initialize empty lists
+role_tools = []  # For executable functions
+task_tools = []  # For OpenAI API definitions
+
+# Process each tool
+for tool_name in tools_list:
+    if tool_name in tools_dict:
+        # 1. Get the tool definition
+        tool_def = tools_dict[tool_name].copy()
+        
+        # 2. Separate the callable function
+        callable_func = tool_def.pop("callable")
+        
+        # 3. Store the function for execution
+        role_tools.append(callable_func)
+        
+        # 4. Store the API definition
+        task_tools.append(tool_def)
+        
+        # 5. Give agent access to functions
+        agent.tools = role_tools
+
+# Create task with API definitions
+task = Task(
+    description="...",
+    tools=task_tools,  # OpenAI API will use these
+    agent=agent,       # Agent has access to callable functions
+    # ... other parameters ...
+)
+```
+
+## Why This Works
+
+1. **API Communication**
+   - OpenAI API receives clean JSON tool definitions
+   - No Python functions that would cause serialization errors
+
+2. **Function Execution**
+   - Agent has access to actual Python functions
+   - Can execute tools when OpenAI decides to use them
+
+3. **Separation of Concerns**
+   - `task_tools`: Describes what tools can do (for OpenAI)
+   - `role_tools`: Actually does the work (for Python)
+
+## Common Errors and Solutions
+
+1. **"Invalid type for 'tools[0]'"**
+   - Cause: Sending null or invalid tool definition to OpenAI
+   - Solution: Use proper tool definition format in `task_tools`
+
+2. **"Object of type function is not JSON serializable"**
+   - Cause: Trying to send Python function to OpenAI API
+   - Solution: Remove callable function from API definition
+
+3. **"Tool is not callable"**
+   - Cause: Agent doesn't have access to executable functions
+   - Solution: Set `agent.tools = role_tools`
+
+## Best Practices
+
+1. Always initialize both `task_tools` and `role_tools` lists
+2. Make clean copies of tool definitions to avoid modifying originals
+3. Keep tool definitions JSON-serializable for API communication
+4. Ensure agents have access to callable functions
+5. Document tool parameters and return values clearly
+
+This structure maintains clean separation between API communication and actual function execution, making your AI agent system both reliable and maintainable.

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "PraisonAI"
-version = "2.0.24"
+version = "2.0.28"
 description = "PraisonAI is an AI Agents Framework with Self Reflection. PraisonAI application combines PraisonAI Agents, AutoGen, and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customisation, and efficient human–agent collaboration."
 readme = "README.md"
 license = ""
@@ -12,7 +12,7 @@ dependencies = [
     "rich>=13.7",
     "markdown>=3.5",
     "pyparsing>=3.0.0",
-    "praisonaiagents>=0.0.18",
+    "praisonaiagents>=0.0.20",
     "python-dotenv>=0.19.0",
     "instructor>=1.3.3",
     "PyYAML>=6.0",
@@ -84,7 +84,7 @@ autogen = ["pyautogen>=0.2.19", "praisonai-tools>=0.0.7", "crewai"]
 
 [tool.poetry]
 name = "PraisonAI"
-version = "2.0.24"
+version = "2.0.28"
 description = "PraisonAI is an AI Agents Framework with Self Reflection. PraisonAI application combines PraisonAI Agents, AutoGen, and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customisation, and efficient human–agent collaboration."
 authors = ["Mervin Praison"]
 license = ""
@@ -102,7 +102,7 @@ python = ">=3.10,<3.13"
 rich = ">=13.7"
 markdown = ">=3.5"
 pyparsing = ">=3.0.0"
-praisonaiagents = ">=0.0.18"
+praisonaiagents = ">=0.0.20"
 python-dotenv = ">=0.19.0"
 instructor = ">=1.3.3"
 PyYAML = ">=6.0"

uv.lock

@@ -3061,7 +3061,7 @@ wheels = [
 
 [[package]]
 name = "praisonai"
-version = "2.0.24"
+version = "2.0.28"
 source = { editable = "." }
 dependencies = [
     { name = "instructor" },
@@ -3198,7 +3198,7 @@ requires-dist = [
     { name = "plotly", marker = "extra == 'realtime'", specifier = ">=5.24.0" },
     { name = "praisonai-tools", marker = "extra == 'autogen'", specifier = ">=0.0.7" },
     { name = "praisonai-tools", marker = "extra == 'crewai'", specifier = ">=0.0.7" },
-    { name = "praisonaiagents", specifier = ">=0.0.18" },
+    { name = "praisonaiagents", specifier = ">=0.0.20" },
     { name = "pyautogen", marker = "extra == 'autogen'", specifier = ">=0.2.19" },
     { name = "pydantic", marker = "extra == 'chat'", specifier = "<=2.10.1" },
     { name = "pydantic", marker = "extra == 'code'", specifier = "<=2.10.1" },
@@ -3251,16 +3251,16 @@ wheels = [
 
 [[package]]
 name = "praisonaiagents"
-version = "0.0.18"
+version = "0.0.20"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "openai" },
     { name = "pydantic" },
     { name = "rich" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/09/e4/9bf056c4a9ecb5cf47766b9442b3b608881f530c4c28e233cbc6adb1f2d1/praisonaiagents-0.0.18.tar.gz", hash = "sha256:56744f82f806999fca328f9f9f8ae8b5c40cf312cf4fb6c0c34c30661f206d23", size = 23337 }
+sdist = { url = "https://files.pythonhosted.org/packages/8e/89/0e9d17b7113772ab469f3d113af51fb3ff5c2f16eb0a1b70667a12478358/praisonaiagents-0.0.20.tar.gz", hash = "sha256:15e08f2c8c06643e091870ba0f15c1614f6052dea45986c877dad52e8fe7f06e", size = 23885 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/78/b8/abfccfc0e82832721987b9c58d703f163a5573c5615ae5b5f3609f8877a0/praisonaiagents-0.0.18-py3-none-any.whl", hash = "sha256:fa9374f065ade18535ce05e27d2bb1ca326810ed6bbec5421597526f31add792", size = 29334 },
+    { url = "https://files.pythonhosted.org/packages/f8/94/5f62ded3aad4ee5d879e8b9712be4a3268abc2d89f71b10999109cef147c/praisonaiagents-0.0.20-py3-none-any.whl", hash = "sha256:3e9c62f3c4d8978bea8e0c95359a49e20db833511e17e122ccc06eb77996a618", size = 29883 },
 ]
 
 [[package]]