praisonaiagents 0.0.13__tar.gz → 0.0.14__tar.gz

{praisonaiagents-0.0.13 → praisonaiagents-0.0.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: praisonaiagents
-Version: 0.0.13
+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.13 → praisonaiagents-0.0.14}/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-0.0.13 → praisonaiagents-0.0.14}/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,9 @@ 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
@@ -55,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
@@ -251,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",
@@ -397,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-0.0.13 → praisonaiagents-0.0.14}/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 → praisonaiagents-0.0.14}/praisonaiagents.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: praisonaiagents
-Version: 0.0.13
+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.13 → praisonaiagents-0.0.14}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "praisonaiagents"
-version = "0.0.13"
+version = "0.0.14"
 description = "Praison AI agents for completing complex tasks with Self Reflection Agents"
 authors = [
     { name="Mervin Praison" }