PraisonAI 2.2.34__tar.gz → 2.2.36__tar.gz

{praisonai-2.2.34 → praisonai-2.2.36}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: PraisonAI
-Version: 2.2.34
+Version: 2.2.36
 Summary: 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.
 Author: Mervin Praison
 Requires-Python: >=3.10
@@ -64,7 +64,7 @@ Requires-Dist: playwright (>=1.47.0) ; extra == "code"
 Requires-Dist: plotly (>=5.24.0) ; extra == "realtime"
 Requires-Dist: praisonai-tools (>=0.0.15) ; extra == "autogen"
 Requires-Dist: praisonai-tools (>=0.0.15) ; extra == "crewai"
-Requires-Dist: praisonaiagents (>=0.0.107)
+Requires-Dist: praisonaiagents (>=0.0.109)
 Requires-Dist: pyautogen (>=0.2.19) ; extra == "autogen"
 Requires-Dist: pydantic (<=2.10.1) ; extra == "chat"
 Requires-Dist: pydantic (<=2.10.1) ; extra == "code"

{praisonai-2.2.34 → praisonai-2.2.36}/praisonai/cli.py

@@ -170,6 +170,25 @@ class PraisonAI:
             pass
         return None
 
+    def read_file_if_provided(self, file_path):
+        """
+        Read content from a file if the file path is provided.
+        Returns the file content or None if file cannot be read.
+        """
+        if not file_path:
+            return None
+        
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                file_content = f.read().strip()
+                return file_content if file_content else None
+        except FileNotFoundError:
+            print(f"[red]ERROR: File not found: {file_path}[/red]")
+            sys.exit(1)
+        except Exception as e:
+            print(f"[red]ERROR: Failed to read file: {e}[/red]")
+            sys.exit(1)
+
     def main(self):
         """
         The main function of the PraisonAI object. It parses the command-line arguments,
@@ -189,15 +208,24 @@ class PraisonAI:
 
         # Check for piped input from stdin
         stdin_input = self.read_stdin_if_available()
+        
+        # Check for file input if --file is provided
+        file_input = self.read_file_if_provided(getattr(args, 'file', None))
 
         if args.command:
             if args.command.startswith("tests.test") or args.command.startswith("tests/test"):  # Argument used for testing purposes
                 print("test")
                 return "test"
             else:
-                # If stdin input is available, append it to the command
+                # Combine command with any available inputs (stdin and/or file)
+                combined_inputs = []
                 if stdin_input:
-                    combined_prompt = f"{args.command} {stdin_input}"
+                    combined_inputs.append(stdin_input)
+                if file_input:
+                    combined_inputs.append(file_input)
+                
+                if combined_inputs:
+                    combined_prompt = f"{args.command} {' '.join(combined_inputs)}"
                     result = self.handle_direct_prompt(combined_prompt)
                     print(result)
                     return result
@@ -206,20 +234,30 @@ class PraisonAI:
         elif hasattr(args, 'direct_prompt') and args.direct_prompt:
             # Only handle direct prompt if agent_file wasn't explicitly set in constructor
             if original_agent_file == "agents.yaml":  # Default value, so safe to use direct prompt
-                # If stdin input is available, append it to the direct prompt
-                prompt = args.direct_prompt
+                # Combine direct prompt with any available inputs (stdin and/or file)
+                prompt_parts = [args.direct_prompt]
                 if stdin_input:
-                    prompt = f"{args.direct_prompt} {stdin_input}"
+                    prompt_parts.append(stdin_input)
+                if file_input:
+                    prompt_parts.append(file_input)
+                prompt = ' '.join(prompt_parts)
                 result = self.handle_direct_prompt(prompt)
                 print(result)
                 return result
             else:
                 # Agent file was explicitly set, ignore direct prompt and use the file
                 pass
-        elif stdin_input:
-            # If only stdin input is provided (no command), use it as direct prompt
-            if original_agent_file == "agents.yaml":  # Default value, so safe to use stdin as prompt
-                result = self.handle_direct_prompt(stdin_input)
+        elif stdin_input or file_input:
+            # If only stdin/file input is provided (no command), use it as direct prompt
+            if original_agent_file == "agents.yaml":  # Default value, so safe to use input as prompt
+                # Combine any available inputs
+                inputs = []
+                if stdin_input:
+                    inputs.append(stdin_input)
+                if file_input:
+                    inputs.append(file_input)
+                combined_input = ' '.join(inputs)
+                result = self.handle_direct_prompt(combined_input)
                 print(result)
                 return result
         # If no command or direct_prompt, preserve agent_file from constructor (don't overwrite)
@@ -530,6 +568,7 @@ class PraisonAI:
         parser.add_argument("--public", action="store_true", help="Use ngrok to expose the server publicly (only with --call)")
         parser.add_argument("--merge", action="store_true", help="Merge existing agents.yaml with auto-generated agents instead of overwriting")
         parser.add_argument("--claudecode", action="store_true", help="Enable Claude Code integration for file modifications and coding tasks")
+        parser.add_argument("--file", "-f", type=str, help="Read input from a file and append it to the prompt")
         
         # If we're in a test environment, parse with empty args to avoid pytest interference
         if in_test_env:

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

{praisonai-2.2.34 → praisonai-2.2.36}/praisonai/ui/agents.py

@@ -467,10 +467,12 @@ async def ui_run_praisonai(config, topic, tools_dict):
                     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.")
+            
+            # Set the agent's tools after collecting all tools
+            if role_tools:
+                agent.tools = role_tools
 
             for tname, tdetails in details.get('tasks', {}).items():
                 description_filled = tdetails['description'].format(topic=topic)

{praisonai-2.2.34 → praisonai-2.2.36}/praisonai/ui/chat.py

@@ -7,6 +7,8 @@ import json
 import asyncio
 import io
 import base64
+import importlib.util
+import inspect
 
 # Third-party imports
 from dotenv import load_dotenv
@@ -59,6 +61,76 @@ def load_setting(key: str) -> str:
 
 cl_data._data_layer = db_manager
 
+def load_custom_tools():
+    """Load custom tools from tools.py if it exists"""
+    custom_tools = {}
+    try:
+        spec = importlib.util.spec_from_file_location("tools", "tools.py")
+        if spec is None:
+            logger.debug("tools.py not found in current directory")
+            return custom_tools
+        
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+        
+        # Load all functions from tools.py
+        for name, obj in inspect.getmembers(module):
+            if not name.startswith('_') and callable(obj) and not inspect.isclass(obj):
+                # Store function in globals for access
+                globals()[name] = obj
+                
+                # Get function signature to build parameters
+                sig = inspect.signature(obj)
+                params_properties = {}
+                required_params = []
+                
+                for param_name, param in sig.parameters.items():
+                    if param_name != 'self':  # Skip self parameter
+                        # Get type annotation if available
+                        param_type = "string"  # Default type
+                        if param.annotation != inspect.Parameter.empty:
+                            if param.annotation == int:
+                                param_type = "integer"
+                            elif param.annotation == float:
+                                param_type = "number"
+                            elif param.annotation == bool:
+                                param_type = "boolean"
+                        
+                        params_properties[param_name] = {
+                            "type": param_type,
+                            "description": f"Parameter {param_name}"
+                        }
+                        
+                        # Add to required if no default value
+                        if param.default == inspect.Parameter.empty:
+                            required_params.append(param_name)
+                
+                # Build tool definition
+                tool_def = {
+                    "type": "function",
+                    "function": {
+                        "name": name,
+                        "description": obj.__doc__ or f"Function {name.replace('_', ' ')}",
+                        "parameters": {
+                            "type": "object",
+                            "properties": params_properties,
+                            "required": required_params
+                        }
+                    }
+                }
+                
+                custom_tools[name] = tool_def
+                logger.info(f"Loaded custom tool: {name}")
+        
+        logger.info(f"Loaded {len(custom_tools)} custom tools from tools.py")
+    except Exception as e:
+        logger.warning(f"Error loading custom tools: {e}")
+    
+    return custom_tools
+
+# Load custom tools
+custom_tools_dict = load_custom_tools()
+
 tavily_api_key = os.getenv("TAVILY_API_KEY")
 tavily_client = TavilyClient(api_key=tavily_api_key) if tavily_api_key else None
 
@@ -72,7 +144,7 @@ async def tavily_web_search(query):
     response = tavily_client.search(query)
     logger.debug(f"Tavily search response: {response}")
 
-    async with AsyncAsyncWebCrawler() as crawler:
+    async with AsyncWebCrawler() as crawler:
         results = []
         for result in response.get('results', []):
             url = result.get('url')
@@ -97,20 +169,28 @@ async def tavily_web_search(query):
         "results": results
     })
 
-tools = [{
-    "type": "function",
-    "function": {
-        "name": "tavily_web_search",
-        "description": "Search the web using Tavily API and crawl the resulting URLs",
-        "parameters": {
-            "type": "object",
-            "properties": {
-                "query": {"type": "string", "description": "Search query"}
-            },
-            "required": ["query"]
+# Build tools list with Tavily and custom tools
+tools = []
+
+# Add Tavily tool if API key is available
+if tavily_api_key:
+    tools.append({
+        "type": "function",
+        "function": {
+            "name": "tavily_web_search",
+            "description": "Search the web using Tavily API and crawl the resulting URLs",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "query": {"type": "string", "description": "Search query"}
+                },
+                "required": ["query"]
+            }
         }
-    }
-}] if tavily_api_key else []
+    })
+
+# Add custom tools from tools.py
+tools.extend(list(custom_tools_dict.values()))
 
 # Authentication configuration
 AUTH_PASSWORD_ENABLED = os.getenv("AUTH_PASSWORD_ENABLED", "true").lower() == "true"  # Password authentication enabled by default
@@ -235,7 +315,8 @@ User Question: {message.content}
             ]
         }
 
-    if tavily_api_key:
+    # Pass tools if we have any (Tavily or custom)
+    if tools:
         completion_params["tools"] = tools
         completion_params["tool_choice"] = "auto"
 
@@ -254,7 +335,7 @@ User Question: {message.content}
                 await msg.stream_token(token)
                 full_response += token
 
-            if tavily_api_key and 'tool_calls' in delta and delta['tool_calls'] is not None:
+            if tools and 'tool_calls' in delta and delta['tool_calls'] is not None:
                 for tool_call in delta['tool_calls']:
                     if current_tool_call is None or tool_call.index != current_tool_call['index']:
                         if current_tool_call:
@@ -284,10 +365,17 @@ User Question: {message.content}
     cl.user_session.set("message_history", message_history)
     await msg.update()
 
-    if tavily_api_key and tool_calls:
-        available_functions = {
-            "tavily_web_search": tavily_web_search,
-        }
+    if tool_calls and tools:  # Check if we have any tools and tool calls
+        available_functions = {}
+        
+        # Add Tavily function if available
+        if tavily_api_key:
+            available_functions["tavily_web_search"] = tavily_web_search
+        
+        # Add all custom tool functions from globals
+        for tool_name in custom_tools_dict:
+            if tool_name in globals():
+                available_functions[tool_name] = globals()[tool_name]
         messages = message_history + [{"role": "assistant", "content": None, "function_call": {
             "name": tool_calls[0]['function']['name'],
             "arguments": tool_calls[0]['function']['arguments']
@@ -301,9 +389,25 @@ User Question: {message.content}
                 if function_args:
                     try:
                         function_args = json.loads(function_args)
-                        function_response = await function_to_call(
-                            query=function_args.get("query"),
-                        )
+                        
+                        # Call function based on whether it's async or sync
+                        if asyncio.iscoroutinefunction(function_to_call):
+                            # For async functions like tavily_web_search
+                            if function_name == "tavily_web_search":
+                                function_response = await function_to_call(
+                                    query=function_args.get("query"),
+                                )
+                            else:
+                                # For custom async functions, pass all arguments
+                                function_response = await function_to_call(**function_args)
+                        else:
+                            # For sync functions (most custom tools)
+                            function_response = function_to_call(**function_args)
+                        
+                        # Convert response to string if needed
+                        if not isinstance(function_response, str):
+                            function_response = json.dumps(function_response)
+                        
                         messages.append(
                             {
                                 "role": "function",
@@ -313,6 +417,15 @@ User Question: {message.content}
                         )
                     except json.JSONDecodeError:
                         logger.error(f"Failed to parse function arguments: {function_args}")
+                    except Exception as e:
+                        logger.error(f"Error calling function {function_name}: {str(e)}")
+                        messages.append(
+                            {
+                                "role": "function",
+                                "name": function_name,
+                                "content": f"Error: {str(e)}",
+                            }
+                        )
 
         second_response = await acompletion(
             model=model_name,

{praisonai-2.2.34 → praisonai-2.2.36}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "PraisonAI"
-version = "2.2.34"
+version = "2.2.36"
 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.107",
+    "praisonaiagents>=0.0.109",
     "python-dotenv>=0.19.0",
     "instructor>=1.3.3",
     "PyYAML>=6.0",
@@ -95,7 +95,7 @@ autogen = ["pyautogen>=0.2.19", "praisonai-tools>=0.0.15", "crewai"]
 
 [tool.poetry]
 name = "PraisonAI"
-version = "2.2.34"
+version = "2.2.36"
 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 = ""
@@ -113,7 +113,7 @@ python = ">=3.10,<3.13"
 rich = ">=13.7"
 markdown = ">=3.5"
 pyparsing = ">=3.0.0"
-praisonaiagents = ">=0.0.107"
+praisonaiagents = ">=0.0.109"
 python-dotenv = ">=0.19.0"
 instructor = ">=1.3.3"
 PyYAML = ">=6.0"