PraisonAI 2.2.21__tar.gz → 2.2.24__tar.gz

{praisonai-2.2.21 → praisonai-2.2.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: PraisonAI
-Version: 2.2.21
+Version: 2.2.24
 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
@@ -21,6 +21,7 @@ Provides-Extra: google
 Provides-Extra: gradio
 Provides-Extra: openai
 Provides-Extra: realtime
+Provides-Extra: train
 Provides-Extra: ui
 Requires-Dist: PyYAML (>=6.0)
 Requires-Dist: agentops (>=0.3.12) ; extra == "agentops"
@@ -63,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.91)
+Requires-Dist: praisonaiagents (>=0.0.95)
 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.21 → praisonai-2.2.24}/praisonai/auto.py

@@ -121,12 +121,12 @@ Tools are not available for {framework}. To use tools, install:
             mode=instructor.Mode.JSON,
         )
 
-    def generate(self):
+    def generate(self, merge=False):
         """
         Generates a team structure for the specified topic.
 
         Args:
-            None
+            merge (bool): Whether to merge with existing agents.yaml file instead of overwriting.
 
         Returns:
             str: The full path of the YAML file containing the generated team structure.
@@ -149,45 +149,118 @@ Tools are not available for {framework}. To use tools, install:
             ]
         )
         json_data = json.loads(response.model_dump_json())
-        self.convert_and_save(json_data)
+        self.convert_and_save(json_data, merge=merge)
         full_path = os.path.abspath(self.agent_file)
         return full_path
 
-    def convert_and_save(self, json_data):
+    def convert_and_save(self, json_data, merge=False):
         """Converts the provided JSON data into the desired YAML format and saves it to a file.
 
         Args:
             json_data (dict): The JSON data representing the team structure.
-            topic (str, optional): The topic to be inserted into the YAML. Defaults to "Artificial Intelligence".
-            agent_file (str, optional): The name of the YAML file to save. Defaults to "test.yaml".
+            merge (bool): Whether to merge with existing agents.yaml file instead of overwriting.
         """
 
-        yaml_data = {
-            "framework": self.framework,
-            "topic": self.topic,
-            "roles": {},
-            "dependencies": []
-        }
+        # Handle merge functionality
+        if merge and os.path.exists(self.agent_file):
+            yaml_data = self.merge_with_existing_agents(json_data)
+        else:
+            # Original behavior: create new yaml_data structure
+            yaml_data = {
+                "framework": self.framework,
+                "topic": self.topic,
+                "roles": {},
+                "dependencies": []
+            }
+
+            for role_id, role_details in json_data['roles'].items():
+                yaml_data['roles'][role_id] = {
+                    "backstory": "" + role_details['backstory'],
+                    "goal": role_details['goal'],
+                    "role": role_details['role'],
+                    "tasks": {},
+                    # "tools": role_details.get('tools', []),
+                    "tools": ['']
+                }
+
+                for task_id, task_details in role_details['tasks'].items():
+                    yaml_data['roles'][role_id]['tasks'][task_id] = {
+                        "description": "" + task_details['description'],
+                        "expected_output": "" + task_details['expected_output']
+                    }
+
+        # Save to YAML file, maintaining the order
+        with open(self.agent_file, 'w') as f:
+            yaml.dump(yaml_data, f, allow_unicode=True, sort_keys=False)
 
-        for role_id, role_details in json_data['roles'].items():
-            yaml_data['roles'][role_id] = {
+    def merge_with_existing_agents(self, new_json_data):
+        """
+        Merge existing agents.yaml with new auto-generated agents.
+        
+        Args:
+            new_json_data (dict): The JSON data representing the new team structure.
+            
+        Returns:
+            dict: The merged YAML data structure.
+        """
+        try:
+            # Load existing agents.yaml
+            with open(self.agent_file, 'r') as f:
+                existing_data = yaml.safe_load(f)
+            
+            if not existing_data:
+                # If existing file is empty, treat as new file
+                existing_data = {"roles": {}, "dependencies": []}
+        except (yaml.YAMLError, FileNotFoundError) as e:
+            logging.warning(f"Could not load existing agents file {self.agent_file}: {e}")
+            logging.warning("Creating new file instead of merging")
+            existing_data = {"roles": {}, "dependencies": []}
+        
+        # Start with existing data structure
+        merged_data = existing_data.copy()
+        
+        # Ensure required fields exist
+        if 'roles' not in merged_data:
+            merged_data['roles'] = {}
+        if 'dependencies' not in merged_data:
+            merged_data['dependencies'] = []
+        if 'framework' not in merged_data:
+            merged_data['framework'] = self.framework
+        
+        # Handle topic merging
+        existing_topic = merged_data.get('topic', '')
+        new_topic = self.topic
+        if existing_topic and existing_topic != new_topic:
+            merged_data['topic'] = f"{existing_topic} + {new_topic}"
+        else:
+            merged_data['topic'] = new_topic
+        
+        # Merge new roles with existing ones
+        for role_id, role_details in new_json_data['roles'].items():
+            # Check for conflicts and rename if necessary
+            final_role_id = role_id
+            counter = 1
+            while final_role_id in merged_data['roles']:
+                final_role_id = f"{role_id}_auto_{counter}"
+                counter += 1
+            
+            # Add the new role
+            merged_data['roles'][final_role_id] = {
                 "backstory": "" + role_details['backstory'],
                 "goal": role_details['goal'],
                 "role": role_details['role'],
                 "tasks": {},
-                # "tools": role_details.get('tools', []),
                 "tools": ['']
             }
-
+            
+            # Add tasks for this role
             for task_id, task_details in role_details['tasks'].items():
-                yaml_data['roles'][role_id]['tasks'][task_id] = {
+                merged_data['roles'][final_role_id]['tasks'][task_id] = {
                     "description": "" + task_details['description'],
                     "expected_output": "" + task_details['expected_output']
                 }
-
-        # Save to YAML file, maintaining the order
-        with open(self.agent_file, 'w') as f:
-            yaml.dump(yaml_data, f, allow_unicode=True, sort_keys=False)
+        
+        return merged_data
 
     def get_user_content(self):
         """

