praisonaiagents 0.0.19__py3-none-any.whl → 0.0.21__py3-none-any.whl

praisonaiagents/__init__.py

@@ -5,6 +5,7 @@ Praison AI Agents - A package for hierarchical AI agent task execution
 from .agent.agent import Agent
 from .agents.agents import PraisonAIAgents
 from .task.task import Task
+from .tools.tools import Tools
 from .main import (
     TaskOutput,
     ReflectionOutput,
@@ -17,12 +18,18 @@ from .main import (
     clean_triple_backticks,
     error_logs,
     register_display_callback,
-    display_callbacks,
+    sync_display_callbacks,
+    async_display_callbacks,
 )
 
+# Add Agents as an alias for PraisonAIAgents
+Agents = PraisonAIAgents
+
 __all__ = [
     'Agent',
     'PraisonAIAgents',
+    'Agents',
+    'Tools',
     'Task',
     'TaskOutput',
     'ReflectionOutput',
@@ -35,5 +42,6 @@ __all__ = [
     'clean_triple_backticks',
     'error_logs',
     'register_display_callback',
-    'display_callbacks',
+    'sync_display_callbacks',
+    'async_display_callbacks',
 ] 

praisonaiagents/agent/agent.py

@@ -3,7 +3,7 @@ import time
 import json
 import logging
 import asyncio
-from typing import List, Optional, Any, Dict, Union, Literal
+from typing import List, Optional, Any, Dict, Union, Literal, TYPE_CHECKING
 from rich.console import Console
 from rich.live import Live
 from openai import AsyncOpenAI
@@ -19,6 +19,9 @@ from ..main import (
     error_logs
 )
 
+if TYPE_CHECKING:
+    from ..task.task import Task
+
 class Agent:
     def _generate_tool_definition(self, function_name):
         """
@@ -132,10 +135,11 @@ class Agent:
 
     def __init__(
         self,
-        name: str,
-        role: str,
-        goal: str,
-        backstory: str,
+        name: Optional[str] = None,
+        role: Optional[str] = None,
+        goal: Optional[str] = None,
+        backstory: Optional[str] = None,
+        instructions: Optional[str] = None,
         llm: Optional[Union[str, Any]] = "gpt-4o",
         tools: Optional[List[Any]] = None,
         function_calling_llm: Optional[Any] = None,
@@ -158,15 +162,33 @@ class Agent:
         knowledge_sources: Optional[List[Any]] = None,
         use_system_prompt: Optional[bool] = True,
         markdown: bool = True,
-        self_reflect: bool = True,
+        self_reflect: Optional[bool] = None,
         max_reflect: int = 3,
         min_reflect: int = 1,
         reflect_llm: Optional[str] = None
     ):
-        self.name = name
-        self.role = role
-        self.goal = goal
-        self.backstory = backstory
+        # Handle backward compatibility for required fields
+        if all(x is None for x in [name, role, goal, backstory, instructions]):
+            raise ValueError("At least one of name, role, goal, backstory, or instructions must be provided")
+
+        # If instructions are provided, use them to set role, goal, and backstory
+        if instructions:
+            self.name = name or "Agent"
+            self.role = role or "Assistant"
+            self.goal = goal or instructions
+            self.backstory = backstory or instructions
+            # Set self_reflect to False by default for instruction-based agents
+            self.self_reflect = False if self_reflect is None else self_reflect
+        else:
+            # Use provided values or defaults
+            self.name = name or "Agent"
+            self.role = role or "Assistant"
+            self.goal = goal or "Help the user with their tasks"
+            self.backstory = backstory or "I am an AI assistant"
+            # Default to True for traditional agents if not specified
+            self.self_reflect = True if self_reflect is None else self_reflect
+        
+        self.instructions = instructions
         self.llm = llm
         self.tools = tools if tools else []  # Store original tools
         self.function_calling_llm = function_calling_llm
@@ -190,7 +212,6 @@ class Agent:
         self.use_system_prompt = use_system_prompt
         self.chat_history = []
         self.markdown = markdown
-        self.self_reflect = self_reflect
         self.max_reflect = max_reflect
         self.min_reflect = min_reflect
         self.reflect_llm = reflect_llm
@@ -202,6 +223,21 @@ Your Role: {self.role}\n
 Your Goal: {self.goal}
         """
 
+    def generate_task(self) -> 'Task':
+        """Generate a Task object from the agent's instructions"""
+        from ..task.task import Task
+        
+        description = self.instructions if self.instructions else f"Execute task as {self.role} with goal: {self.goal}"
+        expected_output = "Complete the assigned task successfully"
+        
+        return Task(
+            name=self.name,
+            description=description,
+            expected_output=expected_output,
+            agent=self,
+            tools=self.tools
+        )
+
     def execute_tool(self, function_name, arguments):
         """
         Execute a tool dynamically based on the function name and arguments.

praisonaiagents/agents/agents.py

@@ -41,7 +41,10 @@ def process_video(video_path: str, seconds_per_frame=2):
     return base64_frames
 
 class PraisonAIAgents:
-    def __init__(self, agents, tasks, verbose=0, completion_checker=None, max_retries=5, process="sequential", manager_llm=None):
+    def __init__(self, agents, tasks=None, verbose=0, completion_checker=None, max_retries=5, process="sequential", manager_llm=None):
+        if not agents:
+            raise ValueError("At least one agent must be provided")
+            
         self.agents = agents
         self.tasks = {}
         if max_retries < 3:
@@ -54,9 +57,36 @@ class PraisonAIAgents:
         if not manager_llm:
             logging.debug("No manager_llm provided. Using OPENAI_MODEL_NAME environment variable or defaulting to 'gpt-4o'")
         self.manager_llm = manager_llm if manager_llm else os.getenv('OPENAI_MODEL_NAME', 'gpt-4o')
+        
+        # If no tasks provided, generate them from agents
+        if tasks is None:
+            tasks = []
+            for agent in self.agents:
+                task = agent.generate_task()
+                tasks.append(task)
+            logging.info(f"Auto-generated {len(tasks)} tasks from agents")
+        else:
+            # Validate tasks for backward compatibility
+            if not tasks:
+                raise ValueError("If tasks are provided, at least one task must be present")
+            logging.info(f"Using {len(tasks)} provided tasks")
+        
+        # Add tasks and set their status
         for task in tasks:
             self.add_task(task)
             task.status = "not started"
+            
+        # If tasks were auto-generated from agents or process is sequential, set up sequential flow
+        if len(tasks) > 1 and (process == "sequential" or all(task.next_tasks == [] for task in tasks)):
+            for i in range(len(tasks) - 1):
+                # Set up next task relationship
+                tasks[i].next_tasks = [tasks[i + 1].name]
+                # Set up context for the next task to include the current task
+                if tasks[i + 1].context is None:
+                    tasks[i + 1].context = []
+                tasks[i + 1].context.append(tasks[i])
+            logging.info("Set up sequential flow with automatic context passing")
+        
         self._state = {}  # Add state storage at PraisonAIAgents level
 
     def add_task(self, task):
@@ -119,9 +149,9 @@ Expected Output: {task.expected_output}.
                 else:
                     context_results += f"Previous task {context_task.name if context_task.name else context_task.description} had no result.\n"
             task_prompt += f"""
-            Here are the results of previous tasks that might be useful:\n
-            {context_results}
-            """
+Here are the results of previous tasks that might be useful:\n
+{context_results}
+"""
         task_prompt += "Please provide only the final result of your work. Do not add any conversation or extra explanation."
 
         if self.verbose >= 2:
@@ -320,7 +350,7 @@ Expected Output: {task.expected_output}.
         task_prompt = f"""
 You need to do the following task: {task.description}.
 Expected Output: {task.expected_output}.
-        """
+"""
         if task.context:
             context_results = ""
             for context_task in task.context:
@@ -329,9 +359,9 @@ Expected Output: {task.expected_output}.
                 else:
                     context_results += f"Previous task {context_task.name if context_task.name else context_task.description} had no result.\n"
             task_prompt += f"""
-            Here are the results of previous tasks that might be useful:\n
-            {context_results}
-            """
+Here are the results of previous tasks that might be useful:\n
+{context_results}
+"""
         task_prompt += "Please provide only the final result of your work. Do not add any conversation or extra explanation."
 
         if self.verbose >= 2:

praisonaiagents/main.py

@@ -26,12 +26,49 @@ logging.basicConfig(
 # Global list to store error logs
 error_logs = []
 
-# Global callback registry
-display_callbacks = {}
+# Separate registries for sync and async callbacks
+sync_display_callbacks = {}
+async_display_callbacks = {}
+
+# At the top of the file, add display_callbacks to __all__
+__all__ = [
+    'error_logs',
+    'register_display_callback',
+    'sync_display_callbacks',
+    'async_display_callbacks',
+    # ... other exports
+]
+
+def register_display_callback(display_type: str, callback_fn, is_async: bool = False):
+    """Register a synchronous or asynchronous callback function for a specific display type.
+    
+    Args:
+        display_type (str): Type of display event ('interaction', 'self_reflection', etc.)
+        callback_fn: The callback function to register
+        is_async (bool): Whether the callback is asynchronous
+    """
+    if is_async:
+        async_display_callbacks[display_type] = callback_fn
+    else:
+        sync_display_callbacks[display_type] = callback_fn
 
-def register_display_callback(display_type: str, callback_fn):
-    """Register a callback function for a specific display type."""
-    display_callbacks[display_type] = callback_fn
+async def execute_callback(display_type: str, **kwargs):
+    """Execute both sync and async callbacks for a given display type.
+    
+    Args:
+        display_type (str): Type of display event
+        **kwargs: Arguments to pass to the callback functions
+    """
+    # Execute synchronous callback if registered
+    if display_type in sync_display_callbacks:
+        callback = sync_display_callbacks[display_type]
+        loop = asyncio.get_event_loop()
+        await loop.run_in_executor(None, lambda: callback(**kwargs))
+    
+    # Execute asynchronous callback if registered
+    if display_type in async_display_callbacks:
+        callback = async_display_callbacks[display_type]
+        await callback(**kwargs)
 
 def _clean_display_content(content: str, max_length: int = 20000) -> str:
     """Helper function to clean and truncate content for display."""
@@ -54,11 +91,10 @@ def _clean_display_content(content: str, max_length: int = 20000) -> str:
     return content.strip()
 
 def display_interaction(message, response, markdown=True, generation_time=None, console=None):
-    """Display the interaction between user and assistant."""
+    """Synchronous version of display_interaction."""
     if console is None:
         console = Console()
     
-    # Handle multimodal content (list)
     if isinstance(message, list):
         text_content = next((item["text"] for item in message if item["type"] == "text"), "")
         message = text_content
@@ -66,16 +102,16 @@ def display_interaction(message, response, markdown=True, generation_time=None,
     message = _clean_display_content(str(message))
     response = _clean_display_content(str(response))
 
-    # Execute callback if registered
-    if 'interaction' in display_callbacks:
-        display_callbacks['interaction'](
+    # Execute synchronous callback if registered
+    if 'interaction' in sync_display_callbacks:
+        sync_display_callbacks['interaction'](
             message=message,
             response=response,
             markdown=markdown,
             generation_time=generation_time
         )
 
-    # Existing display logic...
+    # Rest of the display logic...
     if generation_time:
         console.print(Text(f"Response generated in {generation_time:.1f}s", style="dim"))
 
@@ -94,8 +130,8 @@ def display_self_reflection(message: str, console=None):
     message = _clean_display_content(str(message))
     
     # Execute callback if registered
-    if 'self_reflection' in display_callbacks:
-        display_callbacks['self_reflection'](message=message)
+    if 'self_reflection' in sync_display_callbacks:
+        sync_display_callbacks['self_reflection'](message=message)
     
     console.print(Panel.fit(Text(message, style="bold yellow"), title="Self Reflection", border_style="magenta"))
 
@@ -107,8 +143,8 @@ def display_instruction(message: str, console=None):
     message = _clean_display_content(str(message))
     
     # Execute callback if registered
-    if 'instruction' in display_callbacks:
-        display_callbacks['instruction'](message=message)
+    if 'instruction' in sync_display_callbacks:
+        sync_display_callbacks['instruction'](message=message)
     
     console.print(Panel.fit(Text(message, style="bold blue"), title="Instruction", border_style="cyan"))
 
@@ -120,8 +156,8 @@ def display_tool_call(message: str, console=None):
     message = _clean_display_content(str(message))
     
     # Execute callback if registered
-    if 'tool_call' in display_callbacks:
-        display_callbacks['tool_call'](message=message)
+    if 'tool_call' in sync_display_callbacks:
+        sync_display_callbacks['tool_call'](message=message)
     
     console.print(Panel.fit(Text(message, style="bold cyan"), title="Tool Call", border_style="green"))
 
@@ -133,8 +169,8 @@ def display_error(message: str, console=None):
     message = _clean_display_content(str(message))
     
     # Execute callback if registered
-    if 'error' in display_callbacks:
-        display_callbacks['error'](message=message)
+    if 'error' in sync_display_callbacks:
+        sync_display_callbacks['error'](message=message)
     
     console.print(Panel.fit(Text(message, style="bold red"), title="Error", border_style="red"))
     error_logs.append(message)
@@ -151,8 +187,8 @@ def display_generating(content: str = "", start_time: Optional[float] = None):
     content = _clean_display_content(str(content))
     
     # Execute callback if registered
-    if 'generating' in display_callbacks:
-        display_callbacks['generating'](
+    if 'generating' in sync_display_callbacks:
+        sync_display_callbacks['generating'](
             content=content,
             elapsed_time=elapsed_str.strip() if elapsed_str else None
         )
@@ -172,26 +208,16 @@ async def adisplay_interaction(message, response, markdown=True, generation_time
     message = _clean_display_content(str(message))
     response = _clean_display_content(str(response))
 
-    if 'interaction' in display_callbacks:
-        callback = display_callbacks['interaction']
-        if asyncio.iscoroutinefunction(callback):
-            await callback(
-                message=message,
-                response=response,
-                markdown=markdown,
-                generation_time=generation_time
-            )
-        else:
-            loop = asyncio.get_event_loop()
-            await loop.run_in_executor(
-                None,
-                callback,
-                message,
-                response,
-                markdown,
-                generation_time
-            )
+    # Execute callbacks
+    await execute_callback(
+        'interaction',
+        message=message,
+        response=response,
+        markdown=markdown,
+        generation_time=generation_time
+    )
 
+    # Rest of the display logic...
     if generation_time:
         console.print(Text(f"Response generated in {generation_time:.1f}s", style="dim"))
 
@@ -210,13 +236,8 @@ async def adisplay_self_reflection(message: str, console=None):
         console = Console()
     message = _clean_display_content(str(message))
     
-    if 'self_reflection' in display_callbacks:
-        callback = display_callbacks['self_reflection']
-        if asyncio.iscoroutinefunction(callback):
-            await callback(message=message)
-        else:
-            loop = asyncio.get_event_loop()
-            await loop.run_in_executor(None, callback, message)
+    if 'self_reflection' in async_display_callbacks:
+        await async_display_callbacks['self_reflection'](message=message)
     
     console.print(Panel.fit(Text(message, style="bold yellow"), title="Self Reflection", border_style="magenta"))
 
@@ -228,13 +249,8 @@ async def adisplay_instruction(message: str, console=None):
         console = Console()
     message = _clean_display_content(str(message))
     
-    if 'instruction' in display_callbacks:
-        callback = display_callbacks['instruction']
-        if asyncio.iscoroutinefunction(callback):
-            await callback(message=message)
-        else:
-            loop = asyncio.get_event_loop()
-            await loop.run_in_executor(None, callback, message)
+    if 'instruction' in async_display_callbacks:
+        await async_display_callbacks['instruction'](message=message)
     
     console.print(Panel.fit(Text(message, style="bold blue"), title="Instruction", border_style="cyan"))
 
@@ -246,13 +262,8 @@ async def adisplay_tool_call(message: str, console=None):
         console = Console()
     message = _clean_display_content(str(message))
     
-    if 'tool_call' in display_callbacks:
-        callback = display_callbacks['tool_call']
-        if asyncio.iscoroutinefunction(callback):
-            await callback(message=message)
-        else:
-            loop = asyncio.get_event_loop()
-            await loop.run_in_executor(None, callback, message)
+    if 'tool_call' in async_display_callbacks:
+        await async_display_callbacks['tool_call'](message=message)
     
     console.print(Panel.fit(Text(message, style="bold cyan"), title="Tool Call", border_style="green"))
 
@@ -264,13 +275,8 @@ async def adisplay_error(message: str, console=None):
         console = Console()
     message = _clean_display_content(str(message))
     
-    if 'error' in display_callbacks:
-        callback = display_callbacks['error']
-        if asyncio.iscoroutinefunction(callback):
-            await callback(message=message)
-        else:
-            loop = asyncio.get_event_loop()
-            await loop.run_in_executor(None, callback, message)
+    if 'error' in async_display_callbacks:
+        await async_display_callbacks['error'](message=message)
     
     console.print(Panel.fit(Text(message, style="bold red"), title="Error", border_style="red"))
     error_logs.append(message)
@@ -287,21 +293,11 @@ async def adisplay_generating(content: str = "", start_time: Optional[float] = N
     
     content = _clean_display_content(str(content))
     
-    if 'generating' in display_callbacks:
-        callback = display_callbacks['generating']
-        if asyncio.iscoroutinefunction(callback):
-            await callback(
-                content=content,
-                elapsed_time=elapsed_str.strip() if elapsed_str else None
-            )
-        else:
-            loop = asyncio.get_event_loop()
-            await loop.run_in_executor(
-                None,
-                callback,
-                content,
-                elapsed_str.strip() if elapsed_str else None
-            )
+    if 'generating' in async_display_callbacks:
+        await async_display_callbacks['generating'](
+            content=content,
+            elapsed_time=elapsed_str.strip() if elapsed_str else None
+        )
     
     return Panel(Markdown(content), title=f"Generating...{elapsed_str}", border_style="green")
 

praisonaiagents/tools/__init__.py

@@ -0,0 +1,4 @@
+"""Tools package for PraisonAI Agents"""
+from .tools import Tools
+
+__all__ = ['Tools'] 

praisonaiagents/tools/tools.py

@@ -0,0 +1,40 @@
+"""Tools module for PraisonAI Agents"""
+from typing import List, Dict
+import logging
+import importlib
+
+class Tools:
+    @staticmethod
+    def internet_search(query: str) -> List[Dict]:
+        """
+        Perform a search using DuckDuckGo.
+
+        Args:
+            query (str): The search query.
+
+        Returns:
+            list: A list of search result titles, URLs, and snippets.
+        """
+        # Check if duckduckgo_search is installed
+        if importlib.util.find_spec("duckduckgo_search") is None:
+            error_msg = "DuckDuckGo search is not available. Please install duckduckgo_search package using: pip install duckduckgo_search"
+            logging.error(error_msg)
+            return [{"error": error_msg}]
+
+        try:
+            # Import only when needed
+            from duckduckgo_search import DDGS
+            results = []
+            ddgs = DDGS()
+            for result in ddgs.text(keywords=query, max_results=5):
+                results.append({
+                    "title": result.get("title", ""),
+                    "url": result.get("href", ""),
+                    "snippet": result.get("body", "")
+                })
+            return results
+
+        except Exception as e:
+            error_msg = f"Error during DuckDuckGo search: {e}"
+            logging.error(error_msg)
+            return [{"error": error_msg}] 

{praisonaiagents-0.0.19.dist-info → praisonaiagents-0.0.21.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: praisonaiagents
-Version: 0.0.19
+Version: 0.0.21
 Summary: Praison AI agents for completing complex tasks with Self Reflection Agents
 Author: Mervin Praison
 Requires-Dist: pydantic

{praisonaiagents-0.0.19.dist-info → praisonaiagents-0.0.21.dist-info}/RECORD

@@ -1,9 +1,9 @@
-praisonaiagents/__init__.py,sha256=bXQwi56S1iZOXs_TyXs3doxVxAeRAyqKVyZEIoBOipM,853
-praisonaiagents/main.py,sha256=XtrOfVDK4KEaclOTBxUXpc_q9F44Udue6u1W8wMvSrg,12529
+praisonaiagents/__init__.py,sha256=xJLN8i6V9SRmJFMxSRWDQt_hBePoupVd3WanNIgbBbc,1052
+praisonaiagents/main.py,sha256=7Phfe0gdxHzbhPb3WRzBTfq9CaLq0K31M5DM_4oCiCQ,12451
 praisonaiagents/agent/__init__.py,sha256=sKO8wGEXvtCrvV1e834r1Okv0XAqAxqZCqz6hKLiTvA,79
-praisonaiagents/agent/agent.py,sha256=_UmUWGbZjd3tApPX2T6RPB5Pll3Gos97XBhhg_zmfn8,30662
+praisonaiagents/agent/agent.py,sha256=NjoFCM1d2IWEgAGNcc_g0OGMLWUebkba_BgQtjM1tT4,32419
 praisonaiagents/agents/__init__.py,sha256=7RDeQNSqZg5uBjD4M_0p_F6YgfWuDuxPFydPU50kDYc,120
-praisonaiagents/agents/agents.py,sha256=P8JJ1849-djMDkMuP0kNhPwtg97L8gO60jYXzXFcPc0,21762
+praisonaiagents/agents/agents.py,sha256=EnrX-nvIsRyi2Xv1fBpZZ1kCaY9CvrcNqxgL_GNqaQc,23089
 praisonaiagents/build/lib/praisonaiagents/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4TvPL-rYUUGg,1
 praisonaiagents/build/lib/praisonaiagents/main.py,sha256=zDhN5KKtKbfruolDNxlyJkcFlkSt4KQkQTDRfQVAhxc,3960
 praisonaiagents/build/lib/praisonaiagents/agent/__init__.py,sha256=sKO8wGEXvtCrvV1e834r1Okv0XAqAxqZCqz6hKLiTvA,79
@@ -16,7 +16,9 @@ praisonaiagents/process/__init__.py,sha256=lkYbL7Hn5a0ldvJtkdH23vfIIZLIcanK-65C0
 praisonaiagents/process/process.py,sha256=4qXdrCDQPH5MtvHvdJVURXKNgSl6ae3OYTiqAF_A2ZU,24295
 praisonaiagents/task/__init__.py,sha256=VL5hXVmyGjINb34AalxpBMl-YW9m5EDcRkMTKkSSl7c,80
 praisonaiagents/task/task.py,sha256=UiiWgLDOdX_w0opP8h8-u-leVZlq1CkpGUmf7L2qyJs,3110
-praisonaiagents-0.0.19.dist-info/METADATA,sha256=engdE6dLJ0SxfZv28CX2MKTZuYc04I_CdIWBjOdijXA,233
-praisonaiagents-0.0.19.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-praisonaiagents-0.0.19.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
-praisonaiagents-0.0.19.dist-info/RECORD,,
+praisonaiagents/tools/__init__.py,sha256=rFen7LHI55mxBVW2raQmqKnK_JFuvTVVAuUmrQpDg_c,87
+praisonaiagents/tools/tools.py,sha256=fs0fjW7Y_k9qsaR0CmlPjayiiVrDxDmgfr5SwR1Tdck,1363
+praisonaiagents-0.0.21.dist-info/METADATA,sha256=o5mWRqp1BpA36xWCw2V7mArC7iujMSD2z6lTWl8_9Qo,233
+praisonaiagents-0.0.21.dist-info/WHEEL,sha256=A3WOREP4zgxI0fKrHUG8DC8013e3dK3n7a6HDbcEIwE,91
+praisonaiagents-0.0.21.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
+praisonaiagents-0.0.21.dist-info/RECORD,,

{praisonaiagents-0.0.19.dist-info → praisonaiagents-0.0.21.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.6.0)
+Generator: setuptools (75.7.0)
 Root-Is-Purelib: true
 Tag: py3-none-any