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

praisonaiagents/agents/agents.py

@@ -10,6 +10,7 @@ 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]
@@ -256,254 +257,24 @@ Expected Output: {task.expected_output}.
 
     def run_all_tasks(self):
         """Execute tasks based on execution mode"""
+        process = Process(
+            tasks=self.tasks,
+            agents=self.agents,
+            manager_llm=self.manager_llm,
+            verbose=self.verbose
+        )
+        
         if self.process == "workflow":
-            # 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.
-"""
-                                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
+            for task_id in process.workflow():
                 self.run_task(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
-
         elif self.process == "sequential":
-            # Keep original sequential execution
-            for task_id in self.tasks:
-                if self.tasks[task_id].status != "completed":
-                    self.run_task(task_id)
-
+            for task_id in process.sequential():
+                self.run_task(task_id)
         elif self.process == "hierarchical":
-            # Keep original hierarchical execution
-            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 = self.add_task(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...")
-                    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}")
-                    self.run_task(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")
+            for task_id in process.hierarchical():
+                if isinstance(task_id, Task):
+                    task_id = self.add_task(task_id)
+                self.run_task(task_id)
 
     def get_task_status(self, task_id):
         if task_id in self.tasks:

praisonaiagents/process/__init__.py

@@ -0,0 +1,3 @@
+from .process import Process
+
+__all__ = ['Process'] 

praisonaiagents/process/process.py

@@ -0,0 +1,262 @@
+import logging
+from typing import Dict, Optional, List
+from pydantic import BaseModel
+from ..agent.agent import Agent
+from ..task.task import Task
+
+class LoopItems(BaseModel):
+    items: List[any]
+
+class Process:
+    def __init__(self, tasks: Dict[str, Task], agents: List[Agent], manager_llm: Optional[str] = None, verbose: bool = False):
+        self.tasks = tasks
+        self.agents = agents
+        self.manager_llm = manager_llm
+        self.verbose = verbose
+
+    def workflow(self):
+        # 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.
+"""
+                            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
+
+    def sequential(self):
+        for task_id in self.tasks:
+            if self.tasks[task_id].status != "completed":
+                yield task_id
+
+    def hierarchical(self):
+        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...")
+                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") 

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

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

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

@@ -3,7 +3,7 @@ praisonaiagents/main.py,sha256=K2OxVKPmo4dNJbSWIsXDi_hm9CRx5O4km_74UGcszhk,5744
 praisonaiagents/agent/__init__.py,sha256=sKO8wGEXvtCrvV1e834r1Okv0XAqAxqZCqz6hKLiTvA,79
 praisonaiagents/agent/agent.py,sha256=zTYcDpJ5DzzBnefwLvhrtBlGQoRI4ZZAioDu5nKTPSs,24042
 praisonaiagents/agents/__init__.py,sha256=7RDeQNSqZg5uBjD4M_0p_F6YgfWuDuxPFydPU50kDYc,120
-praisonaiagents/agents/agents.py,sha256=ITvH8Yq_OzhyMC_Aid4qlqQbEM9cCfp7SayXg0ASJ5k,24526
+praisonaiagents/agents/agents.py,sha256=ngPFNTmv3whf22litkQacUGaRghX-NbLPAC6Ejy9qoU,13003
 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
@@ -12,9 +12,11 @@ praisonaiagents/build/lib/praisonaiagents/agents/__init__.py,sha256=cgCLFLFcLp9S
 praisonaiagents/build/lib/praisonaiagents/agents/agents.py,sha256=P2FAtlfD3kPib5a1oLVYanxlU6e4-GhBMQ0YDY5MHY4,13473
 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/task/__init__.py,sha256=VL5hXVmyGjINb34AalxpBMl-YW9m5EDcRkMTKkSSl7c,80
 praisonaiagents/task/task.py,sha256=oMC5Zz1dMj0Ceice69aBS1KQQXMLqphc8wNOQ9zcu0Q,2570
-praisonaiagents-0.0.14.dist-info/METADATA,sha256=-pdlX7m7Sr2IovIrRt9QyBfkiwgK81rEd3_VklcmHNs,233
-praisonaiagents-0.0.14.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-praisonaiagents-0.0.14.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
-praisonaiagents-0.0.14.dist-info/RECORD,,
+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,,