{praisonai-2.2.21 → praisonai-2.2.24}/praisonai/cli.py

@@ -5,6 +5,7 @@ import argparse
 from .version import __version__
 import yaml
 import os
+import time
 from rich import print
 from dotenv import load_dotenv
 load_dotenv()
@@ -25,6 +26,7 @@ CALL_MODULE_AVAILABLE = False
 CREWAI_AVAILABLE = False
 AUTOGEN_AVAILABLE = False
 PRAISONAI_AVAILABLE = False
+TRAIN_AVAILABLE = False
 try:
     # Create necessary directories and set CHAINLIT_APP_ROOT
     if "CHAINLIT_APP_ROOT" not in os.environ:
@@ -71,6 +73,12 @@ try:
 except ImportError:
     pass
 
+try:
+    from unsloth import FastLanguageModel
+    TRAIN_AVAILABLE = True
+except ImportError:
+    pass
+
 logging.basicConfig(level=os.environ.get('LOGLEVEL', 'INFO'), format='%(asctime)s - %(levelname)s - %(message)s')
 logging.getLogger('alembic').setLevel(logging.ERROR)
 logging.getLogger('gradio').setLevel(logging.ERROR)
@@ -217,9 +225,66 @@ class PraisonAI:
         # If no command or direct_prompt, preserve agent_file from constructor (don't overwrite)
 
         if args.deploy:
