praisonaiagents 0.0.58__py3-none-any.whl → 0.0.59__py3-none-any.whl

praisonaiagents/process/process.py

@@ -12,6 +12,8 @@ class LoopItems(BaseModel):
     items: List[Any]
 
 class Process:
+    DEFAULT_RETRY_LIMIT = 3  # Predefined retry limit in a common place
+
     def __init__(self, tasks: Dict[str, Task], agents: List[Agent], manager_llm: Optional[str] = None, verbose: bool = False, max_iter: int = 10):
         logging.debug(f"=== Initializing Process ===")
         logging.debug(f"Number of tasks: {len(tasks)}")
@@ -19,12 +21,52 @@ class Process:
         logging.debug(f"Manager LLM: {manager_llm}")
         logging.debug(f"Verbose mode: {verbose}")
         logging.debug(f"Max iterations: {max_iter}")
-        
+
         self.tasks = tasks
         self.agents = agents
         self.manager_llm = manager_llm
         self.verbose = verbose
         self.max_iter = max_iter
+        self.task_retry_counter: Dict[str, int] = {} # Initialize retry counter
+        self.workflow_finished = False # ADDED: Workflow finished flag
+
+    def _find_next_not_started_task(self) -> Optional[Task]:
+        """Fallback mechanism to find the next 'not started' task."""
+        fallback_attempts = 0
+        temp_current_task = None
+        
+        # Clear previous task context before finding next task
+        for task in self.tasks.values():
+            if hasattr(task, 'description') and 'Input data from previous tasks:' in task.description:
+                task.description = task.description.split('Input data from previous tasks:')[0].strip()
+        
+        while fallback_attempts < Process.DEFAULT_RETRY_LIMIT and not temp_current_task:
+            fallback_attempts += 1
+            logging.debug(f"Fallback attempt {fallback_attempts}: Trying to find next 'not started' task.")
+            for task_candidate in self.tasks.values():
+                if task_candidate.status == "not started":
+                    # Check if there's a condition path to this task
+                    current_conditions = task_candidate.condition or {}
+                    leads_to_task = any(
+                        task_value for task_value in current_conditions.values() 
+                        if isinstance(task_value, (list, str)) and task_value
+                    )
+                    
+                    if not leads_to_task and not task_candidate.next_tasks:
+                        continue  # Skip if no valid path exists
+                        
+                    if self.task_retry_counter.get(task_candidate.id, 0) < Process.DEFAULT_RETRY_LIMIT:
+                        self.task_retry_counter[task_candidate.id] = self.task_retry_counter.get(task_candidate.id, 0) + 1
+                        temp_current_task = task_candidate
+                        logging.debug(f"Fallback attempt {fallback_attempts}: Found 'not started' task: {temp_current_task.name}, retry count: {self.task_retry_counter[temp_current_task.id]}")
+                        return temp_current_task # Return the found task immediately
+                    else:
+                        logging.debug(f"Max retries reached for task {task_candidate.name} in fallback mode, marking as failed.")
+                        task_candidate.status = "failed"
+            if not temp_current_task:
+                logging.debug(f"Fallback attempt {fallback_attempts}: No 'not started' task found within retry limit.")
+        return None # Return None if no task found after all attempts
+
 
     async def aworkflow(self) -> AsyncGenerator[str, None]:
         """Async version of workflow method"""
@@ -48,23 +90,50 @@ class Process:
                 start_task = task
                 logging.debug(f"Found marked start task: {task.name} (id: {task_id})")
                 break
-        
+
         if not start_task:
             start_task = list(self.tasks.values())[0]
             logging.debug(f"No start task marked, using first task: {start_task.name}")
-        
+
         current_task = start_task
         visited_tasks = set()
         loop_data = {}  # Store loop-specific data
 
         # TODO: start task with loop feature is not available in aworkflow method
-        
+
         while current_task:
             current_iter += 1
             if current_iter > self.max_iter:
                 logging.info(f"Max iteration limit {self.max_iter} reached, ending workflow.")
                 break
 
+            # ADDED: Check workflow finished flag at the start of each cycle
+            if self.workflow_finished:
+                logging.info("Workflow finished early as all tasks are completed.")
+                break
+
+            # Add task summary at start of each cycle
+            logging.debug(f"""
+=== Workflow Cycle {current_iter} Summary ===
+Total tasks: {len(self.tasks)}
+Outstanding tasks: {sum(1 for t in self.tasks.values() if t.status != "completed")}
+Completed tasks: {sum(1 for t in self.tasks.values() if t.status == "completed")}
+Tasks by status:
+- Not started: {sum(1 for t in self.tasks.values() if t.status == "not started")}
+- In progress: {sum(1 for t in self.tasks.values() if t.status == "in_progress")}
+- Completed: {sum(1 for t in self.tasks.values() if t.status == "completed")}
+Tasks by type:
+- Loop tasks: {sum(1 for t in self.tasks.values() if t.task_type == "loop")}
+- Decision tasks: {sum(1 for t in self.tasks.values() if t.task_type == "decision")}
+- Regular tasks: {sum(1 for t in self.tasks.values() if t.task_type not in ["loop", "decision"])}
+            """)
+
+            # ADDED: Check if all tasks are completed and set workflow_finished flag
+            if all(task.status == "completed" for task in self.tasks.values()):
+                logging.info("All tasks are completed.")
+                self.workflow_finished = True
+                # The next iteration loop check will break the workflow
+
             task_id = current_task.id
             logging.debug(f"""
 === Task Execution Details ===
@@ -76,11 +145,11 @@ Next tasks: {current_task.next_tasks}
 Context tasks: {[t.name for t in current_task.context] if current_task.context else []}
 Description length: {len(current_task.description)}
             """)
