praisonaiagents 0.0.42__py3-none-any.whl → 0.0.44__py3-none-any.whl

praisonaiagents/agents/agents.py

@@ -45,12 +45,13 @@ def process_video(video_path: str, seconds_per_frame=2):
     return base64_frames
 
 class PraisonAIAgents:
-    def __init__(self, agents, tasks=None, verbose=0, completion_checker=None, max_retries=5, process="sequential", manager_llm=None, memory=False, memory_config=None, embedder=None, user_id=None):
+    def __init__(self, agents, tasks=None, verbose=0, completion_checker=None, max_retries=5, process="sequential", manager_llm=None, memory=False, memory_config=None, embedder=None, user_id=None, max_iter=10):
         if not agents:
             raise ValueError("At least one agent must be provided")
         
         self.run_id = str(uuid.uuid4())  # Auto-generate run_id
         self.user_id = user_id  # Optional user_id
+        self.max_iter = max_iter  # Add max_iter parameter
 
         # Pass user_id to each agent
         for agent in agents:
@@ -402,7 +403,8 @@ Context:
             tasks=self.tasks,
             agents=self.agents,
             manager_llm=self.manager_llm,
-            verbose=self.verbose
+            verbose=self.verbose,
+            max_iter=self.max_iter
         )
         
         if self.process == "workflow":
@@ -710,7 +712,8 @@ Context:
             tasks=self.tasks,
             agents=self.agents,
             manager_llm=self.manager_llm,
-            verbose=self.verbose
+            verbose=self.verbose,
+            max_iter=self.max_iter
         )
         
         if self.process == "workflow":

praisonaiagents/main.py

@@ -23,6 +23,10 @@ logging.basicConfig(
     handlers=[RichHandler(rich_tracebacks=True)]
 )
 
+# Add these lines to suppress markdown parser debug logs
+logging.getLogger('markdown_it').setLevel(logging.WARNING)
+logging.getLogger('rich.markdown').setLevel(logging.WARNING)
+
 # Global list to store error logs
 error_logs = []
 

praisonaiagents/process/process.py

@@ -5,6 +5,8 @@ from pydantic import BaseModel
 from ..agent.agent import Agent
 from ..task.task import Task
 from ..main import display_error, client
+import csv
+import os
 
 class LoopItems(BaseModel):
     items: List[Any]
@@ -62,46 +64,47 @@ 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
-                                )
+#                             # 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}"
+#                             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}"
                 
@@ -144,13 +147,17 @@ Return a JSON object with an 'items' array containing the items to process.
             next_task = None
             if current_task and current_task.result:
                 if current_task.task_type in ["decision", "loop"]:
-                    result = current_task.result.raw.lower()
+                    # MINIMAL CHANGE: use pydantic decision if present
+                    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() in result:
+                        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":  # If empty or explicit exit
+                            if not task_value or task_value == "exit":
                                 logging.info("Workflow exit condition met, ending workflow")
                                 current_task = None
                                 break
@@ -322,7 +329,76 @@ Provide a JSON with the structure:
         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 start_task and start_task.task_type == "loop" and not start_task.input_file:
+            start_task.input_file = "tasks.csv"
+
+        # --- If loop + input_file, read file & create tasks
+        if start_task and start_task.task_type == "loop" and getattr(start_task, "input_file", None):
+            try:
+                file_ext = os.path.splitext(start_task.input_file)[1].lower()
+                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)
+                        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=task_desc,  # Keep full row as description
+                                    agent=start_task.agent,
+                                    name=task_desc,       # Use first column as name
+                                    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:
+                    # If not CSV, read lines
+                    with open(start_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=line.strip(),
+                                agent=start_task.agent,
+                                name=line.strip(),
+                                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:
+                    start_task = new_tasks[0]
+                    logging.info(f"Created {len(new_tasks)} tasks from: {start_task.input_file}")
+            except Exception as e:
+                logging.error(f"Failed to read file tasks: {e}")
+
+        # end of the new block
         current_task = start_task
         visited_tasks = set()
         loop_data = {}  # Store loop-specific data
@@ -346,40 +422,41 @@ 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
-                            )
+#                             # 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}"
+#                             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}"
                 