-            from .deploy import CloudDeployer
-            deployer = CloudDeployer()
-            deployer.run_commands()
+            if args.schedule or args.schedule_config:
+                # Scheduled deployment
+                from .scheduler import create_scheduler
+                
+                # Load configuration from file if provided
+                config = {"max_retries": args.max_retries}
+                schedule_expr = args.schedule
+                provider = args.provider
+                
+                if args.schedule_config:
+                    try:
+                        with open(args.schedule_config, 'r') as f:
+                            file_config = yaml.safe_load(f)
+                        
+                        # Extract deployment config
+                        deploy_config = file_config.get('deployment', {})
+                        schedule_expr = schedule_expr or deploy_config.get('schedule')
+                        provider = deploy_config.get('provider', provider)
+                        config['max_retries'] = deploy_config.get('max_retries', config['max_retries'])
+                        
+                        # Apply environment variables if specified
+                        env_vars = file_config.get('environment', {})
+                        for key, value in env_vars.items():
+                            os.environ[key] = str(value)
+                            
+                    except FileNotFoundError:
+                        print(f"Configuration file not found: {args.schedule_config}")
+                        sys.exit(1)
+                    except yaml.YAMLError as e:
+                        print(f"Error parsing configuration file: {e}")
+                        sys.exit(1)
+                
+                if not schedule_expr:
+                    print("Error: Schedule expression required. Use --schedule or specify in config file.")
+                    sys.exit(1)
+                
+                scheduler = create_scheduler(provider=provider, config=config)
+                
+                print(f"Starting scheduled deployment with schedule: {schedule_expr}")
+                print(f"Provider: {provider}")
+                print(f"Max retries: {config['max_retries']}")
+                print("Press Ctrl+C to stop the scheduler")
+                
+                if scheduler.start(schedule_expr, config['max_retries']):
+                    try:
+                        # Keep the main thread alive
+                        while scheduler.is_running:
+                            time.sleep(1)
+                    except KeyboardInterrupt:
+                        print("\nStopping scheduler...")
+                        scheduler.stop()
+                        print("Scheduler stopped successfully")
+                else:
+                    print("Failed to start scheduler")
+                    sys.exit(1)
+            else:
+                # One-time deployment (backward compatible)
+                from .deploy import CloudDeployer
+                deployer = CloudDeployer()
+                deployer.run_commands()
             return
 
         if getattr(args, 'chat', False):
@@ -242,6 +307,11 @@ class PraisonAI:
             return
 
         if args.command == 'train':
+            if not TRAIN_AVAILABLE:
+                print("[red]ERROR: Training dependencies not installed. Install with:[/red]")
+                print("\npip install \"praisonai[train]\"")
+                print("Or run: praisonai train init\n")
+                sys.exit(1)
             package_root = os.path.dirname(os.path.abspath(__file__))
             config_yaml_destination = os.path.join(os.getcwd(), 'config.yaml')
 
@@ -347,7 +417,7 @@ class PraisonAI:
 
             self.agent_file = "test.yaml"
             generator = AutoGenerator(topic=self.topic, framework=self.framework, agent_file=self.agent_file)
-            self.agent_file = generator.generate()
+            self.agent_file = generator.generate(merge=getattr(args, 'merge', False))
             agents_generator = AgentsGenerator(self.agent_file, self.framework, self.config_list)
             result = agents_generator.generate_crew_and_kickoff()
             print(result)
@@ -360,7 +430,7 @@ class PraisonAI:
 
             self.agent_file = "agents.yaml"
             generator = AutoGenerator(topic=self.topic, framework=self.framework, agent_file=self.agent_file)
-            self.agent_file = generator.generate()
+            self.agent_file = generator.generate(merge=getattr(args, 'merge', False))
             print(f"File {self.agent_file} created successfully")
             return f"File {self.agent_file} created successfully"
 
@@ -406,6 +476,36 @@ class PraisonAI:
             'unittest' in sys.modules
         )
         
+        # Check if we're being used as a library (not from praisonai CLI)
+        # Skip CLI parsing to avoid conflicts with applications like Fabric
+        is_library_usage = (
+            'praisonai' not in sys.argv[0] and
+            not in_test_env
+        )
+        
+        if is_library_usage:
+            # Return default args when used as library to prevent CLI conflicts
+            default_args = argparse.Namespace()
+            default_args.framework = None
+            default_args.ui = None
+            default_args.auto = None
+            default_args.init = None
+            default_args.command = None
+            default_args.deploy = False
+            default_args.schedule = None
+            default_args.schedule_config = None
+            default_args.provider = "gcp"
+            default_args.max_retries = 3
+            default_args.model = None
+            default_args.llm = None
+            default_args.hf = None
+            default_args.ollama = None
+            default_args.dataset = "yahma/alpaca-cleaned"
+            default_args.realtime = False
+            default_args.call = False
+            default_args.public = False
+            return default_args
+        
         # Define special commands
         special_commands = ['chat', 'code', 'call', 'realtime', 'train', 'ui']
         
