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

praisonaiagents/agent/agent.py

@@ -353,13 +353,28 @@ class Agent:
 Your Role: {self.role}\n
 Your Goal: {self.goal}
             """
+            if output_json:
+                system_prompt += f"\nReturn ONLY a JSON object that matches this Pydantic model: {output_json.schema_json()}"
         else:
             system_prompt = None
-        
+
         messages = []
         if system_prompt:
             messages.append({"role": "system", "content": system_prompt})
         messages.extend(self.chat_history)
+
+        # Modify prompt if output_json is specified
+        original_prompt = prompt
+        if output_json:
+            if isinstance(prompt, str):
+                prompt += "\nReturn ONLY a valid JSON object. No other text or explanation."
+            elif isinstance(prompt, list):
+                # For multimodal prompts, append to the text content
+                for item in prompt:
+                    if item["type"] == "text":
+                        item["text"] += "\nReturn ONLY a valid JSON object. No other text or explanation."
+                        break
+
         if isinstance(prompt, list):
             # If we receive a multimodal prompt list, place it directly in the user message
             messages.append({"role": "user", "content": prompt})
@@ -385,13 +400,14 @@ Your Goal: {self.goal}
                 response = self._chat_completion(messages, temperature=temperature, tools=tools if tools else None)
                 if not response:
                     return None
-                    
+
                 tool_calls = getattr(response.choices[0].message, 'tool_calls', None)
+                response_text = response.choices[0].message.content.strip()
 
                 if tool_calls:
                     messages.append({
                         "role": "assistant",
-                        "content": response.choices[0].message.content,
+                        "content": response_text,
                         "tool_calls": tool_calls
                     })
                     
@@ -423,15 +439,31 @@ Your Goal: {self.goal}
                     if not response:
                         return None
                     response_text = response.choices[0].message.content.strip()
-                else:
-                    response_text = response.choices[0].message.content.strip()
+
+                # Handle output_json if specified
+                if output_json:
+                    try:
+                        # Clean the response text to get only JSON
+                        cleaned_json = self.clean_json_output(response_text)
+                        # Parse into Pydantic model
+                        parsed_model = output_json.model_validate_json(cleaned_json)
+                        # Add to chat history and return
+                        self.chat_history.append({"role": "user", "content": original_prompt})
+                        self.chat_history.append({"role": "assistant", "content": response_text})
+                        if self.verbose:
+                            display_interaction(original_prompt, response_text, markdown=self.markdown, 
+                                             generation_time=time.time() - start_time, console=self.console)
+                        return parsed_model
+                    except Exception as e:
+                        display_error(f"Failed to parse response as {output_json.__name__}: {e}")
+                        return None
 
                 if not self.self_reflect:
-                    self.chat_history.append({"role": "user", "content": prompt})
+                    self.chat_history.append({"role": "user", "content": original_prompt})
                     self.chat_history.append({"role": "assistant", "content": response_text})
                     if self.verbose:
                         logging.info(f"Agent {self.name} final response: {response_text}")
-                    display_interaction(prompt, response_text, markdown=self.markdown, generation_time=time.time() - start_time, console=self.console)
+                    display_interaction(original_prompt, response_text, markdown=self.markdown, generation_time=time.time() - start_time, console=self.console)
                     return response_text
 
                 reflection_prompt = f"""
@@ -492,4 +524,16 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                 
             except Exception as e:
                 display_error(f"Error in chat: {e}", console=self.console)
-                return None 
+                return None 
+
+    def clean_json_output(self, output: str) -> str:
+        """Clean and extract JSON from response text."""
+        cleaned = output.strip()
+        # Remove markdown code blocks if present
+        if cleaned.startswith("```json"):
+            cleaned = cleaned[len("```json"):].strip()
+        if cleaned.startswith("```"):
+            cleaned = cleaned[len("```"):].strip()
+        if cleaned.endswith("```"):
+            cleaned = cleaned[:-3].strip()
+        return cleaned 

praisonaiagents/agents/agents.py

@@ -2,7 +2,7 @@ import os
 import time
 import json
 import logging
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Optional, List
 from pydantic import BaseModel
 from rich.text import Text
 from rich.panel import Panel