@@ -396,7 +473,7 @@ Return a JSON object with an 'items' array containing the items to process.
             yield task_id
             visited_tasks.add(task_id)
             
-            # Reset completed task to "not started" so it can run again
+            # Reset completed task to "not started" so it can run again: Only for workflow because some tasks may be revisited
             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"
@@ -422,13 +499,17 @@ Return a JSON object with an 'items' array containing the items to process.
             next_task = None
             if current_task and current_task.result:
                 if current_task.task_type in ["decision", "loop"]:
-                    result = current_task.result.raw.lower()
+                    # MINIMAL CHANGE: use pydantic decision if present
+                    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() in result:
+                        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":  # If empty or explicit exit
+                            if not task_value or task_value == "exit":
                                 logging.info("Workflow exit condition met, ending workflow")
                                 current_task = None
                                 break

praisonaiagents/task/task.py

@@ -1,6 +1,6 @@
 import logging
 import asyncio
-from typing import List, Optional, Dict, Any, Type, Callable, Union, Coroutine
+from typing import List, Optional, Dict, Any, Type, Callable, Union, Coroutine, Literal
 from pydantic import BaseModel
 from ..main import TaskOutput
 from ..agent.agent import Agent
@@ -37,8 +37,10 @@ class Task:
         is_start: bool = False,
         loop_state: Optional[Dict[str, Union[str, int]]] = None,
         memory=None,
-        quality_check=True
+        quality_check=True,
+        input_file: Optional[str] = None
     ):
+        self.input_file = input_file
         self.id = str(uuid.uuid4()) if id is None else str(id)
         self.name = name
         self.description = description
@@ -83,6 +85,47 @@ class Task:
         # Track previous tasks based on next_tasks relationships
         self.previous_tasks = []
 
+        # If task_type="decision" and output_pydantic is not set
+        if self.task_type == "decision" and not self.output_pydantic:
+            from pydantic import BaseModel
+            from typing import Literal
+
+            # Gather condition keys for the "decision" field
+            condition_keys = list(self.condition.keys())
+            if not condition_keys:
+                # Fall back to placeholders if nothing is specified
+                condition_keys = ["next_task", "exit"]
+
+            # Create a dynamic literal type from condition keys
+            DecisionLiteral = Literal.__getitem__(tuple(condition_keys))
+
+            class DecisionModel(BaseModel):
+                response: str
+                decision: DecisionLiteral
+
+            self.output_pydantic = DecisionModel
+
+        # If task_type="loop" and output_pydantic is not set
+        if self.task_type == "loop" and not self.output_pydantic:
+            from pydantic import BaseModel
+            from typing import Literal
+
+            # Gather condition keys for the "decision" field
+            condition_keys = list(self.condition.keys())
+            if not condition_keys:
+                # Fall back to placeholders if nothing is specified
+                condition_keys = ["next_item", "exit"]
+
+            # Create a dynamic literal type
+            LoopLiteral = Literal.__getitem__(tuple(condition_keys))
+
+            class LoopModel(BaseModel):
+                response: str
+                decision: LoopLiteral
+                loop_id: str  # Additional field for loop
+
+            self.output_pydantic = LoopModel
+
     def __str__(self):
         return f"Task(name='{self.name if self.name else 'None'}', description='{self.description}', agent='{self.agent.name if self.agent else 'None'}', status='{self.status}')"
 

{praisonaiagents-0.0.42.dist-info → praisonaiagents-0.0.44.dist-info}/METADATA

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

{praisonaiagents-0.0.42.dist-info → praisonaiagents-0.0.44.dist-info}/RECORD

@@ -1,18 +1,18 @@
 praisonaiagents/__init__.py,sha256=MCgAj12hVJ0YZmVmdmZgYAAMfPdWSoNSiDlRJCvrJqA,1276
