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

praisonaiagents/llm/llm.py

@@ -113,11 +113,28 @@ class LLM:
             litellm.success_callback = []
             litellm._async_success_callback = []
             litellm.callbacks = []
-            # Additional logging suppression
-            litellm.suppress_debug_messages = True
-            litellm._logging._disable_debugging()
-            logging.getLogger("litellm.utils").setLevel(logging.WARNING)
-            logging.getLogger("litellm.main").setLevel(logging.WARNING)
+            
+            verbose = extra_settings.get('verbose', True)
+            
+            # Only suppress logs if not in debug mode
+            if not isinstance(verbose, bool) and verbose >= 10:
+                # Enable detailed debug logging
+                logging.getLogger("asyncio").setLevel(logging.DEBUG)
+                logging.getLogger("selector_events").setLevel(logging.DEBUG)
+                logging.getLogger("litellm.utils").setLevel(logging.DEBUG)
+                logging.getLogger("litellm.main").setLevel(logging.DEBUG)
+                litellm.suppress_debug_messages = False
+                litellm.set_verbose = True
+            else:
+                # Suppress debug logging for normal operation
+                logging.getLogger("asyncio").setLevel(logging.WARNING)
+                logging.getLogger("selector_events").setLevel(logging.WARNING)
+                logging.getLogger("litellm.utils").setLevel(logging.WARNING)
+                logging.getLogger("litellm.main").setLevel(logging.WARNING)
+                litellm.suppress_debug_messages = True
+                litellm._logging._disable_debugging()
+                warnings.filterwarnings("ignore", category=RuntimeWarning)
+            
         except ImportError:
             raise ImportError(
                 "LiteLLM is required but not installed. "
@@ -145,7 +162,7 @@ class LLM:
         self.extra_settings = extra_settings
         self.console = Console()
         self.chat_history = []
-        self.verbose = extra_settings.get('verbose', True)
+        self.verbose = verbose
         self.markdown = extra_settings.get('markdown', True)
         self.self_reflect = extra_settings.get('self_reflect', False)
         self.max_reflect = extra_settings.get('max_reflect', 3)

praisonaiagents/process/process.py

@@ -13,6 +13,13 @@ class LoopItems(BaseModel):
 
 class Process:
     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)}")
+        logging.debug(f"Number of agents: {len(agents)}")
+        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
@@ -21,25 +28,30 @@ class Process:
 
     async def aworkflow(self) -> AsyncGenerator[str, None]:
         """Async version of workflow method"""
+        logging.debug("=== Starting Async Workflow ===")
         current_iter = 0  # Track how many times we've looped
         # Build workflow relationships first
+        logging.debug("Building workflow relationships...")
         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)
+                        logging.debug(f"Added {task.name} as previous task for {next_task_name}")
 
         # Find start task
+        logging.debug("Finding start task...")
         start_task = None
         for task_id, task in self.tasks.items():
             if task.is_start:
                 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.info("No start task marked, using first task")
+            logging.debug(f"No start task marked, using first task: {start_task.name}")
         
         current_task = start_task
         visited_tasks = set()
@@ -54,7 +66,16 @@ class Process:
                 break
 
             task_id = current_task.id
-            logging.info(f"Executing workflow task: {current_task.name if current_task.name else task_id}")
+            logging.debug(f"""
+=== Task Execution Details ===
+Current task: {current_task.name}
+Type: {current_task.task_type}
+Status: {current_task.status}
+Previous tasks: {current_task.previous_tasks}
+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:
@@ -66,46 +87,6 @@ class Process:
                     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}"
                             context += f"\n{prev_name}: {prev_task.result.raw}"
                         else:
                             context += f"\n{prev_name}: {prev_task.result.raw}"
@@ -119,14 +100,103 @@ class Process:
                 # 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)
+            # Skip execution for loop tasks, only process their subtasks
+            if current_task.task_type == "loop":
+                logging.debug(f"""
+=== Loop Task Details ===
+Name: {current_task.name}
+ID: {current_task.id}
+Status: {current_task.status}
+Next tasks: {current_task.next_tasks}
+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)}
+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"""
+Subtask: {st.name}
+- Status: {st.status}
+- 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")
+                        
+                        # 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)
+                            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
+                else:
+                    logging.debug(f"No subtasks created yet for {current_task.name}")
+                    # Create subtasks if needed
+                    if current_task.input_file:
+                        self._create_loop_subtasks(current_task)
+                        current_task._subtasks_created = True
+                        logging.debug(f"Created subtasks from {current_task.input_file}")
+                    else:
+                        # No input file, mark as done
+                        current_task.status = "completed"
+                        logging.debug(f"No input file, marking {current_task.name} as completed")
+                        if 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
+                        else:
+                            current_task = None
+            else:
+                # Execute non-loop task
+                logging.debug(f"=== Executing non-loop task: {current_task.name} (id: {task_id}) ===")
+                logging.debug(f"Task status: {current_task.status}")
+                logging.debug(f"Task next_tasks: {current_task.next_tasks}")
+                yield task_id
+                visited_tasks.add(task_id)
             
             # Reset completed task to "not started" so it can run again
             if self.tasks[task_id].status == "completed":
-                logging.debug(f"Task {task_id} was completed, resetting to 'not started' for next iteration.")
-                self.tasks[task_id].status = "not started"
+                # Never reset loop tasks, decision tasks, or their subtasks
+                subtask_name = self.tasks[task_id].name
+                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 + "_") 
+                           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"Keeping status as: {self.tasks[task_id].status}")
             
             # Handle loop progression
             if current_task.task_type == "loop":
@@ -179,6 +249,15 @@ class Process:
                 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}
+            """)
+
     async def asequential(self) -> AsyncGenerator[str, None]:
         """Async version of sequential method"""
         for task_id in self.tasks:
@@ -343,33 +422,59 @@ Provide a JSON with the structure:
                 new_tasks = []
                 
                 if file_ext == ".csv":
-                    # existing CSV reading logic
                     with open(start_task.input_file, "r", encoding="utf-8") as f:
-                        # Try as simple CSV first
-                        reader = csv.reader(f)
+                        reader = csv.reader(f, quotechar='"', escapechar='\\')  # Handle quoted/escaped fields
                         previous_task = None
+                        task_count = 0
+                        
                         for i, row in enumerate(reader):
-                            if row:  # Skip empty rows
-                                task_desc = row[0]  # Take first column
-                                row_task = Task(
-                                    description=f"{start_task.description}\n{task_desc}" if start_task.description else task_desc,
-                                    agent=start_task.agent,
-                                    name=f"{start_task.name}_{i+1}" if start_task.name else task_desc,
-                                    expected_output=getattr(start_task, 'expected_output', None),
-                                    is_start=(i == 0),
-                                    task_type="task",
-                                    condition={
-                                        "complete": ["next"],
-                                        "retry": ["current"]
-                                    }
-                                )
-                                self.tasks[row_task.id] = row_task
-                                new_tasks.append(row_task)
+                            if not row:  # Skip truly empty rows
+                                continue
                                 
-                                if previous_task:
-                                    previous_task.next_tasks = [row_task.name]
-                                    previous_task.condition["complete"] = [row_task.name]
-                                previous_task = row_task
+                            # Properly handle Q&A pairs with potential commas
+                            task_desc = row[0].strip() if row else ""
+                            if len(row) > 1:
+                                # Preserve all fields in case of multiple commas
+                                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,
+                                name=f"{start_task.name}_{task_count}" if start_task.name else task_desc,
+                                expected_output=getattr(start_task, 'expected_output', None),
+                                is_start=(task_count == 1),
+                                task_type="decision",  # Change to decision type
+                                next_tasks=inherited_next_tasks,  # Inherit parent's next tasks
+                                condition={
+                                    "done": inherited_next_tasks if inherited_next_tasks else ["next"],  # Use full inherited_next_tasks
+                                    "retry": ["current"],
+                                    "exit": []  # Empty list for exit condition
+                                }
+                            )
+                            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
                     with open(start_task.input_file, "r", encoding="utf-8") as f:
@@ -402,7 +507,7 @@ Provide a JSON with the structure:
             except Exception as e:
                 logging.error(f"Failed to read file tasks: {e}")
 
-        # end of the new block
+        # end of start task handling
         current_task = start_task
         visited_tasks = set()
         loop_data = {}  # Store loop-specific data
@@ -413,8 +518,88 @@ Provide a JSON with the structure:
                 logging.info(f"Max iteration limit {self.max_iter} reached, ending workflow.")
                 break
 
+            # Handle loop task file reading at runtime
+            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)
+                                previous_task = None
+                                for i, row in enumerate(reader):
+                                    if row:  # Skip empty rows
+                                        task_desc = row[0]  # Take first column
+                                        row_task = Task(
+                                            description=f"{current_task.description}\n{task_desc}" if current_task.description else task_desc,
+                                            agent=current_task.agent,
+                                            name=f"{current_task.name}_{i+1}" if current_task.name else task_desc,
+                                            expected_output=getattr(current_task, 'expected_output', None),
+                                            is_start=(i == 0),
+                                            task_type="task",
+                                            condition={
+                                                "complete": ["next"],
+                                                "retry": ["current"]
+                                            }
+                                        )
+                                        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]
+                                        previous_task = row_task
+                        else:
+                            with open(current_task.input_file, "r", encoding="utf-8") as f:
+                                lines = f.read().splitlines()
+                                previous_task = None
+                                for i, line in enumerate(lines):
+                                    row_task = Task(
+                                        description=f"{current_task.description}\n{line.strip()}" if current_task.description else line.strip(),
+                                        agent=current_task.agent,
+                                        name=f"{current_task.name}_{i+1}" if current_task.name else line.strip(),
+                                        expected_output=getattr(current_task, 'expected_output', None),
+                                        is_start=(i == 0),
+                                        task_type="task",
+                                        condition={
+                                            "complete": ["next"],
+                                            "retry": ["current"]
+                                        }
+                                    )
+                                    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]
+                                    previous_task = row_task
+
+                        if new_tasks:
+                            current_task.next_tasks = [new_tasks[0].name]
+                            current_task._subtasks_created = True
+                            logging.info(f"Created {len(new_tasks)} tasks from: {current_task.input_file} for loop task {current_task.name}")
+                    except Exception as e:
+                        logging.error(f"Failed to read file tasks for loop task {current_task.name}: {e}")
+
             task_id = current_task.id