@@ -10,6 +10,10 @@ from rich.console import Console
 from ..main import display_error, TaskOutput, error_logs, client
 from ..agent.agent import Agent
 from ..task.task import Task
+from ..process.process import Process
+
+class LoopItems(BaseModel):
+    items: List[Any]
 
 def encode_file_to_base64(file_path: str) -> str:
     """Base64-encode a file."""
@@ -55,6 +59,7 @@ class PraisonAIAgents:
         for task in tasks:
             self.add_task(task)
             task.status = "not started"
+        self._state = {}  # Add state storage at PraisonAIAgents level
 
     def add_task(self, task):
         task_id = self.task_id_counter
@@ -251,122 +256,25 @@ Expected Output: {task.expected_output}.
             logging.info(f"Task {task_id} failed after {self.max_retries} retries.")
 
     def run_all_tasks(self):
-        if self.process == "sequential":
-            for task_id in self.tasks:
-                if self.tasks[task_id].status != "completed":
-                    self.run_task(task_id)
+        """Execute tasks based on execution mode"""
+        process = Process(
+            tasks=self.tasks,
+            agents=self.agents,
+            manager_llm=self.manager_llm,
+            verbose=self.verbose
+        )
+        
+        if self.process == "workflow":
+            for task_id in process.workflow():
+                self.run_task(task_id)
+        elif self.process == "sequential":
+            for task_id in process.sequential():
+                self.run_task(task_id)
         elif self.process == "hierarchical":
-            logging.debug(f"Starting hierarchical task execution with {len(self.tasks)} tasks")
-            manager_agent = Agent(
-                name="Manager",
-                role="Project manager",
-                goal="Manage the entire flow of tasks and delegate them to the right agent",
-                backstory="Expert project manager to coordinate tasks among agents",
-                llm=self.manager_llm,
-                verbose=self.verbose,
-                markdown=True,
-                self_reflect=False
-            )
-
-            class ManagerInstructions(BaseModel):
-                task_id: int
-                agent_name: str
-                action: str
-
-            manager_task = Task(
-                name="manager_task",
-                description="Decide the order of tasks and which agent executes them",
-                expected_output="All tasks completed successfully",
-                agent=manager_agent
-            )
-            manager_task_id = self.add_task(manager_task)
-            logging.info(f"Created manager task with ID {manager_task_id}")
-
-            completed_count = 0
-            total_tasks = len(self.tasks) - 1
-            logging.info(f"Need to complete {total_tasks} tasks (excluding manager task)")
-
-            while completed_count < total_tasks:
-                tasks_summary = []
-                for tid, tk in self.tasks.items():
-                    if tk.name == "manager_task":
-                        continue
-                    task_info = {
-                        "task_id": tid,
-                        "name": tk.name,
-                        "description": tk.description,
-                        "status": tk.status if tk.status else "not started",
-                        "agent": tk.agent.name if tk.agent else "No agent"
-                    }
-                    tasks_summary.append(task_info)
-                    logging.info(f"Task {tid} status: {task_info}")
-
-                manager_prompt = f"""
-Here is the current status of all tasks except yours (manager_task):
-{tasks_summary}
-
-Provide a JSON with the structure:
-{{
-   "task_id": <int>,
-   "agent_name": "<string>",
-   "action": "<execute or stop>"
-}}
-"""
-
-                try:
-                    logging.info("Requesting manager instructions...")
-                    manager_response = client.beta.chat.completions.parse(
-                        model=self.manager_llm,
-                        messages=[
-                            {"role": "system", "content": manager_task.description},
-                            {"role": "user", "content": manager_prompt}
-                        ],
-                        temperature=0.7,
-                        response_format=ManagerInstructions
-                    )
-                    parsed_instructions = manager_response.choices[0].message.parsed
-                    logging.info(f"Manager instructions: {parsed_instructions}")
-                except Exception as e:
-                    display_error(f"Manager parse error: {e}")
-                    logging.error(f"Manager parse error: {str(e)}", exc_info=True)
-                    break
-
-                selected_task_id = parsed_instructions.task_id
-                selected_agent_name = parsed_instructions.agent_name
-                action = parsed_instructions.action
-
-                logging.info(f"Manager selected task_id={selected_task_id}, agent={selected_agent_name}, action={action}")
-
-                if action.lower() == "stop":
-                    logging.info("Manager decided to stop task execution")
-                    break
-
-                if selected_task_id not in self.tasks:
-                    error_msg = f"Manager selected invalid task id {selected_task_id}"
-                    display_error(error_msg)
-                    logging.error(error_msg)
-                    break
-
-                original_agent = self.tasks[selected_task_id].agent.name if self.tasks[selected_task_id].agent else "None"
-                for a in self.agents:
-                    if a.name == selected_agent_name:
-                        self.tasks[selected_task_id].agent = a
-                        logging.info(f"Changed agent for task {selected_task_id} from {original_agent} to {selected_agent_name}")
-                        break
-
-                if self.tasks[selected_task_id].status != "completed":
-                    logging.info(f"Starting execution of task {selected_task_id}")
-                    self.run_task(selected_task_id)
-                    logging.info(f"Finished execution of task {selected_task_id}, status: {self.tasks[selected_task_id].status}")
-
-                if self.tasks[selected_task_id].status == "completed":
-                    completed_count += 1
-                    logging.info(f"Task {selected_task_id} completed. Total completed: {completed_count}/{total_tasks}")
-
-            self.tasks[manager_task.id].status = "completed"
-            if self.verbose >= 1:
-                logging.info("All tasks completed under manager supervision.")
-            logging.info("Hierarchical task execution finished")
+            for task_id in process.hierarchical():
+                if isinstance(task_id, Task):
+                    task_id = self.add_task(task_id)
+                self.run_task(task_id)
 
     def get_task_status(self, task_id):
         if task_id in self.tasks:
@@ -397,4 +305,20 @@ Provide a JSON with the structure:
         return {
             "task_status": self.get_all_tasks_status(),
             "task_results": {task_id: self.get_task_result(task_id) for task_id in self.tasks}
-        } 
+        } 
+
+    def set_state(self, key: str, value: Any) -> None:
+        """Set a state value"""
+        self._state[key] = value
+
+    def get_state(self, key: str, default: Any = None) -> Any:
+        """Get a state value"""
+        return self._state.get(key, default)
+
+    def update_state(self, updates: Dict) -> None:
+        """Update multiple state values"""
+        self._state.update(updates)
+
+    def clear_state(self) -> None:
+        """Clear all state values"""
+        self._state.clear() 

praisonaiagents/process/__init__.py

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

praisonaiagents/process/process.py

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

praisonaiagents/task/task.py

@@ -1,8 +1,9 @@
 import logging
-from typing import List, Optional, Dict, Any, Type
+from typing import List, Optional, Dict, Any, Type, Callable, Union
 from pydantic import BaseModel
 from ..main import TaskOutput
 from ..agent.agent import Agent
+import uuid
 
 class Task:
     def __init__(
@@ -23,11 +24,17 @@ class Task:
         result: Optional[TaskOutput] = None,
         create_directory: Optional[bool] = False,
         id: Optional[int] = None,
-        images: Optional[List[str]] = None
+        images: Optional[List[str]] = None,
+        next_tasks: Optional[List[str]] = None,
+        task_type: str = "task",
+        condition: Optional[Dict[str, List[str]]] = None,
+        is_start: bool = False,
+        loop_state: Optional[Dict[str, Union[str, int]]] = None
     ):
+        self.id = str(uuid.uuid4()) if id is None else str(id)
+        self.name = name
         self.description = description
         self.expected_output = expected_output
-        self.name = name
         self.agent = agent
         self.tools = tools if tools else []
         self.context = context if context else []
@@ -40,11 +47,18 @@ class Task:
         self.status = status
         self.result = result
         self.create_directory = create_directory
-        self.id = id
         self.images = images if images else []
+        self.next_tasks = next_tasks if next_tasks else []
+        self.task_type = task_type
+        self.condition = condition if condition else {}
+        self.is_start = is_start
+        self.loop_state = loop_state if loop_state else {}
 
         if self.output_json and self.output_pydantic:
             raise ValueError("Only one output type can be defined")
 