-            
+
             # 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)
@@ -90,16 +159,16 @@ Description length: {len(current_task.description)}
                             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
-            
+
             # Skip execution for loop tasks, only process their subtasks
             if current_task.task_type == "loop":
                 logging.debug(f"""
@@ -112,7 +181,7 @@ Condition: {current_task.condition}
 Subtasks created: {getattr(current_task, '_subtasks_created', False)}
 Input file: {getattr(current_task, 'input_file', None)}
                 """)
-                
+
                 # Check if subtasks are created and completed
                 if getattr(current_task, "_subtasks_created", False):
                     subtasks = [
@@ -125,7 +194,7 @@ Total subtasks: {len(subtasks)}
 Completed: {sum(1 for st in subtasks if st.status == "completed")}
 Pending: {sum(1 for st in subtasks if st.status != "completed")}
                     """)
-                    
+
                     # Log detailed subtask info
                     for st in subtasks:
                         logging.debug(f"""
@@ -134,27 +203,53 @@ Subtask: {st.name}
 - Next tasks: {st.next_tasks}
 - Condition: {st.condition}
                         """)
-                    
+
                     if subtasks and all(st.status == "completed" for st in subtasks):
                         logging.debug(f"=== All {len(subtasks)} subtasks completed for {current_task.name} ===")
-                        
+
                         # Mark loop task completed and move to next task
                         current_task.status = "completed"
                         logging.debug(f"Loop {current_task.name} marked as completed")
+
+                        # Set result for loop task when all subtasks complete
+                        if not current_task.result:
+                            # Get result from last completed subtask
+                            last_subtask = next((t for t in reversed(subtasks) if t.status == "completed"), None)
+                            if last_subtask and last_subtask.result:
+                                current_task.result = last_subtask.result
                         
-                        # Move to next task if available
-                        if current_task.next_tasks:
-                            next_task_name = current_task.next_tasks[0]
-                            logging.debug(f"Attempting transition to next task: {next_task_name}")
-                            next_task = next((t for t in self.tasks.values() if t.name == next_task_name), None)
+                        # Route to next task based on condition
+                        if current_task.condition:
+                            # Get decision from result if available
+                            decision_str = None
+                            if current_task.result:
+                                if current_task.result.pydantic and hasattr(current_task.result.pydantic, "decision"):
+                                    decision_str = current_task.result.pydantic.decision.lower()
+                                elif current_task.result.raw:
+                                    decision_str = current_task.result.raw.lower()
+                            
+                            # For loop tasks, use "done" to follow condition path
+                            if current_task.task_type == "loop" and all(t.status == "completed" for t in subtasks):
+                                decision_str = "done"
+                            
+                            target_tasks = current_task.condition.get(decision_str, []) if decision_str else []
+                            task_value = target_tasks[0] if isinstance(target_tasks, list) else target_tasks
+                            next_task = next((t for t in self.tasks.values() if t.name == task_value), None)
                             if next_task:
-                                logging.debug(f"=== Transitioning: {current_task.name} -> {next_task.name} ===")
-                                logging.debug(f"Next task status: {next_task.status}")
-                                logging.debug(f"Next task condition: {next_task.condition}")
-                            current_task = next_task
-                        else:
-                            logging.debug(f"=== No next tasks for {current_task.name}, ending loop ===")
-                            current_task = None
+                                next_task.status = "not started"  # Reset status to allow execution
+                                logging.debug(f"Routing to {next_task.name} based on decision: {decision_str}")
+                                self.workflow_finished = False
+                                current_task = next_task
+                                # Ensure the task is yielded for execution
+                                if current_task.id not in visited_tasks:
+                                    yield current_task.id
+                                    visited_tasks.add(current_task.id)
+                            else:
+                                # End workflow if no valid next task found
+                                logging.info(f"No valid next task found for decision: {decision_str}")
+                                self.workflow_finished = True
+                                current_task = None
+                                break
                 else:
                     logging.debug(f"No subtasks created yet for {current_task.name}")
                     # Create subtasks if needed
@@ -179,25 +274,38 @@ Subtask: {st.name}
                 logging.debug(f"Task next_tasks: {current_task.next_tasks}")
                 yield task_id
                 visited_tasks.add(task_id)
-            
+
+                # Only end workflow if no next_tasks AND no conditions
+                if not current_task.next_tasks and not current_task.condition and not any(
+                    t.task_type == "loop" and current_task.name.startswith(t.name + "_")
+                    for t in self.tasks.values()
+                ):
+                    logging.info(f"Task {current_task.name} has no next tasks, ending workflow")
+                    self.workflow_finished = True
+                    current_task = None
+                    break
+
             # Reset completed task to "not started" so it can run again
             if self.tasks[task_id].status == "completed":
-                # Never reset loop tasks, decision tasks, or their subtasks
+                # Never reset loop tasks, decision tasks, or their subtasks if rerun is False
                 subtask_name = self.tasks[task_id].name
+                task_to_check = self.tasks[task_id]
                 logging.debug(f"=== Checking reset for completed task: {subtask_name} ===")
-                logging.debug(f"Task type: {self.tasks[task_id].task_type}")
-                logging.debug(f"Task status before reset check: {self.tasks[task_id].status}")
-                
-                if (self.tasks[task_id].task_type not in ["loop", "decision"] and
-                    not any(t.task_type == "loop" and subtask_name.startswith(t.name + "_") 
+                logging.debug(f"Task type: {task_to_check.task_type}")
+                logging.debug(f"Task status before reset check: {task_to_check.status}")
+                logging.debug(f"Task rerun: {getattr(task_to_check, 'rerun', True)}") # default to True if not set
+
+                if (getattr(task_to_check, 'rerun', True) and # Corrected condition - reset only if rerun is True (or default True)
+                    task_to_check.task_type != "loop" and # Removed "decision" from exclusion
+                    not any(t.task_type == "loop" and subtask_name.startswith(t.name + "_")
                            for t in self.tasks.values())):
                     logging.debug(f"=== Resetting non-loop, non-decision task {subtask_name} to 'not started' ===")
                     self.tasks[task_id].status = "not started"
                     logging.debug(f"Task status after reset: {self.tasks[task_id].status}")
                 else:
-                    logging.debug(f"=== Skipping reset for loop/decision/subtask: {subtask_name} ===")
+                    logging.debug(f"=== Skipping reset for loop/decision/subtask or rerun=False: {subtask_name} ===")
                     logging.debug(f"Keeping status as: {self.tasks[task_id].status}")
-            
+
             # Handle loop progression
             if current_task.task_type == "loop":
                 loop_key = f"loop_{current_task.name}"
@@ -205,7 +313,7 @@ Subtask: {st.name}
                     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
@@ -214,38 +322,77 @@ Subtask: {st.name}
                         else:
                             result += "\ndone"
                         current_task.result.raw = result
-                    
+
             # Determine next task based on result
             next_task = None
             if current_task and current_task.result:
                 if current_task.task_type in ["decision", "loop"]:
-                    # MINIMAL CHANGE: use pydantic decision if present
+                    # Get decision from pydantic or raw response
                     decision_str = current_task.result.raw.lower()
                     if current_task.result.pydantic and hasattr(current_task.result.pydantic, "decision"):
                         decision_str = current_task.result.pydantic.decision.lower()
 
-                    # Check conditions
-                    for condition, tasks in current_task.condition.items():
-                        if condition.lower() == decision_str:
-                            # Handle both list and direct string values
-                            task_value = tasks[0] if isinstance(tasks, list) else tasks
-                            if not task_value or task_value == "exit":
-                                logging.info("Workflow exit condition met, ending workflow")
-                                current_task = None
-                                break
-                            next_task_name = task_value
-                            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)
+                    # Check if task has conditions and next_tasks
+                    if current_task.condition:
+                        # Get target task based on decision
+                        target_tasks = current_task.condition.get(decision_str, [])
+                        # Handle all forms of exit conditions
+                        if not target_tasks or target_tasks == "exit" or (isinstance(target_tasks, list) and (not target_tasks or target_tasks[0] == "exit")):
+                            logging.info(f"Workflow exit condition met on decision: {decision_str}")
+                            self.workflow_finished = True
+                            current_task = None
                             break
-            
+                        else:
+                            # Find the target task by name
+                            task_value = target_tasks[0] if isinstance(target_tasks, list) else target_tasks
+                            next_task = next((t for t in self.tasks.values() if t.name == task_value), None)
+                            if next_task:
+                                next_task.status = "not started"  # Reset status to allow execution
+                                logging.debug(f"Routing to {next_task.name} based on decision: {decision_str}")
+                                # Don't mark workflow as finished when following condition path
+                                self.workflow_finished = False
+
+            # If no condition-based routing, use next_tasks
             if not next_task and current_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)
-            
+                if next_task:
+                    # Reset the next task to allow re-execution
+                    next_task.status = "not started"
+                    # Don't mark workflow as finished if we're in a task loop
+                    if (next_task.previous_tasks and current_task.name in next_task.previous_tasks and 
+                        next_task.next_tasks and 
+                        next_task.next_tasks[0] in self.tasks and 
+                        next_task.name in self.tasks[next_task.next_tasks[0]].previous_tasks):
+                        self.workflow_finished = False
+                    logging.debug(f"Following next_tasks to {next_task.name}")
+
             current_task = next_task
             if not current_task:
+                current_task = self._find_next_not_started_task() # General fallback if no next task in workflow
+
+
+            if not current_task:
+                # Add final workflow summary
+                logging.debug(f"""
+=== Final Workflow Summary ===
+Total tasks processed: {len(self.tasks)}
+Final status:
+- Completed tasks: {sum(1 for t in self.tasks.values() if t.status == "completed")}
+- Outstanding tasks: {sum(1 for t in self.tasks.values() if t.status != "completed")}
+Tasks by status:
+- Not started: {sum(1 for t in self.tasks.values() if t.status == "not started")}
+- In progress: {sum(1 for t in self.tasks.values() if t.status == "in_progress")}
+- Completed: {sum(1 for t in self.tasks.values() if t.status == "completed")}
+- Failed: {sum(1 for t in self.tasks.values() if t.status == "failed")}
+Tasks by type:
+- Loop tasks: {sum(1 for t in self.tasks.values() if t.task_type == "loop")}
+- Decision tasks: {sum(1 for t in self.tasks.values() if t.task_type == "decision")}
+- Regular tasks: {sum(1 for t in self.tasks.values() if t.task_type not in ["loop", "decision"])}
+Total iterations: {current_iter}
+Workflow Finished: {self.workflow_finished} # ADDED: Workflow Finished Status
+                """)
+
                 logging.info("Workflow execution completed")
                 break
 
@@ -256,6 +403,7 @@ Task: {current_task.name}
 Final status: {current_task.status}
 Next task: {next_task.name if next_task else None}
 Iteration: {current_iter}/{self.max_iter}
+Workflow Finished: {self.workflow_finished} # ADDED: Workflow Finished Status
             """)
 
     async def asequential(self) -> AsyncGenerator[str, None]:
@@ -387,7 +535,7 @@ Provide a JSON with the structure:
         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") 
+        logging.info("Hierarchical task execution finished")
 
     def workflow(self):
         """Synchronous version of workflow method"""
@@ -406,12 +554,12 @@ Provide a JSON with the structure:
             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")
 
-        # If loop type and no input_file, default to tasks.csv 
+        # If loop type and no input_file, default to tasks.csv
         if start_task and start_task.task_type == "loop" and not start_task.input_file:
             start_task.input_file = "tasks.csv"
 
@@ -420,17 +568,17 @@ Provide a JSON with the structure:
             try:
                 file_ext = os.path.splitext(start_task.input_file)[1].lower()
                 new_tasks = []
-                
+
                 if file_ext == ".csv":
                     with open(start_task.input_file, "r", encoding="utf-8") as f:
                         reader = csv.reader(f, quotechar='"', escapechar='\\')  # Handle quoted/escaped fields
                         previous_task = None
                         task_count = 0
-                        
+
                         for i, row in enumerate(reader):
                             if not row:  # Skip truly empty rows
                                 continue
-                                
+
                             # Properly handle Q&A pairs with potential commas
                             task_desc = row[0].strip() if row else ""
                             if len(row) > 1:
@@ -438,16 +586,16 @@ Provide a JSON with the structure:
                                 question = row[0].strip()
                                 answer = ",".join(field.strip() for field in row[1:])
                                 task_desc = f"Question: {question}\nAnswer: {answer}"
