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

praisonaiagents/agent/agent.py

@@ -140,7 +140,7 @@ class Agent:
         max_rpm: Optional[int] = None,
         max_execution_time: Optional[int] = None,
         memory: bool = True,
-        verbose: bool = False,
+        verbose: bool = True,
         allow_delegation: bool = False,
         step_callback: Optional[Any] = None,
         cache: bool = True,
@@ -191,6 +191,8 @@ class Agent:
         self.max_reflect = max_reflect
         self.min_reflect = min_reflect
         self.reflect_llm = reflect_llm
+        self.console = Console()  # Create a single console instance for the agent
+
     def execute_tool(self, function_name, arguments):
         """
         Execute a tool dynamically based on the function name and arguments.
@@ -235,7 +237,6 @@ class Agent:
         return f"Agent(name='{self.name}', role='{self.role}', goal='{self.goal}')"
 
     def _chat_completion(self, messages, temperature=0.2, tools=None, stream=True):
-        console = Console()
         start_time = time.time()
         logging.debug(f"{self.name} sending messages to LLM: {messages}")
 
@@ -305,12 +306,24 @@ class Agent:
                     stream=True
                 )
                 full_response_text = ""
-                with Live(display_generating("", start_time), refresh_per_second=4) as live:
+                
+                # Create Live display with proper configuration
+                with Live(
+                    display_generating("", start_time),
+                    console=self.console,
+                    refresh_per_second=4,
+                    transient=False,  # Changed to False to preserve output
+                    vertical_overflow="ellipsis",
+                    auto_refresh=True
+                ) as live:
                     for chunk in response_stream:
                         if chunk.choices[0].delta.content:
                             full_response_text += chunk.choices[0].delta.content
                             live.update(display_generating(full_response_text, start_time))
-
+                
+                # Clear the last generating display with a blank line
+                self.console.print()
+                
                 final_response = client.chat.completions.create(
                     model=self.llm,
                     messages=messages,
@@ -340,14 +353,33 @@ 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)
-        messages.append({"role": "user", "content": prompt})
+
+        # 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})
+        else:
+            messages.append({"role": "user", "content": prompt})
 
         final_response_text = None
         reflection_count = 0
@@ -356,18 +388,26 @@ Your Goal: {self.goal}
         while True:
             try:
                 if self.verbose:
-                    display_instruction(f"Agent {self.name} is processing prompt: {prompt}")
+                    # Handle both string and list prompts for instruction display
+                    display_text = prompt
+                    if isinstance(prompt, list):
+                        # Extract text content from multimodal prompt
+                        display_text = next((item["text"] for item in prompt if item["type"] == "text"), "")
+                    
+                    if display_text and str(display_text).strip():
+                        display_instruction(f"Agent {self.name} is processing prompt: {display_text}", console=self.console)
 
                 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
                     })
                     
@@ -376,13 +416,13 @@ Your Goal: {self.goal}
                         arguments = json.loads(tool_call.function.arguments)
 
                         if self.verbose:
-                            display_tool_call(f"Agent {self.name} is calling function '{function_name}' with arguments: {arguments}")
+                            display_tool_call(f"Agent {self.name} is calling function '{function_name}' with arguments: {arguments}", console=self.console)
 
                         tool_result = self.execute_tool(function_name, arguments)
 
                         if tool_result:
                             if self.verbose:
-                                display_tool_call(f"Function '{function_name}' returned: {tool_result}")
+                                display_tool_call(f"Function '{function_name}' returned: {tool_result}", console=self.console)
                             messages.append({
                                 "role": "tool",
                                 "tool_call_id": tool_call.id,
@@ -399,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)
+                    display_interaction(original_prompt, response_text, markdown=self.markdown, generation_time=time.time() - start_time, console=self.console)
                     return response_text
 
                 reflection_prompt = f"""
@@ -430,26 +486,26 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                     reflection_output = reflection_response.choices[0].message.parsed
 
                     if self.verbose:
-                        display_self_reflection(f"Agent {self.name} self reflection (using {self.reflect_llm if self.reflect_llm else self.llm}): reflection='{reflection_output.reflection}' satisfactory='{reflection_output.satisfactory}'")
+                        display_self_reflection(f"Agent {self.name} self reflection (using {self.reflect_llm if self.reflect_llm else self.llm}): reflection='{reflection_output.reflection}' satisfactory='{reflection_output.satisfactory}'", console=self.console)
 
                     messages.append({"role": "assistant", "content": f"Self Reflection: {reflection_output.reflection} Satisfactory?: {reflection_output.satisfactory}"})
 
                     # Only consider satisfactory after minimum reflections
                     if reflection_output.satisfactory == "yes" and reflection_count >= self.min_reflect - 1:
                         if self.verbose:
-                            display_self_reflection("Agent marked the response as satisfactory after meeting minimum reflections")
+                            display_self_reflection("Agent marked the response as satisfactory after meeting minimum reflections", console=self.console)
                         self.chat_history.append({"role": "user", "content": prompt})
                         self.chat_history.append({"role": "assistant", "content": response_text})
-                        display_interaction(prompt, response_text, markdown=self.markdown, generation_time=time.time() - start_time)
+                        display_interaction(prompt, response_text, markdown=self.markdown, generation_time=time.time() - start_time, console=self.console)
                         return response_text
 
                     # Check if we've hit max reflections
                     if reflection_count >= self.max_reflect - 1:
                         if self.verbose:
-                            display_self_reflection("Maximum reflection count reached, returning current response")
+                            display_self_reflection("Maximum reflection count reached, returning current response", console=self.console)
                         self.chat_history.append({"role": "user", "content": prompt})
                         self.chat_history.append({"role": "assistant", "content": response_text})
-                        display_interaction(prompt, response_text, markdown=self.markdown, generation_time=time.time() - start_time)
+                        display_interaction(prompt, response_text, markdown=self.markdown, generation_time=time.time() - start_time, console=self.console)
                         return response_text
 
                     logging.debug(f"{self.name} reflection count {reflection_count + 1}, continuing reflection process")
@@ -460,12 +516,24 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                     continue  # Continue the loop for more reflections
 
                 except Exception as e:
-                    display_error(f"Error in parsing self-reflection json {e}. Retrying")
+                    display_error(f"Error in parsing self-reflection json {e}. Retrying", console=self.console)
                     logging.error("Reflection parsing failed.", exc_info=True)
                     messages.append({"role": "assistant", "content": f"Self Reflection failed."})
                     reflection_count += 1
                     continue  # Continue even after error to try again
                 
             except Exception as e:
-                display_error(f"Error in chat: {e}")
-                return None 
+                display_error(f"Error in chat: {e}", console=self.console)
+                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
@@ -11,6 +11,36 @@ from ..main import display_error, TaskOutput, error_logs, client
 from ..agent.agent import Agent
 from ..task.task import Task
 
+class LoopItems(BaseModel):
+    items: List[Any]
+
+def encode_file_to_base64(file_path: str) -> str:
+    """Base64-encode a file."""
+    import base64
+    with open(file_path, "rb") as f:
+        return base64.b64encode(f.read()).decode("utf-8")
+
+def process_video(video_path: str, seconds_per_frame=2):
+    """Split video into frames (base64-encoded)."""
+    import cv2
+    import base64
+    base64_frames = []
+    video = cv2.VideoCapture(video_path)
+    total_frames = int(video.get(cv2.CAP_PROP_FRAME_COUNT))
+    fps = video.get(cv2.CAP_PROP_FPS)
+    frames_to_skip = int(fps * seconds_per_frame)
+    curr_frame = 0
+    while curr_frame < total_frames:
+        video.set(cv2.CAP_PROP_POS_FRAMES, curr_frame)
+        success, frame = video.read()
+        if not success:
+            break
+        _, buffer = cv2.imencode(".jpg", frame)
+        base64_frames.append(base64.b64encode(buffer).decode("utf-8"))
+        curr_frame += frames_to_skip
+    video.release()
+    return base64_frames
+
 class PraisonAIAgents:
     def __init__(self, agents, tasks, verbose=0, completion_checker=None, max_retries=5, process="sequential", manager_llm=None):
         self.agents = agents