+        # Track previous tasks based on next_tasks relationships
+        self.previous_tasks = []
+
     def __str__(self):
         return f"Task(name='{self.name if self.name else 'None'}', description='{self.description}', agent='{self.agent.name if self.agent else 'None'}', status='{self.status}')" 

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

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

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

@@ -1,9 +1,9 @@
 praisonaiagents/__init__.py,sha256=gI8vEabBTRPsE_E8GA5sBMi4sTtJI-YokPrH2Nor-k0,741
 praisonaiagents/main.py,sha256=K2OxVKPmo4dNJbSWIsXDi_hm9CRx5O4km_74UGcszhk,5744
 praisonaiagents/agent/__init__.py,sha256=sKO8wGEXvtCrvV1e834r1Okv0XAqAxqZCqz6hKLiTvA,79
-praisonaiagents/agent/agent.py,sha256=QjzduZ97-gqFiU6O89EIL0fyTAzTa7RwCoLl29S6-7w,21773
+praisonaiagents/agent/agent.py,sha256=zTYcDpJ5DzzBnefwLvhrtBlGQoRI4ZZAioDu5nKTPSs,24042
 praisonaiagents/agents/__init__.py,sha256=7RDeQNSqZg5uBjD4M_0p_F6YgfWuDuxPFydPU50kDYc,120
-praisonaiagents/agents/agents.py,sha256=X02q695IeScdZKQQI9xNpaGAPeaLxSC26iIFlI5_E0g,16941
+praisonaiagents/agents/agents.py,sha256=ngPFNTmv3whf22litkQacUGaRghX-NbLPAC6Ejy9qoU,13003
 praisonaiagents/build/lib/praisonaiagents/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4TvPL-rYUUGg,1
 praisonaiagents/build/lib/praisonaiagents/main.py,sha256=zDhN5KKtKbfruolDNxlyJkcFlkSt4KQkQTDRfQVAhxc,3960
 praisonaiagents/build/lib/praisonaiagents/agent/__init__.py,sha256=sKO8wGEXvtCrvV1e834r1Okv0XAqAxqZCqz6hKLiTvA,79
@@ -12,9 +12,11 @@ praisonaiagents/build/lib/praisonaiagents/agents/__init__.py,sha256=cgCLFLFcLp9S
 praisonaiagents/build/lib/praisonaiagents/agents/agents.py,sha256=P2FAtlfD3kPib5a1oLVYanxlU6e4-GhBMQ0YDY5MHY4,13473
 praisonaiagents/build/lib/praisonaiagents/task/__init__.py,sha256=VL5hXVmyGjINb34AalxpBMl-YW9m5EDcRkMTKkSSl7c,80
 praisonaiagents/build/lib/praisonaiagents/task/task.py,sha256=4Y1qX8OeEFcid2yhAiPYylvHpuDmWORsyNL16_BiVvI,1831
+praisonaiagents/process/__init__.py,sha256=lkYbL7Hn5a0ldvJtkdH23vfIIZLIcanK-65C0MwaorY,52
+praisonaiagents/process/process.py,sha256=BgtFgTQjLoqHzj97zDtALjuP_ciOErMDB9quDTlZFjg,11676
 praisonaiagents/task/__init__.py,sha256=VL5hXVmyGjINb34AalxpBMl-YW9m5EDcRkMTKkSSl7c,80
-praisonaiagents/task/task.py,sha256=-0GZ8FDo9Sq2Lkwz25Utliuq50FcexwhnZNuQtA3NLw,1922
-praisonaiagents-0.0.13.dist-info/METADATA,sha256=ErtmhU_c6J52-LFUOvMPsBwQztVGkF529xla0L2YWz4,233
-praisonaiagents-0.0.13.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-praisonaiagents-0.0.13.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
-praisonaiagents-0.0.13.dist-info/RECORD,,
+praisonaiagents/task/task.py,sha256=oMC5Zz1dMj0Ceice69aBS1KQQXMLqphc8wNOQ9zcu0Q,2570
+praisonaiagents-0.0.15.dist-info/METADATA,sha256=QERXlBCD9drRfFrI5GwbLzbIaLX_FnOM9UVxFwIwDBo,233
+praisonaiagents-0.0.15.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+praisonaiagents-0.0.15.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
+praisonaiagents-0.0.15.dist-info/RECORD,,