-                            
+
                             if not task_desc:  # Skip rows with empty content
                                 continue
-                                
+
                             task_count += 1
                             logging.debug(f"Processing CSV row {i+1}: {task_desc}")
-                            
+
                             # Inherit next_tasks from parent loop task
                             inherited_next_tasks = start_task.next_tasks if start_task.next_tasks else []
-                            
+
                             row_task = Task(
                                 description=f"{start_task.description}\n{task_desc}" if start_task.description else task_desc,
                                 agent=start_task.agent,
@@ -464,16 +612,16 @@ Provide a JSON with the structure:
                             )
                             self.tasks[row_task.id] = row_task
                             new_tasks.append(row_task)
-                            
+
                             if previous_task:
                                 previous_task.next_tasks = [row_task.name]
                                 previous_task.condition["done"] = [row_task.name]  # Use "done" consistently
                             previous_task = row_task
-                            
+
                             # For the last task in the loop, ensure it points to parent's next tasks
                             if task_count > 0 and not row_task.next_tasks:
                                 row_task.next_tasks = inherited_next_tasks
-                            
+
                         logging.info(f"Processed {task_count} rows from CSV file")
                 else:
                     # If not CSV, read lines
@@ -495,7 +643,7 @@ Provide a JSON with the structure:
                             )
                             self.tasks[row_task.id] = row_task
                             new_tasks.append(row_task)
-                            
+
                             if previous_task:
                                 previous_task.next_tasks = [row_task.name]
                                 previous_task.condition["complete"] = [row_task.name]
@@ -511,26 +659,54 @@ Provide a JSON with the structure:
         current_task = start_task
         visited_tasks = set()
         loop_data = {}  # Store loop-specific data
-        
+
         while current_task:
             current_iter += 1
             if current_iter > self.max_iter:
                 logging.info(f"Max iteration limit {self.max_iter} reached, ending workflow.")
                 break
 
+            # ADDED: Check workflow finished flag at the start of each cycle
+            if self.workflow_finished:
+                logging.info("Workflow finished early as all tasks are completed.")
+                break
+
+            # Add task summary at start of each cycle
+            logging.debug(f"""
+=== Workflow Cycle {current_iter} Summary ===
+Total tasks: {len(self.tasks)}
+Outstanding tasks: {sum(1 for t in self.tasks.values() if t.status != "completed")}
+Completed tasks: {sum(1 for t in self.tasks.values() if t.status == "completed")}
+Tasks by status:
+- Not started: {sum(1 for t in self.tasks.values() if t.status == "not started")}
+- In progress: {sum(1 for t in self.tasks.values() if t.status == "in_progress")}
+- Completed: {sum(1 for t in self.tasks.values() if t.status == "completed")}
+Tasks by type:
+- Loop tasks: {sum(1 for t in self.tasks.values() if t.task_type == "loop")}
+- Decision tasks: {sum(1 for t in self.tasks.values() if t.task_type == "decision")}
+- Regular tasks: {sum(1 for t in self.tasks.values() if t.task_type not in ["loop", "decision"])}
+            """)
+
+            # ADDED: Check if all tasks are completed and set workflow_finished flag
+            if all(task.status == "completed" for task in self.tasks.values()):
+                logging.info("All tasks are completed.")
+                self.workflow_finished = True
+                # The next iteration loop check will break the workflow
+
+
             # Handle loop task file reading at runtime