@@ -416,6 +516,10 @@ class PraisonAI:
         parser.add_argument("--init", nargs=argparse.REMAINDER, help="Initialize agents with optional topic")
         parser.add_argument("command", nargs="?", help="Command to run or direct prompt")
         parser.add_argument("--deploy", action="store_true", help="Deploy the application")
+        parser.add_argument("--schedule", type=str, help="Schedule deployment (e.g., 'daily', 'hourly', '*/6h', '3600')")
+        parser.add_argument("--schedule-config", type=str, help="Path to scheduling configuration file")
+        parser.add_argument("--provider", type=str, default="gcp", help="Deployment provider (gcp, aws, azure)")
+        parser.add_argument("--max-retries", type=int, default=3, help="Maximum retry attempts for scheduled deployments")
         parser.add_argument("--model", type=str, help="Model name")
         parser.add_argument("--llm", type=str, help="LLM model to use for direct prompts")
         parser.add_argument("--hf", type=str, help="Hugging Face model name")
@@ -424,6 +528,7 @@ class PraisonAI:
         parser.add_argument("--realtime", action="store_true", help="Start the realtime voice interaction interface")
         parser.add_argument("--call", action="store_true", help="Start the PraisonAI Call server")
         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")
         
         # If we're in a test environment, parse with empty args to avoid pytest interference
         if in_test_env:
@@ -509,6 +614,11 @@ class PraisonAI:
                 sys.exit(0)
 
             elif args.command == 'train':
+                if not TRAIN_AVAILABLE:
+                    print("[red]ERROR: Training dependencies not installed. Install with:[/red]")
+                    print("\npip install \"praisonai[train]\"")
+                    print("Or run: praisonai train init\n")
+                    sys.exit(1)
                 package_root = os.path.dirname(os.path.abspath(__file__))
                 config_yaml_destination = os.path.join(os.getcwd(), 'config.yaml')
 

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

praisonai-2.2.24/praisonai/scheduler.py

