swarmai/agents/ManagerAgent.py

import os
import openai
import re
import random
import json

from swarmai.agents.AgentBase import AgentBase
from swarmai.utils.ai_engines.GPTConversEngine import GPTConversEngine
from swarmai.utils.task_queue.Task import Task
from swarmai.utils.PromptFactory import PromptFactory

class ManagerAgent(AgentBase):
    """Manager agent class that is responsible for breaking down the tasks into subtasks and assigning them into the task queue.
    """

    def __init__(self, agent_id, agent_type, swarm, logger):
        super().__init__(agent_id, agent_type, swarm, logger)
        self.engine = GPTConversEngine("gpt-3.5-turbo", 0.25, 2000)
        
        self.TASK_METHODS = {
            Task.TaskTypes.report_preparation: self.report_preparation,
            Task.TaskTypes.breakdown_to_subtasks: self.breakdown_to_subtasks,
        }

    def perform_task(self):
        self.step = "perform_task"
        try:
            # self.task is already taken in the beginning of the cycle in AgentBase
            if not isinstance(self.task, Task):
                raise Exception(f"Task is not of type Task, but {type(self.task)}")
            
            task_type = self.task.task_type
            if task_type not in self.TASK_METHODS:
                raise Exception(f"Task type {task_type} is not supported by the agent {self.agent_id} of type {self.agent_type}")
            
            self.result = self.TASK_METHODS[task_type](self.task.task_description)
            return True
        except Exception as e:
            self.log(message = f"Agent {self.agent_id} of type {self.agent_type} failed to perform the task {self.task.task_description[:20]}...{self.task.task_description[-20:]} of type {self.task.task_type} with error {e}", level = "error")
            return False

    def share(self):
        pass

    def report_preparation(self, task_description):
        """The manager agent prepares a report.
        For each goal of the swarm:
            1. It reads the current report.
            2. It analyses which information is missing in the report to solve the global task.
            3. Then it tries to find this information in the shared memory
            Updating report:
                If it finds the information:
                    it adds it to the report
                else:
                    it adds the task to the task queue

                Finally: resets the report preparation task
        """
        global_goal = self.swarm.global_goal
        goals = self.swarm.goals.copy()
        random.shuffle(goals)

        for _, goal in enumerate(goals):
            idx = self.swarm.goals.index(goal)
            report_json = self._get_report_json()

            # find the goal. The format is the following: {1: {"Question": goal_i, "Answer": answer_i}, 2:...}
            if idx in report_json:
                prev_answer = report_json[idx]["Answer"]
            else:
                prev_answer = ""

            missing_information_list = self._analyse_report(global_goal, goal, prev_answer)
                
            for el in missing_information_list:
                self._add_subtasks_to_task_queue([('google_search', f"For the purpose of {goal}, find information about {el}", 50)])

            # update the report
            info_from_memory = self.shared_memory.ask_question(f"For the purpose of {global_goal}, try to find information about {goal}. Summarise it shortly and indclude web-lins of sources. Be an extremely critical analyst!.") 
            if info_from_memory is None:
                info_from_memory = ""
            conversation = [
                {"role": "system", "content": PromptFactory.StandardPrompts.summarisation_for_task_prompt },
                {"role": "user", "content": info_from_memory + prev_answer + f"\nUsing all the info above answer the question:\n{goal}\n"},
            ]
            summary = self.engine.call_model(conversation)

            # add to the report
            report_json = self._get_report_json()
            report_json[idx] = {"Question": goal, "Answer": summary}
            self.swarm.interact_with_output(json.dumps(report_json), method="write")

        self.swarm.create_report_qa_task()

    def _get_report_json(self):
        report = self.swarm.interact_with_output("",  method="read")
        if report == "":
            report = "{}"
        # parse json
        report_json = json.loads(report)
        return report_json

    def _analyse_report(self, global_goal, goal, prev_answer):
        """Checks what information is missing in the report to solve the global task.
        """
        prompt = (
            f"Our global goal is:\n{global_goal}\n\n"
            f"The following answer was prepared to solve this goal:\n{prev_answer}\n\n"
            f"Which information is missing in the report to solve the following subgoal:\n{goal}\n\n"
            f"If no information is missing or no extention possible, output: ['no_missing_info']"
            f"Provide a list of specific points that are missing from the report to solve a our subgoal.\n\n"
        )
        conversation = [
            {"role": "user", "content": prompt},
        ]
        missing_information_output = self.engine.call_model(conversation)

        # parse the output
        missing_information_output = re.search(r"\[.*\]", missing_information_output)
        if missing_information_output is None:
            return []
        missing_information_output = missing_information_output.group(0)
        missing_information_output = missing_information_output.replace("[", "").replace("]", "").replace("'", "").strip()
        missing_information_list = missing_information_output.split(",")

        if missing_information_list == ["no_missing_info"]:
            return []
        
        if len(missing_information_list) == 1:
            missing_information_list = missing_information_output.split(";")

        return missing_information_list

    def _repair_json(self, text):
        """Reparing the output of the model to be a valid JSON.
        """
        prompt = (
            "Act as a professional json repairer. Repair the following JSON if needed to make sure it conform to the correct json formatting.\n"
            "Make sure it's a single valid JSON object.\n"
            """The report ABSOLUTELY MUST be in the following JSON format:  {[{"Question": "question1", "Answer": "answer1", "Sources": "web links of the sources"}, {"Question": "question2", "Answer": "answer2", "Sources": "web links of the sources"},...]}"""
        )
        conversation = [
            {"role": "user", "content": prompt+text},
        ]
        return self.engine.call_model(conversation)

    def breakdown_to_subtasks(self, main_task_description):
        """Breaks down the main task into subtasks and adds them to the task queue.
        """
        self.step = "breakdown_to_subtasks"

        task_breakdown_prompt = PromptFactory.StandardPrompts.task_breakdown
        allowed_subtusk_types = [str(t_i) for t_i in self.swarm.TASK_TYPES]
        allowed_subtusk_types_str = "\nFollowing subtasks are allowed:" + ", ".join(allowed_subtusk_types)
        output_format = f"\nThe output MUST be ONLY a list of subtasks in the following format: [[(subtask_type; subtask_description; priority in 0 to 100), (subtask_type; subtask_description; priority in 0 to 100), ...]]"
        one_shot_example = (
            "\nExample: \n"
            "Task: Write a report about the current state of the project.\n"
            "Subtasks:\n"
            f"[[({allowed_subtusk_types[0]}; Find information about the project; 50), ({allowed_subtusk_types[-1]}; Write a conclusion; 5)]]\n"
        )

        task_prompt = (
            "Task: " + main_task_description + "\n"
            "Subtasks:"
        )

        # generate a conversation
        conversation = [
            {"role": "system", "content": task_breakdown_prompt + allowed_subtusk_types_str + output_format + one_shot_example},
            {"role": "user", "content": task_prompt}
        ]

        result = self.engine.call_model(conversation)
        result = result.replace("\n", "").replace("\r", "").replace("\t", "").strip()

        # parse the result

        # first, find the substring enclosed in [[]]
        subtasks_str = re.search(r"\[.*\]", result)
        try:
            subtasks_str = subtasks_str.group(0)
        except:
            raise Exception(f"Failed to parse the result {result}")

        # then, find all substrings enclosed in ()
        subtasks = []
        for subtask_str_i in re.findall(r"\(.*?\)", subtasks_str):
            subtask_str_i = subtask_str_i.replace("(", "").replace(")", "").replace("[", "").replace("]", "").replace("'", "").strip()
            result_split = subtask_str_i.split(";")

            try:
                subtask_type = result_split[0].strip()
            except:
                continue

            try:
                subtask_description = result_split[1].strip()
            except:
                continue

            try:
                prio_int = int(result_split[2].strip())
            except:
                prio_int = 0

            subtasks.append((subtask_type.strip(), subtask_description.strip(), prio_int))

        # add subtasks to the task queue
        self._add_subtasks_to_task_queue(subtasks)

        # add to shared memory
        self.log(
            message=f"Task:\n'{main_task_description}'\n\nwas broken down into {len(subtasks)} subtasks:\n{subtasks}",
        )
        # self._send_data_to_swarm(
        #     data = f"Task '{main_task_description}' was broken down into {len(subtasks)} subtasks: {subtasks}"
        # )
        return subtasks

    def _add_subtasks_to_task_queue(self, subtask_list: list):
        if len(subtask_list) == 0:
            return

        self.step = "_add_subtasks_to_task_queue"
        summary_conversation = [
            {"role": "system", "content": "Be very concise and precise when summarising the global task. Focus on the most important aspects of the global task to guide the model in performing a given subtask. Don't mention any subtasks but only the main mission as a guide."},
            {"role": "user", "content": f"""Global Task:\n{self.task.task_description}\nSubtasks:\n{"||".join([x[1] for x in subtask_list])}\nSummary of the global task:"""},
        ]
        task_summary = self.engine.call_model(summary_conversation)
        for task_i in subtask_list:
            try:
                # generating a task object
                taks_obj_i = Task(
                    priority=task_i[2],
                    task_type=task_i[0],
                    task_description=f"""For the purpose of '{task_summary}' Perform ONLY the following task: {task_i[1]}""",
                )
                self.swarm.task_queue.add_task(taks_obj_i)
            except:
                continue