praisonaiagents 0.0.2__py3-none-any.whl → 0.0.4__py3-none-any.whl

{agents → praisonaiagents}/__init__.py

@@ -3,7 +3,7 @@ Praison AI Agents - A package for hierarchical AI agent task execution
 """
 
 from .agent.agent import Agent
-from .agents.agents import Agents
+from .agents.agents import PraisonAIAgents
 from .task.task import Task
 from .main import (
     TaskOutput,
@@ -20,7 +20,7 @@ from .main import (
 
 __all__ = [
     'Agent',
-    'Agents',
+    'PraisonAIAgents',
     'Task',
     'TaskOutput',
     'ReflectionOutput',

praisonaiagents/agents/__init__.py

@@ -0,0 +1,4 @@
+"""Agents module for managing multiple AI agents"""
+from .agents import PraisonAIAgents
+
+__all__ = ['PraisonAIAgents'] 

praisonaiagents/agents/agents.py

@@ -0,0 +1,318 @@
+import os
+import time
+import json
+import logging
+from typing import Any, Dict, Optional
+from pydantic import BaseModel
+from rich.text import Text
+from rich.panel import Panel
+from rich.console import Console
+from ..main import display_error, TaskOutput, error_logs, client
+from ..agent.agent import Agent
+from ..task.task import Task
+
+class PraisonAIAgents:
+    def __init__(self, agents, tasks, verbose=0, completion_checker=None, max_retries=5, process="sequential", manager_llm=None):
+        self.agents = agents
+        self.tasks = {}
+        if max_retries < 3:
+            max_retries = 3
+        self.completion_checker = completion_checker if completion_checker else self.default_completion_checker
+        self.task_id_counter = 0
+        self.verbose = verbose
+        self.max_retries = max_retries
+        self.process = process
+        self.manager_llm = manager_llm
+        for task in tasks:
+            self.add_task(task)
+            task.status = "not started"
+
+    def add_task(self, task):
+        task_id = self.task_id_counter
+        task.id = task_id
+        self.tasks[task_id] = task
+        self.task_id_counter += 1
+        return task_id
+
+    def clean_json_output(self, output: str) -> str:
+        cleaned = output.strip()
+        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
+
+    def default_completion_checker(self, task, agent_output):
+        if task.output_json and task.result and task.result.json_dict:
+            return True
+        if task.output_pydantic and task.result and task.result.pydantic:
+            return True
+        return len(agent_output.strip()) > 0
+
+    def execute_task(self, task_id):
+        if task_id not in self.tasks:
+            display_error(f"Error: Task with ID {task_id} does not exist")
+            return
+        task = self.tasks[task_id]
+        if task.status == "not started":
+            task.status = "in progress"
+
+        executor_agent = task.agent
+
+        task_prompt = f"""
+        You need to do the following task: {task.description}.
+        Expected Output: {task.expected_output}.
+        """
+        if task.context:
+            context_results = ""
+            for context_task in task.context:
+                if context_task.result:
+                    context_results += f"Result of previous task {context_task.name if context_task.name else context_task.description}: {context_task.result.raw}\n"
+                else:
+                    context_results += f"Previous task {context_task.name if context_task.name else context_task.description} had no result.\n"
+            task_prompt += f"""
+            Here are the results of previous tasks that might be useful:\n
+            {context_results}
+            """
+        task_prompt += "Please provide only the final result of your work. Do not add any conversation or extra explanation."
+
+        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 agent_output:
+            task_output = TaskOutput(
+                description=task.description,
+                summary=task.description[:10],
+                raw=agent_output,
+                agent=executor_agent.name,
+                output_format="RAW"
+            )
+
+            if task.output_json:
+                cleaned = self.clean_json_output(agent_output)
+                try:
+                    parsed = json.loads(cleaned)
+                    task_output.json_dict = parsed
+                    task_output.output_format = "JSON"
+                except:
+                    logging.warning(f"Warning: Could not parse output of task {task_id} as JSON")
+                    logging.debug(f"Output that failed JSON parsing: {agent_output}")
+
+            if task.output_pydantic:
+                cleaned = self.clean_json_output(agent_output)
+                try:
+                    parsed = json.loads(cleaned)
+                    pyd_obj = task.output_pydantic(**parsed)
+                    task_output.pydantic = pyd_obj
+                    task_output.output_format = "Pydantic"
+                except:
+                    logging.warning(f"Warning: Could not parse output of task {task_id} as Pydantic Model")
+                    logging.debug(f"Output that failed Pydantic parsing: {agent_output}")
+
+            task.result = task_output
+            return task_output
+        else:
+            task.status = "failed"
+            return None
+
+    def save_output_to_file(self, task, task_output):
+        if task.output_file:
+            try:
+                if task.create_directory:
+                    os.makedirs(os.path.dirname(task.output_file), exist_ok=True)
+                with open(task.output_file, "w") as f:
+                    f.write(str(task_output))
+                if self.verbose >= 1:
+                    logging.info(f"Task output saved to {task.output_file}")
+            except Exception as e:
+                display_error(f"Error saving task output to file: {e}")
+
+    def run_task(self, task_id):
+        if task_id not in self.tasks:
+            display_error(f"Error: Task with ID {task_id} does not exist")
+            return
+        task = self.tasks[task_id]
+        if task.status == "completed":
+            logging.info(f"Task with ID {task_id} is already completed")
+            return
+
+        retries = 0
+        while task.status != "completed" and retries < self.max_retries:
+            logging.debug(f"Attempt {retries+1} for task {task_id}")
+            if task.status in ["not started", "in progress"]:
+                task_output = self.execute_task(task_id)
+                if task_output and self.completion_checker(task, task_output.raw):
+                    task.status = "completed"
+                    if task.callback:
+                        task.callback(task_output)
+                    self.save_output_to_file(task, task_output)
+                    if self.verbose >= 1:
+                        logging.info(f"Task {task_id} completed successfully.")
+                else:
+                    task.status = "in progress"
+                    if self.verbose >= 1:
+                        logging.info(f"Task {task_id} not completed, retrying")
+                    time.sleep(1)
+                    retries += 1
+            else:
+                if task.status == "failed":
+                    logging.info("Task is failed, resetting to in-progress for another try...")
+                    task.status = "in progress"
+                else:
+                    logging.info("Invalid Task status")
+                    break
+
+        if retries == self.max_retries and task.status != "completed":
+            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)
+        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")
+
+    def get_task_status(self, task_id):
+        if task_id in self.tasks:
+            return self.tasks[task_id].status
+        return None
+
+    def get_all_tasks_status(self):
+        return {task_id: self.tasks[task_id].status for task_id in self.tasks}
+
+    def get_task_result(self, task_id):
+        if task_id in self.tasks:
+            return self.tasks[task_id].result
+        return None
+
+    def get_task_details(self, task_id):
+        if task_id in self.tasks:
+            return str(self.tasks[task_id])
+        return None
+
+    def get_agent_details(self, agent_name):
+        agent = [task.agent for task in self.tasks.values() if task.agent and task.agent.name == agent_name]
+        if agent:
+            return str(agent[0])
+        return None
+
+    def start(self):
+        self.run_all_tasks()
+        return {
+            "task_status": self.get_all_tasks_status(),
+            "task_results": {task_id: self.get_task_result(task_id) for task_id in self.tasks}
+        } 

praisonaiagents/build/lib/praisonaiagents/__init__.py

@@ -0,0 +1 @@
+ 

praisonaiagents/build/lib/praisonaiagents/agent/__init__.py

@@ -0,0 +1,4 @@
+"""Agent module for AI agents"""
+from .agent import Agent
+
+__all__ = ['Agent'] 

praisonaiagents/build/lib/praisonaiagents/agent/agent.py

@@ -0,0 +1,350 @@
+import logging
+import json
+import time
+from typing import List, Optional, Any, Dict, Union, Literal
+from rich.console import Console
+from rich.live import Live
+from ..main import (
+    display_error,
+    display_tool_call,
+    display_instruction,
+    display_interaction,
+    display_generating,
+    ReflectionOutput,
+    client,
+    error_logs
+)
+
+class Agent:
+    def __init__(
+        self,
+        name: str,
+        role: str,
+        goal: str,
+        backstory: str,
+        llm: Optional[Union[str, Any]] = "gpt-4o-mini",
+        tools: Optional[List[Any]] = None,
+        function_calling_llm: Optional[Any] = None,
+        max_iter: int = 20,
+        max_rpm: Optional[int] = None,
+        max_execution_time: Optional[int] = None,
+        memory: bool = True,
+        verbose: bool = False,
+        allow_delegation: bool = False,
+        step_callback: Optional[Any] = None,
+        cache: bool = True,
+        system_template: Optional[str] = None,
+        prompt_template: Optional[str] = None,
+        response_template: Optional[str] = None,
+        allow_code_execution: Optional[bool] = False,
+        max_retry_limit: int = 2,
+        respect_context_window: bool = True,
+        code_execution_mode: Literal["safe", "unsafe"] = "safe",
+        embedder_config: Optional[Dict[str, Any]] = None,
+        knowledge_sources: Optional[List[Any]] = None,
+        use_system_prompt: Optional[bool] = True,
+        markdown: bool = True,
+        self_reflect: bool = True,
+        max_reflection_iter: int = 3
+    ):
+        self.name = name
+        self.role = role
+        self.goal = goal
+        self.backstory = backstory
+        self.llm = llm
+        self.tools = tools if tools else []
+        self.function_calling_llm = function_calling_llm
+        self.max_iter = max_iter
+        self.max_rpm = max_rpm
+        self.max_execution_time = max_execution_time
+        self.memory = memory
+        self.verbose = verbose
+        self.allow_delegation = allow_delegation
+        self.step_callback = step_callback
+        self.cache = cache
+        self.system_template = system_template
+        self.prompt_template = prompt_template
+        self.response_template = response_template
+        self.allow_code_execution = allow_code_execution
+        self.max_retry_limit = max_retry_limit
+        self.respect_context_window = respect_context_window
+        self.code_execution_mode = code_execution_mode
+        self.embedder_config = embedder_config
+        self.knowledge_sources = knowledge_sources
+        self.use_system_prompt = use_system_prompt
+        self.chat_history = []
+        self.markdown = markdown
+        self.self_reflect = self_reflect
+        self.max_reflection_iter = max_reflection_iter
+
+    def execute_tool(self, function_name, arguments):
+        logging.debug(f"{self.name} executing tool {function_name} with arguments: {arguments}")
+        if function_name == "get_weather":
+            location = arguments.get("location", "Unknown Location")
+            return {"temperature": "25C", "condition": "Sunny", "location": location}
+        elif function_name == "search_tool":
+            query = arguments.get("query", "AI trends in 2024")
+            return {"results": [
+                {"title": "AI advancements in 2024", "link": "url1", "summary": "Lots of advancements"},
+                {"title": "New trends in AI", "link": "url2", "summary": "New trends being found"}
+            ]}
+        else:
+            return f"Tool '{function_name}' is not recognized"
+
+    def clear_history(self):
+        self.chat_history = []
+
+    def __str__(self):
+        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}")
+
+        formatted_tools = []
+        if tools:
+            for tool in tools:
+                if isinstance(tool, dict):
+                    formatted_tools.append(tool)
+                elif hasattr(tool, "to_openai_tool"):
+                    formatted_tools.append(tool.to_openai_tool())
+                elif isinstance(tool, str):
+                    formatted_tools.append({
+                        "type": "function",
+                        "function": {
+                            "name": tool,
+                            "description": f"This is a tool called {tool}",
+                            "parameters": {
+                                "type": "object",
+                                "properties": {},
+                            },
+                        }
+                    })
+                else:
+                    display_error(f"Warning: Tool {tool} not recognized")
+
+        try:
+            initial_response = client.chat.completions.create(
+                model=self.llm,
+                messages=messages,
+                temperature=temperature,
+                tools=formatted_tools if formatted_tools else None,
+                stream=False
+            )
+
+            tool_calls = getattr(initial_response.choices[0].message, 'tool_calls', None)
+
+            if tool_calls:
+                messages.append({
+                    "role": "assistant",
+                    "content": initial_response.choices[0].message.content,
+                    "tool_calls": tool_calls
+                })
+
+                for tool_call in tool_calls:
+                    function_name = tool_call.function.name
+                    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}")
+
+                    tool_result = self.execute_tool(function_name, arguments)
+                    results_str = json.dumps(tool_result) if tool_result else "Function returned an empty output"
+
+                    if self.verbose:
+                        display_tool_call(f"Function '{function_name}' returned: {results_str}")
+
+                    messages.append({
+                        "role": "tool",
+                        "tool_call_id": tool_call.id,
+                        "content": results_str
+                    })
+
+            if stream:
+                response_stream = client.chat.completions.create(
+                    model=self.llm,
+                    messages=messages,
+                    temperature=temperature,
+                    stream=True
+                )
+                full_response_text = ""
+                with Live(display_generating("", start_time), refresh_per_second=4) 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))
+
+                final_response = client.chat.completions.create(
+                    model=self.llm,
+                    messages=messages,
+                    temperature=temperature,
+                    stream=False
+                )
+                return final_response
+            else:
+                if tool_calls:
+                    final_response = client.chat.completions.create(
+                        model=self.llm,
+                        messages=messages,
+                        temperature=temperature,
+                        stream=False
+                    )
+                    return final_response
+                else:
+                    return initial_response
+
+        except Exception as e:
+            display_error(f"Error in chat completion: {e}")
+            return None
+
+    def chat(self, prompt, temperature=0.2, tools=None, output_json=None):
+        if self.use_system_prompt:
+            system_prompt = f"""{self.backstory}\n
+            Your Role: {self.role}\n
+            Your Goal: {self.goal}
+            """
+        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})
+
+        final_response_text = None
+        reflection_count = 0
+        start_time = time.time()
+
+        while True:
+            try:
+                if self.verbose:
+                    display_instruction(f"Agent {self.name} is processing prompt: {prompt}")
+
+                formatted_tools = []
+                if tools:
+                    for tool in tools:
+                        if isinstance(tool, dict):
+                            formatted_tools.append(tool)
+                        elif hasattr(tool, "to_openai_tool"):
+                            formatted_tools.append(tool.to_openai_tool())
+                        elif isinstance(tool, str):
+                            formatted_tools.append({
+                                "type": "function",
+                                "function": {
+                                    "name": tool,
+                                    "description": f"This is a tool called {tool}",
+                                    "parameters": {
+                                        "type": "object",
+                                        "properties": {},
+                                    },
+                                }
+                            })
+                        else:
+                            display_error(f"Warning: Tool {tool} not recognized")
+
+                response = self._chat_completion(messages, temperature=temperature, tools=formatted_tools if formatted_tools else None)
+                if not response:
+                    return None
+                    
+                tool_calls = getattr(response.choices[0].message, 'tool_calls', None)
+
+                if tool_calls:
+                    messages.append({
+                        "role": "assistant",
+                        "content": response.choices[0].message.content,
+                        "tool_calls": tool_calls
+                    })
+                    
+                    for tool_call in tool_calls:
+                        function_name = tool_call.function.name
+                        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}")
+
+                        tool_result = self.execute_tool(function_name, arguments)
+
+                        if tool_result:
+                            if self.verbose:
+                                display_tool_call(f"Function '{function_name}' returned: {tool_result}")
+                            messages.append({
+                                "role": "tool",
+                                "tool_call_id": tool_call.id,
+                                "content": json.dumps(tool_result)
+                            })
+                        else:
+                            messages.append({
+                                "role": "tool",
+                                "tool_call_id": tool_call.id,
+                                "content": "Function returned an empty output"
+                            })
+                        
+                    response = self._chat_completion(messages, temperature=temperature)
+                    if not response:
+                        return None
+                    response_text = response.choices[0].message.content.strip()
+                else:
+                    response_text = response.choices[0].message.content.strip()
+
+                if not self.self_reflect:
+                    self.chat_history.append({"role": "user", "content": 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)
+                    return response_text
+
+                reflection_prompt = f"""
+                Reflect on your previous response: '{response_text}'.
+                Identify any flaws, improvements, or actions.
+                Provide a "satisfactory" status ('yes' or 'no').
+                Output MUST be JSON with 'reflection' and 'satisfactory'.
+                """
+                logging.debug(f"{self.name} reflection attempt {reflection_count+1}, sending prompt: {reflection_prompt}")
+                messages.append({"role": "user", "content": reflection_prompt})
+
+                try:
+                    reflection_response = client.beta.chat.completions.parse(
+                        model=self.llm,
+                        messages=messages,
+                        temperature=temperature,
+                        response_format=ReflectionOutput
+                    )
+
+                    reflection_output = reflection_response.choices[0].message.parsed
+
+                    if self.verbose:
+                        display_self_reflection(f"Agent {self.name} self reflection: reflection='{reflection_output.reflection}' satisfactory='{reflection_output.satisfactory}'")
+
+                    messages.append({"role": "assistant", "content": f"Self Reflection: {reflection_output.reflection} Satisfactory?: {reflection_output.satisfactory}"})
+
+                    if reflection_output.satisfactory == "yes":
+                        if self.verbose:
+                            display_self_reflection("Agent marked the response as satisfactory")
+                        self.chat_history.append({"role": "assistant", "content": response_text})
+                        display_interaction(prompt, response_text, markdown=self.markdown, generation_time=time.time() - start_time)
+                        return response_text
+
+                    logging.debug(f"{self.name} reflection not satisfactory, requesting regeneration.")
+                    messages.append({"role": "user", "content": "Now regenerate your response using the reflection you made"})
+                    response = self._chat_completion(messages, temperature=temperature, tools=None, stream=True)
+                    response_text = response.choices[0].message.content.strip()
+                except Exception as e:
+                    display_error(f"Error in parsing self-reflection json {e}. Retrying")
+                    logging.error("Reflection parsing failed.", exc_info=True)
+                    messages.append({"role": "assistant", "content": f"Self Reflection failed."})
+                
+                reflection_count += 1
+
+                self.chat_history.append({"role": "user", "content": 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)
+                return response_text
+            except Exception as e:
+                display_error(f"Error in chat: {e}")
+                return None 

praisonaiagents/main.py

@@ -0,0 +1,112 @@
+import os
+import time
+import json
+import logging
+from typing import List, Optional, Dict, Any, Union, Literal, Type
+from openai import OpenAI
+from pydantic import BaseModel
+from rich import print
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+from rich.markdown import Markdown
+from rich.logging import RichHandler
+from rich.live import Live
+
+LOGLEVEL = os.environ.get('LOGLEVEL', 'INFO').upper()
+
+logging.basicConfig(
+    level=getattr(logging, LOGLEVEL, logging.INFO),
+    format="%(asctime)s %(filename)s:%(lineno)d %(levelname)s %(message)s",
+    datefmt="[%X]",
+    handlers=[RichHandler(rich_tracebacks=True)]
+)
+
+# 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:
+        console.print(Text(f"Response generated in {generation_time:.1f}s", style="dim"))
+    else:
+        console.print(Text("Response Generation Complete", style="dim"))
+
+    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(message, style="bold yellow"), title="Self Reflection", border_style="magenta"))
+
+def display_instruction(message: str):
+    console = Console()
+    console.print(Panel.fit(Text(message, style="bold blue"), title="Instruction", border_style="cyan"))
+
+def display_tool_call(message: str):
+    console = Console()
+    console.print(Panel.fit(Text(message, style="bold cyan"), title="Tool Call", border_style="green"))
+
+def display_error(message: str):
+    console = Console()
+    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):
+    elapsed_str = ""
+    if start_time is not None:
+        elapsed = time.time() - start_time
+        elapsed_str = f" {elapsed:.1f}s"
+    return Panel(Markdown(content), title=f"Generating...{elapsed_str}", border_style="green")
+
+def clean_triple_backticks(text: str) -> str:
+    """Remove triple backticks and surrounding json fences from a string."""
+    cleaned = text.strip()
+    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
+
+class ReflectionOutput(BaseModel):
+    reflection: str
+    satisfactory: Literal["yes", "no"]
+
+client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY"))
+
+class TaskOutput(BaseModel):
+    description: str
+    summary: Optional[str] = None
+    raw: str
+    pydantic: Optional[BaseModel] = None
+    json_dict: Optional[Dict[str, Any]] = None
+    agent: str
+    output_format: Literal["RAW", "JSON", "Pydantic"] = "RAW"
+
+    def json(self) -> Optional[str]:
+        if self.output_format == "JSON" and self.json_dict:
+            return json.dumps(self.json_dict)
+        return None
+
+    def to_dict(self) -> dict:
+        output_dict = {}
+        if self.json_dict:
+            output_dict.update(self.json_dict)
+        if self.pydantic:
+            output_dict.update(self.pydantic.model_dump())
+        return output_dict
+
+    def __str__(self):
+        if self.pydantic:
+            return str(self.pydantic)
+        elif self.json_dict:
+            return json.dumps(self.json_dict)
+        else:
+            return self.raw 

praisonaiagents/task/__init__.py

@@ -0,0 +1,4 @@
+"""Task module for AI agent tasks"""
+from .task import Task
+
+__all__ = ['Task'] 

praisonaiagents/task/task.py

@@ -0,0 +1,48 @@
+import logging
+from typing import List, Optional, Dict, Any, Type
+from pydantic import BaseModel
+from ..main import TaskOutput
+from ..agent.agent import Agent
+
+class Task:
+    def __init__(
+        self,
+        description: str,
+        expected_output: str,
+        agent: Optional[Agent] = None,
+        name: Optional[str] = None,
+        tools: Optional[List[Any]] = None,
+        context: Optional[List["Task"]] = None,
+        async_execution: Optional[bool] = False,
+        config: Optional[Dict[str, Any]] = None,
+        output_file: Optional[str] = None,
+        output_json: Optional[Type[BaseModel]] = None,
+        output_pydantic: Optional[Type[BaseModel]] = None,
+        callback: Optional[Any] = None,
+        status: str = "not started",
+        result: Optional[TaskOutput] = None,
+        create_directory: Optional[bool] = False,
+        id: Optional[int] = None
+    ):
+        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 []
+        self.async_execution = async_execution
+        self.config = config if config else {}
+        self.output_file = output_file
+        self.output_json = output_json
+        self.output_pydantic = output_pydantic
+        self.callback = callback
+        self.status = status
+        self.result = result
+        self.create_directory = create_directory
+        self.id = id
+
+        if self.output_json and self.output_pydantic:
+            raise ValueError("Only one output type can be defined")
+
+    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.2.dist-info → praisonaiagents-0.0.4.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: praisonaiagents
-Version: 0.0.2
-Summary: Hierarchical AI agents for task execution
+Version: 0.0.4
+Summary: Praison AI agents for completing complex tasks with Self Reflection Agents
 Author: Mervin Praison
 Requires-Dist: pydantic
 Requires-Dist: rich

praisonaiagents-0.0.4.dist-info/RECORD

@@ -0,0 +1,20 @@
+praisonaiagents/__init__.py,sha256=gI8vEabBTRPsE_E8GA5sBMi4sTtJI-YokPrH2Nor-k0,741
+praisonaiagents/main.py,sha256=zDhN5KKtKbfruolDNxlyJkcFlkSt4KQkQTDRfQVAhxc,3960
+praisonaiagents/agent/__init__.py,sha256=sKO8wGEXvtCrvV1e834r1Okv0XAqAxqZCqz6hKLiTvA,79
+praisonaiagents/agent/agent.py,sha256=CCCjv-qtr6hSB-BG7C8l3z-pXQpnTkX9bW6me36YiaU,15512
+praisonaiagents/agents/__init__.py,sha256=7RDeQNSqZg5uBjD4M_0p_F6YgfWuDuxPFydPU50kDYc,120
+praisonaiagents/agents/agents.py,sha256=kgzesSMIOHB_ig_qJmCY5jzllaIcuy56jsJnFvpEAyk,13482
+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
+praisonaiagents/build/lib/praisonaiagents/agent/agent.py,sha256=PwbeW6v4Ldcl10JQr9_7TBfg4_FskQh-mGoFUdGxg8w,15483
+praisonaiagents/build/lib/praisonaiagents/agents/__init__.py,sha256=cgCLFLFcLp9SizmFSHUkH5aX-1seAAsRtQbtIHBBso4,101
+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/task/__init__.py,sha256=VL5hXVmyGjINb34AalxpBMl-YW9m5EDcRkMTKkSSl7c,80
+praisonaiagents/task/task.py,sha256=4Y1qX8OeEFcid2yhAiPYylvHpuDmWORsyNL16_BiVvI,1831
+praisonaiagents-0.0.4.dist-info/METADATA,sha256=l-buIBQrgYLY8_1_qAQ6-ZqKJ1OlBNtjejWEFMcy4gQ,232
+praisonaiagents-0.0.4.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+praisonaiagents-0.0.4.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
+praisonaiagents-0.0.4.dist-info/RECORD,,

praisonaiagents-0.0.4.dist-info/top_level.txt

@@ -0,0 +1 @@
+praisonaiagents

praisonaiagents-0.0.2.dist-info/RECORD

@@ -1,12 +0,0 @@
-agents/__init__.py,sha256=479EdtuXm27prpz83bfm6DCoUfx-W0u-LNIphAlqXDc,723
-agents/main.py,sha256=zDhN5KKtKbfruolDNxlyJkcFlkSt4KQkQTDRfQVAhxc,3960
-agents/agent/__init__.py,sha256=sKO8wGEXvtCrvV1e834r1Okv0XAqAxqZCqz6hKLiTvA,79
-agents/agent/agent.py,sha256=CCCjv-qtr6hSB-BG7C8l3z-pXQpnTkX9bW6me36YiaU,15512
-agents/agents/__init__.py,sha256=cgCLFLFcLp9SizmFSHUkH5aX-1seAAsRtQbtIHBBso4,101
-agents/agents/agents.py,sha256=P2FAtlfD3kPib5a1oLVYanxlU6e4-GhBMQ0YDY5MHY4,13473
-agents/task/__init__.py,sha256=VL5hXVmyGjINb34AalxpBMl-YW9m5EDcRkMTKkSSl7c,80
-agents/task/task.py,sha256=4Y1qX8OeEFcid2yhAiPYylvHpuDmWORsyNL16_BiVvI,1831
-praisonaiagents-0.0.2.dist-info/METADATA,sha256=hCCZISknDJwJREyP1L92Dot8Hk0fjE4XMhFAkeknOdo,199
-praisonaiagents-0.0.2.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-praisonaiagents-0.0.2.dist-info/top_level.txt,sha256=OHAN-tVxGXbi966rMQE_BK7YyDEYoe-JL20jvf6URgI,7
-praisonaiagents-0.0.2.dist-info/RECORD,,

praisonaiagents-0.0.2.dist-info/top_level.txt

@@ -1 +0,0 @@
-agents