praisonaiagents 0.0.15__py3-none-any.whl → 0.0.17__py3-none-any.whl

praisonaiagents/agent/agent.py

@@ -1,9 +1,12 @@
-import logging
-import json
+import os
 import time
+import json
+import logging
+import asyncio
 from typing import List, Optional, Any, Dict, Union, Literal
 from rich.console import Console
 from rich.live import Live
+from openai import AsyncOpenAI
 from ..main import (
     display_error,
     display_tool_call,
@@ -192,6 +195,12 @@ class Agent:
         self.min_reflect = min_reflect
         self.reflect_llm = reflect_llm
         self.console = Console()  # Create a single console instance for the agent
+        
+        # Initialize system prompt
+        self.system_prompt = f"""{self.backstory}\n
+Your Role: {self.role}\n
+Your Goal: {self.goal}
+        """
 
     def execute_tool(self, function_name, arguments):
         """
@@ -536,4 +545,143 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
             cleaned = cleaned[len("```"):].strip()
         if cleaned.endswith("```"):
             cleaned = cleaned[:-3].strip()
-        return cleaned 
+        return cleaned 
+
+    async def achat(self, prompt, temperature=0.2, tools=None, output_json=None):
+        """Async version of chat method"""
+        try:
+            # Build system prompt
+            system_prompt = self.system_prompt
+            if output_json:
+                system_prompt += f"\nReturn ONLY a JSON object that matches this Pydantic model: {output_json.schema_json()}"
+
+            # Build messages
+            if isinstance(prompt, str):
+                messages = [
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": prompt + ("\nReturn ONLY a valid JSON object. No other text or explanation." if output_json else "")}
+                ]
+            else:
+                # For multimodal prompts
+                messages = [
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": prompt}
+                ]
+                if output_json:
+                    # Add JSON instruction to text content
+                    for item in messages[-1]["content"]:
+                        if item["type"] == "text":
+                            item["text"] += "\nReturn ONLY a valid JSON object. No other text or explanation."
+                            break
+
+            # Format tools if provided
+            formatted_tools = []
+            if tools:
+                for tool in tools:
+                    if isinstance(tool, str):
+                        tool_def = self._generate_tool_definition(tool)
+                        if tool_def:
+                            formatted_tools.append(tool_def)
+                    elif isinstance(tool, dict):
+                        formatted_tools.append(tool)
+                    elif hasattr(tool, "to_openai_tool"):
+                        formatted_tools.append(tool.to_openai_tool())
+                    elif callable(tool):
+                        formatted_tools.append(self._generate_tool_definition(tool.__name__))
+
+            # Create async OpenAI client
+            async_client = AsyncOpenAI()
+
+            # Make the API call based on the type of request
+            if tools:
+                response = await async_client.chat.completions.create(
+                    model=self.llm,
+                    messages=messages,
+                    temperature=temperature,
+                    tools=formatted_tools
+                )
+                return await self._achat_completion(response, tools)
+            elif output_json:
+                response = await async_client.chat.completions.create(
+                    model=self.llm,
+                    messages=messages,
+                    temperature=temperature,
+                    response_format={"type": "json_object"}
+                )
+                result = response.choices[0].message.content
+                # Clean and parse the JSON response
+                cleaned_json = self.clean_json_output(result)
+                try:
+                    parsed = json.loads(cleaned_json)
+                    return output_json(**parsed)
+                except Exception as e:
+                    display_error(f"Error parsing JSON response: {e}")
+                    return None
+            else:
+                response = await async_client.chat.completions.create(
+                    model=self.llm,
+                    messages=messages,
+                    temperature=temperature
+                )
+                return response.choices[0].message.content
+        except Exception as e:
+            display_error(f"Error in chat completion: {e}")
+            return None
+
+    async def _achat_completion(self, response, tools):
+        """Async version of _chat_completion method"""
+        try:
+            message = response.choices[0].message
+            if not hasattr(message, 'tool_calls') or not message.tool_calls:
+                return message.content
+
+            results = []
+            for tool_call in message.tool_calls:
+                try:
+                    function_name = tool_call.function.name
+                    arguments = json.loads(tool_call.function.arguments)
+                    
+                    # Find the matching tool
+                    tool = next((t for t in tools if t.__name__ == function_name), None)
+                    if not tool:
+                        display_error(f"Tool {function_name} not found")
+                        continue
+                    
+                    # Check if the tool is async
+                    if asyncio.iscoroutinefunction(tool):
+                        result = await tool(**arguments)
+                    else:
+                        # Run sync function in executor to avoid blocking
+                        loop = asyncio.get_event_loop()
+                        result = await loop.run_in_executor(None, lambda: tool(**arguments))
+                    
+                    results.append(result)
+                except Exception as e:
+                    display_error(f"Error executing tool {function_name}: {e}")
+                    results.append(None)
+
+            # If we have results, format them into a response
+            if results:
+                formatted_results = "\n".join([str(r) for r in results if r is not None])
+                if formatted_results:
+                    messages = [
+                        {"role": "system", "content": self.system_prompt},
+                        {"role": "assistant", "content": "Here are the tool results:"},
+                        {"role": "user", "content": formatted_results + "\nPlease process these results and provide a final response."}
+                    ]
+                    try:
+                        async_client = AsyncOpenAI()
+                        final_response = await async_client.chat.completions.create(
+                            model=self.llm,
+                            messages=messages,
+                            temperature=0.2
+                        )
+                        return final_response.choices[0].message.content
+                    except Exception as e:
+                        display_error(f"Error in final chat completion: {e}")
+                        return formatted_results
+                return formatted_results
+            return None
+        except Exception as e:
+            display_error(f"Error in _achat_completion: {e}")
+            return None 

praisonaiagents/agents/agents.py

@@ -10,10 +10,8 @@ from rich.console import Console
 from ..main import display_error, TaskOutput, error_logs, client
 from ..agent.agent import Agent
 from ..task.task import Task
-from ..process.process import Process
-
-class LoopItems(BaseModel):
-    items: List[Any]
+from ..process.process import Process, LoopItems
+import asyncio
 
 def encode_file_to_base64(file_path: str) -> str:
     """Base64-encode a file."""
@@ -85,7 +83,8 @@ class PraisonAIAgents:
             return True
         return len(agent_output.strip()) > 0
 
-    def execute_task(self, task_id):
+    async def aexecute_task(self, task_id):
+        """Async version of execute_task method"""
         if task_id not in self.tasks:
             display_error(f"Error: Task with ID {task_id} does not exist")
             return
@@ -162,12 +161,12 @@ Expected Output: {task.expected_output}.
                         })
                 return content
 
-            agent_output = executor_agent.chat(
+            agent_output = await executor_agent.achat(
                 _get_multimodal_message(task_prompt, task.images),
                 tools=task.tools
             )
         else:
-            agent_output = executor_agent.chat(task_prompt, tools=task.tools)
+            agent_output = await executor_agent.achat(task_prompt, tools=task.tools)
 
         if agent_output:
             task_output = TaskOutput(
@@ -205,6 +204,83 @@ Expected Output: {task.expected_output}.
             task.status = "failed"
             return None
 
+    async def arun_task(self, task_id):
+        """Async version of run_task method"""
+        if task_id not in self.tasks:
+            display_error(f"Error: Task with ID {task_id} does not exist")
+            return
+        task = self.tasks[task_id]
+        if task.status == "completed":
+            logging.info(f"Task with ID {task_id} is already completed")
+            return
+
+        retries = 0
+        while task.status != "completed" and retries < self.max_retries:
+            logging.debug(f"Attempt {retries+1} for task {task_id}")
+            if task.status in ["not started", "in progress"]:
+                task_output = await self.aexecute_task(task_id)
+                if task_output and self.completion_checker(task, task_output.raw):
+                    task.status = "completed"
+                    if task.callback:
+                        await task.execute_callback(task_output)
+                    self.save_output_to_file(task, task_output)
+                    if self.verbose >= 1:
+                        logging.info(f"Task {task_id} completed successfully.")
+                else:
+                    task.status = "in progress"
+                    if self.verbose >= 1:
+                        logging.info(f"Task {task_id} not completed, retrying")
+                    await asyncio.sleep(1)
+                    retries += 1
+            else:
+                if task.status == "failed":
+                    logging.info("Task is failed, resetting to in-progress for another try...")
+                    task.status = "in progress"
+                else:
+                    logging.info("Invalid Task status")
+                    break
+
+        if retries == self.max_retries and task.status != "completed":
+            logging.info(f"Task {task_id} failed after {self.max_retries} retries.")
+
+    async def arun_all_tasks(self):
+        """Async version of run_all_tasks method"""
+        process = Process(
+            tasks=self.tasks,
+            agents=self.agents,
+            manager_llm=self.manager_llm,
+            verbose=self.verbose
+        )
+        
+        if self.process == "workflow":
+            async for task_id in process.aworkflow():
+                if self.tasks[task_id].async_execution:
+                    await self.arun_task(task_id)
+                else:
+                    self.run_task(task_id)
+        elif self.process == "sequential":
+            async for task_id in process.asequential():
+                if self.tasks[task_id].async_execution:
+                    await self.arun_task(task_id)
+                else:
+                    self.run_task(task_id)
+        elif self.process == "hierarchical":
+            async for task_id in process.ahierarchical():
+                if isinstance(task_id, Task):
+                    task_id = self.add_task(task_id)
+                if self.tasks[task_id].async_execution:
+                    await self.arun_task(task_id)
+                else:
+                    self.run_task(task_id)
+
+    async def astart(self):
+        """Async version of start method"""
+        await self.arun_all_tasks()
+        return {
+            "task_status": self.get_all_tasks_status(),
+            "task_results": {task_id: self.get_task_result(task_id) for task_id in self.tasks}
+        }
+
     def save_output_to_file(self, task, task_output):
         if task.output_file:
             try:
@@ -217,7 +293,129 @@ Expected Output: {task.expected_output}.
             except Exception as e:
                 display_error(f"Error saving task output to file: {e}")
 
+    def execute_task(self, task_id):
+        """Synchronous version of execute_task method"""
+        if task_id not in self.tasks:
+            display_error(f"Error: Task with ID {task_id} does not exist")
+            return
+        task = self.tasks[task_id]
+        
+        # Only import multimodal dependencies if task has images
+        if task.images and task.status == "not started":
+            try:
+                import cv2
+                import base64
+                from moviepy import VideoFileClip
+            except ImportError as e:
+                display_error(f"Error: Missing required dependencies for image/video processing: {e}")
+                display_error("Please install with: pip install opencv-python moviepy")
+                task.status = "failed"
+                return None
+
+        if task.status == "not started":
+            task.status = "in progress"
+
+        executor_agent = task.agent
+
+        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:
+                if context_task.result:
+                    context_results += f"Result of previous task {context_task.name if context_task.name else context_task.description}: {context_task.result.raw}\n"
+                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}
+            """
+        task_prompt += "Please provide only the final result of your work. Do not add any conversation or extra explanation."
+
+        if self.verbose >= 2:
+            logging.info(f"Executing task {task_id}: {task.description} using {executor_agent.name}")
+        logging.debug(f"Starting execution of task {task_id} with prompt:\n{task_prompt}")
+
+        if task.images:
+            def _get_multimodal_message(text_prompt, images):
+                content = [{"type": "text", "text": text_prompt}]
+
+                for img in images:
+                    # If local file path for a valid image
+                    if os.path.exists(img):
+                        ext = os.path.splitext(img)[1].lower()
+                        # If it's a .mp4, convert to frames
+                        if ext == ".mp4":
+                            frames = process_video(img, seconds_per_frame=1)
+                            content.append({"type": "text", "text": "These are frames from the video."})
+                            for f in frames:
+                                content.append({
+                                    "type": "image_url",
+                                    "image_url": {"url": f"data:image/jpg;base64,{f}"}
+                                })
+                        else:
+                            encoded = encode_file_to_base64(img)
+                            content.append({
+                                "type": "image_url",
+                                "image_url": {
+                                    "url": f"data:image/{ext.lstrip('.')};base64,{encoded}"
+                                }
+                            })
+                    else:
+                        # Treat as a remote URL
+                        content.append({
+                            "type": "image_url",
+                            "image_url": {"url": img}
+                        })
+                return content
+
+            agent_output = executor_agent.chat(
+                _get_multimodal_message(task_prompt, task.images),
+                tools=task.tools
+            )
+        else:
+            agent_output = executor_agent.chat(task_prompt, tools=task.tools)
+
+        if agent_output:
+            task_output = TaskOutput(
+                description=task.description,
+                summary=task.description[:10],
+                raw=agent_output,
+                agent=executor_agent.name,
+                output_format="RAW"
+            )
+
+            if task.output_json:
+                cleaned = self.clean_json_output(agent_output)
+                try:
+                    parsed = json.loads(cleaned)
+                    task_output.json_dict = parsed
+                    task_output.output_format = "JSON"
+                except:
+                    logging.warning(f"Warning: Could not parse output of task {task_id} as JSON")
+                    logging.debug(f"Output that failed JSON parsing: {agent_output}")
+
+            if task.output_pydantic:
+                cleaned = self.clean_json_output(agent_output)
+                try:
+                    parsed = json.loads(cleaned)
+                    pyd_obj = task.output_pydantic(**parsed)
+                    task_output.pydantic = pyd_obj
+                    task_output.output_format = "Pydantic"
+                except:
+                    logging.warning(f"Warning: Could not parse output of task {task_id} as Pydantic Model")
+                    logging.debug(f"Output that failed Pydantic parsing: {agent_output}")
+
+            task.result = task_output
+            return task_output
+        else:
+            task.status = "failed"
+            return None
+
     def run_task(self, task_id):
+        """Synchronous version of run_task method"""
         if task_id not in self.tasks:
             display_error(f"Error: Task with ID {task_id} does not exist")
             return
@@ -256,7 +454,7 @@ Expected Output: {task.expected_output}.
             logging.info(f"Task {task_id} failed after {self.max_retries} retries.")
 
     def run_all_tasks(self):
-        """Execute tasks based on execution mode"""
+        """Synchronous version of run_all_tasks method"""
         process = Process(
             tasks=self.tasks,
             agents=self.agents,

praisonaiagents/process/process.py

@@ -1,11 +1,13 @@
 import logging
-from typing import Dict, Optional, List
+import asyncio
+from typing import Dict, Optional, List, Any, AsyncGenerator
 from pydantic import BaseModel
 from ..agent.agent import Agent
 from ..task.task import Task
+from ..main import display_error, client
 
 class LoopItems(BaseModel):
-    items: List[any]
+    items: List[Any]
 
 class Process:
     def __init__(self, tasks: Dict[str, Task], agents: List[Agent], manager_llm: Optional[str] = None, verbose: bool = False):
@@ -14,7 +16,275 @@ class Process:
         self.manager_llm = manager_llm
         self.verbose = verbose
 
+    async def aworkflow(self) -> AsyncGenerator[str, None]:
+        """Async version of workflow method"""
+        # Build workflow relationships first
+        for task in self.tasks.values():
+            if task.next_tasks:
+                for next_task_name in task.next_tasks:
+                    next_task = next((t for t in self.tasks.values() if t.name == next_task_name), None)
+                    if next_task:
+                        next_task.previous_tasks.append(task.name)
+
+        # Find start task
+        start_task = None
+        for task_id, task in self.tasks.items():
+            if task.is_start:
+                start_task = task
+                break
+        
+        if not start_task:
+            start_task = list(self.tasks.values())[0]
+            logging.info("No start task marked, using first task")
+        
+        current_task = start_task
+        visited_tasks = set()
+        loop_data = {}  # Store loop-specific data
+        
+        while current_task and current_task.id not in visited_tasks:
+            task_id = current_task.id
+            logging.info(f"Executing workflow task: {current_task.name if current_task.name else task_id}")
+            
+            # Add context from previous tasks to description
+            if current_task.previous_tasks or current_task.context:
+                context = "\nInput data from previous tasks:"
+                
+                # Add data from previous tasks in workflow
+                for prev_name in current_task.previous_tasks:
+                    prev_task = next((t for t in self.tasks.values() if t.name == prev_name), None)
+                    if prev_task and prev_task.result:
+                        # Handle loop data
+                        if current_task.task_type == "loop":
+                            # create a loop manager Agent
+                            loop_manager = Agent(
+                                name="Loop Manager",
+                                role="Loop data processor",
+                                goal="Process loop data and convert it to list format",
+                                backstory="Expert at handling loop data and converting it to proper format",
+                                llm=self.manager_llm,
+                                verbose=self.verbose,
+                                markdown=True
+                            )
+
+                            # get the loop data convert it to list using calling Agent class chat
+                            loop_prompt = f"""
+Process this data into a list format:
+{prev_task.result.raw}
+
+Return a JSON object with an 'items' array containing the items to process.
+"""
+                            if current_task.async_execution:
+                                loop_data_str = await loop_manager.achat(
+                                    prompt=loop_prompt,
+                                    output_json=LoopItems
+                                )
+                            else:
+                                loop_data_str = loop_manager.chat(
+                                    prompt=loop_prompt,
+                                    output_json=LoopItems
+                                )
+                            
+                            try:
+                                # The response will already be parsed into LoopItems model
+                                loop_data[f"loop_{current_task.name}"] = {
+                                    "items": loop_data_str.items,
+                                    "index": 0,
+                                    "remaining": len(loop_data_str.items)
+                                }
+                                context += f"\nCurrent loop item: {loop_data_str.items[0]}"
+                            except Exception as e:
+                                display_error(f"Failed to process loop data: {e}")
+                                context += f"\n{prev_name}: {prev_task.result.raw}"
+                        else:
+                            context += f"\n{prev_name}: {prev_task.result.raw}"
+                
+                # Add data from context tasks
+                if current_task.context:
+                    for ctx_task in current_task.context:
+                        if ctx_task.result and ctx_task.name != current_task.name:
+                            context += f"\n{ctx_task.name}: {ctx_task.result.raw}"
+                
+                # Update task description with context
+                current_task.description = current_task.description + context
+            
+            # Execute task using existing run_task method
+            yield task_id
+            visited_tasks.add(task_id)
+            
+            # Handle loop progression
+            if current_task.task_type == "loop":
+                loop_key = f"loop_{current_task.name}"
+                if loop_key in loop_data:
+                    loop_info = loop_data[loop_key]
+                    loop_info["index"] += 1
+                    has_more = loop_info["remaining"] > 0
+                    
+                    # Update result to trigger correct condition
+                    if current_task.result:
+                        result = current_task.result.raw
+                        if has_more:
+                            result += "\nmore"
+                        else:
+                            result += "\ndone"
+                        current_task.result.raw = result
+                    
+            # Determine next task based on result
+            next_task = None
+            if current_task.result:
+                if current_task.task_type in ["decision", "loop"]:
+                    result = current_task.result.raw.lower()
+                    # Check conditions
+                    for condition, tasks in current_task.condition.items():
+                        if condition.lower() in result and tasks:
+                            next_task_name = tasks[0]
+                            next_task = next((t for t in self.tasks.values() if t.name == next_task_name), None)
+                            # For loops, allow revisiting the same task
+                            if next_task and next_task.id == current_task.id:
+                                visited_tasks.discard(current_task.id)
+                            break
+            
+                if not next_task and current_task.next_tasks:
+                    next_task_name = current_task.next_tasks[0]
+                    next_task = next((t for t in self.tasks.values() if t.name == next_task_name), None)
+            
+            current_task = next_task
+            if not current_task:
+                logging.info("Workflow execution completed")
+                break
+
+    async def asequential(self) -> AsyncGenerator[str, None]:
+        """Async version of sequential method"""
+        for task_id in self.tasks:
+            if self.tasks[task_id].status != "completed":
+                yield task_id
+
+    async def ahierarchical(self) -> AsyncGenerator[str, None]:
+        """Async version of hierarchical method"""
+        logging.debug(f"Starting hierarchical task execution with {len(self.tasks)} tasks")
+        manager_agent = Agent(
+            name="Manager",
+            role="Project manager",
+            goal="Manage the entire flow of tasks and delegate them to the right agent",
+            backstory="Expert project manager to coordinate tasks among agents",
+            llm=self.manager_llm,
+            verbose=self.verbose,
+            markdown=True,
+            self_reflect=False
+        )
+
+        class ManagerInstructions(BaseModel):
+            task_id: int
+            agent_name: str
+            action: str
+
+        manager_task = Task(
+            name="manager_task",
+            description="Decide the order of tasks and which agent executes them",
+            expected_output="All tasks completed successfully",
+            agent=manager_agent
+        )
+        manager_task_id = yield manager_task
+        logging.info(f"Created manager task with ID {manager_task_id}")
+
+        completed_count = 0
+        total_tasks = len(self.tasks) - 1
+        logging.info(f"Need to complete {total_tasks} tasks (excluding manager task)")
+
+        while completed_count < total_tasks:
+            tasks_summary = []
+            for tid, tk in self.tasks.items():
+                if tk.name == "manager_task":
+                    continue
+                task_info = {
+                    "task_id": tid,
+                    "name": tk.name,
+                    "description": tk.description,
+                    "status": tk.status if tk.status else "not started",
+                    "agent": tk.agent.name if tk.agent else "No agent"
+                }
+                tasks_summary.append(task_info)
+                logging.info(f"Task {tid} status: {task_info}")
+
+            manager_prompt = f"""
+Here is the current status of all tasks except yours (manager_task):
+{tasks_summary}
+
+Provide a JSON with the structure:
+{{
+   "task_id": <int>,
+   "agent_name": "<string>",
+   "action": "<execute or stop>"
+}}
+"""
+
+            try:
+                logging.info("Requesting manager instructions...")
+                if manager_task.async_execution:
+                    manager_response = await client.beta.chat.completions.parse(
+                        model=self.manager_llm,
+                        messages=[
+                            {"role": "system", "content": manager_task.description},
+                            {"role": "user", "content": manager_prompt}
+                        ],
+                        temperature=0.7,
+                        response_format=ManagerInstructions
+                    )
+                else:
+                    manager_response = client.beta.chat.completions.parse(
+                        model=self.manager_llm,
+                        messages=[
+                            {"role": "system", "content": manager_task.description},
+                            {"role": "user", "content": manager_prompt}
+                        ],
+                        temperature=0.7,
+                        response_format=ManagerInstructions
+                    )
+                parsed_instructions = manager_response.choices[0].message.parsed
+                logging.info(f"Manager instructions: {parsed_instructions}")
+            except Exception as e:
+                display_error(f"Manager parse error: {e}")
+                logging.error(f"Manager parse error: {str(e)}", exc_info=True)
+                break
+
+            selected_task_id = parsed_instructions.task_id
+            selected_agent_name = parsed_instructions.agent_name
+            action = parsed_instructions.action
+
+            logging.info(f"Manager selected task_id={selected_task_id}, agent={selected_agent_name}, action={action}")
+
+            if action.lower() == "stop":
+                logging.info("Manager decided to stop task execution")
+                break
+
+            if selected_task_id not in self.tasks:
+                error_msg = f"Manager selected invalid task id {selected_task_id}"
+                display_error(error_msg)
+                logging.error(error_msg)
+                break
+
+            original_agent = self.tasks[selected_task_id].agent.name if self.tasks[selected_task_id].agent else "None"
+            for a in self.agents:
+                if a.name == selected_agent_name:
+                    self.tasks[selected_task_id].agent = a
+                    logging.info(f"Changed agent for task {selected_task_id} from {original_agent} to {selected_agent_name}")
+                    break
+
+            if self.tasks[selected_task_id].status != "completed":
+                logging.info(f"Starting execution of task {selected_task_id}")
+                yield selected_task_id
+                logging.info(f"Finished execution of task {selected_task_id}, status: {self.tasks[selected_task_id].status}")
+
+            if self.tasks[selected_task_id].status == "completed":
+                completed_count += 1
+                logging.info(f"Task {selected_task_id} completed. Total completed: {completed_count}/{total_tasks}")
+
+        self.tasks[manager_task.id].status = "completed"
+        if self.verbose >= 1:
+            logging.info("All tasks completed under manager supervision.")
+        logging.info("Hierarchical task execution finished") 
+
     def workflow(self):
+        """Synchronous version of workflow method"""
         # Build workflow relationships first
         for task in self.tasks.values():
             if task.next_tasks:
@@ -144,11 +414,13 @@ Return a JSON object with an 'items' array containing the items to process.
                 break
 
     def sequential(self):
+        """Synchronous version of sequential method"""
         for task_id in self.tasks:
             if self.tasks[task_id].status != "completed":
                 yield task_id
 
     def hierarchical(self):
+        """Synchronous version of hierarchical method"""
         logging.debug(f"Starting hierarchical task execution with {len(self.tasks)} tasks")
         manager_agent = Agent(
             name="Manager",

praisonaiagents/task/task.py

@@ -1,5 +1,6 @@
 import logging
-from typing import List, Optional, Dict, Any, Type, Callable, Union
+import asyncio
+from typing import List, Optional, Dict, Any, Type, Callable, Union, Coroutine
 from pydantic import BaseModel
 from ..main import TaskOutput
 from ..agent.agent import Agent
@@ -19,7 +20,7 @@ class Task:
         output_file: Optional[str] = None,
         output_json: Optional[Type[BaseModel]] = None,
         output_pydantic: Optional[Type[BaseModel]] = None,
-        callback: Optional[Any] = None,
+        callback: Optional[Union[Callable[[TaskOutput], Any], Callable[[TaskOutput], Coroutine[Any, Any, Any]]]] = None,
         status: str = "not started",
         result: Optional[TaskOutput] = None,
         create_directory: Optional[bool] = False,
@@ -61,4 +62,13 @@ class Task:
         self.previous_tasks = []
 
     def __str__(self):
-        return f"Task(name='{self.name if self.name else 'None'}', description='{self.description}', agent='{self.agent.name if self.agent else 'None'}', status='{self.status}')" 
+        return f"Task(name='{self.name if self.name else 'None'}', description='{self.description}', agent='{self.agent.name if self.agent else 'None'}', status='{self.status}')"
+
+    async def execute_callback(self, task_output: TaskOutput) -> None:
+        """Execute the callback function, handling both sync and async callbacks"""
+        if self.callback:
+            if asyncio.iscoroutinefunction(self.callback):
+                await self.callback(task_output)
+            else:
+                loop = asyncio.get_event_loop()
+                await loop.run_in_executor(None, self.callback, task_output) 

{praisonaiagents-0.0.15.dist-info → praisonaiagents-0.0.17.dist-info}/METADATA

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

{praisonaiagents-0.0.15.dist-info → praisonaiagents-0.0.17.dist-info}/RECORD

@@ -1,9 +1,9 @@
 praisonaiagents/__init__.py,sha256=gI8vEabBTRPsE_E8GA5sBMi4sTtJI-YokPrH2Nor-k0,741
 praisonaiagents/main.py,sha256=K2OxVKPmo4dNJbSWIsXDi_hm9CRx5O4km_74UGcszhk,5744
 praisonaiagents/agent/__init__.py,sha256=sKO8wGEXvtCrvV1e834r1Okv0XAqAxqZCqz6hKLiTvA,79
-praisonaiagents/agent/agent.py,sha256=zTYcDpJ5DzzBnefwLvhrtBlGQoRI4ZZAioDu5nKTPSs,24042
+praisonaiagents/agent/agent.py,sha256=_UmUWGbZjd3tApPX2T6RPB5Pll3Gos97XBhhg_zmfn8,30662
 praisonaiagents/agents/__init__.py,sha256=7RDeQNSqZg5uBjD4M_0p_F6YgfWuDuxPFydPU50kDYc,120
-praisonaiagents/agents/agents.py,sha256=ngPFNTmv3whf22litkQacUGaRghX-NbLPAC6Ejy9qoU,13003
+praisonaiagents/agents/agents.py,sha256=P8JJ1849-djMDkMuP0kNhPwtg97L8gO60jYXzXFcPc0,21762
 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
@@ -13,10 +13,10 @@ praisonaiagents/build/lib/praisonaiagents/agents/agents.py,sha256=P2FAtlfD3kPib5
 praisonaiagents/build/lib/praisonaiagents/task/__init__.py,sha256=VL5hXVmyGjINb34AalxpBMl-YW9m5EDcRkMTKkSSl7c,80
 praisonaiagents/build/lib/praisonaiagents/task/task.py,sha256=4Y1qX8OeEFcid2yhAiPYylvHpuDmWORsyNL16_BiVvI,1831
 praisonaiagents/process/__init__.py,sha256=lkYbL7Hn5a0ldvJtkdH23vfIIZLIcanK-65C0MwaorY,52
-praisonaiagents/process/process.py,sha256=BgtFgTQjLoqHzj97zDtALjuP_ciOErMDB9quDTlZFjg,11676
+praisonaiagents/process/process.py,sha256=4qXdrCDQPH5MtvHvdJVURXKNgSl6ae3OYTiqAF_A2ZU,24295
 praisonaiagents/task/__init__.py,sha256=VL5hXVmyGjINb34AalxpBMl-YW9m5EDcRkMTKkSSl7c,80
-praisonaiagents/task/task.py,sha256=oMC5Zz1dMj0Ceice69aBS1KQQXMLqphc8wNOQ9zcu0Q,2570
-praisonaiagents-0.0.15.dist-info/METADATA,sha256=QERXlBCD9drRfFrI5GwbLzbIaLX_FnOM9UVxFwIwDBo,233
-praisonaiagents-0.0.15.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-praisonaiagents-0.0.15.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
-praisonaiagents-0.0.15.dist-info/RECORD,,
+praisonaiagents/task/task.py,sha256=UiiWgLDOdX_w0opP8h8-u-leVZlq1CkpGUmf7L2qyJs,3110
+praisonaiagents-0.0.17.dist-info/METADATA,sha256=oh0bnTHpGDwnn15L-t8v4kdApFBwOZ_BKj24mGnJUqA,233
+praisonaiagents-0.0.17.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+praisonaiagents-0.0.17.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
+praisonaiagents-0.0.17.dist-info/RECORD,,