-            logging.info(f"Executing workflow task: {current_task.name if current_task.name else task_id}")
+            logging.debug(f"""
+=== Task Execution Details ===
+Current task: {current_task.name}
+Type: {current_task.task_type}
+Status: {current_task.status}
+Previous tasks: {current_task.previous_tasks}
+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:
@@ -426,40 +611,6 @@ Provide a JSON with the structure:
                     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}"
                             context += f"\n{prev_name}: {prev_task.result.raw}"
                         else:
                             context += f"\n{prev_name}: {prev_task.result.raw}"
@@ -473,14 +624,103 @@ Provide a JSON with the structure:
                 # 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)
+            # Skip execution for loop tasks, only process their subtasks
+            if current_task.task_type == "loop":
+                logging.debug(f"""
+=== Loop Task Details ===
+Name: {current_task.name}
+ID: {current_task.id}
+Status: {current_task.status}
+Next tasks: {current_task.next_tasks}
+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)}
+Completed: {sum(1 for st in subtasks if st.status == "completed")}
+Pending: {sum(1 for st in subtasks if st.status != "completed")}
+                    """)
+
+                    for st in subtasks:
+                        logging.debug(f"""
+Subtask: {st.name}
+- Status: {st.status}
+- 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")
+                        
+                        # 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)
+                            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
+                else:
+                    logging.debug(f"No subtasks created yet for {current_task.name}")
+                    # Create subtasks if needed
+                    if current_task.input_file:
+                        self._create_loop_subtasks(current_task)
+                        current_task._subtasks_created = True
+                        logging.debug(f"Created subtasks from {current_task.input_file}")
+                    else:
+                        # No input file, mark as done
+                        current_task.status = "completed"
+                        logging.debug(f"No input file, marking {current_task.name} as completed")
+                        if 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
+                        else:
+                            current_task = None
+            else:
+                # Execute non-loop task
+                logging.debug(f"=== Executing non-loop task: {current_task.name} (id: {task_id}) ===")
+                logging.debug(f"Task status: {current_task.status}")
+                logging.debug(f"Task next_tasks: {current_task.next_tasks}")
+                yield task_id
+                visited_tasks.add(task_id)
             
-            # Reset completed task to "not started" so it can run again: Only for workflow because some tasks may be revisited
+            # Reset completed task to "not started" so it can run again
             if self.tasks[task_id].status == "completed":
-                logging.debug(f"Task {task_id} was completed, resetting to 'not started' for next iteration.")
-                self.tasks[task_id].status = "not started"
+                # Never reset loop tasks, decision tasks, or their subtasks
+                subtask_name = self.tasks[task_id].name
+                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 + "_") 
+                           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"Keeping status as: {self.tasks[task_id].status}")
             
             # Handle loop progression
             if current_task.task_type == "loop":

praisonaiagents/tools/__init__.py

@@ -135,6 +135,27 @@ TOOL_MAPPINGS = {
     'group_by': ('.pandas_tools', 'PandasTools'),
     'pivot_table': ('.pandas_tools', 'PandasTools'),
     'pandas_tools': ('.pandas_tools', 'PandasTools'),
+
+    # Chain of Thought Training Tools
+    'cot_run': ('.train.data.generatecot', 'GenerateCOT'),           # Orchestrates text solution
+    'cot_run_dict': ('.train.data.generatecot', 'GenerateCOT'),      # Orchestrates dict-based solution
+    'cot_generate': ('.train.data.generatecot', 'GenerateCOT'),      # Generate text solution
+    'cot_generate_dict': ('.train.data.generatecot', 'GenerateCOT'), # Generate structured solution
+    'cot_improve': ('.train.data.generatecot', 'GenerateCOT'),       # Improve text solution
+    'cot_improve_dict': ('.train.data.generatecot', 'GenerateCOT'),  # Improve dict-based solution
+    'cot_check': ('.train.data.generatecot', 'GenerateCOT'),         # Check correctness
+    'cot_find_error': ('.train.data.generatecot', 'GenerateCOT'),    # Locate error in solution
+    'cot_load_answers': ('.train.data.generatecot', 'GenerateCOT'),  # Load QA pairs
+    
+    # COT Save/Export with QA Pairs
+    'cot_save_solutions_with_qa_pairs': ('.train.data.generatecot', 'GenerateCOT'),    # Save with QA pairs
+    'cot_append_solutions_with_qa_pairs': ('.train.data.generatecot', 'GenerateCOT'),  # Append with QA pairs
+    'cot_export_json_with_qa_pairs': ('.train.data.generatecot', 'GenerateCOT'),       # Export JSON with QA pairs
+    'cot_export_csv_with_qa_pairs': ('.train.data.generatecot', 'GenerateCOT'),        # Export CSV with QA pairs
+    'cot_append_csv_with_qa_pairs': ('.train.data.generatecot', 'GenerateCOT'),        # Append CSV with QA pairs
+    'cot_save': ('.train.data.generatecot', 'GenerateCOT'),                           # Save single QA to file
+    'cot_upload_to_huggingface': ('.train.data.generatecot', 'GenerateCOT'),           # Upload dataset to HuggingFace
+    'cot_tools': ('.train.data.generatecot', 'GenerateCOT'),                           # Full toolkit access
 }
 
 _instances = {}  # Cache for class instances