-            if (current_task.task_type == "loop" and 
-                current_task is not start_task and 
+            if (current_task.task_type == "loop" and
+                current_task is not start_task and
                 getattr(current_task, "_subtasks_created", False) is not True):
-                
+
                 if not current_task.input_file:
                     current_task.input_file = "tasks.csv"
-                
+
                 if getattr(current_task, "input_file", None):
                     try:
                         file_ext = os.path.splitext(current_task.input_file)[1].lower()
                         new_tasks = []
-                        
+
                         if file_ext == ".csv":
                             with open(current_task.input_file, "r", encoding="utf-8") as f:
                                 reader = csv.reader(f)
@@ -552,7 +728,7 @@ Provide a JSON with the structure:
                                         )
                                         self.tasks[row_task.id] = row_task
                                         new_tasks.append(row_task)
-                                        
+
                                         if previous_task:
                                             previous_task.next_tasks = [row_task.name]
                                             previous_task.condition["complete"] = [row_task.name]
@@ -576,7 +752,7 @@ Provide a JSON with the structure:
                                     )
                                     self.tasks[row_task.id] = row_task
                                     new_tasks.append(row_task)
-                                    
+
                                     if previous_task:
                                         previous_task.next_tasks = [row_task.name]
                                         previous_task.condition["complete"] = [row_task.name]
@@ -600,11 +776,11 @@ Next tasks: {current_task.next_tasks}
 Context tasks: {[t.name for t in current_task.context] if current_task.context else []}
 Description length: {len(current_task.description)}
             """)
-            
+
             # 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)
@@ -614,16 +790,16 @@ Description length: {len(current_task.description)}
                             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
-            
+
             # Skip execution for loop tasks, only process their subtasks
             if current_task.task_type == "loop":
                 logging.debug(f"""
@@ -636,14 +812,14 @@ Condition: {current_task.condition}
 Subtasks created: {getattr(current_task, '_subtasks_created', False)}
 Input file: {getattr(current_task, 'input_file', None)}
                 """)
-                
+
                 # Check if subtasks are created and completed
                 if getattr(current_task, "_subtasks_created", False):
                     subtasks = [
                         t for t in self.tasks.values()
                         if t.name.startswith(current_task.name + "_")
                     ]
-                    
+
                     logging.debug(f"""
 === Subtask Status Check ===
 Total subtasks: {len(subtasks)}
@@ -661,24 +837,50 @@ Subtask: {st.name}
 
                     if subtasks and all(st.status == "completed" for st in subtasks):
                         logging.debug(f"=== All {len(subtasks)} subtasks completed for {current_task.name} ===")
-                        
+
                         # Mark loop task completed and move to next task
                         current_task.status = "completed"
                         logging.debug(f"Loop {current_task.name} marked as completed")
+
+                        # Set result for loop task when all subtasks complete
+                        if not current_task.result:
+                            # Get result from last completed subtask
+                            last_subtask = next((t for t in reversed(subtasks) if t.status == "completed"), None)
+                            if last_subtask and last_subtask.result:
+                                current_task.result = last_subtask.result
                         
-                        # Move to next task if available
-                        if current_task.next_tasks:
-                            next_task_name = current_task.next_tasks[0]
-                            logging.debug(f"Attempting transition to next task: {next_task_name}")
-                            next_task = next((t for t in self.tasks.values() if t.name == next_task_name), None)
+                        # Route to next task based on condition
+                        if current_task.condition:
+                            # Get decision from result if available
+                            decision_str = None
+                            if current_task.result:
+                                if current_task.result.pydantic and hasattr(current_task.result.pydantic, "decision"):
+                                    decision_str = current_task.result.pydantic.decision.lower()
+                                elif current_task.result.raw:
+                                    decision_str = current_task.result.raw.lower()
+                            
+                            # For loop tasks, use "done" to follow condition path
+                            if current_task.task_type == "loop" and all(t.status == "completed" for t in subtasks):
+                                decision_str = "done"
+                            
+                            target_tasks = current_task.condition.get(decision_str, []) if decision_str else []
+                            task_value = target_tasks[0] if isinstance(target_tasks, list) else target_tasks
+                            next_task = next((t for t in self.tasks.values() if t.name == task_value), None)
                             if next_task:
-                                logging.debug(f"=== Transitioning: {current_task.name} -> {next_task.name} ===")
-                                logging.debug(f"Next task status: {next_task.status}")
-                                logging.debug(f"Next task condition: {next_task.condition}")
-                            current_task = next_task
-                        else:
-                            logging.debug(f"=== No next tasks for {current_task.name}, ending loop ===")
-                            current_task = None
+                                next_task.status = "not started"  # Reset status to allow execution
+                                logging.debug(f"Routing to {next_task.name} based on decision: {decision_str}")
+                                self.workflow_finished = False
+                                current_task = next_task
+                                # Ensure the task is yielded for execution
+                                if current_task.id not in visited_tasks:
+                                    yield current_task.id
+                                    visited_tasks.add(current_task.id)
+                            else:
+                                # End workflow if no valid next task found
+                                logging.info(f"No valid next task found for decision: {decision_str}")
+                                self.workflow_finished = True
+                                current_task = None
+                                break
                 else:
                     logging.debug(f"No subtasks created yet for {current_task.name}")
                     # Create subtasks if needed
