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.26 gunicorn markdown
+RUN pip install flask praisonai==2.0.28 gunicorn markdown
 EXPOSE 8080
 CMD ["gunicorn", "-b", "0.0.0.0:8080", "api:app"]

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.26 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;)
             

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.26.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.26 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/agents.py

@@ -5,6 +5,8 @@ import yaml
 import logging
 import inspect
 import chainlit as cl
+from praisonaiagents import Agent, Task, PraisonAIAgents, register_display_callback
+
 framework = "praisonai"
 config_list = [
     {
@@ -14,12 +16,19 @@ config_list = [
     }
 ]
 
-agent_file = "test.yaml"
-
-actions=[
+actions = [
     cl.Action(name="run", value="run", label="✅ Run"),
     cl.Action(name="modify", value="modify", label="🔧 Modify"),
 ]
+
+@cl.action_callback("run")
+async def on_run(action):
+    await main(cl.Message(content=""))
+
+@cl.action_callback("modify")
+async def on_modify(action):
+    await cl.Message(content="Modify the agents and tools from below settings").send()
+
 import os
 import sys
 import yaml
@@ -37,9 +46,6 @@ import chainlit as cl
 from chainlit.types import ThreadDict
 import chainlit.data as cl_data
 
-# External imports from your local packages (adjust if needed)
-from praisonaiagents import Agent, Task, PraisonAIAgents
-
 # -----------------------------------------------------------------------------
 # Global Setup
 # -----------------------------------------------------------------------------
@@ -53,14 +59,12 @@ message_queue = Queue()  # Queue to handle messages sent to Chainlit UI
 agent_file = "agents.yaml"
 
 # -----------------------------------------------------------------------------
-# Database and Settings Logic (untouched logic with minimal additions for Chainlit)
+# Database and Settings Logic
 # -----------------------------------------------------------------------------
 
 MAX_RETRIES = 3
 RETRY_DELAY = 1  # seconds
 
-# Original DatabaseManager from chainlit_ui.py, unmodified logic, plus minimal
-# placeholder methods for Chainlit's data layer calls (create_user, get_user, etc.)
 from db import DatabaseManager
 
 async def init_database_with_retry():
@@ -118,7 +122,7 @@ async def update_thread_metadata(thread_id: str, metadata: dict):
             raise
 
 # -----------------------------------------------------------------------------
-# Callback Manager (untouched from colab_combined.py)
+# Callback Manager
 # -----------------------------------------------------------------------------
 
 class CallbackManager:
@@ -161,7 +165,50 @@ def callback(name: str, is_async: bool = False):
     return decorator
 
 # -----------------------------------------------------------------------------
-# Tools Loader (untouched logic but returning dict for tools)
+# ADDITIONAL CALLBACKS
+# -----------------------------------------------------------------------------
+def interaction_callback(message=None, response=None, **kwargs):
+    logger.debug(f"[CALLBACK: interaction] Message: {message} | Response: {response}")
+    message_queue.put({
+        "content": f"[CALLBACK: interaction] Message: {message} | Response: {response}",
+        "author": "Callback"
+    })
+
+def error_callback(message=None, **kwargs):
+    logger.error(f"[CALLBACK: error] Message: {message}")
+    message_queue.put({
+        "content": f"[CALLBACK: error] Message: {message}",
+        "author": "Callback"
+    })
+
+def tool_call_callback(message=None, **kwargs):
+    logger.debug(f"[CALLBACK: tool_call] Tool used: {message}")
+    message_queue.put({
+        "content": f"[CALLBACK: tool_call] Tool used: {message}",
+        "author": "Callback"
+    })
+
+def instruction_callback(message=None, **kwargs):
+    logger.debug(f"[CALLBACK: instruction] Instruction: {message}")
+    message_queue.put({
+        "content": f"[CALLBACK: instruction] Instruction: {message}",
+        "author": "Callback"
+    })
+
+def self_reflection_callback(message=None, **kwargs):
+    logger.debug(f"[CALLBACK: self_reflection] Reflection: {message}")
+    message_queue.put({
+        "content": f"[CALLBACK: self_reflection] Reflection: {message}",
+        "author": "Callback"
+    })
+
+register_display_callback('error', error_callback)
+register_display_callback('tool_call', tool_call_callback)
+register_display_callback('instruction', instruction_callback)
+register_display_callback('self_reflection', self_reflection_callback)
+
+# -----------------------------------------------------------------------------
+# Tools Loader
 # -----------------------------------------------------------------------------
 
 def load_tools_from_tools_py():
@@ -172,7 +219,6 @@ def load_tools_from_tools_py():
     tools_dict = {}
     try:
         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_dict
@@ -182,7 +228,10 @@ def load_tools_from_tools_py():
 
         for name, obj in inspect.getmembers(module):
             if not name.startswith('_') and callable(obj) and not inspect.isclass(obj):
+                # Store the function in globals
                 globals()[name] = obj
+
+                # Build the function definition
                 tool_def = {
                     "type": "function",
                     "function": {
@@ -190,16 +239,14 @@ def load_tools_from_tools_py():
                         "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"]
+                            "properties": {},
+                            "required": []
                         }
-                    }
+                    },
+                    # Keep the actual callable as well
+                    "callable": obj,
                 }
+
                 tools_dict[name] = tool_def
                 logger.info(f"Loaded and globalized tool function: {name}")
 