@@ -0,0 +1,215 @@
+import re
+import threading
+import time
+import logging
+from datetime import datetime, timedelta
+from typing import Union, Optional, Callable, Dict, Any
+from abc import ABC, abstractmethod
+
+logger = logging.getLogger(__name__)
+
+class DeployerInterface(ABC):
+    """Abstract interface for deployers to ensure provider compatibility."""
+    
+    @abstractmethod
+    def deploy(self) -> bool:
+        """Execute deployment. Returns True on success, False on failure."""
+        pass
+
+class CloudDeployerAdapter(DeployerInterface):
+    """Adapter for existing CloudDeployer to match interface."""
+    
+    def __init__(self):
+        from .deploy import CloudDeployer
+        self._deployer = CloudDeployer()
+    
+    def deploy(self) -> bool:
+        """Execute deployment using CloudDeployer."""
+        try:
+            self._deployer.run_commands()
+            return True
+        except Exception as e:
+            logger.error(f"Deployment failed: {e}")
+            return False
+
+class ScheduleParser:
+    """Parse schedule expressions into intervals."""
+    
+    @staticmethod
+    def parse(schedule_expr: str) -> int:
+        """
+        Parse schedule expression and return interval in seconds.
+        
+        Supported formats:
+        - "daily" -> 86400 seconds
+        - "hourly" -> 3600 seconds
+        - "*/30m" -> 1800 seconds (every 30 minutes)
+        - "*/6h" -> 21600 seconds (every 6 hours)
+        - "60" -> 60 seconds (plain number)
+        """
+        schedule_expr = schedule_expr.strip().lower()
+        
+        if schedule_expr == "daily":
+            return 86400
+        elif schedule_expr == "hourly":
+            return 3600
+        elif schedule_expr.isdigit():
+            return int(schedule_expr)
+        elif schedule_expr.startswith("*/"):
+            # Handle */30m, */6h patterns
+            interval_part = schedule_expr[2:]
+            if interval_part.endswith("m"):
+                minutes = int(interval_part[:-1])
+                return minutes * 60
+            elif interval_part.endswith("h"):
+                hours = int(interval_part[:-1])
+                return hours * 3600
+            elif interval_part.endswith("s"):
+                return int(interval_part[:-1])
+            else:
+                return int(interval_part)
+        else:
+            raise ValueError(f"Unsupported schedule format: {schedule_expr}")
+
+class DeploymentScheduler:
+    """
+    Minimal deployment scheduler with provider-agnostic design.
+    
+    Features:
+    - Simple interval-based scheduling
+    - Thread-safe operation
+    - Extensible deployer factory pattern
+    - Minimal dependencies
+    """
+    
+    def __init__(self, schedule_config: Optional[Dict[str, Any]] = None):
+        self.config = schedule_config or {}
+        self.is_running = False
+        self._stop_event = threading.Event()
+        self._thread = None
+        self._deployer = None
+        
+    def set_deployer(self, deployer: DeployerInterface):
+        """Set custom deployer implementation."""
+        self._deployer = deployer
+        
+    def _get_deployer(self) -> DeployerInterface:
+        """Get deployer instance using factory pattern."""
+        if self._deployer:
+            return self._deployer
+        
+        # Default to CloudDeployer for backward compatibility
+        return CloudDeployerAdapter()
+    
+    def start(self, schedule_expr: str, max_retries: int = 3) -> bool:
+        """
+        Start scheduled deployment.
+        
+        Args:
+            schedule_expr: Schedule expression (e.g., "daily", "*/6h", "3600")
+            max_retries: Maximum retry attempts on failure
+            
+        Returns:
+            True if scheduler started successfully
+        """
+        if self.is_running:
+            logger.warning("Scheduler is already running")
+            return False
+            
+        try:
+            interval = ScheduleParser.parse(schedule_expr)
+            self.is_running = True
+            self._stop_event.clear()
+            
+            self._thread = threading.Thread(
+                target=self._run_schedule,
+                args=(interval, max_retries),
+                daemon=True
+            )
+            self._thread.start()
+            
+            logger.info(f"Deployment scheduler started with {interval}s interval")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to start scheduler: {e}")
+            self.is_running = False
+            return False
+    
+    def stop(self) -> bool:
+        """Stop the scheduler."""
+        if not self.is_running:
+            return True
+            
+        self._stop_event.set()
+        if self._thread and self._thread.is_alive():
+            self._thread.join(timeout=5)
+            
+        self.is_running = False
+        logger.info("Deployment scheduler stopped")
+        return True
+    
+    def _run_schedule(self, interval: int, max_retries: int):
+        """Internal method to run scheduled deployments."""
+        deployer = self._get_deployer()
+        
+        while not self._stop_event.is_set():
+            logger.info("Starting scheduled deployment")
+            
+            success = False
+            for attempt in range(max_retries):
+                try:
+                    if deployer.deploy():
+                        logger.info(f"Deployment successful on attempt {attempt + 1}")
+                        success = True
+                        break
+                    else:
+                        logger.warning(f"Deployment failed on attempt {attempt + 1}")
+                except Exception as e:
+                    logger.error(f"Deployment error on attempt {attempt + 1}: {e}")
+                
+                if attempt < max_retries - 1:
+                    time.sleep(30)  # Wait before retry
+            
+            if not success:
+                logger.error(f"Deployment failed after {max_retries} attempts")
+            
+            # Wait for next scheduled time
+            self._stop_event.wait(interval)
+    
+    def deploy_once(self) -> bool:
+        """Execute a single deployment immediately."""
+        deployer = self._get_deployer()
+        try:
+            return deployer.deploy()
+        except Exception as e:
+            logger.error(f"One-time deployment failed: {e}")
+            return False
+
+def create_scheduler(provider: str = "gcp", config: Optional[Dict[str, Any]] = None) -> DeploymentScheduler:
+    """
+    Factory function to create scheduler for different providers.
+    
+    Args:
+        provider: Deployment provider ("gcp", "aws", "azure", etc.)
+        config: Optional configuration dict
+        
+    Returns:
+        Configured DeploymentScheduler instance
+    """
+    scheduler = DeploymentScheduler(config)
+    
+    # Provider-specific deployer setup can be added here
+    if provider == "gcp":
+        # Default CloudDeployer for GCP
+        pass
+    elif provider == "aws":
+        # Future: AWS deployer implementation
+        logger.warning("AWS provider not yet implemented, using default")
+    elif provider == "azure":
+        # Future: Azure deployer implementation  
+        logger.warning("Azure provider not yet implemented, using default")
+    else:
+        logger.warning(f"Unknown provider {provider}, using default")
+    
+    return scheduler