@@ -703,25 +905,39 @@ Subtask: {st.name}
                 logging.debug(f"Task next_tasks: {current_task.next_tasks}")
                 yield task_id
                 visited_tasks.add(task_id)
-            
+
+                # Only end workflow if no next_tasks AND no conditions
+                if not current_task.next_tasks and not current_task.condition and not any(
+                    t.task_type == "loop" and current_task.name.startswith(t.name + "_")
+                    for t in self.tasks.values()
+                ):
+                    logging.info(f"Task {current_task.name} has no next tasks, ending workflow")
+                    self.workflow_finished = True
+                    current_task = None
+                    break
+
             # Reset completed task to "not started" so it can run again
             if self.tasks[task_id].status == "completed":
-                # Never reset loop tasks, decision tasks, or their subtasks
+                # Never reset loop tasks, decision tasks, or their subtasks if rerun is False
                 subtask_name = self.tasks[task_id].name
+                task_to_check = self.tasks[task_id]
                 logging.debug(f"=== Checking reset for completed task: {subtask_name} ===")
-                logging.debug(f"Task type: {self.tasks[task_id].task_type}")
-                logging.debug(f"Task status before reset check: {self.tasks[task_id].status}")
-                
-                if (self.tasks[task_id].task_type not in ["loop", "decision"] and
-                    not any(t.task_type == "loop" and subtask_name.startswith(t.name + "_") 
+                logging.debug(f"Task type: {task_to_check.task_type}")
+                logging.debug(f"Task status before reset check: {task_to_check.status}")
+                logging.debug(f"Task rerun: {getattr(task_to_check, 'rerun', True)}") # default to True if not set
+
+                if (getattr(task_to_check, 'rerun', True) and # Corrected condition - reset only if rerun is True (or default True)
+                    task_to_check.task_type != "loop" and # Removed "decision" from exclusion
+                    not any(t.task_type == "loop" and subtask_name.startswith(t.name + "_")
                            for t in self.tasks.values())):
                     logging.debug(f"=== Resetting non-loop, non-decision task {subtask_name} to 'not started' ===")
                     self.tasks[task_id].status = "not started"
                     logging.debug(f"Task status after reset: {self.tasks[task_id].status}")
                 else:
-                    logging.debug(f"=== Skipping reset for loop/decision/subtask: {subtask_name} ===")
+                    logging.debug(f"=== Skipping reset for loop/decision/subtask or rerun=False: {subtask_name} ===")
                     logging.debug(f"Keeping status as: {self.tasks[task_id].status}")
-            
+
+
             # Handle loop progression
             if current_task.task_type == "loop":
                 loop_key = f"loop_{current_task.name}"
@@ -729,7 +945,7 @@ Subtask: {st.name}
                     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
@@ -738,41 +954,90 @@ Subtask: {st.name}
                         else:
                             result += "\ndone"
                         current_task.result.raw = result
-                    
+
             # Determine next task based on result
             next_task = None
             if current_task and current_task.result:
                 if current_task.task_type in ["decision", "loop"]:
-                    # MINIMAL CHANGE: use pydantic decision if present
+                    # Get decision from pydantic or raw response
                     decision_str = current_task.result.raw.lower()
                     if current_task.result.pydantic and hasattr(current_task.result.pydantic, "decision"):
                         decision_str = current_task.result.pydantic.decision.lower()
 
-                    # Check conditions
-                    for condition, tasks in current_task.condition.items():
-                        if condition.lower() == decision_str:
-                            # Handle both list and direct string values
-                            task_value = tasks[0] if isinstance(tasks, list) else tasks
-                            if not task_value or task_value == "exit":
-                                logging.info("Workflow exit condition met, ending workflow")
-                                current_task = None
-                                break
-                            next_task_name = task_value
-                            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)
+                    # Check if task has conditions and next_tasks
+                    if current_task.condition:
+                        # Get target task based on decision
+                        target_tasks = current_task.condition.get(decision_str, [])
+                        # Handle all forms of exit conditions
+                        if not target_tasks or target_tasks == "exit" or (isinstance(target_tasks, list) and (not target_tasks or target_tasks[0] == "exit")):
+                            logging.info(f"Workflow exit condition met on decision: {decision_str}")
+                            self.workflow_finished = True
+                            current_task = None
                             break
-            
+                        else:
+                            # Find the target task by name
+                            task_value = target_tasks[0] if isinstance(target_tasks, list) else target_tasks
+                            next_task = next((t for t in self.tasks.values() if t.name == task_value), None)
+                            if next_task:
+                                next_task.status = "not started"  # Reset status to allow execution
+                                logging.debug(f"Routing to {next_task.name} based on decision: {decision_str}")
+                                # Don't mark workflow as finished when following condition path
+                                self.workflow_finished = False
+
+            # If no condition-based routing, use next_tasks
             if not next_task and current_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)
-            
+                if next_task:
+                    # Reset the next task to allow re-execution
+                    next_task.status = "not started"
+                    # Don't mark workflow as finished if we're in a task loop
+                    if (next_task.previous_tasks and current_task.name in next_task.previous_tasks and 
+                        next_task.next_tasks and 
+                        next_task.next_tasks[0] in self.tasks and 
+                        next_task.name in self.tasks[next_task.next_tasks[0]].previous_tasks):
+                        self.workflow_finished = False
+                    logging.debug(f"Following next_tasks to {next_task.name}")
+
             current_task = next_task
             if not current_task:
+                current_task = self._find_next_not_started_task() # General fallback if no next task in workflow
+
+
+            if not current_task:
+                # Add final workflow summary
+                logging.debug(f"""
+=== Final Workflow Summary ===
+Total tasks processed: {len(self.tasks)}
+Final status:
+- Completed tasks: {sum(1 for t in self.tasks.values() if t.status == "completed")}
+- Outstanding tasks: {sum(1 for t in self.tasks.values() if t.status != "completed")}
+Tasks by status:
+- Not started: {sum(1 for t in self.tasks.values() if t.status == "not started")}
+- In progress: {sum(1 for t in self.tasks.values() if t.status == "in_progress")}
+- Completed: {sum(1 for t in self.tasks.values() if t.status == "completed")}
+- Failed: {sum(1 for t in self.tasks.values() if t.status == "failed")}
+Tasks by type:
+- Loop tasks: {sum(1 for t in self.tasks.values() if t.task_type == "loop")}
+- Decision tasks: {sum(1 for t in self.tasks.values() if t.task_type == "decision")}
+- Regular tasks: {sum(1 for t in self.tasks.values() if t.task_type not in ["loop", "decision"])}
+Total iterations: {current_iter}
+Workflow Finished: {self.workflow_finished} # ADDED: Workflow Finished Status
+                """)
+
                 logging.info("Workflow execution completed")
                 break
 
+            # Add completion logging
+            logging.debug(f"""
+=== Task Completion ===
+Task: {current_task.name}
+Final status: {current_task.status}
+Next task: {next_task.name if next_task else None}
+Iteration: {current_iter}/{self.max_iter}
+Workflow Finished: {self.workflow_finished} # ADDED: Workflow Finished Status
+            """)
+
     def sequential(self):
         """Synchronous version of sequential method"""
         for task_id in self.tasks:
@@ -891,4 +1156,4 @@ Provide a JSON with the structure:
         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") 
+        logging.info("Hierarchical task execution finished")

praisonaiagents/task/task.py

@@ -38,7 +38,8 @@ class Task:
         loop_state: Optional[Dict[str, Union[str, int]]] = None,
         memory=None,
         quality_check=True,
-        input_file: Optional[str] = None
+        input_file: Optional[str] = None,
+        rerun: bool = False # Renamed from can_rerun and logic inverted, default True for backward compatibility
     ):
         # Add check if memory config is provided
         if memory is not None or (config and config.get('memory_config')):
@@ -76,6 +77,7 @@ class Task:
         self.loop_state = loop_state if loop_state else {}
         self.memory = memory
         self.quality_check = quality_check
+        self.rerun = rerun # Assigning the rerun parameter
 
         # Set logger level based on config verbose level
         verbose = self.config.get("verbose", 0)
@@ -83,7 +85,7 @@ class Task:
             logger.setLevel(logging.INFO)
         else:
             logger.setLevel(logging.WARNING)
-            
+
         # Also set third-party loggers to WARNING
         logging.getLogger('chromadb').setLevel(logging.WARNING)
         logging.getLogger('openai').setLevel(logging.WARNING)
@@ -148,7 +150,7 @@ class Task:
                 logger.info(f"Task {self.id}: Initializing memory from config: {self.config['memory_config']}")
                 self.memory = Memory(config=self.config['memory_config'])
                 logger.info(f"Task {self.id}: Memory initialized successfully")
-                
+
                 # Verify database was created
                 if os.path.exists(self.config['memory_config']['storage']['path']):
                     logger.info(f"Task {self.id}: Memory database exists after initialization")
@@ -182,11 +184,11 @@ class Task:
         """Execute callback and store quality metrics if enabled"""
         logger.info(f"Task {self.id}: execute_callback called")
         logger.info(f"Quality check enabled: {self.quality_check}")
-        
+
         # Initialize memory if not already initialized
         if not self.memory:
             self.memory = self.initialize_memory()
-        
+
         logger.info(f"Memory object exists: {self.memory is not None}")
         if self.memory:
             logger.info(f"Memory config: {self.memory.cfg}")
@@ -202,24 +204,24 @@ class Task:
             except Exception as e:
                 logger.error(f"Task {self.id}: Failed to store task output in memory: {e}")
                 logger.exception(e)
-        
+
         logger.info(f"Task output: {task_output.raw[:100]}...")
-        
+
         if self.quality_check and self.memory:
             try:
                 logger.info(f"Task {self.id}: Starting memory operations")
                 logger.info(f"Task {self.id}: Calculating quality metrics for output: {task_output.raw[:100]}...")
-                
+
                 # Get quality metrics from LLM
                 metrics = self.memory.calculate_quality_metrics(
                     task_output.raw,
                     self.expected_output
                 )
                 logger.info(f"Task {self.id}: Quality metrics calculated: {metrics}")
-                
+
                 quality_score = metrics.get("accuracy", 0.0)
                 logger.info(f"Task {self.id}: Quality score: {quality_score}")
-                
+
                 # Store in both short and long-term memory with higher threshold
                 logger.info(f"Task {self.id}: Finalizing task output in memory...")
                 self.memory.finalize_task_output(
@@ -231,7 +233,7 @@ class Task:
                     task_id=self.id
                 )
                 logger.info(f"Task {self.id}: Finalized task output in memory")