@@ -209,7 +256,7 @@ def load_tools_from_tools_py():
     return tools_dict
 
 # -----------------------------------------------------------------------------
-# Async Queue Processor (untouched logic)
+# Async Queue Processor
 # -----------------------------------------------------------------------------
 
 async def process_message_queue():
@@ -223,7 +270,7 @@ async def process_message_queue():
             logger.error(f"Error processing message queue: {e}")
 
 # -----------------------------------------------------------------------------
-# Step & Task Callbacks (Async & Sync) (untouched logic)
+# Step & Task Callbacks
 # -----------------------------------------------------------------------------
 
 async def step_callback(step_details):
@@ -351,9 +398,8 @@ def sync_step_callback_wrapper(step_details):
         logger.error(f"Error in sync_step_callback_wrapper: {e}", exc_info=True)
 
 # -----------------------------------------------------------------------------
-# Main PraisonAI Runner (untouched logic)
+# Main PraisonAI Runner
 # -----------------------------------------------------------------------------
-
 async def ui_run_praisonai(config, topic, tools_dict):
     logger.info("Starting ui_run_praisonai")
     agents_map = {}
@@ -370,8 +416,6 @@ async def ui_run_praisonai(config, topic, tools_dict):
             goal_filled = details['goal'].format(topic=topic)
             backstory_filled = details['backstory'].format(topic=topic)
 
-            await cl.Message(content=f"[DEBUG] Creating agent: {role_name}", author="System").send()
-
             def step_callback_sync(step_details):
                 step_details["agent_name"] = role_name
                 try:
@@ -394,7 +438,8 @@ async def ui_run_praisonai(config, topic, tools_dict):
                 max_rpm=details.get('max_rpm'),
                 max_execution_time=details.get('max_execution_time'),
                 cache=details.get('cache', True),
-                step_callback=step_callback_sync
+                step_callback=step_callback_sync,
+                self_reflect=details.get('self_reflect', False)
             )
             agents_map[role] = agent
 
@@ -402,17 +447,35 @@ async def ui_run_praisonai(config, topic, tools_dict):
         for role, details in config['roles'].items():
             agent = agents_map[role]
             role_name = agent.name
+
+            # -------------------------------------------------------------
+            # FIX: Skip empty or invalid tool names to avoid null tool objects
+            # -------------------------------------------------------------
             role_tools = []
+            task_tools = []  # Initialize task_tools outside the loop
+            
             for tool_name in details.get('tools', []):
+                if not tool_name or not tool_name.strip():
+                    logger.warning("Skipping empty tool name.")
+                    continue
                 if tool_name in tools_dict:
-                    role_tools.append(tools_dict[tool_name])
+                    # Create a copy of the tool definition
+                    tool_def = tools_dict[tool_name].copy()
+                    # Store the callable separately and remove from definition
+                    callable_func = tool_def.pop("callable")
+                    # Add callable to role_tools for task execution
+                    role_tools.append(callable_func)
+                    # Add API tool definition to task's tools
+                    task_tools.append(tool_def)
+                    # Also set the agent's tools to include both
+                    agent.tools = role_tools
+                else:
+                    logger.warning(f"Tool '{tool_name}' not found. Skipping.")
 
             for tname, tdetails in details.get('tasks', {}).items():
                 description_filled = tdetails['description'].format(topic=topic)
                 expected_output_filled = tdetails['expected_output'].format(topic=topic)
 
-                await cl.Message(content=f"[DEBUG] Created task: {tname} for {role_name}", author="System").send()
-
                 def task_callback_sync(task_output):
                     try:
                         loop_ = asyncio.new_event_loop()
@@ -426,7 +489,7 @@ async def ui_run_praisonai(config, topic, tools_dict):
                     description=description_filled,
                     expected_output=expected_output_filled,
                     agent=agent,
-                    tools=role_tools,
+                    tools=task_tools,  # Pass API tool definitions
                     async_execution=True,
                     context=[],
                     config=tdetails.get('config', {}),
@@ -454,6 +517,7 @@ async def ui_run_praisonai(config, topic, tools_dict):
 
         await cl.Message(content="Starting PraisonAI agents execution...", author="System").send()
 