-praisonaiagents/main.py,sha256=uMBdwxjnJKHLPUzr_5vXlkuhCUO6EW5O8XC0M-h47sE,13915
+praisonaiagents/main.py,sha256=wcFooRmCY38wtkSNFt6-nhZafgrHotCZE0S6U8IWgUY,14093
 praisonaiagents/agent/__init__.py,sha256=sKO8wGEXvtCrvV1e834r1Okv0XAqAxqZCqz6hKLiTvA,79
 praisonaiagents/agent/agent.py,sha256=rWvuZKP1fMF-BBe7I554FVk56Wse_iHyjoRRNEuyC5o,37836
 praisonaiagents/agents/__init__.py,sha256=_1d6Pqyk9EoBSo7E68sKyd1jDRlN1vxvVIRpoMc0Jcw,168
-praisonaiagents/agents/agents.py,sha256=oGCnbyLE22PU1AqXFhJZpzBnoW926mXXfWi-Q2hhklg,33359
+praisonaiagents/agents/agents.py,sha256=J86IWZ8Kv8LulHODX8klwGVGGB2AmmcMzWl9QsEPAv0,33503
 praisonaiagents/agents/autoagents.py,sha256=bjC2O5oZmoJItJXIMPTWc2lsp_AJC9tMiTQOal2hwPA,13532
 praisonaiagents/knowledge/__init__.py,sha256=xL1Eh-a3xsHyIcU4foOWF-JdWYIYBALJH9bge0Ujuto,246
 praisonaiagents/knowledge/chunking.py,sha256=FzoNY0q8MkvG4gADqk4JcRhmH3lcEHbRdonDgitQa30,6624
 praisonaiagents/knowledge/knowledge.py,sha256=dJd8WuFV3w-zWaSAcT21PcXGRIZZc6YxBsJZDfmZNrk,12358
 praisonaiagents/memory/memory.py,sha256=ZxqSpOUxk9jeTKGW0ZiTifC0uZtym-EZILP3kuOOKkU,35626
 praisonaiagents/process/__init__.py,sha256=lkYbL7Hn5a0ldvJtkdH23vfIIZLIcanK-65C0MwaorY,52
-praisonaiagents/process/process.py,sha256=uSudOFI1ZlGM_nbT8qHD4iIP3y5Ygu8V-izLot2te70,26316
+praisonaiagents/process/process.py,sha256=_1Nk37kOYakPaUWAJff86rP0ENyykXqMnhTp8E0efuE,30802
 praisonaiagents/task/__init__.py,sha256=VL5hXVmyGjINb34AalxpBMl-YW9m5EDcRkMTKkSSl7c,80
-praisonaiagents/task/task.py,sha256=Tf3CzFNctfTBiy67wfOfT7RnopPGsBntsrHF8012BnE,11383
+praisonaiagents/task/task.py,sha256=VcUl7dVNy5gj3Gq4H9SQU9S3Oy-0qYHSG-lEIlx2Rvg,13085
 praisonaiagents/tools/__init__.py,sha256=-0lV5n5cG54vYW6REjXIfuJnCLKnfQIDlXsySCaPB9s,7347
 praisonaiagents/tools/arxiv_tools.py,sha256=1stb31zTjLTon4jCnpZG5de9rKc9QWgC0leLegvPXWo,10528
 praisonaiagents/tools/calculator_tools.py,sha256=S1xPT74Geurvjm52QMMIG29zDXVEWJmM6nmyY7yF298,9571
@@ -33,7 +33,7 @@ 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.42.dist-info/METADATA,sha256=hnuRVdAhcy4TQs7hFrfZGRmgiMzg-VbN9Iym7X1JY-8,664
-praisonaiagents-0.0.42.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-praisonaiagents-0.0.42.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
-praisonaiagents-0.0.42.dist-info/RECORD,,
+praisonaiagents-0.0.44.dist-info/METADATA,sha256=uT2HYHiW4f0vTb-n0HzzUU2XYCPi2zjsvdBDfAIkcI4,664
+praisonaiagents-0.0.44.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+praisonaiagents-0.0.44.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
+praisonaiagents-0.0.44.dist-info/RECORD,,