@@ -28,6 +58,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
@@ -58,6 +89,19 @@ class PraisonAIAgents:
             display_error(f"Error: Task with ID {task_id} does not exist")
             return
         task = self.tasks[task_id]
+        
+        # Only import multimodal dependencies if task has images
+        if task.images and task.status == "not started":
+            try:
+                import cv2
+                import base64
+                from moviepy import VideoFileClip
+            except ImportError as e:
+                display_error(f"Error: Missing required dependencies for image/video processing: {e}")
+                display_error("Please install with: pip install opencv-python moviepy")
+                task.status = "failed"
+                return None
+
         if task.status == "not started":
             task.status = "in progress"
 
@@ -83,7 +127,47 @@ Expected Output: {task.expected_output}.
         if self.verbose >= 2:
             logging.info(f"Executing task {task_id}: {task.description} using {executor_agent.name}")
         logging.debug(f"Starting execution of task {task_id} with prompt:\n{task_prompt}")
-        agent_output = executor_agent.chat(task_prompt, tools=task.tools)
+
+        if task.images:
+            def _get_multimodal_message(text_prompt, images):
+                content = [{"type": "text", "text": text_prompt}]
+
+                for img in images:
+                    # If local file path for a valid image
+                    if os.path.exists(img):
+                        ext = os.path.splitext(img)[1].lower()
+                        # If it's a .mp4, convert to frames
+                        if ext == ".mp4":
+                            frames = process_video(img, seconds_per_frame=1)
+                            content.append({"type": "text", "text": "These are frames from the video."})
+                            for f in frames:
+                                content.append({
+                                    "type": "image_url",
+                                    "image_url": {"url": f"data:image/jpg;base64,{f}"}
+                                })
+                        else:
+                            encoded = encode_file_to_base64(img)
+                            content.append({
+                                "type": "image_url",
+                                "image_url": {
+                                    "url": f"data:image/{ext.lstrip('.')};base64,{encoded}"
+                                }
+                            })
+                    else:
+                        # Treat as a remote URL
+                        content.append({
+                            "type": "image_url",
+                            "image_url": {"url": img}
+                        })
+                return content
+
+            agent_output = executor_agent.chat(
+                _get_multimodal_message(task_prompt, task.images),
+                tools=task.tools
+            )
+        else:
+            agent_output = executor_agent.chat(task_prompt, tools=task.tools)
+
         if agent_output:
             task_output = TaskOutput(
                 description=task.description,
@@ -171,11 +255,144 @@ 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":
+        """Execute tasks based on execution mode"""
+        if self.process == "workflow":
+            # Build workflow relationships first
+            for task in self.tasks.values():
+                if task.next_tasks:
+                    for next_task_name in task.next_tasks:
+                        next_task = next((t for t in self.tasks.values() if t.name == next_task_name), None)
+                        if next_task:
+                            next_task.previous_tasks.append(task.name)
+
+            # Find start task
+            start_task = None
+            for task_id, task in self.tasks.items():
+                if task.is_start:
+                    start_task = task
+                    break
+            
+            if not start_task:
+                start_task = list(self.tasks.values())[0]
+                logging.info("No start task marked, using first task")
+            
+            current_task = start_task
+            visited_tasks = set()
+            loop_data = {}  # Store loop-specific data
+            
+            while current_task and current_task.id not in visited_tasks:
+                task_id = current_task.id
+                logging.info(f"Executing workflow task: {current_task.name if current_task.name else task_id}")
+                
+                # Add context from previous tasks to description
+                if current_task.previous_tasks or current_task.context:
+                    context = "\nInput data from previous tasks:"
+                    
+                    # Add data from previous tasks in workflow
+                    for prev_name in current_task.previous_tasks:
+                        prev_task = next((t for t in self.tasks.values() if t.name == prev_name), None)
+                        if prev_task and prev_task.result:
+                            # Handle loop data
+                            if current_task.task_type == "loop":
+                                # create a loop manager Agent
+                                loop_manager = Agent(
+                                    name="Loop Manager",
+                                    role="Loop data processor",
+                                    goal="Process loop data and convert it to list format",
+                                    backstory="Expert at handling loop data and converting it to proper format",
+                                    llm=self.manager_llm,
+                                    verbose=self.verbose,
+                                    markdown=True
+                                )
+
+                                # get the loop data convert it to list using calling Agent class chat
+                                loop_prompt = f"""
+Process this data into a list format:
+{prev_task.result.raw}
+
+Return a JSON object with an 'items' array containing the items to process.
+"""
+                                loop_data_str = loop_manager.chat(
+                                    prompt=loop_prompt,
+                                    output_json=LoopItems
+                                )
+                                
+                                try:
+                                    # The response will already be parsed into LoopItems model
+                                    loop_data[f"loop_{current_task.name}"] = {
+                                        "items": loop_data_str.items,
+                                        "index": 0,
+                                        "remaining": len(loop_data_str.items)
+                                    }
+                                    context += f"\nCurrent loop item: {loop_data_str.items[0]}"
+                                except Exception as e:
+                                    display_error(f"Failed to process loop data: {e}")
+                                    context += f"\n{prev_name}: {prev_task.result.raw}"
+                            else:
+                                context += f"\n{prev_name}: {prev_task.result.raw}"
+                    
+                    # Add data from context tasks
+                    if current_task.context:
+                        for ctx_task in current_task.context:
+                            if ctx_task.result and ctx_task.name != current_task.name:
+                                context += f"\n{ctx_task.name}: {ctx_task.result.raw}"
+                    
+                    # Update task description with context
+                    current_task.description = current_task.description + context
+                
+                # Execute task using existing run_task method
+                self.run_task(task_id)
+                visited_tasks.add(task_id)
+                
+                # Handle loop progression
+                if current_task.task_type == "loop":
+                    loop_key = f"loop_{current_task.name}"
+                    if loop_key in loop_data:
+                        loop_info = loop_data[loop_key]
+                        loop_info["index"] += 1
+                        has_more = loop_info["remaining"] > 0
+                        
+                        # Update result to trigger correct condition
+                        if current_task.result:
+                            result = current_task.result.raw
+                            if has_more:
+                                result += "\nmore"
+                            else:
+                                result += "\ndone"
+                            current_task.result.raw = result
+                        
+                # Determine next task based on result
+                next_task = None
+                if current_task.result:
+                    if current_task.task_type in ["decision", "loop"]:
+                        result = current_task.result.raw.lower()
+                        # Check conditions
+                        for condition, tasks in current_task.condition.items():
+                            if condition.lower() in result and tasks:
+                                next_task_name = tasks[0]
+                                next_task = next((t for t in self.tasks.values() if t.name == next_task_name), None)
+                                # For loops, allow revisiting the same task
+                                if next_task and next_task.id == current_task.id:
+                                    visited_tasks.discard(current_task.id)
+                                break
+                
+                    if not next_task and current_task.next_tasks:
+                        next_task_name = current_task.next_tasks[0]
+                        next_task = next((t for t in self.tasks.values() if t.name == next_task_name), None)
+                
+                current_task = next_task
+                if not current_task:
+                    logging.info("Workflow execution completed")
+                    break
+
+        elif self.process == "sequential":
+            # Keep original sequential execution
             for task_id in self.tasks:
                 if self.tasks[task_id].status != "completed":
                     self.run_task(task_id)
+
         elif self.process == "hierarchical":
+            # Keep original hierarchical execution
             logging.debug(f"Starting hierarchical task execution with {len(self.tasks)} tasks")
             manager_agent = Agent(
                 name="Manager",
@@ -317,4 +534,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/main.py

@@ -25,43 +25,92 @@ logging.basicConfig(
 # Global list to store error logs
 error_logs = []
 
-def display_interaction(message: str, response: str, markdown: bool = True, generation_time: Optional[float] = None):
-    console = Console()
-    if generation_time is not None:
+def _clean_display_content(content: str, max_length: int = 20000) -> str:
+    """Helper function to clean and truncate content for display."""
+    if not content or not str(content).strip():
+        return ""
+        
+    content = str(content)
+    # Handle base64 content
+    if "base64" in content:
+        content_parts = []
+        for line in content.split('\n'):
+            if "base64" not in line:
+                content_parts.append(line)
+        content = '\n'.join(content_parts)
+    
+    # Truncate if too long
+    if len(content) > max_length:
+        content = content[:max_length] + "..."
+    
+    return content.strip()
+
+def display_interaction(message, response, markdown=True, generation_time=None, console=None):
+    """Display the interaction between user and assistant."""
+    if console is None:
+        console = Console()
+    if generation_time:
         console.print(Text(f"Response generated in {generation_time:.1f}s", style="dim"))
-    else:
-        console.print(Text("Response Generation Complete", style="dim"))
+
+    # Handle multimodal content (list)
+    if isinstance(message, list):
+        # Extract just the text content from the multimodal message
+        text_content = next((item["text"] for item in message if item["type"] == "text"), "")
+        message = text_content
+
+    message = _clean_display_content(str(message))
+    response = _clean_display_content(str(response))
 
     if markdown:
         console.print(Panel.fit(Markdown(message), title="Message", border_style="cyan"))
         console.print(Panel.fit(Markdown(response), title="Response", border_style="cyan"))
     else:
         console.print(Panel.fit(Text(message, style="bold green"), title="Message", border_style="cyan"))
-        console.print(Panel.fit(Text(response, style="bold white"), title="Response", border_style="cyan"))
-
-def display_self_reflection(message: str):
-    console = Console()
+        console.print(Panel.fit(Text(response, style="bold blue"), title="Response", border_style="cyan"))
+
+def display_self_reflection(message: str, console=None):
+    if not message or not message.strip():
+        return
+    if console is None:
+        console = Console()
+    message = _clean_display_content(str(message))
     console.print(Panel.fit(Text(message, style="bold yellow"), title="Self Reflection", border_style="magenta"))
 
-def display_instruction(message: str):
-    console = Console()
+def display_instruction(message: str, console=None):
+    if not message or not message.strip():
+        return
+    if console is None:
+        console = Console()
+    message = _clean_display_content(str(message))
     console.print(Panel.fit(Text(message, style="bold blue"), title="Instruction", border_style="cyan"))
 
-def display_tool_call(message: str):
-    console = Console()
+def display_tool_call(message: str, console=None):
+    if not message or not message.strip():
+        return
+    if console is None:
+        console = Console()
+    message = _clean_display_content(str(message))
     console.print(Panel.fit(Text(message, style="bold cyan"), title="Tool Call", border_style="green"))
 
-def display_error(message: str):
-    console = Console()
+def display_error(message: str, console=None):
+    if not message or not message.strip():
+        return
+    if console is None:
+        console = Console()
+    message = _clean_display_content(str(message))
     console.print(Panel.fit(Text(message, style="bold red"), title="Error", border_style="red"))
     # Store errors
     error_logs.append(message)
 
 def display_generating(content: str = "", start_time: Optional[float] = None):
+    if not content or not str(content).strip():
+        return Panel("", title="", border_style="green")  # Return empty panel when no content
     elapsed_str = ""
     if start_time is not None:
         elapsed = time.time() - start_time
         elapsed_str = f" {elapsed:.1f}s"
+    
+    content = _clean_display_content(str(content))
     return Panel(Markdown(content), title=f"Generating...{elapsed_str}", border_style="green")
 
 def clean_triple_backticks(text: str) -> str:

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__(
@@ -22,11 +23,18 @@ class Task:
         status: str = "not started",
         result: Optional[TaskOutput] = None,
         create_directory: Optional[bool] = False,
-        id: Optional[int] = None
+        id: Optional[int] = 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 []
@@ -39,10 +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.12.dist-info → praisonaiagents-0.0.14.dist-info}/METADATA

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

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

@@ -1,9 +1,9 @@
 praisonaiagents/__init__.py,sha256=gI8vEabBTRPsE_E8GA5sBMi4sTtJI-YokPrH2Nor-k0,741
-praisonaiagents/main.py,sha256=zDhN5KKtKbfruolDNxlyJkcFlkSt4KQkQTDRfQVAhxc,3960
+praisonaiagents/main.py,sha256=K2OxVKPmo4dNJbSWIsXDi_hm9CRx5O4km_74UGcszhk,5744
 praisonaiagents/agent/__init__.py,sha256=sKO8wGEXvtCrvV1e834r1Okv0XAqAxqZCqz6hKLiTvA,79
-praisonaiagents/agent/agent.py,sha256=hf9z2XwdUF5n_A1ztDM9qGvaKJj40SqJm9WblwLcKjI,20328
+praisonaiagents/agent/agent.py,sha256=zTYcDpJ5DzzBnefwLvhrtBlGQoRI4ZZAioDu5nKTPSs,24042
 praisonaiagents/agents/__init__.py,sha256=7RDeQNSqZg5uBjD4M_0p_F6YgfWuDuxPFydPU50kDYc,120
-praisonaiagents/agents/agents.py,sha256=CBN7OQwFbTgiKXVn7o8987mBH9TUr5s721AC-FSu8AQ,13680
+praisonaiagents/agents/agents.py,sha256=ITvH8Yq_OzhyMC_Aid4qlqQbEM9cCfp7SayXg0ASJ5k,24526
 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
@@ -13,8 +13,8 @@ praisonaiagents/build/lib/praisonaiagents/agents/agents.py,sha256=P2FAtlfD3kPib5
 praisonaiagents/build/lib/praisonaiagents/task/__init__.py,sha256=VL5hXVmyGjINb34AalxpBMl-YW9m5EDcRkMTKkSSl7c,80
 praisonaiagents/build/lib/praisonaiagents/task/task.py,sha256=4Y1qX8OeEFcid2yhAiPYylvHpuDmWORsyNL16_BiVvI,1831
 praisonaiagents/task/__init__.py,sha256=VL5hXVmyGjINb34AalxpBMl-YW9m5EDcRkMTKkSSl7c,80
-praisonaiagents/task/task.py,sha256=4Y1qX8OeEFcid2yhAiPYylvHpuDmWORsyNL16_BiVvI,1831
-praisonaiagents-0.0.12.dist-info/METADATA,sha256=ci_5OYkXaI9I_O1sMV3-P-i-Gi9jX9S_GzDXCNrnV8Y,233
-praisonaiagents-0.0.12.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-praisonaiagents-0.0.12.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
-praisonaiagents-0.0.12.dist-info/RECORD,,
+praisonaiagents/task/task.py,sha256=oMC5Zz1dMj0Ceice69aBS1KQQXMLqphc8wNOQ9zcu0Q,2570
+praisonaiagents-0.0.14.dist-info/METADATA,sha256=-pdlX7m7Sr2IovIrRt9QyBfkiwgK81rEd3_VklcmHNs,233
+praisonaiagents-0.0.14.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+praisonaiagents-0.0.14.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
+praisonaiagents-0.0.14.dist-info/RECORD,,