+        # Decide how to process tasks
         if config.get('process') == 'hierarchical':
             prai_agents = PraisonAIAgents(
                 agents=list(agents_map.values()),
@@ -493,10 +557,11 @@ async def ui_run_praisonai(config, topic, tools_dict):
         raise
 
 # -----------------------------------------------------------------------------
-# Chainlit Handlers + logic from chainlit_ui.py (no changes in logic)
+# Chainlit Handlers + logic
 # -----------------------------------------------------------------------------
 
 tools_dict = load_tools_from_tools_py()
+print(f"[DEBUG] tools_dict: {tools_dict}")
 
 # Load agent config (default) from 'agents.yaml'
 with open(agent_file, 'r') as f:
@@ -520,9 +585,6 @@ if AUTH_PASSWORD_ENABLED:
 
 @cl.set_chat_profiles
 async def set_profiles(current_user: cl.User):
-    """
-    Keep all the same starter logic from chainlit_ui.py.
-    """
     return [
         cl.ChatProfile(
             name="Auto",
@@ -577,7 +639,6 @@ async def set_profiles(current_user: cl.User):
 @cl.on_chat_start
 async def start_chat():
     try:
-        # Load model name from database
         model_name = load_setting("model_name") or os.getenv("MODEL_NAME", "gpt-4o-mini")
         cl.user_session.set("model_name", model_name)
         logger.debug(f"Model name: {model_name}")
@@ -587,16 +648,19 @@ async def start_chat():
             [{"role": "system", "content": "You are a helpful assistant."}],
         )
         
-        # Create tools.py if it doesn't exist
         if not os.path.exists("tools.py"):
             with open("tools.py", "w") as f:
                 f.write("# Add your custom tools here\n")
         
+        if not os.path.exists("agents.yaml"):
+            with open("agents.yaml", "w") as f:
+                f.write("# Add your custom agents here\n")
+        
         settings = await cl.ChatSettings(
             [
                 TextInput(id="Model", label="OpenAI - Model", initial=model_name),
                 TextInput(id="BaseUrl", label="OpenAI - Base URL", initial=config_list[0]['base_url']),
-                TextInput(id="ApiKey", label="OpenAI - API Key", initial=config_list[0]['api_key']), 
+                TextInput(id="ApiKey", label="OpenAI - API Key", initial=config_list[0]['api_key']),
                 Select(
                     id="Framework",
                     label="Framework",
@@ -608,7 +672,7 @@ async def start_chat():
         cl.user_session.set("settings", settings)
         chat_profile = cl.user_session.get("chat_profile")
 
-        if chat_profile=="Manual":
+        if chat_profile == "Manual":
             agent_file = "agents.yaml"
             full_agent_file_path = os.path.abspath(agent_file)
             if os.path.exists(full_agent_file_path):
@@ -628,7 +692,7 @@ async def start_chat():
                 [
                     TextInput(id="Model", label="OpenAI - Model", initial=model_name),
                     TextInput(id="BaseUrl", label="OpenAI - Base URL", initial=config_list[0]['base_url']),
-                    TextInput(id="ApiKey", label="OpenAI - API Key", initial=config_list[0]['api_key']), 
+                    TextInput(id="ApiKey", label="OpenAI - API Key", initial=config_list[0]['api_key']),
                     Select(
                         id="Framework",
                         label="Framework",
@@ -655,13 +719,8 @@ async def start_chat():
         logger.error(f"Error in start_chat: {str(e)}")
         await cl.Message(content=f"An error occurred while starting the chat: {str(e)}").send()
 
-
 @cl.on_chat_resume
 async def on_chat_resume(thread: ThreadDict):
-    """
-    Logic from chainlit_ui.py for chat resume:
-    - Restore message history from thread steps
-    """
     try:
         message_history = cl.user_session.get("message_history", [])
         root_messages = [m for m in thread["steps"] if m["parentId"] is None]
@@ -676,27 +735,19 @@ async def on_chat_resume(thread: ThreadDict):
 
 @cl.on_message
 async def main(message: cl.Message):
-    """
-    Merged logic from colab_combined.py and chainlit_ui.py for main message:
-    - Use existing ui_run_praisonai to process user message with PraisonAI
-    - Keep message history, no changes to logic
-    """
     try:
         logger.info(f"User message: {message.content}")
-        await cl.Message(
-            content=f"🔄 Processing your request: {message.content}...",
-            author="System"
-        ).send()
-
+        msg = cl.Message(content="")
+        await msg.stream_token(f"🔄 Processing your request: {message.content}...")
+        
         # Run PraisonAI
         result = await ui_run_praisonai(config, message.content, tools_dict)
 
-        # Update message history
         message_history = cl.user_session.get("message_history", [])
         message_history.append({"role": "user", "content": message.content})
         message_history.append({"role": "assistant", "content": str(result)})
         cl.user_session.set("message_history", message_history)
-
+        await msg.send()
     except Exception as e:
         error_msg = f"Error running PraisonAI agents: {str(e)}"
         logger.error(error_msg, exc_info=True)
@@ -704,14 +755,12 @@ async def main(message: cl.Message):
 
 @cl.on_settings_update
 async def on_settings_update(settings):
-    """Handle updates to the ChatSettings form."""
     try:
         global config_list, framework
         config_list[0]['model'] = settings["Model"]
         config_list[0]['base_url'] = settings["BaseUrl"]
         config_list[0]['api_key'] = settings["ApiKey"]
         
-        # Save settings to database with retry
         for attempt in range(MAX_RETRIES):
             try:
                 await save_setting_with_retry("model_name", config_list[0]['model'])
@@ -724,7 +773,6 @@ async def on_settings_update(settings):
                     continue
                 raise
         
-        # Save to environment variables for compatibility
         os.environ["OPENAI_API_KEY"] = config_list[0]['api_key']
         os.environ["OPENAI_MODEL_NAME"] = config_list[0]['model']
         os.environ["OPENAI_API_BASE"] = config_list[0]['base_url']
@@ -739,7 +787,6 @@ async def on_settings_update(settings):
             with open("tools.py", "w") as f:
                 f.write(settings["tools"])
         
-        # Update thread metadata if exists with retry
         thread_id = cl.user_session.get("thread_id")
         if thread_id:
             for attempt in range(MAX_RETRIES):
@@ -749,6 +796,7 @@ async def on_settings_update(settings):
                         metadata = thread.get("metadata", {})
                         if isinstance(metadata, str):
                             try:
+                                import json
                                 metadata = json.loads(metadata)
                             except json.JSONDecodeError:
                                 metadata = {}
@@ -766,10 +814,9 @@ async def on_settings_update(settings):
     except Exception as e:
         logger.error(f"Error updating settings: {str(e)}")
         await cl.Message(content=f"An error occurred while updating settings: {str(e)}. Retrying...").send()
-        # One final retry after a longer delay
         try:
             await asyncio.sleep(RETRY_DELAY * 2)
             await on_settings_update(settings)
         except Exception as e:
             logger.error(f"Final retry failed: {str(e)}")
-            await cl.Message(content=f"Failed to update settings after retries: {str(e)}").send()
+            await cl.Message(content=f"Failed to update settings after retries: {str(e)}").send()

praisonai/ui/together.py

@@ -1,775 +0,0 @@
-from chainlit.input_widget import Select, TextInput
-import os
-import sys
-import yaml
-import logging
-import inspect
-import chainlit as cl
-framework = "praisonai"
-config_list = [
-    {
-        'model': os.environ.get("OPENAI_MODEL_NAME", "gpt-4o"),
-        'base_url': os.environ.get("OPENAI_API_BASE", "https://api.openai.com/v1"),
-        'api_key': os.environ.get("OPENAI_API_KEY", "")
-    }
-]
-
-agent_file = "test.yaml"
-
-actions=[
-    cl.Action(name="run", value="run", label="✅ Run"),
-    cl.Action(name="modify", value="modify", label="🔧 Modify"),
-]
-import os
-import sys
-import yaml
-import logging
-import inspect
-import asyncio
-import importlib.util
-import sqlite3
-from queue import Queue
-from datetime import datetime
-from dotenv import load_dotenv
-
-# Chainlit imports
-import chainlit as cl
-from chainlit.types import ThreadDict
-import chainlit.data as cl_data
-
-# External imports from your local packages (adjust if needed)
-from praisonaiagents import Agent, Task, PraisonAIAgents
-
-# -----------------------------------------------------------------------------
-# Global Setup
-# -----------------------------------------------------------------------------
-
-load_dotenv()
-log_level = os.getenv("LOGLEVEL", "INFO").upper()
-logger = logging.getLogger(__name__)
-logger.setLevel(log_level)
-
-message_queue = Queue()  # Queue to handle messages sent to Chainlit UI
-agent_file = "agents.yaml"
-
-# -----------------------------------------------------------------------------
-# Database and Settings Logic (untouched logic with minimal additions for Chainlit)
-# -----------------------------------------------------------------------------
-
-MAX_RETRIES = 3
-RETRY_DELAY = 1  # seconds
-
-# Original DatabaseManager from chainlit_ui.py, unmodified logic, plus minimal
-# placeholder methods for Chainlit's data layer calls (create_user, get_user, etc.)
-from db import DatabaseManager
-
-async def init_database_with_retry():
-    db = DatabaseManager()
-    for attempt in range(MAX_RETRIES):
-        try:
-            db.initialize()
-            return db
-        except sqlite3.OperationalError as e:
-            if "database is locked" in str(e) and attempt < MAX_RETRIES - 1:
-                await asyncio.sleep(RETRY_DELAY)
-                continue
-            raise
-
-db_manager = asyncio.run(init_database_with_retry())
-cl_data._data_layer = db_manager
-
-async def save_setting_with_retry(key: str, value: str):
-    for attempt in range(MAX_RETRIES):
-        try:
-            await db_manager.save_setting(key, value)
-            return
-        except sqlite3.OperationalError as e:
-            if "database is locked" in str(e) and attempt < MAX_RETRIES - 1:
-                await asyncio.sleep(RETRY_DELAY)
-                continue
-            raise
-
-async def load_setting_with_retry(key: str) -> str:
-    for attempt in range(MAX_RETRIES):
-        try:
-            return await db_manager.load_setting(key)
-        except sqlite3.OperationalError as e:
-            if "database is locked" in str(e) and attempt < MAX_RETRIES - 1:
-                await asyncio.sleep(RETRY_DELAY)
-                continue
-            raise
-    return ""
-
-def save_setting(key: str, value: str):
-    asyncio.run(save_setting_with_retry(key, value))
-
-def load_setting(key: str) -> str:
-    return asyncio.run(load_setting_with_retry(key))
-
-async def update_thread_metadata(thread_id: str, metadata: dict):
-    for attempt in range(MAX_RETRIES):
-        try:
-            await cl_data.update_thread(thread_id, metadata=metadata)
-            return
-        except sqlite3.OperationalError as e:
-            if "database is locked" in str(e) and attempt < MAX_RETRIES - 1:
-                await asyncio.sleep(RETRY_DELAY)
-                continue
-            raise
-
-# -----------------------------------------------------------------------------
-# Callback Manager (untouched from colab_combined.py)
-# -----------------------------------------------------------------------------
-
-class CallbackManager:
-    def __init__(self):
-        self._callbacks = {}
-
-    def register(self, name: str, callback, is_async: bool = False) -> None:
-        self._callbacks[name] = {'func': callback, 'is_async': is_async}
-
-    async def call(self, name: str, **kwargs) -> None:
-        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)}")
-
-callback_manager = CallbackManager()
-
-def register_callback(name: str, callback, is_async: bool = False) -> None:
-    callback_manager.register(name, callback, is_async)
-
-async def trigger_callback(name: str, **kwargs) -> None:
-    await callback_manager.call(name, **kwargs)
-
-def callback(name: str, is_async: bool = False):
-    def decorator(func):
-        register_callback(name, func, is_async)
-        return func
-    return decorator
-
-# -----------------------------------------------------------------------------
-# Tools Loader (untouched logic but returning dict for tools)
-# -----------------------------------------------------------------------------
-
-def load_tools_from_tools_py():
-    """
-    Imports and returns all contents from tools.py file.
-    Also adds the tools to the global namespace.
-    """
-    tools_dict = {}
-    try:
-        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_dict
-
-        module = importlib.util.module_from_spec(spec)
-        spec.loader.exec_module(module)
-
-        for name, obj in inspect.getmembers(module):
-            if not name.startswith('_') and callable(obj) and not inspect.isclass(obj):
-                globals()[name] = obj
-                tool_def = {
-                    "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"]
-                        }
-                    }
-                }
-                tools_dict[name] = tool_def
-                logger.info(f"Loaded and globalized tool function: {name}")
-
-        logger.info(f"Loaded {len(tools_dict)} tool functions from tools.py")
-    except Exception as e:
-        logger.warning(f"Error loading tools from tools.py: {e}")
-    return tools_dict
-
-# -----------------------------------------------------------------------------
-# Async Queue Processor (untouched logic)
-# -----------------------------------------------------------------------------
-
-async def process_message_queue():
-    while True:
-        try:
-            if not message_queue.empty():
-                msg_data = message_queue.get()
-                await cl.Message(**msg_data).send()
-            await asyncio.sleep(0.1)
-        except Exception as e:
-            logger.error(f"Error processing message queue: {e}")
-
-# -----------------------------------------------------------------------------
-# Step & Task Callbacks (Async & Sync) (untouched logic)
-# -----------------------------------------------------------------------------
-
-async def step_callback(step_details):
-    logger.info(f"[CALLBACK DEBUG] step_callback: {step_details}")
-    agent_name = step_details.get("agent_name", "Agent")
-    try:
-        if step_details.get("response"):
-            message_queue.put({
-                "content": f"Agent Response: {step_details['response']}",
-                "author": agent_name
-            })
-        if step_details.get("tool_name"):
-            message_queue.put({
-                "content": f"🛠️ Using tool: {step_details['tool_name']}",
-                "author": "System"
-            })
-    except Exception as e:
-        logger.error(f"Error in step_callback: {e}", exc_info=True)
-
-async def task_callback(task_output):
-    logger.info(f"[CALLBACK DEBUG] task_callback: type={type(task_output)}")
-    try:
-        if hasattr(task_output, 'raw'):
-            content = task_output.raw
-        elif hasattr(task_output, 'content'):
-            content = task_output.content
-        else:
-            content = str(task_output)
-        message_queue.put({
-            "content": f"Task Output: {content}",
-            "author": "Task"
-        })
-    except Exception as e:
-        logger.error(f"Error in task_callback: {e}", exc_info=True)
-
-async def step_callback_wrapper(step_details):
-    logger.info(f"[CALLBACK DEBUG] step_callback_wrapper: {step_details}")
-    agent_name = step_details.get("agent_name", "Agent")
-    try:
-        if not cl.context.context_var.get():
-            logger.warning("[CALLBACK DEBUG] No Chainlit context in wrapper.")
-            return
-        if step_details.get("response"):
-            await cl.Message(
-                content=f"{agent_name}: {step_details['response']}",
-                author=agent_name,
-            ).send()
-        if step_details.get("tool_name"):
-            await cl.Message(
-                content=f"🛠️ {agent_name} is using tool: {step_details['tool_name']}",
-                author="System",
-            ).send()
-        if step_details.get("thought"):
-            await cl.Message(
-                content=f"💭 {agent_name}'s thought: {step_details['thought']}",
-                author=agent_name,
-            ).send()
-    except Exception as e:
-        logger.error(f"Error in step_callback_wrapper: {e}", exc_info=True)
-        try:
-            await cl.Message(content=f"Error in step callback: {e}", author="System").send()
-        except Exception as send_error:
-            logger.error(f"Error sending error message: {send_error}")
-
-async def task_callback_wrapper(task_output):
-    logger.info("[CALLBACK DEBUG] task_callback_wrapper triggered")
-    try:
-        if not cl.context.context_var.get():
-            logger.warning("[CALLBACK DEBUG] No Chainlit context in task wrapper.")
-            return
-        if hasattr(task_output, 'raw'):
-            content = task_output.raw
-        elif hasattr(task_output, 'content'):
-            content = task_output.content
-        else:
-            content = str(task_output)
-
-        await cl.Message(
-            content=f"✅ Agent completed task:\n{content}",
-            author="Agent",
-        ).send()
-
-        if hasattr(task_output, 'details'):
-            await cl.Message(
-                content=f"📝 Additional details:\n{task_output.details}",
-                author="Agent",
-            ).send()
-    except Exception as e:
-        logger.error(f"Error in task_callback_wrapper: {e}", exc_info=True)
-        try:
-            await cl.Message(content=f"Error in task callback: {e}", author="System").send()
-        except Exception as send_error:
-            logger.error(f"Error sending error message: {send_error}")
-
-def sync_task_callback_wrapper(task_output):
-    logger.info("[CALLBACK DEBUG] sync_task_callback_wrapper")
-    try:
-        try:
-            loop = asyncio.get_event_loop()
-        except RuntimeError:
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-
-        if loop.is_running():
-            asyncio.run_coroutine_threadsafe(task_callback_wrapper(task_output), loop)
-        else:
-            loop.run_until_complete(task_callback_wrapper(task_output))
-    except Exception as e:
-        logger.error(f"Error in sync_task_callback_wrapper: {e}", exc_info=True)
-
-def sync_step_callback_wrapper(step_details):
-    logger.info("[CALLBACK DEBUG] sync_step_callback_wrapper")
-    try:
-        try:
-            loop = asyncio.get_event_loop()
-        except RuntimeError:
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-
-        if loop.is_running():
-            asyncio.run_coroutine_threadsafe(step_callback_wrapper(step_details), loop)
-        else:
-            loop.run_until_complete(step_callback_wrapper(step_details))
-    except Exception as e:
-        logger.error(f"Error in sync_step_callback_wrapper: {e}", exc_info=True)
-
-# -----------------------------------------------------------------------------
-# Main PraisonAI Runner (untouched logic)
-# -----------------------------------------------------------------------------
-
-async def ui_run_praisonai(config, topic, tools_dict):
-    logger.info("Starting ui_run_praisonai")
-    agents_map = {}
-    tasks = []
-    tasks_dict = {}
-
-    try:
-        queue_processor = asyncio.create_task(process_message_queue())
-
-        # Create agents
-        for role, details in config['roles'].items():
-            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)
-
-            await cl.Message(content=f"[DEBUG] Creating agent: {role_name}", author="System").send()
-
-            def step_callback_sync(step_details):
-                step_details["agent_name"] = role_name
-                try:
-                    loop_ = asyncio.new_event_loop()
-                    asyncio.set_event_loop(loop_)
-                    loop_.run_until_complete(step_callback(step_details))
-                    loop_.close()
-                except Exception as e:
-                    logger.error(f"Error in step_callback_sync: {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_map[role] = agent
-
-        # Create tasks
-        for role, details in config['roles'].items():
-            agent = agents_map[role]
-            role_name = agent.name
-            role_tools = []
-            for tool_name in details.get('tools', []):
-                if tool_name in tools_dict:
-                    role_tools.append(tools_dict[tool_name])
-
-            for tname, tdetails in details.get('tasks', {}).items():
-                description_filled = tdetails['description'].format(topic=topic)
-                expected_output_filled = tdetails['expected_output'].format(topic=topic)
-
-                await cl.Message(content=f"[DEBUG] Created task: {tname} for {role_name}", author="System").send()
-
-                def task_callback_sync(task_output):
-                    try:
-                        loop_ = asyncio.new_event_loop()
-                        asyncio.set_event_loop(loop_)
-                        loop_.run_until_complete(task_callback(task_output))
-                        loop_.close()
-                    except Exception as e:
-                        logger.error(f"Error in task_callback_sync: {e}", exc_info=True)
-
-                task = Task(
-                    description=description_filled,
-                    expected_output=expected_output_filled,
-                    agent=agent,
-                    tools=role_tools,
-                    async_execution=True,
-                    context=[],
-                    config=tdetails.get('config', {}),
-                    output_json=tdetails.get('output_json'),
-                    output_pydantic=tdetails.get('output_pydantic'),
-                    output_file=tdetails.get('output_file', ""),
-                    callback=task_callback_sync,
-                    create_directory=tdetails.get('create_directory', False)
-                )
-                tasks.append(task)
-                tasks_dict[tname] = task
-
-        # Build context links
-        for role, details in config['roles'].items():
-            for tname, tdetails in details.get('tasks', {}).items():
-                if tname not in tasks_dict:
-                    continue
-                task = tasks_dict[tname]
-                context_tasks = [
-                    tasks_dict[ctx]
-                    for ctx in tdetails.get('context', [])
-                    if ctx in tasks_dict
-                ]
-                task.context = context_tasks
-
-        await cl.Message(content="Starting PraisonAI agents execution...", author="System").send()
-
-        if config.get('process') == 'hierarchical':
-            prai_agents = PraisonAIAgents(
-                agents=list(agents_map.values()),
-                tasks=tasks,
-                verbose=True,
-                process="hierarchical",
-                manager_llm=config.get('manager_llm', 'gpt-4o')
-            )
-        else:
-            prai_agents = PraisonAIAgents(
-                agents=list(agents_map.values()),
-                tasks=tasks,
-                verbose=2
-            )
-
-        cl.user_session.set("agents", prai_agents)
-
-        loop = asyncio.get_event_loop()
-        response = await loop.run_in_executor(None, prai_agents.start)
-
-        if hasattr(response, 'raw'):
-            result = response.raw
-        elif hasattr(response, 'content'):
-            result = response.content
-        else:
-            result = str(response)
-
-        await cl.Message(content="PraisonAI agents execution completed.", author="System").send()
-        await asyncio.sleep(1)
-        queue_processor.cancel()
-        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
-
-# -----------------------------------------------------------------------------
-# Chainlit Handlers + logic from chainlit_ui.py (no changes in logic)
-# -----------------------------------------------------------------------------
-
-tools_dict = load_tools_from_tools_py()
-
-# Load agent config (default) from 'agents.yaml'
-with open(agent_file, 'r') as f:
-    config = yaml.safe_load(f)
-
-AUTH_PASSWORD_ENABLED = os.getenv("AUTH_PASSWORD_ENABLED", "true").lower() == "true"
-CHAINLIT_AUTH_SECRET = os.getenv("CHAINLIT_AUTH_SECRET")
-if not CHAINLIT_AUTH_SECRET:
-    os.environ["CHAINLIT_AUTH_SECRET"] = "p8BPhQChpg@J>jBz$wGxqLX2V>yTVgP*7Ky9H$aV:axW~ANNX-7_T:o@lnyCBu^U"
-
-username_env = os.getenv("CHAINLIT_USERNAME", "admin")
-password_env = os.getenv("CHAINLIT_PASSWORD", "admin")
-
-def simple_auth_callback(u: str, p: str):
-    if (u, p) == (username_env, password_env):
-        return cl.User(identifier=u, metadata={"role": "ADMIN", "provider": "credentials"})
-    return None
-
-if AUTH_PASSWORD_ENABLED:
-    auth_callback = cl.password_auth_callback(simple_auth_callback)
-
-@cl.set_chat_profiles
-async def set_profiles(current_user: cl.User):
-    """
-    Keep all the same starter logic from chainlit_ui.py.
-    """
-    return [
-        cl.ChatProfile(
-            name="Auto",
-            markdown_description=(
-                "Automatically generate agents and tasks based on your input."
-            ),
-            starters=[
-                cl.Starter(
-                    label="Create a movie script",
-                    message=(
-                        "Create a movie script about a futuristic society where AI "
-                        "and humans coexist, focusing on the conflict and resolution "
-                        "between them. Start with an intriguing opening scene."
-                    ),
-                    icon="/public/movie.svg",
-                ),
-                cl.Starter(
-                    label="Design a fantasy world",
-                    message=(
-                        "Design a detailed fantasy world with unique geography, "
-                        "cultures, and magical systems. Start by describing the main "
-                        "continent and its inhabitants."
-                    ),
-                    icon="/public/fantasy.svg",
-                ),
-                cl.Starter(
-                    label="Write a futuristic political thriller",
-                    message=(
-                        "Write a futuristic political thriller involving a conspiracy "
-                        "within a global government. Start with a high-stakes meeting "
-                        "that sets the plot in motion."
-                    ),
-                    icon="/public/thriller.svg",
-                ),
-                cl.Starter(
-                    label="Develop a new board game",
-                    message=(
-                        "Develop a new, innovative board game. Describe the game's "
-                        "objective, rules, and unique mechanics. Create a scenario to "
-                        "illustrate gameplay."
-                    ),
-                    icon="/public/game.svg",
-                ),
-            ],
-        ),
-        cl.ChatProfile(
-            name="Manual",
-            markdown_description="Manually define your agents and tasks using a YAML file.",
-        ),
-    ]
-
-@cl.on_chat_start
-async def start_chat():
-    try:
-        # Load model name from database
-        model_name = load_setting("model_name") or os.getenv("MODEL_NAME", "gpt-4o-mini")
-        cl.user_session.set("model_name", model_name)
-        logger.debug(f"Model name: {model_name}")
-
-        cl.user_session.set(
-            "message_history",
-            [{"role": "system", "content": "You are a helpful assistant."}],
-        )
-        
-        # Create tools.py if it doesn't exist
-        if not os.path.exists("tools.py"):
-            with open("tools.py", "w") as f:
-                f.write("# Add your custom tools here\n")
-        
-        settings = await cl.ChatSettings(
-            [
-                TextInput(id="Model", label="OpenAI - Model", initial=model_name),
-                TextInput(id="BaseUrl", label="OpenAI - Base URL", initial=config_list[0]['base_url']),
-                TextInput(id="ApiKey", label="OpenAI - API Key", initial=config_list[0]['api_key']), 
-                Select(
-                    id="Framework",
-                    label="Framework",
-                    values=["praisonai", "crewai", "autogen"],
-                    initial_index=0,
-                ),
-            ]
-        ).send()
-        cl.user_session.set("settings", settings)
-        chat_profile = cl.user_session.get("chat_profile")
-
-        if chat_profile=="Manual":
-            agent_file = "agents.yaml"
-            full_agent_file_path = os.path.abspath(agent_file)
-            if os.path.exists(full_agent_file_path):
-                with open(full_agent_file_path, 'r') as f:
-                    yaml_content = f.read()
-                msg = cl.Message(content=yaml_content, language="yaml")
-                await msg.send()
-                
-            full_tools_file_path = os.path.abspath("tools.py")
-            if os.path.exists(full_tools_file_path):
-                with open(full_tools_file_path, 'r') as f:
-                    tools_content = f.read()
-                msg = cl.Message(content=tools_content, language="python")
-                await msg.send()
-
-            settings = await cl.ChatSettings(
-                [
-                    TextInput(id="Model", label="OpenAI - Model", initial=model_name),
-                    TextInput(id="BaseUrl", label="OpenAI - Base URL", initial=config_list[0]['base_url']),
-                    TextInput(id="ApiKey", label="OpenAI - API Key", initial=config_list[0]['api_key']), 
-                    Select(
-                        id="Framework",
-                        label="Framework",
-                        values=["praisonai", "crewai", "autogen"],
-                        initial_index=0,
-                    ),
-                    TextInput(id="agents", label="agents.yaml", initial=yaml_content, multiline=True),
-                    TextInput(id="tools", label="tools.py", initial=tools_content, multiline=True),
-                ]
-            ).send()
-            cl.user_session.set("settings", settings)
-            
-            res = await cl.AskActionMessage(
-                content="Pick an action!",
-                actions=actions,
-            ).send()
-            if res and res.get("value") == "modify":
-                await cl.Message(content="Modify the agents and tools from below settings", actions=actions).send()
-            elif res and res.get("value") == "run":
-                await main(cl.Message(content="", actions=actions))
-
-        await on_settings_update(settings)
-    except Exception as e:
-        logger.error(f"Error in start_chat: {str(e)}")
-        await cl.Message(content=f"An error occurred while starting the chat: {str(e)}").send()
-
-
-@cl.on_chat_resume
-async def on_chat_resume(thread: ThreadDict):
-    """
-    Logic from chainlit_ui.py for chat resume:
-    - Restore message history from thread steps
-    """
-    try:
-        message_history = cl.user_session.get("message_history", [])
-        root_messages = [m for m in thread["steps"] if m["parentId"] is None]
-        for message in root_messages:
-            if message["type"] == "user_message":
-                message_history.append({"role": "user", "content": message["output"]})
-            elif message["type"] == "ai_message":
-                message_history.append({"role": "assistant", "content": message["content"]})
-        cl.user_session.set("message_history", message_history)
-    except Exception as e:
-        logger.error(f"Error in on_chat_resume: {str(e)}")
-
-@cl.on_message
-async def main(message: cl.Message):
-    """
-    Merged logic from colab_combined.py and chainlit_ui.py for main message:
-    - Use existing ui_run_praisonai to process user message with PraisonAI
-    - Keep message history, no changes to logic
-    """
-    try:
-        logger.info(f"User message: {message.content}")
-        await cl.Message(
-            content=f"🔄 Processing your request: {message.content}...",
-            author="System"
-        ).send()
-
-        # Run PraisonAI
-        result = await ui_run_praisonai(config, message.content, tools_dict)
-
-        # Update message history
-        message_history = cl.user_session.get("message_history", [])
-        message_history.append({"role": "user", "content": message.content})
-        message_history.append({"role": "assistant", "content": str(result)})
-        cl.user_session.set("message_history", message_history)
-
-    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_settings_update
-async def on_settings_update(settings):
-    """Handle updates to the ChatSettings form."""
-    try:
-        global config_list, framework
-        config_list[0]['model'] = settings["Model"]
-        config_list[0]['base_url'] = settings["BaseUrl"]
-        config_list[0]['api_key'] = settings["ApiKey"]
-        
-        # Save settings to database with retry
-        for attempt in range(MAX_RETRIES):
-            try:
-                await save_setting_with_retry("model_name", config_list[0]['model'])
-                await save_setting_with_retry("base_url", config_list[0]['base_url'])
-                await save_setting_with_retry("api_key", config_list[0]['api_key'])
-                break
-            except sqlite3.OperationalError as e:
-                if "database is locked" in str(e) and attempt < MAX_RETRIES - 1:
-                    await asyncio.sleep(RETRY_DELAY)
-                    continue
-                raise
-        
-        # Save to environment variables for compatibility
-        os.environ["OPENAI_API_KEY"] = config_list[0]['api_key']
-        os.environ["OPENAI_MODEL_NAME"] = config_list[0]['model']
-        os.environ["OPENAI_API_BASE"] = config_list[0]['base_url']
-        os.environ["MODEL_NAME"] = config_list[0]['model']
-        framework = settings["Framework"]
-        os.environ["FRAMEWORK"] = framework
-        
-        if "agents" in settings:
-            with open("agents.yaml", "w") as f:
-                f.write(settings["agents"])
-        if "tools" in settings:
-            with open("tools.py", "w") as f:
-                f.write(settings["tools"])
-        
-        # Update thread metadata if exists with retry
-        thread_id = cl.user_session.get("thread_id")
-        if thread_id:
-            for attempt in range(MAX_RETRIES):
-                try:
-                    thread = await cl_data.get_thread(thread_id)
-                    if thread:
-                        metadata = thread.get("metadata", {})
-                        if isinstance(metadata, str):
-                            try:
-                                metadata = json.loads(metadata)
-                            except json.JSONDecodeError:
-                                metadata = {}
-                        metadata["model_name"] = config_list[0]['model']
-                        await cl_data.update_thread(thread_id, metadata=metadata)
-                        cl.user_session.set("metadata", metadata)
-                    break
-                except sqlite3.OperationalError as e:
-                    if "database is locked" in str(e) and attempt < MAX_RETRIES - 1:
-                        await asyncio.sleep(RETRY_DELAY)
-                        continue
-                    raise
-        
-        logger.info("Settings updated successfully")
-    except Exception as e:
-        logger.error(f"Error updating settings: {str(e)}")
-        await cl.Message(content=f"An error occurred while updating settings: {str(e)}. Retrying...").send()
-        # One final retry after a longer delay
-        try:
-            await asyncio.sleep(RETRY_DELAY * 2)
-            await on_settings_update(settings)
-        except Exception as e:
-            logger.error(f"Final retry failed: {str(e)}")
-            await cl.Message(content=f"Failed to update settings after retries: {str(e)}").send()

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.26"
+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 = ""
@@ -84,7 +84,7 @@ autogen = ["pyautogen>=0.2.19", "praisonai-tools>=0.0.7", "crewai"]
 
 [tool.poetry]
 name = "PraisonAI"
-version = "2.0.26"
+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 = ""

uv.lock

@@ -3061,7 +3061,7 @@ wheels = [
 
 [[package]]
 name = "praisonai"
-version = "2.0.26"
+version = "2.0.28"
 source = { editable = "." }
 dependencies = [
     { name = "instructor" },