{praisonai-2.2.21 → praisonai-2.2.24}/praisonai/ui/code.py

@@ -20,6 +20,7 @@ from chainlit.input_widget import TextInput
 from chainlit.types import ThreadDict
 import chainlit.data as cl_data
 from litellm import acompletion
+import litellm
 from db import DatabaseManager
 
 # Load environment variables
@@ -40,6 +41,15 @@ logger.addHandler(console_handler)
 # Set the logging level for the logger
 logger.setLevel(log_level)
 
+# Configure litellm same as in llm.py
+litellm.set_verbose = False
+litellm.success_callback = []
+litellm._async_success_callback = []
+litellm.callbacks = []
+litellm.drop_params = True
+litellm.modify_params = True
+litellm.suppress_debug_messages = True
+
 CHAINLIT_AUTH_SECRET = os.getenv("CHAINLIT_AUTH_SECRET")
 
 if not CHAINLIT_AUTH_SECRET:
@@ -55,6 +65,17 @@ db_manager.initialize()
 
 deleted_thread_ids = []  # type: List[str]
 
+def _build_completion_params(model_name, **override_params):
+    """Build parameters for litellm completion calls with proper model handling"""
+    params = {
+        "model": model_name,
+    }
+    
+    # Override with any provided parameters
+    params.update(override_params)
+    
+    return params
+
 def save_setting(key: str, value: str):
     """Saves a setting to the database.
     
@@ -237,12 +258,12 @@ Context:
     msg = cl.Message(content="")
     await msg.send()
 
-    # Prepare the completion parameters
-    completion_params = {
-        "model": model_name,
-        "messages": message_history,
-        "stream": True,
-    }
+    # Prepare the completion parameters using the helper function
+    completion_params = _build_completion_params(
+        model_name,
+        messages=message_history,
+        stream=True,
+    )
 
     # If an image is uploaded, include it in the message
     if image:
@@ -344,9 +365,11 @@ Context:
                         logger.error(f"Failed to parse function arguments: {function_args}")
 
         second_response = await acompletion(
-            model=model_name,
-            stream=True,
-            messages=messages,
+            **_build_completion_params(
+                model_name,
+                stream=True,
+                messages=messages,
+            )
         )
         logger.debug(f"Second LLM response: {second_response}")
 

{praisonai-2.2.21 → praisonai-2.2.24}/praisonai/ui/realtimeclient/tools.py

@@ -108,7 +108,7 @@ async def tavily_web_search_handler(query):
         try:
             response = tavily_client.search(query_with_date)
             logger.debug(f"Tavily search response: {response}")
-            results = process_tavily_results(response)
+            results = await process_tavily_results(response)
         except Exception as e:
             logger.error(f"Error in Tavily search: {str(e)}")
             results = await fallback_to_duckduckgo(query_with_date)
@@ -121,63 +121,63 @@ async def tavily_web_search_handler(query):
         "results": results
     })
 
-def process_tavily_results(response):
-    crawler = AsyncWebCrawler()
-    crawler.warmup()
-    results = []
-    for result in response.get('results', []):
-        url = result.get('url')
-        if url:
-            try:
-                crawl_result = crawler.run(url=url)
-                results.append({
-                    "content": result.get('content'),
-                    "url": url,
-                    "full_content": crawl_result.markdown
-                })
-            except Exception as e:
-                logger.error(f"Error crawling {url}: {str(e)}")
-                results.append({
-                    "content": result.get('content'),
-                    "url": url,
-                    "full_content": "Error: Unable to crawl this URL"
-                })
-    return results
-
-async def fallback_to_duckduckgo(query):
-    try:
-        with DDGS() as ddgs:
-            ddg_results = list(ddgs.text(query, max_results=5))
-        
-        logger.debug(f"DuckDuckGo search results: {ddg_results}")
-        
-        crawler = AsyncWebCrawler()
-        crawler.warmup()
+async def process_tavily_results(response):
+    async with AsyncWebCrawler() as crawler:
         results = []
-        
-        for result in ddg_results:
-            url = result.get('href')
+        for result in response.get('results', []):
+            url = result.get('url')
             if url:
                 try:
-                    crawl_result = crawler.run(url=url)
+                    crawl_result = await crawler.arun(url=url)
+                    full_content = crawl_result.markdown if crawl_result and hasattr(crawl_result, 'markdown') and crawl_result.markdown else "No content available"
                     results.append({
-                        "content": result.get('body'),
+                        "content": result.get('content'),
                         "url": url,
-                        "full_content": crawl_result.markdown
+                        "full_content": full_content
                     })
                 except Exception as e:
                     logger.error(f"Error crawling {url}: {str(e)}")
                     results.append({
-                        "content": result.get('body'),
+                        "content": result.get('content'),
                         "url": url,
                         "full_content": "Error: Unable to crawl this URL"
                     })
-            else:
-                results.append({
-                    "content": result.get('body'),
-                    "url": "N/A",
-                    "full_content": "No URL provided for crawling"
-                })
+    return results
+
+async def fallback_to_duckduckgo(query):
+    try:
+        with DDGS() as ddgs:
+            ddg_results = list(ddgs.text(query, max_results=5))
+        
+        logger.debug(f"DuckDuckGo search results: {ddg_results}")
+        
+        async with AsyncWebCrawler() as crawler:
+            results = []
+            
+            for result in ddg_results:
+                url = result.get('href')
+                if url:
+                    try:
+                        crawl_result = await crawler.arun(url=url)
+                        full_content = crawl_result.markdown if crawl_result and hasattr(crawl_result, 'markdown') and crawl_result.markdown else "No content available"
+                        results.append({
+                            "content": result.get('body'),
+                            "url": url,
+                            "full_content": full_content
+                        })
+                    except Exception as e:
+                        logger.error(f"Error crawling {url}: {str(e)}")
+                        results.append({
+                            "content": result.get('body'),
+                            "url": url,
+                            "full_content": "Error: Unable to crawl this URL"
+                        })
+                else:
+                    results.append({
+                        "content": result.get('body'),
+                        "url": "N/A",
+                        "full_content": "No URL provided for crawling"
+                    })
         
         return results
     except Exception as e:

{praisonai-2.2.21 → praisonai-2.2.24}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "PraisonAI"
-version = "2.2.21"
+version = "2.2.24"
 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.91",
+    "praisonaiagents>=0.0.95",
     "python-dotenv>=0.19.0",
     "instructor>=1.3.3",
     "PyYAML>=6.0",
@@ -89,12 +89,13 @@ call = [
     "rich",
     "openai>=1.54.0",
 ]
+train = []
 crewai = ["crewai>=0.32.0", "praisonai-tools>=0.0.15"]
 autogen = ["pyautogen>=0.2.19", "praisonai-tools>=0.0.15", "crewai"]
 
 [tool.poetry]
 name = "PraisonAI"
-version = "2.2.21"
+version = "2.2.24"
 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 = ""
@@ -112,7 +113,7 @@ python = ">=3.10,<3.13"
 rich = ">=13.7"
 markdown = ">=3.5"
 pyparsing = ">=3.0.0"
-praisonaiagents = ">=0.0.91"
+praisonaiagents = ">=0.0.95"
 python-dotenv = ">=0.19.0"
 instructor = ">=1.3.3"
 PyYAML = ">=6.0"
@@ -146,6 +147,7 @@ sqlalchemy = {version = ">=2.0.36", optional = true}
 playwright = {version = ">=1.47.0", optional = true}
 openai = {version = ">=1.54.0", optional = true}
 pydantic = {version = "<=2.10.1", optional = true}
+# unsloth = {version = ">=2024.11.7", extras = ["colab-new"], optional = true}
 
 [tool.poetry.group.docs.dependencies]
 mkdocs = "*"
@@ -249,7 +251,7 @@ code = [
     "playwright",
     "pydantic"
 ]
-train = ["setup-conda-env"]
+train = []
 realtime = [
     "chainlit", 
     "litellm",