@@ -161,7 +182,7 @@ def __getattr__(name: str) -> Any:
         ]:
             return getattr(module, name)
         if name in ['file_tools', 'pandas_tools', 'wikipedia_tools',
-                   'newspaper_tools', 'arxiv_tools', 'spider_tools', 'duckdb_tools', 'csv_tools', 'json_tools', 'excel_tools', 'xml_tools', 'yaml_tools', 'calculator_tools', 'python_tools', 'shell_tools']:
+                   'newspaper_tools', 'arxiv_tools', 'spider_tools', 'duckdb_tools', 'csv_tools', 'json_tools', 'excel_tools', 'xml_tools', 'yaml_tools', 'calculator_tools', 'python_tools', 'shell_tools', 'cot_tools']:
             return module  # Returns the callable module
         return getattr(module, name)
     else:

praisonaiagents/tools/csv_tools.py

@@ -89,7 +89,7 @@ class CSVTools:
     def write_csv(
         self,
         filepath: str,
-        data: List[Dict[str, Any]],
+        data: Union[List[Dict[str, Any]], str],
         encoding: str = 'utf-8',
         delimiter: str = ',',
         index: bool = False,
@@ -102,35 +102,66 @@ class CSVTools:
         
         Args:
             filepath: Path to CSV file
-            data: List of row dicts to write
-            encoding: File encoding
-            delimiter: Column delimiter
-            index: Whether to write row indices
-            header: Whether to write column headers
-            float_format: Format string for float values
-            date_format: Format string for date values
-            mode: Write mode ('w' for write, 'a' for append)
-            
+            data: Either a list of dictionaries or a string containing CSV data
+                  If string, each line should be comma-separated values
+            encoding: File encoding (default: 'utf-8')
+            delimiter: Column delimiter (default: ',')
+            index: Whether to write row indices (default: False)
+            header: Whether to write column headers (default: True)
+            float_format: Format string for float values (default: None)
+            date_format: Format string for date values (default: None)
+            mode: Write mode - 'w' for write, 'a' for append (default: 'w')
+        
         Returns:
-            bool: Success status
+            bool: True if successful, False otherwise
         """
         try:
             pd = self._get_pandas()
             if pd is None:
                 return False
 
-            df = pd.DataFrame(data)
-            df.to_csv(
-                filepath,
-                encoding=encoding,
-                sep=delimiter,
-                index=index,
-                header=header,
-                float_format=float_format,
-                date_format=date_format,
-                mode=mode
-            )
-            return True
+            # Handle string input
+            if isinstance(data, str):
+                # Convert string to list of dicts
+                rows = []
+                if delimiter in data:
+                    # Get existing columns if file exists and in append mode
+                    existing_cols = []
+                    if mode == 'a' and Path(filepath).exists():
+                        try:
+                            existing_df = pd.read_csv(filepath, nrows=1)
+                            existing_cols = existing_df.columns.tolist()
+                        except:
+                            pass
+
+                    values = [v.strip() for v in data.split(delimiter)]
+                    
+                    if existing_cols:
+                        # Use existing column names
+                        row_dict = dict(zip(existing_cols, values))
+                    else:
+                        # Create generic column names
+                        row_dict = {f'col{i}': val for i, val in enumerate(values)}
+                    
+                    rows.append(row_dict)
+                    data = rows
+
+                df = pd.DataFrame(data)
+                
+                # Handle append mode properly
+                write_header = header if mode == 'w' else (header and not Path(filepath).exists())
+                
+                df.to_csv(
+                    filepath,
+                    encoding=encoding,
+                    sep=delimiter,
+                    index=index,
+                    header=write_header,
+                    float_format=float_format,
+                    date_format=date_format,
+                    mode=mode
+                )
+                return True
             
         except Exception as e:
             error_msg = f"Error writing CSV file {filepath}: {str(e)}"

praisonaiagents/tools/train/data/generatecot.py

@@ -0,0 +1,500 @@
+from typing import Dict, Optional, Union, Any
+import json
+from datetime import datetime
+from openai import OpenAI
+from pydantic import BaseModel
+
+# Lazy loader for LLM
+def get_llm():
+    try:
+        from praisonaiagents.llm.llm import LLM
+        return LLM
+    except ImportError:
+        raise ImportError(
+            "LLM is required for this toolbut not installed. "
+            "Please install with: pip install 'praisonaiagents[llm]' datasets huggingface-hub pandas"
+        )
+
+class GenerateCOT:
+    def __init__(
+        self,
+        qa_pairs: Optional[Dict[str, str]] = None,
+        model: str = "gpt-4o-mini",
+        api_key: Optional[str] = None,
+        max_attempts: int = 3
+    ):
+        self.qa_pairs = qa_pairs or {}
+        self.max_attempts = max_attempts
+        self.solutions = {}
+        self.llm = get_llm()(model=model)  # Get LLM class and instantiate
+        self.model = model
+
+    def _ask_ai(self, prompt: str) -> str:
+        return self.llm.get_response(prompt, temperature=0.7)
+        
+    def _build_solution_prompt(self, question: str, context: str) -> str:
+        return f"""
+        Solve this problem step by step: {question}
+        Context: {context}
+        Steps needed:
+        1. Break down the problem
+        2. Show your work
+        3. Explain each step
+        4. Give final answer
+        """
+
+    def cot_generate(self, question: str, context: str = "") -> str:
+        prompt = self._build_solution_prompt(question, context)
+        return self._ask_ai(prompt)
+        
+    def cot_check(self, question: str, answer: str) -> bool:
+        if question not in self.qa_pairs:
+            raise ValueError(f"No correct answer found for: {question}")
+            
+        prompt = f"""
+        Question: {question}
+        Given Answer: {answer}
+        Correct Answer: {self.qa_pairs[question]}
+        Is the given answer correct? Reply only with 'true' or 'false'.
+        """
+        return self._ask_ai(prompt).lower().strip() == "true"
+        
+    def cot_find_error(self, question: str, solution: str) -> int:
+        if self.cot_check(question, solution):
+            return -1
+            
+        sentences = [s.strip() for s in solution.replace('。', '.').split('.') if s.strip()]
+        left, right = 0, len(sentences)
+        
+        while left < right:
+            mid = (left + right) // 2
+            partial = '. '.join(sentences[:mid]) + '.'
+            if self.cot_check(question, partial):
+                left = mid + 1
+            else:
+                right = mid
+                
+        return left
+        
+    def cot_improve(self, question: str, current: str) -> str:
+        best_solution = current
+        best_score = self._rate_solution(question, current)
+        attempts = 0
+        
+        while attempts < self.max_attempts:
+            attempts += 1
+            new_solution = self.cot_generate(question, current)
+            new_score = self._rate_solution(question, new_solution)
+            
+            if new_score > best_score:
+                best_solution = new_solution
+                best_score = new_score
+                
+            if best_score > 0.8:
+                break
+                
+        return best_solution
+        
+    def _rate_solution(self, question: str, solution: str) -> float:
+        prompt = f"""
+        Rate this solution from 0 to 1:
+        Question: {question}
+        Solution: {solution}
+        Correct Answer: {self.qa_pairs.get(question, '')}
+        Return only a number between 0 and 1.
+        """
+        try:
+            score = float(self._ask_ai(prompt))
+            return min(max(score, 0), 1)
+        except:
+            return 0.0
+            
+    def cot_run(self, question: str) -> str:
+        """Run COT generation for a single question."""
+        solution = self.cot_generate(question)
+        if self.cot_check(question, solution):
+            return solution
+
+        solution = self.cot_improve(question, solution)
+        
+        error_pos = self.cot_find_error(question, solution)
+        if error_pos != -1:
+            correct_part = '. '.join(solution.split('. ')[:error_pos]) + '.'
+            solution = self.cot_generate(question, correct_part)
+
+        self.solutions[question] = {
+            "solution": solution,
+            "error_position": error_pos,
+        }
+        return solution
+        
+    def cot_load_answers(self, filepath: str) -> bool:
+        try:
+            with open(filepath, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+            self.qa_pairs.update(data)
+            return True
+        except Exception as e:
+            print(f"Error loading answers: {e}")
+            return False
+            
+    def _is_qa_pairs(self, qa_pairs: Any) -> bool:
+        """Validate if input is a proper QA pairs dictionary."""
+        if not qa_pairs:
+            return True  # None or empty is valid
+        if not isinstance(qa_pairs, dict):
+            raise ValueError("qa_pairs must be a dictionary with questions as keys and answers as values")
+        return True
+
+    def cot_append_solutions_with_qa_pairs(
+        self,
+        filepath: str = 'solutions.json',
+        qa_pairs: Optional[Dict[str, str]] = None
+    ) -> None:
+        """Appends current solutions to existing file or creates a new one."""
+        try:
+            self._is_qa_pairs(qa_pairs)  # Validate format
+            if qa_pairs:
+                self.qa_pairs.update(qa_pairs)
+
+            data = {
+                "solutions": self.solutions,
+                "qa_pairs": self.qa_pairs,
+                "saved_at": datetime.now().isoformat()
+            }
+
+            existing_data = {}
+            try:
+                with open(filepath, 'r', encoding='utf-8') as f:
+                    existing_data = json.load(f)
+            except (FileNotFoundError, json.JSONDecodeError):
+                pass
+
+            if existing_data:
+                existing_data["solutions"].update(data["solutions"])
+                existing_data["qa_pairs"].update(data["qa_pairs"])
+                existing_data["saved_at"] = data["saved_at"]
+                data = existing_data
+
+            with open(filepath, 'w', encoding='utf-8') as f:
+                json.dump(data, f, ensure_ascii=False, indent=2)
+        except Exception as e:
+            print(f"Error appending solutions: {e}")
+
+    def cot_save_solutions_with_qa_pairs(
+        self,
+        filepath: str = 'solutions.json',
+        append: bool = False,
+        qa_pairs: Optional[Dict[str, str]] = None
+    ) -> None:
+        try:
+            self._is_qa_pairs(qa_pairs)  # Validate format
+            if qa_pairs:
+                self.qa_pairs.update(qa_pairs)
+
+            if append:
+                self.cot_append_solutions_with_qa_pairs(filepath)
+                return
+
+            data = {
+                "solutions": self.solutions,
+                "qa_pairs": self.qa_pairs,
+                "saved_at": datetime.now().isoformat()
+            }
+            with open(filepath, 'w', encoding='utf-8') as f:
+                json.dump(data, f, ensure_ascii=False, indent=2)
+        except Exception as e:
+            print(f"Error saving solutions: {e}")
+
+    def cot_generate_dict(self, question: str, context: str = "") -> dict:
+        prompt = self._build_solution_prompt(question, context)
+        thought_process = self._ask_ai(prompt)
+        
+        final_answer_prompt = f"""
+        Based on this solution, what is the final answer only:
+        {thought_process}
+        Give only the final answer, no explanation.
+        """
+        final_answer = self._ask_ai(final_answer_prompt)
+        return {
+            "thought_process": thought_process,
+            "final_answer": final_answer
+        }
+
+    def cot_improve_dict(self, question: str, current_solution: str) -> dict:
+        """
+        Improves the existing solution (text form), returning the best dictionary-based version.
+        """
+        best_solution = {
+            "thought_process": current_solution,
+            "final_answer": current_solution
+        }
+        best_score = self._rate_solution(question, current_solution)
+        attempts = 0
+
+        while attempts < self.max_attempts:
+            attempts += 1
+            new_solution = self.cot_generate_dict(question, current_solution)
+            new_score = self._rate_solution(question, new_solution["thought_process"])
+            if new_score > best_score:
+                best_solution = new_solution
+                best_score = new_score
+            if best_score > 0.8:
+                break
+        return best_solution
+
+    def cot_run_dict(self, question: str) -> dict:
+        """Uses the dictionary-based solution approach, storing the final solution in self.solutions."""
+        solution = self.cot_generate_dict(question)
+        if self.cot_check(question, solution["final_answer"]):
+            self.solutions[question] = solution
+            return solution
+
+        improved = self.cot_improve_dict(question, solution["thought_process"])
+        if self.cot_check(question, improved["final_answer"]):
+            self.solutions[question] = improved
+            return improved
+
+        error_pos = self.cot_find_error(question, improved["thought_process"])
+        if error_pos != -1:
+            partial_solution = '. '.join(improved["thought_process"].split('. ')[:error_pos]) + '.'
+            final = self.cot_generate_dict(question, partial_solution)
+            self.solutions[question] = final
+            return final
+
+        self.solutions[question] = improved
+        return improved
+
+    def cot_export_json_with_qa_pairs(
+        self,
+        filepath: str = 'dataset.json',
+        save_to_file: bool = True,
+        qa_pairs: Optional[Dict[str, str]] = None
+    ) -> Union[str, list]:
+        """
+        Export solutions in Alpaca training format with their full thought process.
+        """
+        try:
+            self._is_qa_pairs(qa_pairs)  # Validate format
+            if qa_pairs:
+                self.qa_pairs.update(qa_pairs)
+                # Generate solutions if empty
+                if not self.solutions:
+                    for question in qa_pairs:
+                        self.cot_run_dict(question)
+
+            alpaca_data = []
+            for question, sol in self.solutions.items():
+                alpaca_data.append({
+                    "instruction": question,
+                    "input": "",
+                    "output": sol.get("thought_process", "")
+                })
+
+            if not save_to_file:
+                return alpaca_data
+
+            with open(filepath, 'w', encoding='utf-8') as f:
+                json.dump(alpaca_data, f, ensure_ascii=False, indent=2)
+            return filepath
+        except Exception as e:
+            print(f"Error exporting to Alpaca format: {e}")
+            return None
+
+    def cot_export_csv_with_qa_pairs(
+        self,
+        filepath: str = 'dataset.csv',
+        qa_pairs: Optional[Dict[str, str]] = None
+    ) -> Optional[str]:
+        """Export solutions in CSV format."""
+        try:
+            self._is_qa_pairs(qa_pairs)  # Validate format
+            if qa_pairs:
+                self.qa_pairs.update(qa_pairs)
+                # Generate solutions if empty
+                if not self.solutions:
+                    for question in qa_pairs:
+                        self.cot_run_dict(question)
+
+            with open(filepath, 'w', newline='', encoding='utf-8') as f:
+                writer = csv.writer(f)
+                writer.writerow(['instruction', 'input', 'output'])
+                for question, sol in self.solutions.items():
+                    writer.writerow([question, '', sol.get("thought_process", "")])
+            return filepath
+        except Exception as e:
+            print(f"Error exporting to CSV format: {e}")
+            return None
+
+    def cot_save(
+        self,
+        question: str,
+        answer: str,
+        filepath: str = 'dataset.csv'
+    ) -> Optional[str]:
+        """
+        Save a single question-answer pair with chain of thought to CSV file.
+        Creates file with headers if it doesn't exist.
+        """
+        try:
+            # Add the current QA pair to self.qa_pairs
+            self.qa_pairs[question] = answer
+            
+            # Generate solution
+            solution = self.cot_run_dict(question)
+            
+            import csv
+            import os
+            file_exists = os.path.exists(filepath)
+
+            with open(filepath, 'a', newline='', encoding='utf-8') as f:
+                writer = csv.writer(f)
+                if not file_exists:
+                    writer.writerow(['instruction', 'input', 'output'])
+                writer.writerow([question, '', solution.get("thought_process", "")])
+            return filepath
+        except Exception as e:
+            print(f"Error appending to CSV: {e}")
+            return None
+
+    # Rename existing function to indicate it handles qa_pairs dictionary
+    def cot_append_csv_with_qa_pairs(
+        self,
+        filepath: str = 'dataset.csv',
+        qa_pairs: Optional[Dict[str, str]] = None
+    ) -> Optional[str]:
+        """Append solutions to CSV file using qa_pairs dictionary."""
+        try:
+            self._is_qa_pairs(qa_pairs)  # Validate format
+            if qa_pairs:
+                self.qa_pairs.update(qa_pairs)
+            
+            import csv
+            import os
+            file_exists = os.path.exists(filepath)
+
+            with open(filepath, 'a', newline='', encoding='utf-8') as f:
+                writer = csv.writer(f)
+                if not file_exists:
+                    writer.writerow(['instruction', 'input', 'output'])
+
+                for question, sol in self.solutions.items():
+                    writer.writerow([question, '', sol.get("thought_process", "")])
+            return filepath
+        except Exception as e:
+            print(f"Error appending to CSV: {e}")
+            return None
+
+    def cot_upload_to_huggingface(
+        self,
+        huggingface_username: str,
+        dataset_name: str,
+        filepath: str,
+        private: bool = False
+    ) -> str:
+        """Upload generated solutions to HuggingFace datasets."""
+        try:
+            from datasets import Dataset
+            from huggingface_hub import HfApi, login
+            import pandas as pd
+            
+            # Determine file type and load data
+            if filepath.endswith('.csv'):
+                data = pd.read_csv(filepath)
+            elif filepath.endswith('.json'):
+                data = pd.read_json(filepath)
+            else:
+                raise ValueError("Only CSV and JSON files are supported")
+                
+            # Convert to HuggingFace dataset
+            dataset = Dataset.from_pandas(data)
+            
+            # Upload to HuggingFace
+            repo_id = f"{huggingface_username}/{dataset_name}"
+            dataset.push_to_hub(
+                repo_id,
+                private=private
+            )
+            
+            return f"Dataset uploaded successfully to {repo_id}"
+            
+        except Exception as e:
+            print(f"Error uploading to HuggingFace: {e}")
+            return None
+
+# Usage example:
+if __name__ == "__main__":
+    # Direct QA Pairs Export Example
+    print("\n=== Direct QA Pairs Export Example ===")
+    direct_qa_data = {
+        "Number of r's in the word strawberry": "3"
+    }
+    
+    direct_generator = GenerateCOT()
+
+    # Export with qa_pairs passed directly to functions
+    direct_generator.cot_export_csv_with_qa_pairs(
+        filepath='direct_solutions.csv',
+        qa_pairs=direct_qa_data
+    )
+    
+    # Example of using cot_save for a single QA pair
+    direct_generator.cot_save(
+        question="What is the capital of France?",
+        answer="Paris",
+        filepath="single_qa.csv"
+    )
+    
+
+    
+    # Upload to HuggingFace
+    direct_generator.cot_upload_to_huggingface(
+        huggingface_username="mervinpraison",
+        dataset_name="cot-test",
+        filepath="single_qa.csv"
+    )
+    
+    # direct_generator.cot_export_json_with_qa_pairs(
+    #     filepath='direct_solutions.json',
+    #     qa_pairs=direct_qa_data
+    # )
+
+    # # Rest of the original examples...
+    # qa_data = {
+    #     "What is 2+2?": "4",
+    #     "How many letters in 'hello'?": "5"
+    # }
+    
+    # generator = GenerateCOT(qa_pairs=qa_data)
+    # for question in qa_data:
+    #     solution = generator.cot_run(question)
+    #     print(f"Question: {question}")
+    #     print(f"Solution: {solution}\n")
+    # answer = generator.cot_run("What is 2+2?")
+    # print(answer)
+
+    # # Additional QA data processing example
+    # print("\n=== Processing Additional QA Data ===")
+    # extra_qa_data = {
+
+    #     "What is 5 * 3?": "15"
+    # }
+    
+    # # Create separate generator for additional data
+    # extra_generator = GenerateCOT(qa_pairs=extra_qa_data)
+    
+    # # Process and save solutions
+    # for question in extra_qa_data:
+    #     solution = extra_generator.cot_run_dict(question)
+    #     print(f"Processing extra question: {question}")
+    
+    # # Save solutions separately
+    # extra_generator.cot_save_solutions_with_qa_pairs('extra_qa_solutions.json')
+    
+    # # Export in Alpaca format
+    # extra_generator.cot_export_json_with_qa_pairs(filepath='extra_qa_alpaca.json', save_to_file=True)
+    
+    # # Demonstrate loading saved data
+    # loaded_generator = GenerateCOT(qa_pairs={})
+    # loaded_generator.cot_load_answers('extra_qa_solutions.json')
+    # print("\nLoaded extra QA pairs:", loaded_generator.qa_pairs)

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

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

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

@@ -9,16 +9,16 @@ praisonaiagents/knowledge/__init__.py,sha256=xL1Eh-a3xsHyIcU4foOWF-JdWYIYBALJH9b
 praisonaiagents/knowledge/chunking.py,sha256=FzoNY0q8MkvG4gADqk4JcRhmH3lcEHbRdonDgitQa30,6624
 praisonaiagents/knowledge/knowledge.py,sha256=fQNREDiwdoisfIxJBLVkteXgq_8Gbypfc3UaZbxf5QY,13210
 praisonaiagents/llm/__init__.py,sha256=ttPQQJQq6Tah-0updoEXDZFKWtJAM93rBWRoIgxRWO8,689
-praisonaiagents/llm/llm.py,sha256=4QBFSi2c13qJmYqhwZS7XgiC8YL5K8lbxbUoqR9Y6xM,50481
+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=gP3QQxxFO4oUw_HYLf8MoyWyaj_104LIL_AbwLiBxaU,31261
+praisonaiagents/process/process.py,sha256=BrS8_4Gt2ewXt559hThJTSrXVYG8daabO9tGDaWmrm0,44906
 praisonaiagents/task/__init__.py,sha256=VL5hXVmyGjINb34AalxpBMl-YW9m5EDcRkMTKkSSl7c,80
 praisonaiagents/task/task.py,sha256=ikFjzNm4WPYONSLtWA3uDGNIUx_TvXTeU5SukWoC66E,14271
-praisonaiagents/tools/__init__.py,sha256=-0lV5n5cG54vYW6REjXIfuJnCLKnfQIDlXsySCaPB9s,7347
+praisonaiagents/tools/__init__.py,sha256=CWOYV9SudYY82r45LnNgaVRV3cmsAFdasNRkPrLsgmI,9198
 praisonaiagents/tools/arxiv_tools.py,sha256=1stb31zTjLTon4jCnpZG5de9rKc9QWgC0leLegvPXWo,10528
 praisonaiagents/tools/calculator_tools.py,sha256=S1xPT74Geurvjm52QMMIG29zDXVEWJmM6nmyY7yF298,9571
-praisonaiagents/tools/csv_tools.py,sha256=gX2nYz4ktmpKvXB36jx5-GqddntEQD4G2fVQWTIKrwU,8435
+praisonaiagents/tools/csv_tools.py,sha256=4Yr0QYwBXt-1BDXGLalB2eSsFR2mB5rH3KdHmRBQY6E,10036
 praisonaiagents/tools/duckdb_tools.py,sha256=KB3b-1HcX7ocoxskDpk_7RRpTGHnH8hizIY0ZdLRbIE,8816
 praisonaiagents/tools/duckduckgo_tools.py,sha256=ynlB5ZyWfHYjUq0JZXH12TganqTihgD-2IyRgs32y84,1657
 praisonaiagents/tools/excel_tools.py,sha256=e2HqcwnyBueOyss0xEKxff3zB4w4sNWCOMXvZfbDYlE,11309
@@ -35,7 +35,8 @@ praisonaiagents/tools/wikipedia_tools.py,sha256=pGko-f33wqXgxJTv8db7TbizY5XnzBQR
 praisonaiagents/tools/xml_tools.py,sha256=iYTMBEk5l3L3ryQ1fkUnNVYK-Nnua2Kx2S0dxNMMs1A,17122
 praisonaiagents/tools/yaml_tools.py,sha256=uogAZrhXV9O7xvspAtcTfpKSQYL2nlOTvCQXN94-G9A,14215
 praisonaiagents/tools/yfinance_tools.py,sha256=s2PBj_1v7oQnOobo2fDbQBACEHl61ftG4beG6Z979ZE,8529
-praisonaiagents-0.0.56.dist-info/METADATA,sha256=oh3zNT8tijRBVIJGlTGOlnMXtlKgTIWvILTKj1f5W2Y,830
-praisonaiagents-0.0.56.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-praisonaiagents-0.0.56.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
-praisonaiagents-0.0.56.dist-info/RECORD,,
+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,,