-                
+
                 # Store quality metrics separately
                 logger.info(f"Task {self.id}: Storing quality metrics...")
                 self.memory.store_quality(
@@ -240,7 +242,7 @@ class Task:
                     task_id=self.id,
                     metrics=metrics
                 )
-                
+
                 # Store in both short and long-term memory with higher threshold
                 self.memory.finalize_task_output(
                     content=task_output.raw,
@@ -248,7 +250,7 @@ class Task:
                     quality_score=quality_score,
                     threshold=0.7  # Only high quality outputs in long-term memory
                 )
-                
+
                 # Build context for next tasks
                 if self.next_tasks:
                     logger.info(f"Task {self.id}: Building context for next tasks...")
@@ -257,7 +259,7 @@ class Task:
                         max_items=5
                     )
                     logger.info(f"Task {self.id}: Built context for next tasks: {len(context)} items")
-                
+
                 logger.info(f"Task {self.id}: Memory operations complete")
             except Exception as e:
                 logger.error(f"Task {self.id}: Failed to process memory operations: {e}")
@@ -295,7 +297,7 @@ Expected Output: {self.expected_output}.
                         context_results.append(
                             f"Previous task {context_item.name if context_item.name else context_item.description} has no result yet."
                         )
-            
+
             # Join unique context results
             unique_contexts = list(dict.fromkeys(context_results))  # Remove duplicates
             task_prompt += f"""
@@ -307,7 +309,7 @@ Context:
     def execute_callback_sync(self, task_output: TaskOutput) -> None:
         """
         Synchronous wrapper to ensure that execute_callback is awaited,
-        preventing 'Task was destroyed but pending!' warnings if called 
+        preventing 'Task was destroyed but pending!' warnings if called
         from non-async code.
         """
         import asyncio

{praisonaiagents-0.0.58.dist-info → praisonaiagents-0.0.59.dist-info}/METADATA

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

{praisonaiagents-0.0.58.dist-info → praisonaiagents-0.0.59.dist-info}/RECORD

@@ -12,9 +12,9 @@ praisonaiagents/llm/__init__.py,sha256=ttPQQJQq6Tah-0updoEXDZFKWtJAM93rBWRoIgxRW
 praisonaiagents/llm/llm.py,sha256=G2wKMwitWBJRS6nOq9W77zXtsxvJwsVwXFOKYcllY0E,51386
 praisonaiagents/memory/memory.py,sha256=I8dOTkrl1i-GgQbDcrFOsSruzJ7MiI6Ys37DK27wrUs,35537
 praisonaiagents/process/__init__.py,sha256=lkYbL7Hn5a0ldvJtkdH23vfIIZLIcanK-65C0MwaorY,52
-praisonaiagents/process/process.py,sha256=BrS8_4Gt2ewXt559hThJTSrXVYG8daabO9tGDaWmrm0,44906
+praisonaiagents/process/process.py,sha256=HPw84OhnKQW3EyrDkpoQu0DcpxThbrzR2hWUgwQh9Pw,59955
 praisonaiagents/task/__init__.py,sha256=VL5hXVmyGjINb34AalxpBMl-YW9m5EDcRkMTKkSSl7c,80
-praisonaiagents/task/task.py,sha256=ikFjzNm4WPYONSLtWA3uDGNIUx_TvXTeU5SukWoC66E,14271
+praisonaiagents/task/task.py,sha256=8KztSUKMO74y619TyI8d5DMJ1xPbyQXIB0Ux583oOVw,14259
 praisonaiagents/tools/__init__.py,sha256=CWOYV9SudYY82r45LnNgaVRV3cmsAFdasNRkPrLsgmI,9198
 praisonaiagents/tools/arxiv_tools.py,sha256=1stb31zTjLTon4jCnpZG5de9rKc9QWgC0leLegvPXWo,10528
 praisonaiagents/tools/calculator_tools.py,sha256=S1xPT74Geurvjm52QMMIG29zDXVEWJmM6nmyY7yF298,9571
@@ -36,7 +36,7 @@ praisonaiagents/tools/xml_tools.py,sha256=iYTMBEk5l3L3ryQ1fkUnNVYK-Nnua2Kx2S0dxN
 praisonaiagents/tools/yaml_tools.py,sha256=uogAZrhXV9O7xvspAtcTfpKSQYL2nlOTvCQXN94-G9A,14215
 praisonaiagents/tools/yfinance_tools.py,sha256=s2PBj_1v7oQnOobo2fDbQBACEHl61ftG4beG6Z979ZE,8529
 praisonaiagents/tools/train/data/generatecot.py,sha256=k1gZHtgY1poVp5kajhgs4S9a4-epdA8NyZfYTa34lQU,17651
-praisonaiagents-0.0.58.dist-info/METADATA,sha256=N_DIe_TPq4gXuySMSwVSPpsSarqo7h-_fTAIQaRFGT0,830
-praisonaiagents-0.0.58.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-praisonaiagents-0.0.58.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
-praisonaiagents-0.0.58.dist-info/RECORD,,
+praisonaiagents-0.0.59.dist-info/METADATA,sha256=w6DYqKW5P9b2Rqu02j5Lt4-6K7f-InDrtUfV7fYu_FM,830
+praisonaiagents-0.0.59.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+praisonaiagents-0.0.59.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
+praisonaiagents-0.0.59.dist-info/RECORD,,