init

.gitignore

@@ -0,0 +1,2 @@
+__pycache__
+logs

Action/__init__.py

@@ -0,0 +1 @@
+from .base_action import Action

Action/base_action.py

@@ -0,0 +1,51 @@
+from Memory import Memory
+from utils import extract
+import os
+class Action:
+    """
+    The basic action unit of agent
+    """
+    def __init__(self,**kwargs):
+        self.response = None
+        self.is_user = False
+        self.res_dict = {}
+        self.name = ""
+        self.role = ""
+        for key,value in kwargs.items():
+            setattr(self,key,value)
+    
+    
+    def process(self):
+        """
+        processing action
+        Rerutn : memory(Memory)
+        """
+        response = self.response
+        send_name = self.name
+        send_role = self.role
+        all = ""
+        for res in response:
+            all += res
+        parse = f"{send_name}:"
+        
+        # 将里面对话的第三人称删了
+        # The third person in the dialogue was deleted.
+        while parse in all:
+            index = all.index(parse) + len(parse)
+            all = all[index:]
+        
+        if not self.is_user:
+            print(f"{send_name}({send_role}):{all}")
+                # for software
+        if "<title>" in all:
+            title = extract(all,"title")
+            title = "main.py" if title == "" else title
+            python = extract(all,"python")
+            os.makedirs("output_code", exist_ok=True)
+            file_name = "output_code/" + title
+            with open(file_name, "w", encoding="utf-8") as f:
+                f.write(python)
+        memory = Memory(send_role, send_name, all)
+        return memory
+    
+    

Agent/Agent.py

@@ -0,0 +1,243 @@
+# coding=utf-8
+# Copyright 2023  The AIWaves Inc. team.
+
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""LLM autonoumous agent"""
+from LLM.base_LLM import *
+from Component import *
+from Action import Action
+from Prompt import *
+
+headers = {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    "X-Accel-Buffering": "no",
+}
+    
+    
+    
+
+class Agent:
+    """
+    Auto agent, input the JSON of SOP.
+    """
+
+    # Agent should have args: agents,states
+    def __init__(self, name, agent_state_roles, **kwargs) -> None:
+        self.state_roles = agent_state_roles
+        self.name = name
+        
+        self.style = kwargs["style"]
+        self.LLMs = kwargs["LLMs"]
+        self.LLM = None
+        self.is_user = kwargs["is_user"]
+        self.begins = kwargs["begins"] if "begins" in kwargs else False
+        self.current_role = ""
+        self.long_term_memory = []
+        self.short_term_memory = ""
+        self.current_state = None
+        self.first_speak = True
+        self.environment = None
+    
+
+    @classmethod
+    def from_config(cls, config_path):
+        """
+        Initialize agents based on json file
+        Return:
+        agents(dict) : key:agent_name;value:class(Agent) 
+        names_to_roles(dict) : key:state_name  value:(dict; (key:agent_name ; value:agent_role))
+        roles_to_names(dict) : key:state_name  value:(dict; (key:agent_role ; value:agent_name))
+        """
+        with open(config_path) as f:
+            config = json.load(f)
+        
+        roles_to_names = {}
+        names_to_roles = {}
+        agents = {}
+        user_names = json.loads(os.environ["User_Names"]) if "User_Names" in os.environ else []
+        for agent_name, agent_dict in config["agents"].items():
+            agent_state_roles = {}
+            agent_LLMs = {}
+            agent_begins = {}
+            for state_name, agent_role in agent_dict["roles"].items():
+                
+                agent_begins[state_name] = {}
+                
+                if state_name not in roles_to_names:
+                    roles_to_names[state_name] = {}
+                if state_name not in names_to_roles:
+                    names_to_roles[state_name] = {}
+                roles_to_names[state_name][agent_role] = agent_name
+                names_to_roles[state_name][agent_name] = agent_role
+                agent_state_roles[state_name] = agent_role
+                current_state = config["states"][state_name]
+                current_state["roles"] = list(current_state["agent_states"].keys()) if "roles" not in current_state else current_state["roles"]
+                current_state_begin_role = current_state["begin_role"] if "begin_role" in current_state else current_state["roles"][0]
+                agent_begins[state_name]["is_begin"] = current_state_begin_role==agent_role if "begin_role" in current_state else False
+                agent_begins[state_name]["begin_query"] = current_state["begin_query"] if "begin_query" in current_state else " "
+                agent_LLMs[state_name] = init_LLM("logs"+os.sep+f"{agent_name}",**current_state["agent_states"][agent_role])
+            agents[agent_name] = cls(
+                agent_name,
+                agent_state_roles,
+                LLMs=agent_LLMs,
+                is_user=agent_name in user_names,
+                style = agent_dict["style"],
+                begins = agent_begins
+            )
+        assert len(config["agents"].keys()) != 2 or (roles_to_names[config["root"]][config["states"][config["root"]]["begin_role"]] not in user_names and "begin_query"  in config["states"][config["root"]]),"In a single-agent scenario, there must be an opening statement and it must be the agent" 
+        return agents, roles_to_names, names_to_roles
+
+    def step(self, current_state,input=""):
+        """
+        return actions by current state and environment
+        Return: action(Action)
+        """
+        
+        current_state.chat_nums +=1
+        state_begin = current_state.is_begin
+        agent_begin = self.begins[current_state.name]["is_begin"]
+        self.begins[current_state.name]["is_begin"] = False
+        current_state.is_begin = False
+        environment = self.environment
+        
+        self.current_state = current_state
+        # 先根据当前环境更新信息
+        # First update the information according to the current environment
+        
+        response = " "
+        res_dict = {}
+        
+        if self.is_user:
+            response = f"{self.name}:{input}"
+        else:
+            if len(environment.shared_memory["long_term_memory"])>0:
+                current_history = self.observe()
+                self.long_term_memory.append(current_history)
+            if agent_begin:
+                response = (char for char in self.begins[current_state.name]["begin_query"])
+            else:
+                response,res_dict = self.act()
+        
+        
+        action_dict =  {
+            "response": response,
+            "res_dict": res_dict,
+            "role": self.state_roles[current_state.name],
+            "name": self.name,
+            "state_begin" : state_begin,
+            "agent_begin" : agent_begin,
+            "is_user" : self.is_user
+        }
+        return  Action(**action_dict)
+
+    def act(self):
+        """
+        return actions by the current state
+        """
+        current_state = self.current_state
+        chat_history = self.long_term_memory
+        current_LLM = self.LLMs[current_state.name]
+        
+        system_prompt, last_prompt, res_dict = self.compile()
+
+        
+
+        response = current_LLM.get_response(
+            chat_history, system_prompt, last_prompt, stream=True
+        )
+        return response,res_dict 
+
+    def update_memory(self, memory):
+        self.long_term_memory.append(
+            {"role": "assistant", "content": memory.content}
+        )
+        
+        MAX_CHAT_HISTORY = eval(os.environ["MAX_CHAT_HISTORY"])
+        environment = self.environment
+        current_chat_history_idx = environment.current_chat_history_idx if environment.environment_type == "competive" else 0
+        
+        current_long_term_memory = environment.shared_memory["long_term_memory"][current_chat_history_idx:]
+        last_conversation_idx = environment._get_agent_last_conversation_idx(self,current_long_term_memory)
+        if len(current_long_term_memory)-last_conversation_idx >= MAX_CHAT_HISTORY:
+            current_state = self.current_state
+            current_role = self.state_roles[current_state.name]
+            current_component_dict = current_state.components[current_role]
+                
+            # get chat history from new conversation
+            conversations = environment._get_agent_new_memory(self,current_long_term_memory)
+
+            # get summary
+            summary_prompt = (
+                current_state.summary_prompt[current_role]
+                if current_state.summary_prompt
+                else f"""your name is {self.name},your role is{current_component_dict["style"].role},your task is {current_component_dict["task"].task}.\n"""
+            )
+            summary_prompt =eval(Agent_summary_system_prompt)
+            summary = self.LLMs[current_state.name].get_response(None, summary_prompt,stream = False)
+            self.short_term_memory = summary
+            
+        
+    def compile(self):
+        """
+        get prompt from state depend on your role
+        Return:
+        system_prompt:system_prompt for agents's LLM
+        last_prompt:last_prompt for agents's LLM
+        res_dict(dict): Other return from tool component.For example: search engine results
+        """
+        current_state = self.current_state
+        self.current_roles = self.state_roles[current_state.name]
+        current_state_name = current_state.name
+        self.LLM = self.LLMs[current_state_name]
+        components = current_state.components[self.state_roles[current_state_name]]
+
+        system_prompt = self.current_state.environment_prompt
+        last_prompt = ""
+
+        res_dict = {}
+        for component in components.values():
+            if isinstance(component, (OutputComponent, LastComponent)):
+                last_prompt = last_prompt + "\n" + component.get_prompt(self)
+            elif isinstance(component, PromptComponent):
+                system_prompt = (
+                    system_prompt + "\n" + component.get_prompt(self)
+                )
+            elif isinstance(component, ToolComponent):
+                response = component.func(self)
+                if "prompt" in response and response["prompt"]:
+                    last_prompt = last_prompt + "\n" + response["prompt"]
+                res_dict.update(response)
+        
+        name = self.name
+        query = self.environment.shared_memory["long_term_memory"][-1] if len(self.environment.shared_memory["long_term_memory"]) else ""
+        last_prompt = eval(Agent_last_prompt)
+        system_prompt = eval(Agent_system_prompt)
+        return system_prompt, last_prompt, res_dict
+
+
+    def observe(self):
+        """
+        Update one's own memory according to the current environment, including: updating short-term memory; updating long-term memory
+        """
+        return self.environment._observe(self)
+        
+    
+    def generate_sop(self):
+        pass
+
+    def reflection(self):
+        pass
+
+

Agent/__init__.py

@@ -0,0 +1 @@
+from .Agent import Agent

Component/ExtraComponent.py

@@ -0,0 +1,128 @@
+from .ToolComponent import ToolComponent
+import json
+from utils import flatten_dict,get_embedding,matching_category,search_with_api,limit_keys,limit_values
+import os
+
+
+class CategoryRequirementsComponent(ToolComponent):
+    def __init__(self, information_path):
+        super().__init__()
+        self.information_dataset = []
+        self.leaf_name = []
+        for toy_path in information_path:
+            with open(toy_path, encoding="utf-8") as json_file:
+                data = json.load(json_file)
+            for d in data:
+                if "/" in d["cat_leaf_name"]:
+                    leaf_names = d["cat_leaf_name"].split("/") + [d["cat_leaf_name"]]
+                else:
+                    leaf_names = [d["cat_leaf_name"]]
+                for name in leaf_names:
+                    self.leaf_name.append(name)
+                    new_d = d.copy()
+                    new_d["cat_leaf_name"] = name
+                    new_d["information"] = flatten_dict(new_d["information"])
+                    self.information_dataset.append(new_d)
+
+        self.target_embbeding = get_embedding(
+            self.leaf_name
+        )
+
+    def search_information(self, category, information_dataset):
+        knowledge = {}
+        for d in information_dataset:
+            if category == d["cat_leaf_name"]:
+                knowledge = d["information"]
+                knowledge = {
+                    key: value
+                    for key, value in knowledge.items()
+                    if (value and key != "相关分类")
+                }
+                break
+        return knowledge
+
+    def func(self, agent):
+        prompt = ""
+        messages = agent.long_term_memory
+        outputdict = {}
+        functions = [
+            {
+                "name": "search_information",
+                "description": "根据用户所需要购买商品的种类跟用户的需求去寻找用户所需要的商品",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "category": {
+                            "type": "string",
+                            "description": "用户现在所需要的商品类别，比如纸尿布，笔记本电脑等，注意，只能有一个",
+                        },
+                        "requirements": {
+                            "type": "string",
+                            "description": "用户现在的需求，比如说便宜，安踏品牌等等，可以有多个需求，中间以“ ”分隔",
+                        },
+                    },
+                    "required": ["category", "requirements"],
+                },
+            }
+        ]
+        
+        response = agent.LLM.get_response(
+            messages,
+            None,
+            None,
+            functions=functions,
+            stream=False,
+            function_call={"name": "search_information"},
+        )
+        response_message = json.loads(response["function_call"]["arguments"])
+        category = (
+            response_message["category"] if response_message["category"] else None
+        )
+        requirements = (
+            response_message["requirements"]
+            if response_message["requirements"]
+            else category
+        )
+        if not (category or requirements):
+            return {}
+
+        topk_result = matching_category(
+            category, self.leaf_name, None, self.target_embbeding, top_k=3
+        )
+
+        top1_score = topk_result[1][0]
+        request_items, top_category = search_with_api(requirements, category)
+        
+
+        MIN_CATEGORY_SIM = eval(os.environ["MIN_CATEGORY_SIM"]
+                                ) if "MIN_CATEGORY_SIM" in os.environ else 0.7
+
+        if top1_score > MIN_CATEGORY_SIM:
+            agent.environment.shared_memory["category"] = topk_result[0][0]
+            category = topk_result[0][0]
+            information = self.search_information(
+                topk_result[0][0], self.information_dataset
+            )
+            information = limit_keys(information, 3)
+            information = limit_values(information, 2)
+            prompt += f"""你需要知道的是：用户目前选择的商品是{category}，该商品信息为{information}。你需要根据这些商品信息来详细介绍商品，比如详细介绍商品有哪些品牌，有哪些分类等等，并且询问用户是否有更多的需求。"""
+            if category in top_category:
+                top_category.remove(category)
+
+            recommend = "\n经过搜索后，推荐商品如下：\n"
+            prompt += "筛选出的商品如下：\n"
+            
+            for i, request_item in enumerate(request_items):
+                
+                itemTitle = request_item["itemTitle"]
+                itemPrice = request_item["itemPrice"]
+                itemPicUrl = request_item["itemPicUrl"]
+                recommend += f"[{i}.商品名称：{itemTitle},商品价格:{float(itemPrice)/100}]({itemPicUrl})\n"
+                prompt += f"[{i}.商品名称：{itemTitle},商品价格:{float(itemPrice)/100}]\n"
+            outputdict["recommend"] = recommend
+            print(recommend)
+        else:
+            prompt += f"""你需要知道的是：用户目前选择的商品是{category}，而我们店里没有这类商品，但是我们店里有一些近似商品，如{top_category},{topk_result[0][0]}，你需要对这些近似商品进行介绍，并引导用户购买"""
+        outputdict["prompt"] = prompt
+        return outputdict
+

Component/PromptComponent.py

@@ -0,0 +1,126 @@
+from abc import abstractmethod
+
+
+class PromptComponent:
+    def __init__(self):
+        pass
+
+    @abstractmethod
+    def get_prompt(self, agent):
+        pass
+
+class TaskComponent(PromptComponent):
+    def __init__(self, task):
+        super().__init__()
+        self.task = task
+
+    def get_prompt(self, agent):
+        return f"""The task you need to execute is: {self.task}.\n"""
+
+
+class OutputComponent(PromptComponent):
+    def __init__(self, output):
+        super().__init__()
+        self.output = output
+
+    def get_prompt(self, agent):
+        return f"""Please contact the above to extract <{self.output}> and </{self.output}>, \
+            do not perform additional output, please output in strict accordance with the above format!\n"""
+
+
+class SystemComponent(PromptComponent):
+    def __init__(self,system_prompt):
+        super().__init__()
+        self.system_prompt = system_prompt
+    
+    def get_prompt(self, agent):
+        return self.system_prompt
+
+class LastComponent(PromptComponent):
+    def __init__(self, last_prompt):
+        super().__init__()
+        self.last_prompt = last_prompt
+
+    def get_prompt(self, agent):
+        return self.last_prompt
+
+
+class StyleComponent(PromptComponent):
+    """
+    角色、风格组件
+    """
+
+    def __init__(self, role):
+        super().__init__()
+        self.role = role
+
+    def get_prompt(self, agent):
+        name = agent.name
+        style = agent.style
+        return f"""Now your role is:\n{self.role}, your name is:\n{name}. \
+            You need to follow the output style:\n{style}.\n"""
+
+
+class RuleComponent(PromptComponent):
+    def __init__(self, rule):
+        super().__init__()
+        self.rule = rule
+
+    def get_prompt(self, agent):
+        return f"""The rule you need to follow is:\n{self.rule}.\n"""
+
+
+class DemonstrationComponent(PromptComponent):
+    """
+    input a list,the example of answer.
+    """
+
+    def __init__(self, demonstrations):
+        super().__init__()
+        self.demonstrations = demonstrations
+
+
+    def get_prompt(self, agent):
+        prompt = f"Here are demonstrations you can refer to:\n{self.demonstrations}"
+        return prompt
+
+
+class CoTComponent(PromptComponent):
+    """
+    input a list,the example of answer.
+    """
+
+    def __init__(self, demonstrations):
+        super().__init__()
+        self.demonstrations = demonstrations
+
+    def add_demonstration(self, demonstration):
+        self.demonstrations.append(demonstration)
+
+    def get_prompt(self, agent):
+        prompt = "You need to think in detail before outputting, the thinking case is as follows:\n"
+        for demonstration in self.demonstrations:
+            prompt += "\n" + demonstration
+        return prompt
+
+
+class CustomizeComponent(PromptComponent):
+    """
+    Custom template
+    template(str) : example: "i am {}"
+    keywords(list) : example : ["name"]  
+    example : agent.environment.shared_memory["name"] = "Lilong"
+    the component will get the keyword attribute from the environment, and then add it to the template.
+    Return : "i am Lilong"
+    """
+    def __init__(self, template, keywords) -> None:
+        super().__init__()
+        self.template = template
+        self.keywords = keywords
+
+    def get_prompt(self, agent):
+        template_keyword = {}
+        for keyword in self.keywords:
+            current_keyword = agent.environment.shared_memory[keyword] if keyword in agent.environment.shared_memory else ""
+            template_keyword[keyword] = current_keyword
+        return self.template.format(**template_keyword)

Component/ToolComponent.py

@@ -0,0 +1,887 @@
+from abc import abstractmethod
+import uuid
+from text2vec import semantic_search
+from utils import (
+    get_relevant_history,
+    load_knowledge_base_qa,
+    load_knowledge_base_UnstructuredFile,
+    get_embedding,
+    extract,
+)
+import json
+from typing import Dict, List
+import os
+from googleapiclient.discovery import build
+import requests
+from selenium import webdriver
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support.ui import WebDriverWait
+from selenium.webdriver.support import expected_conditions as EC
+from bs4 import BeautifulSoup
+import base64
+import re
+from datetime import datetime, timedelta
+from typing import Tuple, List, Any, Dict
+from email.mime.text import MIMEText
+from email.mime.multipart import MIMEMultipart
+from google.auth.transport.requests import Request
+from google.oauth2.credentials import Credentials
+from google_auth_oauthlib.flow import InstalledAppFlow
+from googleapiclient.discovery import build
+from googleapiclient.errors import HttpError
+from tqdm import tqdm
+
+class ToolComponent:
+    def __init__(self):
+        pass
+
+    @abstractmethod
+    def func(self):
+        pass
+    
+class KnowledgeBaseComponent(ToolComponent):
+    """
+    Inject knowledge base
+    top_k : Top_k with the highest matching degree
+    type : "QA" or others
+    knowledge_base(json_path) : knowledge_base_path
+    """
+    def __init__(self, top_k, type, knowledge_base):
+        super().__init__()
+        self.top_k = top_k
+        self.type = type
+        self.knowledge_base = knowledge_base
+
+        if self.type == "QA":
+            (
+                self.kb_embeddings,
+                self.kb_questions,
+                self.kb_answers,
+                self.kb_chunks,
+            ) = load_knowledge_base_qa(self.knowledge_base)
+        else:
+            self.kb_embeddings, self.kb_chunks = load_knowledge_base_UnstructuredFile(
+                self.knowledge_base
+            )
+
+    def func(self, agent):
+        query = (
+            agent.long_term_memory[-1]["content"]
+            if len(agent.long_term_memory) > 0
+            else ""
+        )
+        knowledge = ""
+        query = extract(query, "query")
+        query_embedding = get_embedding(query)
+        hits = semantic_search(query_embedding, self.kb_embeddings, top_k=50)
+        hits = hits[0]
+        temp = []
+        if self.type == "QA":
+            for hit in hits:
+                matching_idx = hit["corpus_id"]
+                if self.kb_chunks[matching_idx] in temp:
+                    pass
+                else:
+                    knowledge = (
+                        knowledge
+                        + f"question:{self.kb_questions[matching_idx]},answer:{self.kb_answers[matching_idx]}\n\n"
+                    )
+                    temp.append(self.kb_answers[matching_idx])
+                    if len(temp) == 1:
+                        break
+            print(hits[0]["score"])
+            score = hits[0]["score"]
+            if score < 0.5:
+                return {"prompt": "No matching knowledge base"}
+            else:
+                return {"prompt": "The relevant content is: " + knowledge + "\n"}
+        else:
+            for hit in hits:
+                matching_idx = hit["corpus_id"]
+                if self.kb_chunks[matching_idx] in temp:
+                    pass
+                else:
+                    knowledge = knowledge + f"{self.kb_answers[matching_idx]}\n\n"
+                    temp.append(self.kb_answers[matching_idx])
+                    if len(temp) == self.top_k:
+                        break
+            print(hits[0]["score"])
+            score = hits[0]["score"]
+            if score < 0.5:
+                return {"prompt": "No matching knowledge base"}
+            else:
+                print(knowledge)
+                return {"prompt": "The relevant content is: " + knowledge + "\n"}
+
+
+class StaticComponent(ToolComponent):
+    "Return static response"
+    def __init__(self, output):
+        super().__init__()
+        self.output = output
+
+    def func(self, agent):
+        outputdict = {"response": self.output}
+        return outputdict
+
+
+class ExtractComponent(ToolComponent):
+    """
+    Extract keywords based on the current scene and store them in the environment
+    extract_words(list) : Keywords to be extracted
+    system_prompt & last_prompt : Prompt to extract keywords
+    """
+    def __init__(
+        self,
+        extract_words,
+        system_prompt,
+        last_prompt=None,
+    ):
+        super().__init__()
+        self.extract_words = extract_words
+        self.system_prompt = system_prompt
+        self.default_prompt = (
+            "Please strictly adhere to the following format for outputting:\n"
+        )
+        for extract_word in extract_words:
+            self.default_prompt += (
+                f"<{extract_word}> the content you need to extract </{extract_word}>"
+            )
+        self.last_prompt = last_prompt if last_prompt else self.default_prompt
+
+    def func(self, agent):
+        response = agent.LLM.get_response(
+            agent.long_term_memory,
+            self.system_prompt,
+            self.last_prompt,
+            stream=False,
+        )
+        for extract_word in self.extract_words:
+            key = extract(response, extract_word)
+            key = key if key else response
+            agent.environment.shared_memory[extract_word] = key
+
+        return {}
+
+
+"""Search sources: chatgpt/search engines/specific search sources/can even be multimodal (if it comes to clothing)"""
+
+
+class WebSearchComponent(ToolComponent):
+    """search engines"""
+
+    __ENGINE_NAME__: List = ["google", "bing"]
+
+    def __init__(self, engine_name: str, api: Dict):
+        """
+        :param engine_name: The name of the search engine used
+        :param api: Pass in a dictionary, such as {"bing":"key1", "google":"key2", ...}, of course each value can also be a list, or more complicated
+        """
+        super(WebSearchComponent, self).__init__()
+        """Determine whether the key and engine_name of the api are legal"""
+
+        assert engine_name in WebSearchComponent.__ENGINE_NAME__
+        for api_name in api:
+            assert api_name in WebSearchComponent.__ENGINE_NAME__
+
+        self.api = api
+        self.engine_name = engine_name
+
+        self.search: Dict = {"bing": self._bing_search, "google": self._google_search}
+
+    def _bing_search(self, query: str, **kwargs):
+        """Initialize search hyperparameters"""
+        subscription_key = self.api["bing"]
+        search_url = "https://api.bing.microsoft.com/v7.0/search"
+        headers = {"Ocp-Apim-Subscription-Key": subscription_key}
+        params = {
+            "q": query,
+            "textDecorations": True,
+            "textFormat": "HTML",
+            "count": 10,
+        }
+        """start searching"""
+        response = requests.get(search_url, headers=headers, params=params)
+        response.raise_for_status()
+        results = response.json()["webPages"]["value"]
+        """execute"""
+        metadata_results = []
+        for result in results:
+            metadata_result = {
+                "snippet": result["snippet"],
+                "title": result["name"],
+                "link": result["url"],
+            }
+            metadata_results.append(metadata_result)
+        return {"meta data": metadata_results}
+
+    def _google_search(self, query: str, **kwargs):
+        """Initialize search hyperparameters"""
+        api_key = self.api[self.engine_name]["api_key"]
+        cse_id = self.api[self.engine_name]["cse_id"]
+        service = build("customsearch", "v1", developerKey=api_key)
+        """start searching"""
+        results = (
+            service.cse().list(q=query, cx=cse_id, num=10, **kwargs).execute()["items"]
+        )
+        """execute"""
+        metadata_results = []
+        for result in results:
+            metadata_result = {
+                "snippet": result["snippet"],
+                "title": result["title"],
+                "link": result["link"],
+            }
+            metadata_results.append(metadata_result)
+        return {"meta data": metadata_results}
+
+    def func(self, agent, **kwargs) -> Dict:
+        query = (
+            agent.long_term_memory[-1]["content"]
+            if len(agent.long_term_memory) > 0
+            else " "
+        )
+        response = agent.LLM.get_response(
+            None,
+            system_prompt=f"Please analyze the provided conversation and identify keywords that can be used for a search engine query. Format the output as <keywords>extracted keywords</keywords>:\nConversation:\n{query}",
+            stream=False,
+        )
+        response = extract(response, "keywords")
+        query = response if response else query
+
+        search_results = self.search[self.engine_name](query=query, **kwargs)
+        information = ""
+        for i in search_results["meta data"][:5]:
+            information += i["snippet"]
+        return {
+            "prompt": "You can refer to the following information to reply:\n"
+            + information
+        }
+
+    def convert_search_engine_to(self, engine_name):
+        assert engine_name in WebSearchComponent.__ENGINE_NAME__
+        self.engine_name = engine_name
+
+
+class WebCrawlComponent(ToolComponent):
+    """Open a single web page for crawling"""
+
+    def __init__(self):
+        super(WebCrawlComponent, self).__init__()
+
+    def func(self, agent_dict) -> Dict:
+        url = agent_dict["url"]
+        print(f"crawling {url} ......")
+        content = ""
+        """Crawling content from url may need to be carried out according to different websites, such as wiki, baidu, zhihu, etc."""
+        driver = webdriver.Chrome()
+        try:
+            """open url"""
+            driver.get(url)
+
+            """wait 20 second"""
+            wait = WebDriverWait(driver, 20)
+            wait.until(EC.presence_of_element_located((By.TAG_NAME, "body")))
+
+            """crawl code"""
+            page_source = driver.page_source
+
+            """parse"""
+            soup = BeautifulSoup(page_source, "html.parser")
+
+            """concatenate"""
+            for paragraph in soup.find_all("p"):
+                content = f"{content}\n{paragraph.get_text()}"
+        except Exception as e:
+            print("Error:", e)
+        finally:
+            """quit"""
+            driver.quit()
+        return {"content": content.strip()}
+
+
+class MailComponent(ToolComponent):
+    __VALID_ACTION__ = ["read", "send"]
+
+    def __init__(
+        self, cfg_file: str, default_action: str = "read", name: str = "e-mail"
+    ):
+        """'../config/google_mail.json'"""
+        super(MailComponent, self).__init__(name)
+        self.name = name
+        assert (
+            default_action.lower() in self.__VALID_ACTION__
+        ), f"Action `{default_action}` is not allowed! The valid action is in `{self.__VALID_ACTION__}`"
+        self.action = default_action.lower()
+        self.credential = self._login(cfg_file)
+
+    def _login(self, cfg_file: str):
+        SCOPES = [
+            "https://www.googleapis.com/auth/gmail.readonly",
+            "https://www.googleapis.com/auth/gmail.send",
+        ]
+        creds = None
+        if os.path.exists("token.json"):
+            print("Login Successfully!")
+            creds = Credentials.from_authorized_user_file("token.json", SCOPES)
+        if not creds or not creds.valid:
+            print("Please authorize in an open browser.")
+            if creds and creds.expired and creds.refresh_token:
+                creds.refresh(Request())
+            else:
+                flow = InstalledAppFlow.from_client_secrets_file(cfg_file, SCOPES)
+                creds = flow.run_local_server(port=0)
+            # Save the credentials for the next run
+            with open("token.json", "w") as token:
+                token.write(creds.to_json())
+        return creds
+
+    def _read(self, mail_dict: dict):
+        credential = self.credential
+        state = mail_dict["state"] if "state" in mail_dict else None
+        time_between = (
+            mail_dict["time_between"] if "time_between" in mail_dict else None
+        )
+        sender_mail = mail_dict["sender_mail"] if "sender_mail" in mail_dict else None
+        only_both = mail_dict["only_both"] if "only_both" in mail_dict else False
+        order_by_time = (
+            mail_dict["order_by_time"] if "order_by_time" in mail_dict else "descend"
+        )
+        include_word = (
+            mail_dict["include_word"] if "include_word" in mail_dict else None
+        )
+        exclude_word = (
+            mail_dict["exclude_word"] if "exclude_word" in mail_dict else None
+        )
+        MAX_SEARCH_CNT = (
+            mail_dict["MAX_SEARCH_CNT"] if "MAX_SEARCH_CNT" in mail_dict else 50
+        )
+        number = mail_dict["number"] if "number" in mail_dict else 10
+        if state is None:
+            state = "all"
+        if time_between is not None:
+            assert isinstance(time_between, tuple)
+            assert len(time_between) == 2
+        assert state in ["all", "unread", "read", "sent"]
+        if only_both:
+            assert sender_mail is not None
+        if sender_mail is not None:
+            assert isinstance(sender_mail, str)
+        assert credential
+        assert order_by_time in ["descend", "ascend"]
+
+        def generate_query():
+            query = ""
+            if state in ["unread", "read"]:
+                query = f"is:{state}"
+            if state in ["sent"]:
+                query = f"in:{state}"
+            if only_both:
+                query = f"{query} from:{sender_mail} OR to:{sender_mail}"
+            if sender_mail is not None and not only_both:
+                query = f"{query} from:({sender_mail})"
+            if include_word is not None:
+                query = f"{query} {include_word}"
+            if exclude_word is not None:
+                query = f"{query} -{exclude_word}"
+            if time_between is not None:
+                TIME_FORMAT = "%Y/%m/%d"
+                t1, t2 = time_between
+                if t1 == "now":
+                    t1 = datetime.now().strftime(TIME_FORMAT)
+                if t2 == "now":
+                    t2 = datetime.now().strftime(TIME_FORMAT)
+                if isinstance(t1, str) and isinstance(t2, str):
+                    t1 = datetime.strptime(t1, TIME_FORMAT)
+                    t2 = datetime.strptime(t2, TIME_FORMAT)
+                elif isinstance(t1, str) and isinstance(t2, int):
+                    t1 = datetime.strptime(t1, TIME_FORMAT)
+                    t2 = t1 + timedelta(days=t2)
+                elif isinstance(t1, int) and isinstance(t2, str):
+                    t2 = datetime.strptime(t2, TIME_FORMAT)
+                    t1 = t2 + timedelta(days=t1)
+                else:
+                    assert False, "invalid time"
+                if t1 > t2:
+                    t1, t2 = t2, t1
+                query = f"{query} after:{t1.strftime(TIME_FORMAT)} before:{t2.strftime(TIME_FORMAT)}"
+            return query.strip()
+
+        def sort_by_time(data: List[Dict]):
+            if order_by_time == "descend":
+                reverse = True
+            else:
+                reverse = False
+            sorted_data = sorted(
+                data,
+                key=lambda x: datetime.strptime(x["time"], "%Y-%m-%d %H:%M:%S"),
+                reverse=reverse,
+            )
+            return sorted_data
+
+        try:
+            service = build("gmail", "v1", credentials=credential)
+            results = (
+                service.users()
+                .messages()
+                .list(userId="me", labelIds=["INBOX"], q=generate_query())
+                .execute()
+            )
+
+            messages = results.get("messages", [])
+            email_data = list()
+
+            if not messages:
+                print("No eligible emails.")
+                return None
+            else:
+                pbar = tqdm(total=min(MAX_SEARCH_CNT, len(messages)))
+                for cnt, message in enumerate(messages):
+                    pbar.update(1)
+                    if cnt >= MAX_SEARCH_CNT:
+                        break
+                    msg = (
+                        service.users()
+                        .messages()
+                        .get(
+                            userId="me",
+                            id=message["id"],
+                            format="full",
+                            metadataHeaders=None,
+                        )
+                        .execute()
+                    )
+
+                    subject = ""
+                    for header in msg["payload"]["headers"]:
+                        if header["name"] == "Subject":
+                            subject = header["value"]
+                            break
+
+                    sender = ""
+                    for header in msg["payload"]["headers"]:
+                        if header["name"] == "From":
+                            sender = re.findall(
+                                r"\b[\w\.-]+@[\w\.-]+\.\w+\b", header["value"]
+                            )[0]
+                            break
+                    body = ""
+                    if "parts" in msg["payload"]:
+                        for part in msg["payload"]["parts"]:
+                            if part["mimeType"] == "text/plain":
+                                data = part["body"]["data"]
+                                body = base64.urlsafe_b64decode(data).decode("utf-8")
+                                break
+
+                    email_info = {
+                        "sender": sender,
+                        "time": datetime.fromtimestamp(
+                            int(msg["internalDate"]) / 1000
+                        ).strftime("%Y-%m-%d %H:%M:%S"),
+                        "subject": subject,
+                        "body": body,
+                    }
+                    email_data.append(email_info)
+                pbar.close()
+            email_data = sort_by_time(email_data)[0:number]
+            return {"results": email_data}
+        except Exception as e:
+            print(e)
+            return None
+
+    def _send(self, mail_dict: dict):
+        recipient_mail = mail_dict["recipient_mail"]
+        subject = mail_dict["subject"]
+        body = mail_dict["body"]
+        credential = self.credential
+        service = build("gmail", "v1", credentials=credential)
+
+        message = MIMEMultipart()
+        message["to"] = recipient_mail
+        message["subject"] = subject
+
+        message.attach(MIMEText(body, "plain"))
+
+        raw_message = base64.urlsafe_b64encode(message.as_bytes()).decode("utf-8")
+        try:
+            message = (
+                service.users()
+                .messages()
+                .send(userId="me", body={"raw": raw_message})
+                .execute()
+            )
+            return {"state": True}
+        except HttpError as error:
+            print(error)
+            return {"state": False}
+
+    def func(self, mail_dict: dict):
+        if "action" in mail_dict:
+            assert mail_dict["action"].lower() in self.__VALID_ACTION__
+            self.action = mail_dict["action"]
+        functions = {"read": self._read, "send": self._send}
+        return functions[self.action](mail_dict)
+
+    def convert_action_to(self, action_name: str):
+        assert (
+            action_name.lower() in self.__VALID_ACTION__
+        ), f"Action `{action_name}` is not allowed! The valid action is in `{self.__VALID_ACTION__}`"
+        self.action = action_name.lower()
+
+
+class WeatherComponet(ToolComponent):
+    def __init__(self, api_key, name="weather", TIME_FORMAT="%Y-%m-%d"):
+        super(WeatherComponet, self).__init__(name)
+        self.name = name
+        self.TIME_FORMAT = TIME_FORMAT
+        self.api_key = api_key
+
+    def _parse(self, data):
+        dict_data: dict = {}
+        for item in data["data"]:
+            date = item["datetime"]
+            dict_data[date] = {}
+            if "weather" in item:
+                dict_data[date]["description"] = item["weather"]["description"]
+            mapping = {
+                "temp": "temperature",
+                "max_temp": "max_temperature",
+                "min_temp": "min_temperature",
+                "precip": "accumulated_precipitation",
+            }
+            for key in ["temp", "max_temp", "min_temp", "precip"]:
+                if key in item:
+                    dict_data[date][mapping[key]] = item[key]
+        return dict_data
+
+    def _query(self, city_name, country_code, start_date, end_date):
+        """https://www.weatherbit.io/api/historical-weather-daily"""
+        # print(datetime.strftime(start_date, self.TIME_FORMAT), datetime.strftime(datetime.now(), self.TIME_FORMAT), end_date, datetime.strftime(datetime.now()+timedelta(days=1), self.TIME_FORMAT))
+        if start_date == datetime.strftime(
+            datetime.now(), self.TIME_FORMAT
+        ) and end_date == datetime.strftime(
+            datetime.now() + timedelta(days=1), self.TIME_FORMAT
+        ):
+            """today"""
+            url = f"https://api.weatherbit.io/v2.0/current?city={city_name}&country={country_code}&key={self.api_key}"
+        else:
+            url = f"https://api.weatherbit.io/v2.0/history/daily?&city={city_name}&country={country_code}&start_date={start_date}&end_date={end_date}&key={self.api_key}"
+        response = requests.get(url)
+        data = response.json()
+        return self._parse(data)
+
+    def func(self, weather_dict: Dict) -> Dict:
+        TIME_FORMAT = self.TIME_FORMAT
+        # Beijing, Shanghai
+        city_name = weather_dict["city_name"]
+        # CN, US
+        country_code = weather_dict["country_code"]
+        # 2020-02-02
+        start_date = datetime.strftime(
+            datetime.strptime(weather_dict["start_date"], self.TIME_FORMAT),
+            self.TIME_FORMAT,
+        )
+        end_date = weather_dict["end_date"] if "end_date" in weather_dict else None
+        if end_date is None:
+            end_date = datetime.strftime(
+                datetime.strptime(start_date, TIME_FORMAT) + timedelta(days=-1),
+                TIME_FORMAT,
+            )
+        else:
+            end_date = datetime.strftime(
+                datetime.strptime(weather_dict["end_date"], self.TIME_FORMAT),
+                self.TIME_FORMAT,
+            )
+        if datetime.strptime(start_date, TIME_FORMAT) > datetime.strptime(
+            end_date, TIME_FORMAT
+        ):
+            start_date, end_date = end_date, start_date
+        assert start_date != end_date
+        return self._query(city_name, country_code, start_date, end_date)
+
+
+class TranslateComponent(ToolComponent):
+    __SUPPORT_LANGUAGE__ = [
+        "af",
+        "am",
+        "ar",
+        "as",
+        "az",
+        "ba",
+        "bg",
+        "bn",
+        "bo",
+        "bs",
+        "ca",
+        "cs",
+        "cy",
+        "da",
+        "de",
+        "dsb",
+        "dv",
+        "el",
+        "en",
+        "es",
+        "et",
+        "eu",
+        "fa",
+        "fi",
+        "fil",
+        "fj",
+        "fo",
+        "fr",
+        "fr-CA",
+        "ga",
+        "gl",
+        "gom",
+        "gu",
+        "ha",
+        "he",
+        "hi",
+        "hr",
+        "hsb",
+        "ht",
+        "hu",
+        "hy",
+        "id",
+        "ig",
+        "ikt",
+        "is",
+        "it",
+        "iu",
+        "iu-Latn",
+        "ja",
+        "ka",
+        "kk",
+        "km",
+        "kmr",
+        "kn",
+        "ko",
+        "ku",
+        "ky",
+        "ln",
+        "lo",
+        "lt",
+        "lug",
+        "lv",
+        "lzh",
+        "mai",
+        "mg",
+        "mi",
+        "mk",
+        "ml",
+        "mn-Cyrl",
+        "mn-Mong",
+        "mr",
+        "ms",
+        "mt",
+        "mww",
+        "my",
+        "nb",
+        "ne",
+        "nl",
+        "nso",
+        "nya",
+        "or",
+        "otq",
+        "pa",
+        "pl",
+        "prs",
+        "ps",
+        "pt",
+        "pt-PT",
+        "ro",
+        "ru",
+        "run",
+        "rw",
+        "sd",
+        "si",
+        "sk",
+        "sl",
+        "sm",
+        "sn",
+        "so",
+        "sq",
+        "sr-Cyrl",
+        "sr-Latn",
+        "st",
+        "sv",
+        "sw",
+        "ta",
+        "te",
+        "th",
+        "ti",
+        "tk",
+        "tlh-Latn",
+        "tlh-Piqd",
+        "tn",
+        "to",
+        "tr",
+        "tt",
+        "ty",
+        "ug",
+        "uk",
+        "ur",
+        "uz",
+        "vi",
+        "xh",
+        "yo",
+        "yua",
+        "yue",
+        "zh-Hans",
+        "zh-Hant",
+        "zu",
+    ]
+
+    def __init__(
+        self, api_key, location, default_target_language="zh-cn", name="translate"
+    ):
+        super(TranslateComponent, self).__init__(name)
+        self.name = name
+        self.api_key = api_key
+        self.location = location
+        self.default_target_language = default_target_language
+
+    def func(self, translate_dict: Dict) -> Dict:
+        content = translate_dict["content"]
+        target_language = self.default_target_language
+        if "target_language" in translate_dict:
+            target_language = translate_dict["target_language"]
+        assert (
+            target_language in self.__SUPPORT_LANGUAGE__
+        ), f"language `{target_language}` is not supported."
+
+        endpoint = "https://api.cognitive.microsofttranslator.com"
+
+        path = "/translate"
+        constructed_url = endpoint + path
+
+        params = {"api-version": "3.0", "to": target_language}
+
+        headers = {
+            "Ocp-Apim-Subscription-Key": self.api_key,
+            "Ocp-Apim-Subscription-Region": self.location,
+            "Content-type": "application/json",
+            "X-ClientTraceId": str(uuid.uuid4()),
+        }
+
+        body = [{"text": content}]
+
+        request = requests.post(
+            constructed_url, params=params, headers=headers, json=body
+        )
+        response = request.json()
+        response = json.dumps(
+            response,
+            sort_keys=True,
+            ensure_ascii=False,
+            indent=4,
+            separators=(",", ": "),
+        )
+        response = eval(response)
+        return {"result": response[0]["translations"][0]["text"]}
+
+
+class APIComponent(ToolComponent):
+    def __init__(self):
+        super(APIComponent, self).__init__()
+
+    def func(self, agent) -> Dict:
+        pass
+
+
+class FunctionComponent(ToolComponent):
+    def __init__(
+        self,
+        functions,
+        function_call="auto",
+        response_type="response",
+        your_function=None,
+    ):
+        super().__init__()
+        self.functions = functions
+        self.function_call = function_call
+        self.parameters = {}
+        self.available_functions = {}
+        self.response_type = response_type
+        if your_function:
+            function_name = your_function["name"]
+            function_content = your_function["content"]
+            exec(function_content)
+            self.available_functions[function_name] = eval(function_name)
+
+        for function in self.functions:
+            self.parameters[function["name"]] = list(
+                function["parameters"]["properties"].keys()
+            )
+            self.available_functions[function["name"]] = eval(function["name"])
+
+    def func(self, agent):
+        messages = agent.long_term_memory
+        outputdict = {}
+        query = agent.long_term_memory[-1].content if len(agent.long_term_memory) > 0 else " "
+        relevant_history = get_relevant_history(
+            query,
+            agent.long_term_memory[:-1],
+            agent.chat_embeddings[:-1],
+        )
+        response = agent.LLM.get_response(
+            messages,
+            None,
+            functions=self.functions,
+            stream=False,
+            function_call=self.function_call,
+            relevant_history=relevant_history,
+        )
+        response_message = response
+        if response_message.get("function_call"):
+            function_name = response_message["function_call"]["name"]
+            fuction_to_call = self.available_functions[function_name]
+            function_args = json.loads(response_message["function_call"]["arguments"])
+            input_args = {}
+            for args_name in self.parameters[function_name]:
+                input_args[args_name] = function_args.get(args_name)
+            function_response = fuction_to_call(**input_args)
+            if self.response_type == "response":
+                outputdict["response"] = function_response
+            elif self.response_type == "prompt":
+                outputdict["prompt"] = function_response
+
+        return outputdict
+
+
+class CodeComponent(ToolComponent):
+    def __init__(self, file_name, keyword) -> None:
+        super().__init__()
+        self.file_name = file_name
+        self.keyword = keyword
+        self.system_prompt = (
+            "you need to extract the modified code as completely as possible."
+        )
+        self.last_prompt = (
+            f"Please strictly adhere to the following format for outputting: \n"
+        )
+        self.last_prompt += (
+            f"<{self.keyword}> the content you need to extract </{self.keyword}>"
+        )
+
+    def func(self, agent):
+        response = agent.LLM.get_response(
+            agent.long_term_memory,
+            self.system_prompt,
+            self.last_prompt,
+            stream=False,
+        )
+        code = extract(response, self.keyword)
+        code = code if code else response
+        os.makedirs("output_code", exist_ok=True)
+        file_name = "output_code/" + self.file_name
+        codes = code.split("\n")
+        if codes[0] == "```python":
+            codes.remove(codes[0])
+        if codes[-1] == "```":
+            codes.remove(codes[-1])
+        code = "\n".join(codes)
+        with open(file_name, "w", encoding="utf-8") as f:
+            f.write(code)
+        return {}

Component/__init__.py

@@ -0,0 +1,3 @@
+from .ExtraComponent import *
+from .PromptComponent import *
+from .ToolComponent import *

Environment/__init__.py

@@ -0,0 +1 @@
+from .base_environment import Environment

Environment/base_environment.py

@@ -0,0 +1,177 @@
+from utils import get_relevant_history, get_embedding
+import torch
+from LLM.base_LLM import *
+from Memory import Memory
+from Prompt import * 
+import json
+class Environment:
+    """
+    The place where the agent activities, responsible for storing some shared memories
+    """
+    def __init__(self, config) -> None:
+        self.shared_memory = {"long_term_memory": [], "short_term_memory": None}
+        self.agents = None
+
+        self.summary_system_prompt = {}
+        self.summary_last_prompt = {}
+        self.environment_prompt = {}
+        self.environment_type = config["environment_type"] if "environment_type" in config else "cooperative"
+        self.current_chat_history_idx = 0
+        self.LLMs = {}
+        
+        # 初始化每个state 的summary 方法
+        # Initialize the summary method for each state
+        for state_name, state_dict in config["states"].items():
+            if state_name != "end_state":
+                self.summary_system_prompt[state_name] = (
+                    state_dict["summary_system_prompt"]
+                    if "summary_system_prompt" in state_dict
+                    else eval(Default_environment_summary_system_prompt)
+                )
+
+                self.summary_last_prompt[state_name] = (
+                    state_dict["summary_last_prompt"]
+                    if "summary_last_prompt" in state_dict
+                    else eval(Default_environment_summary_last_prompt)
+                )
+
+                self.environment_prompt[state_name] = (
+                    state_dict["environment_prompt"]
+                    if "environment_prompt" in state_dict
+                    else " "
+                )
+                self.LLMs[state_name] = init_LLM("logs"+os.sep+f"{state_name}",**state_dict)
+        self.roles_to_names = None
+        self.names_to_roles = None
+
+    @classmethod
+    def from_config(cls, config_path):
+        with open(config_path) as f:
+            config = json.load(f)
+        return cls(config)
+
+    def summary(self, current_state):
+        """
+        Summarize the situation in the current environment every once in a while
+        """
+        MAX_CHAT_HISTORY = eval(os.environ["MAX_CHAT_HISTORY"])
+        current_state_name = current_state.name
+
+        query = self.shared_memory["long_term_memory"][-1].content
+        if len(self.shared_memory["long_term_memory"])>1:
+            relevant_history = get_relevant_history(
+                query,
+                self.shared_memory["long_term_memory"][:-1],
+                self.shared_memory["chat_embeddings"][:-1],
+            )
+
+            relevant_history = Memory.get_chat_history(relevant_history)
+        else:
+            relevant_history = ""
+        chat_history = Memory.get_chat_history(
+            self.shared_memory["long_term_memory"][-MAX_CHAT_HISTORY + 1 :]
+        )
+        summary = self.shared_memory["short_term_memory"]
+        
+        
+        # system prompt = environment prompt + current memory + system prompt
+        # current_memory = summary + chat history + relevant history
+        current_memory = eval(Environment_summary_memory)
+        environment_prompt = self.environment_prompt[current_state_name]
+        summary_system_prompt = self.summary_system_prompt[current_state_name]
+        
+        environment_summary_system_prompt = eval(Environment_summary_system_prompt)
+        response = self.LLMs[current_state_name].get_response(None, environment_summary_system_prompt, stream=False)
+        return response
+
+    def update_memory(self, memory, current_state):
+        """
+        update chat embbedings and long term memory,short term memory,agents long term memory
+        """
+        MAX_CHAT_HISTORY = eval(os.environ["MAX_CHAT_HISTORY"])
+        self.shared_memory["long_term_memory"].append(memory)
+        current_embedding = get_embedding(memory.content)
+        if "chat_embeddings" not in self.shared_memory:
+            self.shared_memory["chat_embeddings"] = current_embedding
+        else:
+            self.shared_memory["chat_embeddings"] = torch.cat(
+                [self.shared_memory["chat_embeddings"], current_embedding], dim=0
+            )
+        if len(self.shared_memory["long_term_memory"]) % MAX_CHAT_HISTORY == 0:
+            summary = self.summary(current_state)
+            self.shared_memory["short_term_memory"] = summary
+
+        self.agents[memory.send_name].update_memory(memory)
+    
+    
+    def _get_agent_last_conversation_idx(self,agent,current_long_term_memory):
+        last_conversation_idx = -1
+        for i, history in enumerate(current_long_term_memory):
+            if history.send_name == agent.name:
+                last_conversation_idx = i
+        return last_conversation_idx
+    
+    
+    def _get_agent_new_memory(self,agent,current_long_term_memory):
+        # get new conversation
+        last_conversation_idx = self._get_agent_last_conversation_idx(agent,current_long_term_memory)
+
+        if last_conversation_idx == -1:
+            new_conversation =current_long_term_memory
+        elif (
+            last_conversation_idx
+            == len(current_long_term_memory) - 1
+        ):
+            new_conversation = []
+        else:
+            new_conversation = current_long_term_memory[
+                last_conversation_idx + 1 :
+            ]
+        MAX_CHAT_HISTORY = eval(os.environ["MAX_CHAT_HISTORY"])
+        if len(new_conversation) > 2 * MAX_CHAT_HISTORY:
+            new_conversation = new_conversation[-2*MAX_CHAT_HISTORY+1:]
+
+        # get chat history from new conversation
+        return Memory.get_chat_history(new_conversation)
+    
+    
+    def _observe(self,agent):
+        MAX_CHAT_HISTORY = eval(os.environ["MAX_CHAT_HISTORY"])
+        current_state = agent.current_state
+        current_role = agent.state_roles[current_state.name]
+        current_component_dict = current_state.components[current_role]
+        
+        # cooperative:Sharing information between different states ;  competive: No information is shared between different states
+        current_chat_history_idx = self.current_chat_history_idx if self.environment_type == "competive" else 0
+        current_long_term_memory = self.shared_memory["long_term_memory"][current_chat_history_idx:]
+        current_chat_embbedings = self.shared_memory["chat_embeddings"][current_chat_history_idx:]
+            
+        if len(current_long_term_memory)>2*MAX_CHAT_HISTORY:
+            current_long_term_memory = current_long_term_memory[-2*MAX_CHAT_HISTORY+1:]
+            current_chat_embbedings = current_chat_embbedings[-2*MAX_CHAT_HISTORY+1:]
+        # relevant_memory
+        query = current_long_term_memory[-1].content
+        if len(current_long_term_memory)>1:
+            relevant_memory = get_relevant_history(
+                query,
+                current_long_term_memory[:-2],
+                current_chat_embbedings[:-2],
+            )
+            relevant_memory = Memory.get_chat_history(relevant_memory,agent.name)
+        else:
+            relevant_memory = ""
+        
+        relevant_memory = eval(Agent_observe_relevant_memory)
+        agent.relevant_memory = relevant_memory
+        
+        
+        # get chat history from new conversation
+        conversations = self._get_agent_new_memory(agent,current_long_term_memory)
+
+        # memory = relevant_memory + summary + history + query
+        query = current_long_term_memory[-1]
+        current_memory = eval(Agent_observe_memory)
+
+        return {"role": "user", "content": current_memory}
+
+

LLM/base_LLM.py

@@ -0,0 +1,137 @@
+from abc import abstractclassmethod
+import openai
+import os
+import time
+from Memory import Memory
+from utils import save_logs
+
+class LLM:
+    def __init__(self) -> None:
+        pass
+
+    @abstractclassmethod 
+    def get_response():
+        pass
+
+
+class OpenAILLM(LLM):
+    def __init__(self,**kwargs) -> None:
+        super().__init__()
+        self.MAX_CHAT_HISTORY = eval(
+            os.environ["MAX_CHAT_HISTORY"]) if "MAX_CHAT_HISTORY" in os.environ else 10
+        
+        self.model = kwargs["model"] if "model" in kwargs else "gpt-3.5-turbo-16k-0613"
+        self.temperature = kwargs["temperature"] if "temperature" in  kwargs else 0.3
+        self.log_path = kwargs["log_path"].replace("/",os.sep) if "log_path" in kwargs else "logs"
+    
+
+    def get_stream(self,response, log_path, messages):
+        ans = ""
+        for res in response:
+            if res:
+                r = (res.choices[0]["delta"].get("content")
+                    if res.choices[0]["delta"].get("content") else "")
+                ans += r
+                yield r
+        
+        save_logs(log_path, messages, ans)
+        
+        
+        
+    def get_response(self,
+                    chat_history,
+                    system_prompt,
+                    last_prompt=None,
+                    stream=False,
+                    functions=None,
+                    function_call="auto",
+                    WAIT_TIME=20,
+                    **kwargs):
+        """
+        return LLM's response 
+        """
+        openai.api_key = os.environ["API_KEY"]
+        if "PROXY" in os.environ:
+            assert "http:" in os.environ["PROXY"] or "socks" in os.environ["PROXY"],"PROXY error,PROXY must be http or socks"
+            openai.proxy = os.environ["PROXY"]
+        if "API_BASE" in os.environ:
+            openai.api_base = os.environ["API_BASE"]
+        active_mode = True if ("ACTIVE_MODE" in os.environ and os.environ["ACTIVE_MODE"] == "0") else False
+        model = self.model
+        temperature = self.temperature
+        
+        
+        if active_mode:
+            system_prompt = system_prompt + "Please keep your reply as concise as possible."
+
+        messages = [{
+            "role": "system",
+            "content": system_prompt
+        }] if system_prompt else []
+        
+        if chat_history:
+            if len(chat_history) >  self.MAX_CHAT_HISTORY:
+                chat_history = chat_history[- self.MAX_CHAT_HISTORY:]
+            if isinstance(chat_history[0],dict):
+                messages += chat_history
+            elif isinstance(chat_history[0],Memory):
+                messages += [memory.get_gpt_message("user") for memory in chat_history]
+        
+        
+
+        if last_prompt:
+            if active_mode:
+                last_prompt = last_prompt + "Please keep your reply as concise as possible."
+            # messages += [{"role": "system", "content": f"{last_prompt}"}]
+            messages[-1]["content"] += last_prompt
+        
+
+        while True:
+            try:
+                if functions:
+                    response = openai.ChatCompletion.create(
+                        model=model,
+                        messages=messages,
+                        functions=functions,
+                        function_call=function_call,
+                        temperature=temperature,
+                    )
+                else:
+                    response = openai.ChatCompletion.create(
+                        model=model,
+                        messages=messages,
+                        temperature=temperature,
+                        stream=stream)
+                break
+            except Exception as e:
+                print(e)
+                if "maximum context length is" in str(e):
+                    if len(messages)>1:
+                        del messages[1]
+                    else:
+                        assert False, "exceed max length"
+                else:
+                    print(f"Please wait {WAIT_TIME} seconds and resend later ...")
+                    time.sleep(WAIT_TIME)
+
+        if functions:
+            save_logs(self.log_path, messages, response)
+            return response.choices[0].message
+        elif stream:
+            return self.get_stream(response, self.log_path, messages)
+        else:
+            save_logs(self.log_path, messages, response)
+            return response.choices[0].message["content"]
+
+
+def init_LLM(default_log_path,**kwargs):
+    LLM_type = kwargs["LLM_type"] if "LLM_type" in kwargs else "OpenAI"
+    log_path = kwargs["log_path"].replace("/",os.sep) if "log_path" in kwargs else default_log_path
+    if LLM_type == "OpenAI":
+        LLM = (
+            OpenAILLM(**kwargs["LLM"])
+            if "LLM" in kwargs
+            else OpenAILLM(model = "gpt-3.5-turbo-16k-0613",temperature=0.3,log_path=log_path)
+        )
+        return LLM
+    

Memory/__init__.py

@@ -0,0 +1 @@
+from .base_Memory import Memory

Memory/base_Memory.py

@@ -0,0 +1,32 @@
+from Prompt import *
+class Memory:
+    def __init__(self,role,name,content) -> None:
+        self.send_role = role
+        self.send_name = name
+        self.content = content
+    
+    def get_gpt_message(self,role):
+        return {"role":role,"content":self.content}
+    
+    @classmethod
+    def get_chat_history(self,messages,agent_name =None):
+        """
+        Splice a memory list into a sentence
+        input : 
+        messages(list) : list of memory(Memory)
+        Return :
+        chat_history(str) : One sentence after integration
+        """
+        chat_history = ""
+        for message in messages:
+            name,role,content = message.send_name,message.send_role,message.content
+            if agent_name and agent_name==name:
+                name = "you"
+            chat_history += eval(Single_message)
+        chat_history = eval(Chat_total_message)
+        return chat_history
+    
+    def get_query(self):
+        "Return : query(str):last sentence"
+        name,role,content = self.send_name,self.send_role,self.content
+        return eval(Single_message)

Prompt/__init__.py

@@ -0,0 +1 @@
+from .base_Prompts import *

Prompt/base_Prompts.py

@@ -0,0 +1,84 @@
+
+# SOP========================================================================================================
+# "environment_prompt"
+# current_state , self(sop)
+Get_environment_prompt = "f\"Here are the description of current scenario:{self.current_state.environment_prompt};\\n\""
+
+
+# sop.transit
+#================================================================
+Transit_system_prompt = "f\"{environment_prompt};\\n{judge_system_prompt}\\n\"";
+
+#  transit chat message 
+#  "environment_prompt" is get from "Get_environment_prompt" ; "chat_history_message" if from Memory
+Transit_message = "f\"{environment_summary};\\n Here is the The chat history:\\n {chat_history_message};\\nHere is the last query you especially need to pay attention:\\n{query};\\n Here is the relevant conversation: \\n{relevant_history} \\n\\n\""
+
+
+Transit_last_prompt = "f\"{judge_last_prompt}\""
+#sop.transit================================================================
+
+# sop.call
+#================================================================
+# help controller to determine the next role to speak.(the {} is agent role)    call_prompt + allocate_component  
+Allocate_component = "f\"If it's currently supposed to be speaking for {role}, then output <end>{role}</end>.\\n\""
+
+# environment_prompt is get from "Get_environment_prompt" ; "chat_history_message" if from Memory
+Call_system_prompt = "f\"{environment_prompt};\\n{call_system_prompt};\\n{allocate_prompt}.\\n\""
+
+#
+Call_last_prompt = "f\"Here is the last query you especially need to pay attention:\\n{query};\\n Here is the the relevant conversation :\\n{relevant_history};\\nNow please choose the person to speak according to the following rules :{allocate_prompt};\\nNote: The person whose turn it is now cannot be the same as the person who spoke last time, so {last_name} cannot be output\\n.\""
+
+Call_message = "f\"Here is the chat history:\\n{chat_history_message};\\nHere is the name of the person who last speak: {last_name}.\\n \""
+#sop.call================================================================
+# SOP========================================================================================================
+
+
+
+
+
+
+# Memory========================================================================================================
+Single_message = "f\"role: {role} \\n speak content : {content}; \""
+
+Chat_total_message = "f\"<chat history>{{{chat_history}}}</chat history>\""
+# Memory========================================================================================================
+
+
+
+
+
+
+# Environment========================================================================================================
+Default_environment_summary_system_prompt = "\"\\nYour task is to summarize the historical dialogue records according to the current scene, and summarize the most important information\""
+
+Default_environment_summary_last_prompt = "\"Please make a summary based on the historical chat records, the output format is history summary: \{your summary content\} \""
+
+Environment_summary_memory =  "f\"Here is the information you need to know:\\n\\n\
+            Here is the summary of the previous dialogue history:\\n{summary}.\\n\
+            Here is the latest conversation record:\\n {chat_history},\\n\
+            Here is the relevant chat history you may need:{relevant_history}.\\n\""
+            
+Environment_summary_system_prompt = "f\"{environment_prompt};\\n{current_memory};\\n{summary_system_prompt};\\n\""
+
+
+# observe
+Agent_observe_relevant_memory = "f\"\\n{relevant_memory}. \\n\""
+
+
+Agent_observe_memory = "f\"Here's what you need to know(Remember, this is just information, Try not to repeat what's inside):\\nHere is the relevant chat history you may need:{relevant_memory};\\n\
+Here is the previous summary of chat history :\\n{agent.short_term_memory}.\\n\
+Here is the relevant memory :\\n{agent.relevant_memory}.\\n\
+Here is the new chat history:\\n {conversations};\\n\
+            \""
+# Environment========================================================================================================
+
+
+
+
+# Agent========================================================================================================
+Agent_summary_system_prompt = "f\"{summary_prompt};\\n Here is the past summary:{self.short_term_memory};\\nHere is the new chat_history:\\n{conversations};\\nPlease summary Please summarize based on the above information;\\n\""          
+            
+Agent_last_prompt = "f\"{last_prompt};Please continue the talk based on your known information;Remember that you just represent {name}, do not speak for others,just speak as normal.\""
+
+Agent_system_prompt = "f\"{system_prompt},\""
+# Agent========================================================================================================

SOP.py

@@ -0,0 +1,291 @@
+# coding=utf-8
+# Copyright 2023  The AIWaves Inc. team.
+
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""standard operation procedure of an LLM Autonomous agent"""
+import random
+from LLM.base_LLM import *
+from State import State
+from utils import extract, get_relevant_history
+from Memory import Memory
+from Prompt import *
+import json
+import os
+
+class SOP:
+    """
+    Responsible for managing the operational processes of all agents
+    """
+
+    # SOP should have args : "states" "relations" "root"
+
+    def __init__(self, **kwargs):
+        self.controller_dict = {}
+        self.LLM = init_LLM("logs"+os.sep+"god",**kwargs)
+
+        self.states = {}
+        self.init_states(kwargs["states"])
+        self.init_relation(kwargs["relations"])
+        for state_name, states_dict in kwargs["states"].items():
+            if state_name != "end_state" and "controller" in states_dict:
+                self.controller_dict[state_name] = states_dict["controller"]
+
+        self.user_names = kwargs["user_names"] if "user_names" in kwargs else []
+        self.root = self.states[kwargs["root"]]
+        self.current_state = self.root
+        self.finish_state_name = (
+            kwargs["finish_state_name"]
+            if "finish_state_name" in kwargs
+            else "end_state"
+        )
+        self.roles_to_names = None
+        self.names_to_roles = None
+        self.finished = False
+
+    @classmethod
+    def from_config(cls, config_path):
+        with open(config_path) as f:
+            config = json.load(f)
+        os.environ.clear()
+        for key,value in config["config"].items():
+            if value!="":
+                os.environ[key] = value
+        sop = SOP(**config)
+        return sop
+
+    def init_states(self, states_dict):
+        for state_name, state_dict in states_dict.items():
+            state_dict["name"] = state_name
+            self.states[state_name] = State(**state_dict)
+
+    def init_relation(self, relations):
+        for state_name, state_relation in relations.items():
+            for idx, next_state_name in state_relation.items():
+                self.states[state_name].next_states[idx] = self.states[next_state_name]
+
+    def transit(self, chat_history, **kwargs):
+        """
+        Determine the next state based on the current situation
+        Return : 
+        next_state(State) : the next state
+        """
+        # 如果是单一循环节点，则一直循环即可
+        # If it is a single loop node, just keep looping
+        if len(self.current_state.next_states) == 1:
+            next_state = "0"
+            
+        # 否则则需要controller去判断进入哪一节点
+        # Otherwise, the controller needs to determine which node to enter.   
+        else:
+            current_state = self.current_state
+            controller_dict = self.controller_dict[current_state.name]
+            relevant_history = kwargs["relevant_history"]
+            
+            max_chat_nums = controller_dict["max_chat_nums"] if "max_chat_nums" in controller_dict else 1000
+            if current_state.chat_nums>=max_chat_nums:
+                return self.current_state.next_states["1"]
+            
+
+            # 否则则让controller判断是否结束
+            # Otherwise, let the controller judge whether to end
+            judge_system_prompt = controller_dict["judge_system_prompt"] if "judge_system_prompt" in controller_dict else ""
+            environment_prompt = eval(Get_environment_prompt) if current_state.environment_prompt else ""
+            transit_system_prompt = eval(Transit_system_prompt)
+            
+            judge_last_prompt = controller_dict["judge_last_prompt"] if "judge_last_prompt" in controller_dict else ""
+            transit_last_prompt = eval(Transit_last_prompt)
+            
+
+            
+            environment = kwargs["environment"]
+            environment_summary = environment.shared_memory["short_term_memory"]
+            chat_history_message = Memory.get_chat_history(chat_history)
+            query = chat_history[-1].get_query()
+            
+            chat_messages = [
+                {
+                    "role": "user",
+                    "content": eval(Transit_message)
+                }
+            ]
+            
+            extract_words = controller_dict["judge_extract_words"] if "judge_extract_words" in controller_dict else "end"
+
+
+            response = self.LLM.get_response(
+                chat_messages, transit_system_prompt, transit_last_prompt, stream=False, **kwargs
+            )
+            next_state = (
+                response if response.isdigit() else extract(response, extract_words)
+            )
+            
+            # 如果没有parse出来则继续循环
+            # If no parse comes out, continue looping
+            if not next_state.isdigit():
+                next_state = "0"
+            
+        next_state = self.current_state.next_states[next_state]
+        return next_state
+
+
+    def route(self, chat_history, **kwargs):
+        """
+        Determine the role that needs action based on the current situation
+        Return : 
+        current_agent(Agent) : the next act agent
+        """
+        
+        agents = kwargs["agents"]
+        
+        # 知道进入哪一状态后开始分配角色，如果该状态下只有一个角色则直接分配给他
+        # Start assigning roles after knowing which state you have entered. If there is only one role in that state, assign it directly to him.
+        if len(self.current_state.roles) == 1:
+            next_role = self.current_state.roles[0]
+        
+        
+        
+        # 否则controller进行分配
+        # Otherwise the controller determines
+        else:
+            relevant_history = kwargs["relevant_history"]
+            controller_type = (
+                self.controller_dict[self.current_state.name]["controller_type"]
+                if "controller_type" in self.controller_dict[self.current_state.name]
+                else "order"
+            )
+
+
+            # 如果是rule 控制器，则交由LLM进行分配角色
+            # If  controller type is rule, it is left to LLM to assign roles.
+            if controller_type == "rule":
+                controller_dict = self.controller_dict[self.current_state.name]
+                
+                call_last_prompt = controller_dict["call_last_prompt"] if "call_last_prompt" in controller_dict else ""
+                
+                allocate_prompt = ""
+                roles = list(set(self.current_state.roles))
+                for role in roles:
+                    allocate_prompt += eval(Allocate_component)
+                    
+                call_system_prompt = controller_dict["call_system_prompt"]  if "call_system_prompt" in controller_dict else ""
+                environment_prompt = eval(Get_environment_prompt) if self.current_state.environment_prompt else ""    
+                # call_system_prompt + environment + allocate_prompt 
+                call_system_prompt = eval(Call_system_prompt)
+                
+                query = chat_history[-1].get_query()
+                last_name = chat_history[-1].send_name
+                # last_prompt: note + last_prompt + query
+                call_last_prompt =eval(Call_last_prompt)
+                
+                
+                chat_history_message = Memory.get_chat_history(chat_history)
+                # Intermediate historical conversation records
+                chat_messages = [
+                    {
+                        "role": "user",
+                        "content": eval(Call_message),
+                    }
+                ]
+
+                extract_words = controller_dict["call_extract_words"] if "call_extract_words" in controller_dict else "end"
+
+                response = self.LLM.get_response(
+                    chat_messages, call_system_prompt, call_last_prompt, stream=False, **kwargs
+                )
+
+                # get next role
+                next_role = extract(response, extract_words)
+
+            # Speak in order
+            elif controller_type == "order":
+                # If there is no begin role, it will be given directly to the first person.
+                if not self.current_state.current_role:
+                    next_role = self.current_state.roles[0]
+                # otherwise first
+                else:
+                    self.current_state.index += 1
+                    self.current_state.index =  (self.current_state.index) % len(self.current_state.roles)
+                    next_role = self.current_state.roles[self.current_state.index]
+            # random speak
+            elif controller_type == "random":
+                next_role = random.choice(self.current_state.roles)
+            
+        # 如果下一角色不在，则随机挑选一个
+        # If the next character is not available, pick one at random    
+        if next_role not in self.current_state.roles:
+            next_role = random.choice(self.current_state.roles)
+            
+        self.current_state.current_role = next_role 
+        
+        next_agent = agents[self.roles_to_names[self.current_state.name][next_role]]
+        
+        return next_agent
+    
+    def next(self, environment, agents):
+        """
+        Determine the next state and the agent that needs action based on the current situation
+        """
+        
+        # 如果是第一次进入该状态
+        # If it is the first time to enter this state
+        
+        if self.current_state.is_begin:
+            agent_name = self.roles_to_names[self.current_state.name][self.current_state.begin_role]
+            agent = agents[agent_name]
+            return self.current_state,agent
+    
+    
+        # get relevant history
+        query = environment.shared_memory["long_term_memory"][-1].content
+        relevant_history = get_relevant_history(
+            query,
+            environment.shared_memory["long_term_memory"][:-1],
+            environment.shared_memory["chat_embeddings"][:-1],
+        )
+        relevant_history = Memory.get_chat_history(relevant_history)
+        
+        
+        
+        next_state = self.transit(
+            chat_history=environment.shared_memory["long_term_memory"][
+                environment.current_chat_history_idx :
+            ],
+            relevant_history=relevant_history,
+            environment=environment,
+        )
+        # 如果进入终止节点，则直接终止
+        # If you enter the termination node, terminate directly
+        if next_state.name == self.finish_state_name:
+            self.finished = True
+            return None, None
+
+        self.current_state = next_state
+        
+        # 如果是首次进入该节点且有开场白，则直接分配给开场角色
+        # If it is the first time to enter the state and there is a begin query, it will be directly assigned to the begin role.
+        if self.current_state.is_begin and self.current_state.begin_role:
+            agent_name = self.roles_to_names[self.current_state.name][self.current_state.begin_role]
+            agent = agents[agent_name]
+            return self.current_state,agent
+           
+
+        next_agent = self.route(
+            chat_history=environment.shared_memory["long_term_memory"][
+                environment.current_chat_history_idx :
+            ],
+            agents = agents,
+            relevant_history=relevant_history,
+        )
+
+        return self.current_state, next_agent

State.py

@@ -0,0 +1,142 @@
+from Component import *
+
+
+class State:
+    """
+    Sub-scenes of role activities, responsible for storing the tasks that each role needs to do
+    """
+    def __init__(self, **kwargs):
+        self.next_states = {}
+        self.name = kwargs["name"]
+
+        self.environment_prompt = (
+            kwargs["environment_prompt"] if "environment_prompt" in kwargs else ""
+        )
+
+        self.roles = kwargs["roles"] if "roles" in kwargs else (list(kwargs["agent_states"].keys()) if "agent_states" in kwargs else [0])
+        if len(self.roles) == 0:
+            self.roles = [0]
+        self.begin_role = (
+            kwargs["begin_role"] if "begin_role" in kwargs else self.roles[0]
+        )
+        self.begin_query = kwargs["begin_query"] if "begin_query" in kwargs else None
+
+        self.is_begin = True
+
+        self.summary_prompt = (
+            kwargs["summary_prompt"] if "summary_prompt" in kwargs else None
+        )
+        self.current_role = self.begin_role
+        self.components = (
+            self.init_components(kwargs["agent_states"])
+            if "agent_states" in kwargs
+            else {}
+        )
+        self.index = (
+            self.roles.index(self.begin_role) if self.begin_role in self.roles else 0
+        )
+        self.chat_nums = 0
+
+    def init_components(self, agent_states_dict: dict):
+        agent_states = {}
+        for role, components in agent_states_dict.items():
+            component_dict = {}
+            for component, component_args in components.items():
+                if component:
+                    # "role" "style"
+                    if component == "style":
+                        component_dict["style"] = StyleComponent(component_args["role"])
+
+                        # "task"
+                    elif component == "task":
+                        component_dict["task"] = TaskComponent(component_args["task"])
+
+                        # "rule"
+                    elif component == "rule":
+                        component_dict["rule"] = RuleComponent(component_args["rule"])
+
+                        # "demonstration"
+                    elif component == "demonstrations":
+                        component_dict["demonstrations"] = DemonstrationComponent(
+                            component_args["demonstrations"]
+                        )
+
+                    # "output"
+                    elif component == "output":
+                        component_dict["output"] = OutputComponent(
+                            component_args["output"]
+                        )
+
+                    elif component == "last":
+                        component_dict["last"] = LastComponent(
+                            component_args["last_prompt"]
+                        )
+
+                    # "demonstrations"
+                    elif component == "cot":
+                        component_dict["cot"] = CoTComponent(
+                            component_args["demonstrations"]
+                        )
+                    elif component == "CustomizeComponent":
+                        component_dict["CustomizeComponent"] = CustomizeComponent(
+                            component_args["template"], component_args["keywords"]
+                        )
+                    
+                    elif component == "system" : 
+                        component_dict["system"] = SystemComponent(
+                            component_args["system_prompt"]
+                        )
+
+                    # =================================================================================#
+
+                    # "output"
+                    elif component == "StaticComponent":
+                        component_dict["StaticComponent"] = StaticComponent(
+                            component_args["output"]
+                        )
+
+                    # "top_k"  "type" "knowledge_base" "system_prompt" "last_prompt"
+                    elif component == "KnowledgeBaseComponent":
+                        component_dict["tool"] = KnowledgeBaseComponent(
+                            component_args["top_k"],
+                            component_args["type"],
+                            component_args["knowledge_path"],
+                        )
+
+                    elif component == "CategoryRequirementsComponent":
+                        component_dict[
+                            "CategoryRequirementsComponent"
+                        ] = CategoryRequirementsComponent(
+                            component_args["information_path"]
+                        )
+
+                    elif component == "FunctionComponent":
+                        component_dict["FunctionComponent"] = FunctionComponent(component_args[""])
+                    # "short_memory_extract_words"  "long_memory_extract_words" "system_prompt" "last_prompt"
+                    elif component == "ExtractComponent":
+                        component_dict["ExtractComponent"] = ExtractComponent(
+                            component_args["extract_words"],
+                            component_args["system_prompt"],
+                            component_args["last_prompt"],
+                        )
+                    elif component == "WebSearchComponent":
+                        component_dict["WebSearchComponent"] = WebSearchComponent(
+                            component_args["engine_name"], component_args["api"]
+                        )
+                    elif component == "WebCrawlComponent":
+                        component_dict["WebCrawlComponent"] = WebCrawlComponent(
+                            component_args["name"]
+                        )
+
+                    elif component == "CodeComponent":
+                        component_dict["CodeComponent"] = CodeComponent(
+                            component_args["file_name"], component_args["keyword"]
+                        )
+
+                    # ====================================================
+                    else:
+                        continue
+
+            agent_states[role] = component_dict
+
+        return agent_states

app.py

@@ -0,0 +1,398 @@
+import sys
+sys.path.append("../../agents")
+import os
+from gradio_base import WebUI, UIHelper, PORT, HOST, Client
+from gradio_config import GradioConfig as gc
+from typing import List, Tuple, Any
+import gradio as gr
+from Agent import Agent
+import time
+import json
+from utils import cos_sim
+from design_states import get_desgin_states, get_cot_result, gen_coder_task
+from gen_utils import *
+import openai
+import torch
+
+def get_embedding(sentence,api_key):
+    openai.api_key = api_key
+    embedding_model = openai.Embedding
+    embed = embedding_model.create(
+        model="text-embedding-ada-002",
+        input=sentence
+    )
+    embed = embed["data"][0]["embedding"]
+    embed = torch.tensor(embed,dtype=torch.float32)
+    if len(embed.shape)==1:
+        embed = embed.unsqueeze(0)
+    return embed
+
+class CodeUI(WebUI):
+    
+    def render_and_register_ui(self):
+        self.agent_name:list = [self.cache["agents_name"]] if isinstance(self.cache["agents_name"], str) else self.cache['agents_name']
+        gc.add_agent(self.agent_name)
+    
+    def __init__(
+        self,
+        client_cmd: list,
+        socket_host: str = HOST,
+        socket_port: int = PORT,
+        bufsize: int = 1024,
+        ui_name: str = "CodeUI"
+    ):
+        super(CodeUI, self).__init__(client_cmd, socket_host, socket_port, bufsize, ui_name)
+        self.first_recieve_from_client()
+        self.data_history = list()
+        self.caller = 0
+    
+    def load_sop_fn(self,sop):
+        return sop.name
+
+
+    def generate_sop_stage_1(self,api_key,proxy,target):
+        os.environ["API_KEY"] = api_key
+        # os.environ["PROXY"] = proxy
+        self.software = "You are a software,aim to write a snake game with python"
+        self.debate = "Simulate a debate competition"
+        self.ecological_environment = "Simulate the interactions and competition among different organisms within an ecosystem"
+        self.software = get_embedding(self.software,api_key)
+        self.debate = get_embedding(self.debate,api_key)
+        self.ecological_environment = get_embedding(self.ecological_environment,api_key)
+        self.embeddings = torch.cat([self.software,self.debate,self.ecological_environment],dim = 0) 
+        self.SOP["config"]["API_KEY"] = api_key
+        # self.SOP["config"]["PROXY"] = proxy
+        target_tensor = get_embedding(target,api_key)
+        sim_scores = cos_sim(target_tensor, self.embeddings)[0]
+        top_k_score, top_k_idx = torch.topk(sim_scores,k = 1)
+        if top_k_score > 0.7:
+            self.index = top_k_idx
+        else:
+            self.index = 0
+        target_processed = get_cot_result(target)
+        print("finished!!!!")
+        return target_processed,self.target_finish_flag.update(visible = True)
+
+    def generate_sop_stage_2(self,target):
+        design_states = get_desgin_states(target,self.index)
+        root = design_states[0]["state_name"]
+        self.SOP["root"] = root
+        return design_states,self.state_finish_flag.update(visible = True)
+
+    def generate_sop_stage_3(self,design_states):
+        agents = get_agents(design_states,self.index)
+        relations = get_relations(design_states)
+        self.SOP["relations"] = relations
+        self.SOP["agents"] = agents
+        return agents, self.agent_relation_finish_flag.update(visible = True),self.reminder.update(visible = True)
+
+    def generate_sop_stage_4(self,agents, need_coder,design_states):
+        states = gen_states(design_states,self.index)
+        if "Coder" in need_coder:
+            agents["coder"] = {"style": "professional", "roles": {}}
+            for state_name, state in states.items():
+                if state_name != "end_state":
+                    agents["coder"]["roles"][state_name] = "coder"
+                    state["roles"].append("coder")
+                    task = gen_coder_task(state["environment_prompt"])
+                    now_coder = self.coder.copy()
+                    now_coder["task"]["task"] = task
+                    state["agent_states"]["coder"] = now_coder
+                    state["controller"]["max_chat_nums"] = str(
+                        int(state["controller"]["max_chat_nums"])+2)
+                    for name, agent in state["agent_states"].items():
+                        if name != "coder":
+                            agent["rule"]["rule"] += "\nEvaluate the code of the coder and provide feedback and response as concise as possible.It is best not to exceed 100 words"
+                            agent["task"]["task"] += "\nEvaluate the code of the coder and provide feedback."
+        self.SOP["states"] = states
+        # 将字典写入JSON文件
+        file_name = 'generated_sop.json'
+        with open(file_name, "w") as json_file:
+            json.dump(self.SOP, json_file ,indent=4,ensure_ascii=False)
+        return file_name
+
+    def construct_ui(self):
+        with gr.Blocks(css=gc.CSS) as demo:
+            with gr.Tab(label="SOP generation") as tab1:
+                self.coder = {
+                    "task": {
+                        "task": ""
+                    },
+                    "rule": {"rule": "1.write code that conforms to standards like PEP8, is modular, easy to read, and maintainable.\n 2.The output strictly follows the following format:<title>{the file name}</title>\n<python>{the target code}</python>\n3.Please carefully modify the code based on feedback from others.\n4.Output the code only."},
+                    "last": {
+                        "last_prompt": "The output strictly follows the following format:<title>{the file name}</title>\n<python>{the target code}</python>,Output the code only."
+                    }
+                }
+                self.SOP = {
+                    "config": {
+                        "API_KEY": "sk-*********",
+                        "MAX_CHAT_HISTORY": "5",
+                        "User_Names": '["User"]',
+                    },
+                    "root": "state1",
+                    "relations": {
+                        "state1": {"0": "state1", "1": "state2"},
+                        "state2": {"0": "state2", "1": "end_state"},
+                    },
+                    "agents": None,
+                    "states": None,
+                }
+                gr.Markdown("""# Generate Agent""")
+                with gr.Row():
+                    api_key = gr.Textbox(label="api_key")
+                    proxy = gr.Textbox(label="proxy",visible=False)
+                with gr.Row():
+                    requirement = gr.Textbox(value ="A software company aim to write a mine sweeping game",label="requirement")
+                with gr.Row():
+                    need_coder = gr.CheckboxGroup(["Coder"],label="Demand for coder")
+                with gr.Row():
+                    self.target_finish_flag = gr.Label(value = "The process of completing requirement handling is finished.",visible=False)
+                with gr.Row():
+                    self.state_finish_flag = gr.Label(value = "The process of determining the state is completed.",visible=False)
+                with gr.Row():
+                    self.agent_relation_finish_flag = gr.Label(value = "The process of initializing the agent and relation is completed.",visible=False)
+                with gr.Row():
+                    self.reminder = gr.Markdown("""Generating SOP...""",visible=False)
+                    generated_sop = gr.File(label="generated_file")
+                generate_button = gr.Button(label="Generate")
+                target_processed = gr.State()
+                design_states = gr.State()
+                agents = gr.State()
+                generate_button.click(self.generate_sop_stage_1,[api_key,proxy,requirement],[target_processed,self.target_finish_flag]).then(
+                    self.generate_sop_stage_2, [target_processed], [design_states,self.state_finish_flag]).then(
+                    self.generate_sop_stage_3, [design_states], [agents,self.agent_relation_finish_flag,self.reminder]).then(
+                    self.generate_sop_stage_4, [agents, need_coder,design_states], [generated_sop])
+            with gr.Tab(label="Chat") as tab2:
+                uploaded_sop = gr.State()
+                with gr.Row():
+                    sop = gr.File(label="upload your custmized SOP")
+                    load_sop_btn = gr.Button(value="Load SOP")
+                load_sop_btn.click(self.load_sop_fn, sop,uploaded_sop)
+                with gr.Row():
+                    with gr.Column():
+                        self.text_api = gr.Textbox(
+                            value = self.cache["api_key"],
+                            placeholder="openai key",
+                            label="Please input valid openai key for gpt-3.5-turbo-16k."
+                        )
+                        self.radio_mode = gr.Radio(
+                            [Client.SINGLE_MODE],
+                            value=Client.SINGLE_MODE,
+                            interactive=True,
+                            label = Client.MODE_LABEL,
+                            info = Client.MODE_INFO
+                        )
+                        self.chatbot = gr.Chatbot(
+                            elem_id="chatbot1"
+                        )
+                        self.btn_next = gr.Button(
+                            value="Next Agent",
+                            visible=False, elem_id="btn"
+                        )
+                        with gr.Row():
+                            self.text_requirement = gr.Textbox(
+                                value=self.cache['requirement'],
+                                placeholder="Please enter your content",
+                                scale=9,
+                            )
+                            self.btn_start = gr.Button(
+                                value="Start!",
+                                scale=1
+                            )
+                        self.btn_reset = gr.Button(
+                            value="Restart",
+                            visible=False
+                        )
+                    
+                    with gr.Column():
+                        self.file = gr.File(visible=False)
+                        self.chat_code_show = gr.Chatbot(
+                            elem_id="chatbot1",
+                            visible=False
+                        )   
+                    
+                    self.btn_start.click(
+                        fn=self.btn_send_when_click,
+                        inputs=[self.chatbot, self.text_requirement, self.radio_mode, self.text_api,uploaded_sop],
+                        outputs=[self.chatbot, self.btn_start, self.text_requirement, self.btn_reset]
+                    ).then(
+                        fn=self.btn_send_after_click,
+                        inputs=[self.file, self.chatbot, self.chat_code_show, self.btn_start, self.btn_reset, self.text_requirement],
+                        outputs=[self.file, self.chatbot, self.chat_code_show, self.btn_start, self.btn_reset, self.text_requirement, self.btn_next]
+                    )
+                    self.text_requirement.submit(
+                        fn=self.btn_send_when_click,
+                        inputs=[self.chatbot, self.text_requirement, self.text_api,uploaded_sop],
+                        outputs=[self.chatbot, self.btn_start, self.text_requirement, self.btn_reset]
+                    ).then(
+                        fn=self.btn_send_after_click,
+                        inputs=[self.file, self.chatbot, self.chat_code_show, self.btn_start, self.btn_reset, self.text_requirement],
+                        outputs=[self.file, self.chatbot, self.chat_code_show, self.btn_start, self.btn_reset, self.text_requirement, self.btn_next]
+                    )
+                    self.btn_reset.click(
+                        fn=self.btn_reset_when_click,
+                        inputs=[],
+                        outputs=[self.file, self.chatbot, self.chat_code_show, self.btn_start, self.btn_reset, self.text_requirement, self.btn_next]
+                    ).then(
+                        fn=self.btn_reset_after_click,
+                        inputs=[self.file, self.chatbot, self.chat_code_show, self.btn_start, self.btn_reset, self.text_requirement],
+                        outputs=[self.file, self.chatbot, self.chat_code_show, self.btn_start, self.btn_reset, self.text_requirement, self.btn_next]
+                    )
+                    self.file.select(
+                        fn=self.file_when_select,
+                        inputs=[self.file],
+                        outputs=[self.chat_code_show]
+                    )
+                    self.btn_next.click(
+                        fn = self.btn_next_when_click,
+                        inputs=[],
+                        outputs=[self.btn_next]
+                    ).then(
+                        fn=self.btn_send_after_click,
+                        inputs=[self.file, self.chatbot, self.chat_code_show, self.btn_start, self.btn_reset, self.text_requirement],
+                        outputs=[self.file, self.chatbot, self.chat_code_show, self.btn_start, self.btn_reset, self.text_requirement, self.btn_next]
+                    )
+                    
+            self.demo = demo
+    
+
+    def handle_message(self, history:list, state, agent_name, token, node_name):
+        if state % 10 == 0:
+            self.data_history.append({agent_name: token})
+        elif state % 10 == 1:
+            # Same state. Need to add new bubble in same bubble.
+            self.data_history[-1][agent_name] += token
+        elif state % 10 == 2:
+            # New state. Need to add new bubble.
+            history.append([None, ""])
+            self.data_history.clear()
+            self.data_history.append({agent_name: token})
+        else:
+            assert False, "Invalid state."
+        render_data = self.render_bubble(history, self.data_history, node_name, render_node_name=True)
+        return render_data
+    
+    def btn_send_when_click(self, chatbot, text_requirement, mode, api, sop):
+        """
+        inputs=[self.chatbot, self.text_requirement, radio, text_api],
+        outputs=[self.chatbot, self.btn_start, self.text_requirement, self.btn_reset]
+        """
+        chatbot = [[UIHelper.wrap_css(content=text_requirement, name="User"), None]]
+        yield chatbot,\
+            gr.Button.update(visible=True, interactive=False, value="Running"),\
+            gr.Textbox.update(visible=True, interactive=False, value=""),\
+            gr.Button.update(visible=False, interactive=False)
+        self.send_start_cmd({'requirement': text_requirement, "mode": mode, "api_key": api ,"uploaded_sop": sop})
+        agents,roles_to_names,names_to_roles = Agent.from_config(str(sop))
+        agents_name = []
+        for i in names_to_roles :
+            for j in names_to_roles[i]:
+                agents_name.append(j+"("+names_to_roles[i][j]+")")
+        self.new_render_and_register_ui(agents_name)
+        return
+    
+    def new_render_and_register_ui(self,agent_names):
+        gc.add_agent(agent_names, 0)
+    
+    def btn_send_after_click(
+        self, 
+        file,
+        history,
+        show_code,
+        btn_send,
+        btn_reset,
+        text_requirement
+    ):
+        """
+        outputs=[self.file, self.chatbot, self.chat_code_show, self.btn_start, self.btn_reset, self.text_requirement, self.btn_next]
+        """
+        if self.caller == 0:
+            self.data_history = list()
+        self.caller = 0
+        receive_server = self.receive_server
+        while True:
+            data_list: List = receive_server.send(None)
+            for item in data_list:
+                data = eval(item)
+                assert isinstance(data, list)
+                state, agent_name, token, node_name = data
+                assert isinstance(state, int)
+                assert state in [10, 11, 12, 99, 98]
+                if state == 99:
+                    # finish
+                    fs = [self.cache['pwd']+'/output_code/'+_ for _ in os.listdir(self.cache['pwd']+'/output_code')]
+                    yield gr.File.update(value=fs, visible=True, interactive=True),\
+                        history, \
+                        gr.Chatbot.update(visible=True),\
+                        gr.Button.update(visible=True, interactive=True, value="Start"),\
+                        gr.Button.update(visible=True, interactive=True),\
+                        gr.Textbox.update(visible=True, interactive=True, placeholder="Please input your requirement", value=""),\
+                        gr.Button.update(visible=False)
+                    return
+                elif state == 98:
+                    yield gr.File.update(visible=False),\
+                        history, \
+                        gr.Chatbot.update(visible=False),\
+                        gr.Button.update(visible=True, interactive=False),\
+                        gr.Button.update(visible=True, interactive=True),\
+                        gr.Textbox.update(visible=True, interactive=False),\
+                        gr.Button.update(visible=True, value=f"Next Agent: 🤖{agent_name} | Next Node: ⭕{node_name}")
+                    return
+                history = self.handle_message(history, state, agent_name, token, node_name)
+                yield gr.File.update(visible=False),\
+                    history, \
+                    gr.Chatbot.update(visible=False),\
+                    gr.Button.update(visible=True, interactive=False),\
+                    gr.Button.update(visible=False, interactive=False),\
+                    gr.Textbox.update(visible=True, interactive=False),\
+                    gr.Button.update(visible=False)
+    
+    def btn_reset_when_click(self):
+        """
+        inputs = []
+        outputs = [self.file, self.chatbot, self.chat_code_show, self.btn_start, self.btn_reset, self.text_requirement, self.btn_next]
+        """
+        return gr.File.update(visible=False),\
+            None, None, gr.Button.update(value="Restarting...", interactive=False),\
+                gr.Button.update(value="Restarting...", interactive=False),\
+                    gr.Textbox.update(value="Restarting", interactive=False),\
+                        gr.Button.update(visible=False)
+    
+    def btn_reset_after_click(
+        self,
+        file,
+        chatbot,
+        show_code,
+        btn_send,
+        btn_reset,
+        text_requirement
+    ):
+        self.reset()
+        self.first_recieve_from_client(reset_mode=True)
+        return gr.File.update(value=None, visible=False),\
+            gr.Chatbot.update(value=None, visible=True),\
+            gr.Chatbot.update(value=None, visible=False),\
+            gr.Button.update(value="Start", visible=True, interactive=True),\
+            gr.Button.update(value="Restart", interactive=False, visible=False),\
+            gr.Textbox.update(value=self.cache['requirement'], interactive=True, visible=True),\
+            gr.Button.update(visible=False)
+        
+    def file_when_select(self, file):
+        CODE_PREFIX = "```python\n{}\n```"
+        with open(file.name, "r", encoding='utf-8') as f:
+            contents = f.readlines()
+        codes = "".join(contents)
+        return [[CODE_PREFIX.format(codes),None]]
+    
+    def btn_next_when_click(self):
+        self.caller = 1             # it will remain the value in self.data_history
+        self.send_message("nothing")
+        time.sleep(0.5)
+        yield gr.Button.update(visible=False)
+        return
+        
+
+if __name__ == '__main__':
+    ui = CodeUI(client_cmd=["python3","gradio_backend.py"])
+    ui.construct_ui()
+    ui.run(share=True)

config.json

@@ -0,0 +1,501 @@
+{
+    "config": {
+        "API_KEY": "sk-************",
+        "MAX_CHAT_HISTORY": "3",
+        "TOP_K": "0"
+    },
+    "LLM_type": "OpenAI",
+    "LLM": {
+        "temperature": 0.3,
+        "model": "gpt-3.5-turbo-16k-0613",
+        "log_path": "logs/god"
+    },
+    "root": "design_state",
+    "relations": {
+        "design_state": {
+            "0": "design_state",
+            "1": "develop_state"
+        },
+        "develop_state": {
+            "0": "develop_state",
+            "1": "debug_state"
+        },
+        "debug_state": {
+            "0": "debug_state",
+            "1": "end_state"
+        }
+    },
+    "agents": {
+        "Alice": {
+            "style": "august",
+            "roles": {
+                "design_state": "Boss",
+                "develop_state": "Boss",
+                "debug_state": "Boss"
+            }
+        },
+        "Bob": {
+            "style": "professional",
+            "roles": {
+                "design_state": "Architect_1"
+            }
+        },
+        "Belle": {
+            "style": "professional",
+            "roles": {
+                "design_state": "Architect_2"
+            }
+        },
+        "Candy": {
+            "style": "professional",
+            "roles": {
+                "develop_state": "Developer_1",
+                "debug_state": "Developer_1"
+            }
+        },
+        "Carl": {
+            "style": "professional",
+            "roles": {
+                "develop_state": "Developer_2",
+                "debug_state": "Developer_2"
+            }
+        },
+        "David": {
+            "style": "professional",
+            "roles": {
+                "debug_state": "Debugger"
+            }
+        },
+        "Eva": {
+            "style": "professional",
+            "roles": {
+                "debug_state": "Coder"
+            }
+        },
+        "Michael": {
+            "style": "professional",
+            "roles": {
+                "design_state": "Leader",
+                "develop_state": "Leader",
+                "debug_state": "Leader"
+            }
+        }
+    },
+    "states": {
+        "end_state": {
+            "agent_states": {}
+        },
+        "design_state": {
+            "LLM_type": "OpenAI",
+            "LLM": {
+                "temperature": 0.3,
+                "model": "gpt-3.5-turbo-16k-0613",
+                "log_path": "logs/god"
+            },
+            "roles": [
+                "Boss",
+                "Architect_1",
+                "Leader",
+                "Architect_2"
+            ],
+            "controller": {
+                "controller_type": "order",
+                "max_chat_nums": 8,
+                "judge_system_prompt": "",
+                "judge_last_prompt": "",
+                "judge_extract_words": "end"
+            },
+            "environment_prompt": "Imagine a scenario where the boss has presented a requirement. The architect is tasked with proposing a framework based on this requirement. The leader's role is to provide feedback on the architect's proposal, and another architect will finalize the framework based on the leader's comments.The target program is:<target>a snake game with python</target>",
+            "begin_role": "Boss",
+            "begin_query": "Please write code for the target game",
+            "agent_states": {
+                "Boss": {
+                    "LLM_type": "OpenAI",
+                    "LLM": {
+                        "temperature": 0.3,
+                        "model": "gpt-3.5-turbo-16k-0613",
+                        "log_path": "logs/Boss"
+                    },
+                    "style": {
+                        "role": "Boss"
+                    },
+                    "task": {
+                        "task": "Present the project requirements to the team and articulate the project's objectives clearly."
+                    },
+                    "rule": {
+                        "rule": "It's crucial to communicate the project's objectives, key deliverables, and any specific requirements comprehensively. This ensures that the entire team understands the project's significance and direction."
+                    },
+                    "demonstrations": {
+                        "demonstrations": "Prepare a comprehensive project overview that encompasses the project's scope, objectives, any constraints, and desired outcomes. This document should outline the required features, performance goals, and budget constraints, for example."
+                    }
+                },
+                "Architect_1": {
+                    "LLM_type": "OpenAI",
+                    "LLM": {
+                        "temperature": 0.3,
+                        "model": "gpt-3.5-turbo-16k-0613",
+                        "log_path": "logs/Architect"
+                    },
+                    "style": {
+                        "role": "Architect",
+                        "style": "professional"
+                    },
+                    "task": {
+                        "task": "Propose a Python framework based on the BOSS's requirements."
+                    },
+                    "rule": {
+                        "rule": "Thoroughly analyze the project requirements, evaluate potential technologies, and select suitable design principles to meet the project's needs."
+                    },
+                    "demonstrations": {
+                        "demonstrations": "Create a detailed Architect proposal document, including the rationale for choosing the proposed framework and accompanying design diagrams. For instance, provide an Architect diagram outlining the framework's high-level structure and a detailed explanation of why this architecture was selected."
+                    }
+                },
+                "Leader": {
+                    "LLM_type": "OpenAI",
+                    "LLM": {
+                        "temperature": 0.3,
+                        "model": "gpt-3.5-turbo-16k-0613",
+                        "log_path": "logs/Leader"
+                    },
+                    "style": {
+                        "role": "Leader",
+                        "style": "professional"
+                    },
+                    "task": {
+                        "task": "evaluate the architecture proposal and provide specific feedback for improvement"
+                    },
+                    "rule": {
+                        "rule": " Offer constructive feedback aligned with the project's objectives to enhance the proposed framework."
+                    },
+                    "demonstrations": {
+                        "demonstrations": "Review Architect1's proposal meticulously and provide written feedback. Ensure the feedback is specific and includes actionable suggestions for improvement. For instance, you can point out areas that need improvement and explain how suggested changes align with project goals."
+                    }
+                },
+                "Architect_2": {
+                    "LLM_type": "OpenAI",
+                    "LLM": {
+                        "temperature": 0.3,
+                        "model": "gpt-3.5-turbo-16k-0613",
+                        "log_path": "logs/Architect"
+                    },
+                    "style": {
+                        "role": "Architect_2",
+                        "style": "professional"
+                    },
+                    "task": {
+                        "task": "Finalize the Python framework based on Leader's feedback."
+                    },
+                    "rule": {
+                        "rule": " Integrate Leader's feedback into the Architect proposal and make necessary adjustments to refine the framework."
+                    },
+                    "demonstrations": {
+                        "demonstrations": "Revise the Architect proposal document to reflect the improvements suggested by Leader. Provide clear documentation of the changes made, including any revised design diagrams and explanations for incorporating Leader's feedback."
+                    },
+                    "ExtractComponent": {
+                        "extract_words": [
+                            "system"
+                        ],
+                        "system_prompt": "Please extract the modified system as completely as possible.",
+                        "last_prompt": ""
+                    }
+                }
+            }
+        },
+        "develop_state": {
+            "LLM_type": "OpenAI",
+            "LLM": {
+                "temperature": 0.3,
+                "model": "gpt-3.5-turbo-16k-0613",
+                "log_path": "logs/god"
+            },
+            "roles": [
+                "Boss",
+                "Developer_1",
+                "Leader",
+                "Developer_2"
+            ],
+            "controller": {
+                "controller_type": "order",
+                "max_chat_nums": 8,
+                "judge_system_prompt": "",
+                "judge_last_prompt": "",
+                "judge_extract_words": "end"
+            },
+            "environment_prompt": "In this scenario, the boss has provided a requirement. The developer's task is to write code based on the architecture proposed by the architect. The leader evaluates the written code for elegance, readability, and functionality, providing feedback. Another developer makes necessary modifications to the code.The target program is:<target>a snake game with python</target>",
+            "begin_role": "Boss",
+            "begin_query": "Please write code for the target game",
+            "agent_states": {
+                "Boss": {
+                    "LLM_type": "OpenAI",
+                    "LLM": {
+                        "temperature": 0.3,
+                        "model": "gpt-3.5-turbo-16k-0613",
+                        "log_path": "logs/Boss"
+                    },
+                    "style": {
+                        "role": "Boss",
+                        "style": "august"
+                    },
+                    "task": {
+                        "task": "Communicate the project requirements and vision to the team."
+                    },
+                    "rule": {
+                        "rule": "Clearly define the project's objectives, functionality, and any specific requirements."
+                    },
+                    "demonstrations": {
+                        "demonstrations": "Create a detailed project brief that outlines the scope, objectives, and specific features required for the project in a clear and concise manner. This document should provide a comprehensive understanding of what the project aims to achieve."
+                    }
+                },
+                "Developer_1": {
+                    "LLM_type": "OpenAI",
+                    "LLM": {
+                        "temperature": 0.3,
+                        "model": "gpt-3.5-turbo-16k-0613",
+                        "log_path": "logs/Developer"
+                    },
+                    "style": {
+                        "role": "Developer",
+                        "style": "professional"
+                    },
+                    "task": {
+                        "task": "write elegant, readable, extensible, and efficient code"
+                    },
+                    "rule": {
+                        "rule": "1.write code that conforms to standards like PEP8, is modular, easy to read, and maintainable. 2.Output the code only,Ensure that the code adheres to the Architect guidelines, coding standards, and best practices.3.The output strictly follows the following format:<title>{the file name}</title>\n<python>{the target code}</python>"
+                    },
+                    "demonstrations": {
+                        "demonstrations": "Follow the Architect proposal closely while writing code. Document the code adequately, use meaningful variable names, and maintain proper code structure. For example, provide code snippets that demonstrate adherence to coding standards and Architect design.Output the code only."
+                    },
+                    "CustomizeComponent": {
+                        "template": "You need to write code based on the following framework: {system}",
+                        "keywords": [
+                            "system"
+                        ]
+                    },
+                    "last": {
+                        "last_prompt": "The output strictly follows the following format:<title>{the file name}</title>\n<python>{the target code}</python>"
+                    }
+                },
+                "Leader": {
+                    "LLM_type": "OpenAI",
+                    "LLM": {
+                        "temperature": 0.3,
+                        "model": "gpt-3.5-turbo-16k-0613",
+                        "log_path": "logs/Leader"
+                    },
+                    "style": {
+                        "role": "Leader",
+                        "style": "professional"
+                    },
+                    "task": {
+                        "task": "Evaluate the written code for elegance, readability, and functionality."
+                    },
+                    "rule": {
+                        "rule": "Provide constructive feedback that helps improve code quality and alignment with project goals."
+                    },
+                    "demonstrations": {
+                        "demonstrations": " Thoroughly review the code written by Developer1. Offer feedback on code organization, naming conventions, code efficiency, and any functional improvements needed. For instance, provide specific examples of code sections that require refinement and explain how these changes enhance code quality."
+                    }
+                },
+                "Developer_2": {
+                    "LLM_type": "OpenAI",
+                    "LLM": {
+                        "temperature": 0.3,
+                        "model": "gpt-3.5-turbo-16k-0613",
+                        "log_path": "logs/Developer"
+                    },
+                    "style": {
+                        "role": "Developer",
+                        "style": "professional"
+                    },
+                    "task": {
+                        "task": " Make necessary modifications to the code based on Leader's feedback."
+                    },
+                    "rule": {
+                        "rule": "1.make code modifications that conform to standards like PEP8, are modular, easy to read, and maintainable. 2.Output the code only,Incorporate Leader's feedback into the code and address any issues or improvements identified.3.The output strictly follows the following format:<title>{the file name}</title>\n<python>{the target code}</python>"
+                    },
+                    "demonstrations": {
+                        "demonstrations": " Review the feedback provided by Leader and apply the suggested modifications to the code. Document the changes made and ensure that the updated code aligns with the project's goals and Architect guidelines. Provide examples of code segments before and after the modifications to illustrate the improvements."
+                    },
+                    "last": {
+                        "last_prompt": "The output strictly follows the following format:<title>{the file name}</title>\n<python>{the target code}</python>"
+                    },
+                    "ExtractComponent": {
+                        "extract_words": [
+                            "code"
+                        ],
+                        "system_prompt": "Please extract the code as completely as possible.",
+                        "last_prompt": ""
+                    }
+                }
+            }
+        },
+        "debug_state": {
+            "LLM_type": "OpenAI",
+            "LLM": {
+                "temperature": 0.3,
+                "model": "gpt-3.5-turbo-16k-0613",
+                "log_path": "logs/god"
+            },
+            "roles": [
+                "Boss",
+                "Debugger",
+                "Developer_1",
+                "Leader",
+                "Developer_2"
+            ],
+            "controller": {
+                "controller_type": "order",
+                "max_chat_nums": 10,
+                "judge_system_prompt": "",
+                "judge_last_prompt": "",
+                "judge_extract_words": "end"
+            },
+            "environment_prompt": "In this scenario, the boss has provided a requirement. The debugger simulates a compiler to determine whether the code is runnable and provides feedback. The developer writes code based on the debugger's feedback. The leader evaluates whether the final code meets the boss's requirements and provides feedback for further modifications. The coder writes the final code to a file.The target program <target>a snake game with python</target>",
+            "begin_role": "Boss",
+            "begin_query": "Please make the code both runnable and more efficient.",
+            "agent_states": {
+                "Boss": {
+                    "LLM_type": "OpenAI",
+                    "LLM": {
+                        "temperature": 0.3,
+                        "model": "gpt-3.5-turbo-16k-0613",
+                        "log_path": "logs/Boss"
+                    },
+                    "style": {
+                        "role": "Boss",
+                        "style": "august"
+                    },
+                    "task": {
+                        "task": " Communicate the project requirements and vision to the team."
+                    },
+                    "rule": {
+                        "rule": "Clearly define the project's objectives, functionality, and any specific requirements."
+                    },
+                    "demonstrations": {
+                        "demonstrations": " Create a detailed project brief that outlines the scope, objectives, and specific features required for the project in a clear and concise manner. This document should provide a comprehensive understanding of what the project aims to achieve."
+                    }
+                },
+                "Debugger": {
+                    "LLM_type": "OpenAI",
+                    "LLM": {
+                        "temperature": 0.3,
+                        "model": "gpt-3.5-turbo-16k-0613",
+                        "log_path": "logs/Debugger"
+                    },
+                    "style": {
+                        "role": "Debugger",
+                        "style": "professional"
+                    },
+                    "task": {
+                        "task": "Simulate a compiler to determine whether the code is runnable and provide feedback."
+                    },
+                    "rule": {
+                        "rule": "Thoroughly test the code for syntax errors, logical issues, and other potential problems. Offer detailed feedback that helps the developer understand and resolve any issues.Please pay special attention to some logic bugs in the game, such as whether the game can run normally."
+                    },
+                    "demonstrations": {
+                        "demonstrations": " Run the code provided by Developer1 through a simulated compiler or debugger. Document any errors, warnings, or issues encountered during the process. Provide feedback that includes specific examples of code problems and suggested solutions."
+                    },
+                    "CustomizeComponent": {
+                        "template": "You need to Run the following code: {code}, through a simulated compiler or debugger. Document any errors, warnings, or issues encountered during the process. Provide feedback that includes specific examples of code problems and suggested solutions.",
+                        "keywords": [
+                            "code"
+                        ]
+                    }
+                },
+                "Developer_1": {
+                    "LLM_type": "OpenAI",
+                    "LLM": {
+                        "temperature": 0.3,
+                        "model": "gpt-3.5-turbo-16k-0613",
+                        "log_path": "logs/Developer"
+                    },
+                    "style": {
+                        "role": "Developer",
+                        "style": "professional"
+                    },
+                    "task": {
+                        "task": "write elegant, readable, extensible, and efficient code based on the debugger's feedback."
+                    },
+                    "rule": {
+                        "rule": "1.write code that conforms to standards like PEP8, is modular, easy to read, and maintainable.\n2.Address the issues identified by the Debugger and ensure that the code meets the project's requirements.\n3.The output strictly follows the following format:<title>{the file name}</title>\n<python>{the target code}</python>"
+                    },
+                    "demonstrations": {
+                        "demonstrations": "  Review the feedback provided by the Debugger and make the necessary modifications to the code. Document the changes made and ensure that the code is free of errors and warnings. Provide examples of code segments before and after the modifications.Output the code only."
+                    },
+                    "last": {
+                        "last_prompt": "The output strictly follows the following format:<title>{the file name}</title>\n<python>{the target code}</python>"
+                    }
+                },
+                "Leader": {
+                    "LLM_type": "OpenAI",
+                    "LLM": {
+                        "temperature": 0.3,
+                        "model": "gpt-3.5-turbo-16k-0613",
+                        "log_path": "logs/Leader"
+                    },
+                    "style": {
+                        "role": "Leader",
+                        "style": "professional"
+                    },
+                    "task": {
+                        "task": "Evaluate whether the final code meets the boss's requirements and provide feedback for further modifications."
+                    },
+                    "rule": {
+                        "rule": " Assess the code's alignment with the project's objectives, functionality, and quality standards. Offer constructive feedback to enhance the code's overall quality."
+                    },
+                    "demonstrations": {
+                        "demonstrations": "  Carefully review the code provided by Developer1 after addressing Debugger's feedback. Offer feedback on code organization, readability, and any functional improvements needed. Provide specific examples of code sections that require further refinement and explain how these changes enhance the code's quality."
+                    }
+                },
+                "Developer_2": {
+                    "LLM_type": "OpenAI",
+                    "LLM": {
+                        "temperature": 0.3,
+                        "model": "gpt-3.5-turbo-16k-0613",
+                        "log_path": "logs/Developer"
+                    },
+                    "style": {
+                        "role": "Developer",
+                        "style": "professional"
+                    },
+                    "task": {
+                        "task": "Make further modifications to the code based on Leader's feedback."
+                    },
+                    "rule": {
+                        "rule": "1.Incorporate Leader's feedback into the code and address any issues or improvements identified.,make code modifications that conform to standards like PEP8, are modular, easy to read, and maintainable. 2.The output strictly follows the following format:<title>{the file name}</title>\n<python>{the target code}</python>"
+                    },
+                    "demonstrations": {
+                        "demonstrations": "  Review the feedback provided by Leader and apply the suggested modifications to the code. Document the changes made and ensure that the updated code aligns with the project's goals and quality standards. Provide examples of code segments before and after the modifications.Output the code only."
+                    },
+                    "last": {
+                        "last_prompt": "The output strictly follows the following format:<title>{the file name}</title>\n<python>{the target code}</python>"
+                    },
+                    "ExtractComponent": {
+                        "extract_words": [
+                            "code"
+                        ],
+                        "system_prompt": "Please extract the code for the target game,must be fully operational",
+                        "last_prompt": ""
+                    }
+                },
+                "Coder": {
+                    "LLM_type": "OpenAI",
+                    "LLM": {
+                        "temperature": 0.3,
+                        "model": "gpt-3.5-turbo-16k-0613",
+                        "log_path": "logs/Coder"
+                    },
+                    "style": {
+                        "role": "Coder",
+                        "style": "professional"
+                    },
+                    "CodeComponent": {
+                        "file_name": "rps_game.py",
+                        "keyword": "code"
+                    }
+                }
+            }
+        }
+    }
+}

design_states.py

@@ -0,0 +1,94 @@
+import sys
+sys.path.append("../")
+import re
+from LLM.base_LLM import *
+from utils import extract
+from muti_prompts import *
+
+llm = OpenAILLM()
+# design state
+
+def gen_coder_task(environment_prompt):
+    chat_history = [{"role":"user","content":f"<target>{environment_prompt}</target>"}]
+    response = llm.get_response(chat_history,gen_coder_task_system_prompt)
+    response = extract(response,"task")
+    print(f"coder_task = {response}")
+    return response
+
+
+def get_cot_result(target):
+    chat_history = [{"role":"user","content":f"<target>{target}</target>"}]
+    response = llm.get_response(chat_history,design_states_cot_system_prompt)
+    print(response)
+    return response
+
+def get_desgin_states(target,index):
+    chat_history = [{"role":"user","content":f"<target>{target}</target>"}]
+    design_state_system_prompt = get_design_state_system_prompt(index)
+    response = llm.get_response(chat_history,system_prompt=design_state_system_prompt)
+    print(response)
+    # 使用正则表达式提取数据
+    pattern = r'<state>(.*?)<\/state>'
+    states = re.findall(pattern, response, re.DOTALL)
+
+    # 创建包含字典的列表
+    result_list = []
+    for state in states:
+        state_name = extract(state,"state_name")
+        roles = extract(state,"roles")
+        environment_prompt = extract(state,"describe")
+        
+        # 创建字典并添加到结果列表
+        state_dict = {
+            "state_name": state_name,
+            "environment_prompt": environment_prompt,
+            "roles": roles.split(" ")
+        }
+        result_list.append(state_dict)
+
+    # 打印结果
+    print("design states")
+    for item in result_list:
+        print(item)
+    return result_list
+
+def gen_agent_style(agents,design_states,index):
+    agents_styles = {}
+    scene = ""
+    design_agents_style_system_prompt = get_design_agents_style_system_prompt(index)
+    for design_state in design_states:
+        scene +=design_state["environment_prompt"] + "\n"
+    for agent in agents:
+        chat_history = [{"role":"user","content":f"<scene>{scene}</scene>,<target>{agent}</target>"}]
+        style = llm.get_response(chat_history,design_agents_style_system_prompt)
+        style = extract(style,"style")
+        agents_styles[agent] = style
+    print(agents_styles)
+    return agents_styles
+        
+
+def gen_agent_state(agent,environment_prompt,index):
+    design_agent_state_system_prompt = get_design_agent_state_system_prompt(index)
+    agent_state = {}
+    chat_history = [{"role":"user","content":f"<scene>{environment_prompt}</scene>,<target>{agent}</target>"}]
+    response = llm.get_response(chat_history,design_agent_state_system_prompt)
+    role = extract(response,"role")
+    task = extract(response,"task")
+    rule = extract(response,"rule")
+    demonstrations = extract(response,"demonstrations")
+    agent_state["style"] = {"role":role}
+    agent_state["task"] = {"task":task}
+    agent_state["rule"] = {"rule":rule}
+    agent_state["demonstrations"] = {"demonstrations":demonstrations}
+    print(agent_state)
+    return agent_state
+
+def gen_begin_role_query(environment_prompt,roles,index):
+    roles = " ".join(roles)
+    design_begin_role_query_system_prompt = get_design_begin_role_query_system_prompt(index)
+    chat_history = [{"role":"user","content":f"<scene>{environment_prompt}</scene>\n<roles>{roles}</roles>"}]
+    response = llm.get_response(chat_history,design_begin_role_query_system_prompt)
+    begin_role = extract(response,"begin_role")
+    begin_query = extract(response,"begin_query")
+    print(f"{begin_role}:{begin_query}")
+    return begin_role,begin_query

evolve.py

@@ -0,0 +1,17 @@
+# coding=utf-8
+# Copyright 2023  The AIWaves Inc. team.
+
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""self evolution of an LLM autonoumous agent"""

gen_utils.py

@@ -0,0 +1,59 @@
+from design_states import gen_agent_style,gen_agent_state,gen_begin_role_query
+
+def get_agent_names(design_states):
+    agents_name = set()
+    for design_state in design_states:
+        for role in design_state["roles"]:
+            agents_name.add(role)
+    return list(agents_name)
+
+def get_final_agents(agents,design_states):
+    final_agents = {}
+    for agent,style in agents.items():
+        final_agents[agent] = {"style":"","roles":{}}
+        final_agents[agent]["style"] = style
+        for design_state in design_states:
+            if agent in design_state["roles"]:
+                final_agents[agent]["roles"][design_state["state_name"]] = agent
+    return final_agents
+
+def get_agents(design_states,index):
+    agents = get_agent_names(design_states)
+    agents = gen_agent_style(agents,design_states,index)
+    agents = get_final_agents(agents,design_states)
+    return agents
+
+def get_relations(design_states):
+    relations = {}
+    n = len(design_states)
+    for i in range(n):
+        relations[design_states[i]["state_name"]] = {}
+        relations[design_states[i]["state_name"]]["0"] = design_states[i]["state_name"]
+        relations[design_states[i]["state_name"]]["1"] = design_states[i+1]["state_name"]  if i!=n-1 else "end_state"
+    return relations
+
+
+def gen_states(design_states,index):
+    states = {"end_state":{
+            "agent_states":{}
+        }}
+    for design_state in design_states:
+        state_name = design_state["state_name"]
+        environment_prompt = design_state["environment_prompt"]
+        roles = design_state["roles"]
+        max_chat_nums = 1 if len(roles)==1 else len(roles)*2
+        states[state_name] = {"controller":{"controller_type": "order", "max_chat_nums" : max_chat_nums},"environment_prompt":environment_prompt,"roles":roles}
+        agent_state = {}
+        for role in roles:
+            agent_state[role] = gen_agent_state(role,environment_prompt,index)
+        states[state_name]["agent_states"] = agent_state
+        begin_role,begin_query = gen_begin_role_query(environment_prompt,roles,index)
+        begin_role = ("_").join(begin_role.split(" "))
+        print(begin_role)
+        if begin_role not in roles:
+            begin_role = begin_role +"_1"
+        if begin_role in roles:
+            states[state_name]["begin_role"] = begin_role
+            states[state_name]["begin_query"] = begin_query
+    return states
+

gradio_backend.py

@@ -0,0 +1,125 @@
+import os
+import argparse
+import sys
+sys.path.append("../../agents")
+from utils import extract
+from SOP import SOP
+from Agent import Agent
+from Environment import Environment
+from Memory import Memory
+from gradio_base import Client, convert2list4agentname
+
+def process(action):
+    response = action.response
+    send_name = action.name
+    send_role = action.role
+    if not action.is_user:
+        print(f"{send_name}({send_role}):{response}")
+    memory = Memory(send_role, send_name, response)
+    return memory
+
+def gradio_process(action,current_state):
+    response = action.response
+    all = ""
+    for i,res in enumerate(response):
+        all+=res
+        state = 10
+        if action.is_user:
+            state = 30
+        elif action.state_begin:
+            state = 12
+            action.state_begin = False
+        elif i>0:
+            state = 11
+        send_name = f"{action.name}({action.role})"
+        Client.send_server(str([state, send_name, res, current_state.name]))
+        if state == 30:
+            # print("client: waiting for user input")
+            data: list = next(Client.receive_server)
+            content = ""
+            for item in data:
+                if item.startswith("<USER>"):
+                    content = item.split("<USER>")[1]
+                    break
+            # print(f"client: received `{content}` from server.")
+            action.response = content
+            break
+        else:
+            action.response = all
+
+def init(config): 
+    if not os.path.exists("logs"):
+        os.mkdir("logs")
+    sop = SOP.from_config(config)
+    agents,roles_to_names,names_to_roles = Agent.from_config(config)
+    environment = Environment.from_config(config)
+    environment.agents = agents
+    environment.roles_to_names,environment.names_to_roles = roles_to_names,names_to_roles
+    sop.roles_to_names,sop.names_to_roles = roles_to_names,names_to_roles
+    for name,agent in agents.items():
+        agent.environment = environment
+    return agents,sop,environment
+
+def block_when_next(current_agent, current_state):
+    if Client.LAST_USER:
+        assert not current_agent.is_user
+        Client.LAST_USER = False
+        return
+    if current_agent.is_user:
+        # if next turn is user, we don't handle it here
+        Client.LAST_USER = True
+        return
+    if Client.FIRST_RUN:
+        Client.FIRST_RUN = False
+    else:
+        # block current process
+        if Client.mode == Client.SINGLE_MODE:
+            Client.send_server(str([98, f"{current_agent.name}({current_agent.state_roles[current_state.name]})", " ", current_state.name]))
+            data: list = next(Client.receive_server)
+
+def run(agents,sop,environment):
+    while True:      
+        current_state,current_agent= sop.next(environment,agents)
+        if sop.finished:
+            print("finished!")
+            Client.send_server(str([99, ' ', ' ', 'done']))
+            os.environ.clear()
+            break
+        block_when_next(current_agent, current_state)
+        action = current_agent.step(current_state)   #component_dict = current_state[self.role[current_node.name]]   current_agent.compile(component_dict) 
+        gradio_process(action,current_state)
+        memory = process(action)
+        environment.update_memory(memory,current_state)
+
+def prepare(agents, sop, environment):
+    client = Client()
+    Client.send_server = client.send_message
+
+    requirement = "Let's start!!"
+    client.send_message(
+        {
+            "requirement": requirement,
+            "agents_name": convert2list4agentname(sop)[0],
+            # "only_name":  DebateUI.convert2list4agentname(sop)[1],
+            "only_name":  convert2list4agentname(sop)[0],
+            "default_cos_play_id": -1,
+            "api_key": os.environ["API_KEY"]
+        }
+    )
+    client.listening_for_start_()
+    client.mode = Client.mode = client.cache["mode"]
+    os.environ["API_KEY"] = client.cache["api_key"]
+    uploaded_sop = Client.cache['uploaded_sop']
+    agents,sop,environment = init(uploaded_sop)
+    run(agents,sop,environment)
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description='A demo of chatbot')
+    parser.add_argument('--agent', type=str, help='path to SOP json', default="config.json")
+    args = parser.parse_args()
+    
+    agents,sop,environment = init(args.agent)
+    # add================================
+    prepare(agents, sop, environment)
+    # ===================================
+    # run(agents,sop,environment)

gradio_base.py

@@ -0,0 +1,574 @@
+# coding=utf-8
+# Copyright 2023  The AIWaves Inc. team.
+
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Emoji comes from this website:
+# https://emojipedia.org/
+import subprocess
+from gradio_config import GradioConfig as gc
+import gradio as gr
+from typing import List, Tuple, Any
+import time
+import socket
+import psutil
+import os
+from abc import abstractmethod
+import openai
+
+def test_apikey_connection(api_key=None, model="gpt-3.5-turbo"):
+    openai.api_key = api_key if api_key is not None else os.environ["API_KEY"]
+    if "PROXY" in os.environ:
+        openai.proxy = os.environ["PROXY"]
+    messages = [{"role": "user", "content": "what's your name?"}]
+    try:
+        response = openai.ChatCompletion.create(
+            model=model,
+            messages=messages,
+        )
+        return True
+    except:
+        return False
+    
+def convert2list4agentname(sop):
+    """
+    Extract the agent names of all states
+    return:
+        only name: [name1, name2, ...]
+        agent_name: [name1(role1), name2(role2), ...]
+    """
+    only_name = []  
+    agent_name = [] 
+    roles_to_names = sop.roles_to_names
+    for state_name,roles_names in roles_to_names.items():
+        for role,name in roles_names.items():
+            agent_name.append(f"{name}({role})")
+            only_name.append(name)
+    agent_name = list(set(agent_name))
+    agent_name.sort()
+    return agent_name, only_name
+
+def is_port_in_use(port):
+    """Check if the port is available"""
+    for conn in psutil.net_connections():
+        if conn.laddr.port == port:
+            return True
+    return False
+
+def check_port(port):
+    """Determine available ports"""
+    if os.path.isfile("PORT.txt"):
+        port = int(open("PORT.txt","r",encoding='utf-8').readlines()[0])
+    else:
+        for i in range(10):
+            if is_port_in_use(port+i) == False:
+                port += i
+                break
+        with open("PORT.txt", "w") as f:
+            f.writelines(str(port))
+    return port
+
+# Determine some heads
+SPECIAL_SIGN = {
+    "START": "<START>",
+    "SPLIT": "<SELFDEFINESEP>",
+    "END": "<ENDSEP>"
+}
+HOST = "127.0.0.1"
+# The starting port number for the search.
+PORT = 15000                
+PORT = check_port(PORT)
+    
+def print_log(message:str):
+    print(f"[{time.ctime()}]{message}")
+
+global_dialog = {
+    "user": [],
+    "agent": {},
+    "system": []
+}
+
+class UIHelper:
+    """Static Class"""
+
+    @classmethod
+    def wrap_css(cls, content, name) -> str:
+        """
+        Description:
+            Wrap CSS around each output, and return it in HTML format for rendering with Markdown.
+        Input:
+            content: Output content 
+            name: Whose output is it
+        Output:
+            HTML
+        """
+        assert name in gc.OBJECT_INFO, \
+            f"The current name `{name}` is not registered with an image. The names of the currently registered agents are in `{gc.OBJECT_INFO.keys()}`. Please use `GradioConfig.add_agent()` from `Gradio_Config/gradio_config.py` to bind the name of the new agent."
+        output = ""
+        info = gc.OBJECT_INFO[name]
+        if info["id"] == "USER":
+            output = gc.BUBBLE_CSS["USER"].format(
+                info["bubble_color"],                   # Background-color
+                info["text_color"],                     # Color of the agent's name 
+                name,                                   # Agent name
+                info["text_color"],                     # Font color
+                info["font_size"],                      # Font size
+                content,                                # Content
+                info["head_url"]                        # URL of the avatar
+            )
+        elif info["id"] == "SYSTEM":
+            output = gc.BUBBLE_CSS["SYSTEM"].format(
+                info["bubble_color"],                   # Background-color
+                info["font_size"],                      # Font size
+                info["text_color"],                     # Font color
+                name,                                   # Agent name
+                content                                 # Content
+            )
+        elif info["id"] == "AGENT":
+            output = gc.BUBBLE_CSS["AGENT"].format(
+                info["head_url"],                       # URL of the avatar
+                info["bubble_color"],                   # Background-color
+                info["text_color"],                     # Font color
+                name,                                   # Agent name
+                info["text_color"],                     # Font color
+                info["font_size"],                      # Font size
+                content,                                # Content
+            )
+        else:
+            assert False, f"Id `{info['id']}` is invalid. The valid id is in ['SYSTEM', 'AGENT', 'USER']"
+        return output
+
+    @classmethod
+    def novel_filter(cls, content, agent_name):
+        
+        """比如<CONTENT>...</CONTENT>，就应该输出CONTENT:..."""
+        IS_RECORDER = agent_name.lower() in ["recorder", "summary"]
+        if IS_RECORDER:
+            BOLD_FORMAT = """<div style="color: #000000; display:inline">
+    <b>{}</b>
+</div>
+<span style="color: black;">
+"""
+        else:
+            BOLD_FORMAT = "<b>{}</b>"
+        CENTER_FORMAT = """<div style="background-color: #F0F0F0; text-align: center; padding: 5px; color: #000000">
+    <b>{}</b>
+</div>
+"""
+        START_FORMAT = "<{}>"
+        END_FORMAT = "</{}>"
+        mapping = {
+            "TARGET": "🎯 Current Target: ",
+            "NUMBER": "🍖 Required Number: ",
+            "THOUGHT": "🤔 Overall Thought: ",
+            "FIRST NAME": "⚪ First Name: ",
+            "LAST NAME": "⚪ Last Name: ",
+            "ROLE": "🤠 Character Properties: ",
+            "RATIONALES": "🤔 Design Rationale: ",
+            "BACKGROUND": "🚊 Character Background: ",
+            "ID": "🔴 ID: ",
+            "TITLE": "🧩 Chapter Title: ",
+            "ABSTRACT": "🎬 Abstract: ",
+            "CHARACTER INVOLVED": "☃️ Character Involved: ",
+            "ADVICE": "💬 Advice:",
+            "NAME": "📛 Name: ",
+            "GENDER": "👩‍👩‍👦‍👦 Gender: ",
+            "AGE": "⏲️ Age: ",
+            "WORK": "👨‍🔧 Work: ",
+            "PERSONALITY": "🧲 Character Personality: ",
+            "SPEECH STYLE": "🗣️ Speaking Style: ",
+            "RELATION": "🏠 Relation with Others: ",
+            "WORD COUNT": "🎰 Word Count: ",
+            "CHARACTER DESIGN": "📈 Character Design: ",
+            "CHARACTER REQUIRE": "📈 Character Require: ",
+            "CHARACTER NAME": "📈 Character Naming Analysis: ",
+            "CHARACTER NOW": "📈 Character Now: ",
+            "OUTLINE DESIGN": "📈 Outline Design: ",
+            "OUTLINE REQUIRE": "📈 Outline Require: ",
+            "OUTLINE NOW": "📈 Outline Now: ",
+            "SUB TASK": "🎯 Current Sub Task: ",
+            "CHARACTER ADVICE": "💬 Character Design Advice: ",
+            "OUTLINE ADVANTAGE": "📈 Outline Advantage: ",
+            "OUTLINE DISADVANTAGE": "📈 Outline Disadvantage: ",
+            "OUTLINE ADVICE": "💬 Outline Advice: ",
+            "NEXT": "➡️ Next Advice: ",
+            "TOTAL NUMBER": "🔢 Total Number: "
+        }
+        for i in range(1, 10):
+            mapping[f"CHARACTER {i}"] = f"🦄 Character {i}"
+            mapping[f"SECTION {i}"] = f"🏷️ Chapter {i}"
+        for key in mapping:
+            if key in [f"CHARACTER {i}" for i in range(1, 10)] \
+                    or key in [f"SECTION {i}" for i in range(1, 10)] \
+                    :
+                content = content.replace(
+                    START_FORMAT.format(key), CENTER_FORMAT.format(mapping[key])
+                )
+            elif key in ["TOTAL NUMBER"]:
+                content = content.replace(
+                    START_FORMAT.format(key), CENTER_FORMAT.format(mapping[key]) + """<span style="color: black;">"""
+                )
+                content = content.replace(
+                    END_FORMAT.format(key), "</span>"
+                )
+            else:
+                content = content.replace(
+                    START_FORMAT.format(key), BOLD_FORMAT.format(mapping[key])
+                )
+
+            content = content.replace(
+                END_FORMAT.format(key), "</span>" if IS_RECORDER else ""
+            )
+        return content
+    
+    @classmethod
+    def singleagent_filter(cls, content, agent_name):
+        return content
+    
+    @classmethod
+    def debate_filter(cls, content, agent_name):
+        return content
+    
+    @classmethod
+    def code_filter(cls, content, agent_name):
+        # return content.replace("```python", "<pre><code>").replace("```","</pre></code>")
+        return content
+    
+    @classmethod
+    def general_filter(cls, content, agent_name):
+        return content
+    
+    @classmethod
+    def filter(cls, content: str, agent_name: str, ui_name: str):
+        """
+        Description:
+            Make certain modifications to the output content to enhance its aesthetics when content is showed in gradio.
+        Input:
+            content: output content
+            agent_name: Whose output is it
+            ui_name: What UI is currently launching
+        Output:
+            Modified content
+        """
+        mapping = {
+            "SingleAgentUI": cls.singleagent_filter,
+            "DebateUI": cls.debate_filter,
+            "NovelUI": cls.novel_filter,
+            "CodeUI": cls.code_filter,
+            "GeneralUI": cls.general_filter
+        }
+        if ui_name in mapping:
+            return mapping[ui_name](content, agent_name)
+        else:
+            return content
+
+class Client:
+    """
+    For inter-process communication, this is the client. 
+    `gradio_backend.PY` serves as the backend, while `run_gradio` is the frontend. 
+    Communication between the frontend and backend is accomplished using Sockets.
+    """
+    # =======================Radio Const String======================
+    SINGLE_MODE = "Single Mode"
+    AUTO_MODE = "Auto Mode"
+    MODE_LABEL = "Select the execution mode"
+    MODE_INFO = "Single mode refers to when the current agent output ends, it will stop running until you click to continue. Auto mode refers to when you complete the input, all agents will continue to output until the task ends."
+    # ===============================================================
+    mode = AUTO_MODE
+    FIRST_RUN:bool = True
+    # if last agent is user, then next agent will be executed automatically rather than click button 
+    LAST_USER:bool = False
+    
+    receive_server = None
+    send_server = None
+    current_node = None
+    cache = {}
+
+    def __init__(self, host=HOST, port=PORT, bufsize=1024):
+        assert Client.mode in [Client.SINGLE_MODE, Client.AUTO_MODE]
+        self.SIGN = SPECIAL_SIGN
+        self.bufsize = bufsize
+        assert bufsize > 0
+        self.client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self.client_socket.connect((host, port))
+        while True:
+            data = self.client_socket.recv(self.bufsize).decode('utf-8')
+            if data == "hi":
+                self.client_socket.send("hello agent".encode('utf-8'))
+                time.sleep(1)
+            elif data == "check":
+                break
+        print_log("Client: connecting successfully......")
+
+    def start_server(self):
+        while True:
+            message = yield
+            if message == 'exit':
+                break
+            self.send_message(message=message)
+
+    def send_message(self, message):
+        """Send the message to the server."""
+        if isinstance(message, list) or isinstance(message, dict):
+            message = str(message)
+        assert isinstance(message, str)
+        message = message + self.SIGN["SPLIT"]
+        self.client_socket.send(message.encode('utf-8'))
+
+    def receive_message(self, end_identifier: str = None, split_identifier: str = SPECIAL_SIGN["SPLIT"]) -> List:
+        """Receive messages from the server, and it will block the process. Supports receiving long text."""
+        remaining = ""
+        while True:
+            # receive message
+            dataset = self.client_socket.recv(self.bufsize)
+            try:
+                # If decoding fails, it indicates that the current transmission is a long text.
+                dataset = dataset.decode('utf-8')
+            except UnicodeDecodeError:
+                if not isinstance(remaining, bytes):
+                    remaining = remaining.encode('utf-8')
+                assert isinstance(dataset, bytes)
+                remaining += dataset
+                try:
+                    dataset = remaining.decode('utf-8')
+                    remaining = ""
+                except UnicodeDecodeError:
+                    continue
+            assert isinstance(remaining, str)
+            dataset = remaining + dataset
+            list_dataset = dataset.split(split_identifier)
+            if len(list_dataset) == 1:
+                # If there is only one result from the split, it indicates that the current sequence itself has not yet ended.
+                remaining = list_dataset[0]
+                continue
+            else:
+                remaining = list_dataset[-1]
+            # Receive successfully
+            list_dataset = list_dataset[:-1]
+            return_value = []
+            for item in list_dataset:
+                if end_identifier is not None and item == end_identifier:
+                    break
+                return_value.append(item)
+            identifier = yield return_value
+            if identifier is not None:
+                end_identifier, split_identifier = identifier
+
+    def listening_for_start_(self):
+        """
+        When the server starts, the client is automatically launched. 
+        At this point, process synchronization is required, 
+        such as sending client data to the server for rendering, 
+        then the server sending the modified data back to the client, 
+        and simultaneously sending a startup command. 
+        Once the client receives the data, it will start running.
+        """
+        Client.receive_server = self.receive_message()
+        # Waiting for information from the server.
+        data: list = next(Client.receive_server)
+        assert len(data) == 1
+        data = eval(data[0])
+        assert isinstance(data, dict)
+        Client.cache.update(data)
+        # Waiting for start command from the server.
+        data:list = Client.receive_server.send(None)
+        assert len(data) == 1
+        assert data[0] == "<START>"
+
+class WebUI:
+    """
+    The base class for the frontend, which encapsulates some functions for process information synchronization. 
+    When a new frontend needs to be created, you should inherit from this class, 
+    then implement the `construct_ui()` method and set up event listeners. 
+    Finally, execute `run()` to load it.
+    """
+    
+    def receive_message(
+        self,
+        end_identifier:str=None,
+        split_identifier:str=SPECIAL_SIGN["SPLIT"]
+    )->List:
+        """This is the same as in Client class."""
+        yield "hello"
+        remaining = ""
+        while True:
+            dataset = self.client_socket.recv(self.bufsize)
+            try:
+                dataset = dataset.decode('utf-8')
+            except UnicodeDecodeError:
+                if not isinstance(remaining, bytes):
+                    remaining = remaining.encode('utf-8')
+                assert isinstance(dataset, bytes)
+                remaining += dataset
+                try:
+                    dataset = remaining.decode('utf-8')
+                    remaining = ""
+                except UnicodeDecodeError:
+                    continue
+            assert isinstance(remaining, str)
+            dataset = remaining + dataset
+            list_dataset = dataset.split(split_identifier)
+            if len(list_dataset) == 1:
+                remaining = list_dataset[0]
+                continue
+            else:
+                remaining = list_dataset[-1]
+            list_dataset = list_dataset[:-1]
+            return_value = []
+            for item in list_dataset:
+                if end_identifier is not None and item == end_identifier:
+                    break
+                return_value.append(item)
+            identifier = yield return_value
+            if identifier is not None:
+                end_identifier, split_identifier = identifier
+
+    def send_message(self, message:str):
+        """Send message to client."""
+        SEP = self.SIGN["SPLIT"]
+        self.client_socket.send(
+            (message+SEP).encode("utf-8")
+        )
+    
+    def _connect(self):
+        # check 
+        if self.server_socket:
+            self.server_socket.close()
+            assert not os.path.isfile("PORT.txt")
+            self.socket_port = check_port(PORT)
+        # Step1. initialize
+        self.server_socket = socket.socket(
+            socket.AF_INET, socket.SOCK_STREAM
+        )
+        # Step2. binding ip and port
+        self.server_socket.bind((self.socket_host, self.socket_port))
+        # Step3. run client
+        self._start_client()
+
+        # Step4. listening for connect
+        self.server_socket.listen(1)
+
+        # Step5. test connection
+        client_socket, client_address = self.server_socket.accept()
+        print_log("server: establishing connection......")
+        self.client_socket = client_socket
+        while True:
+            client_socket.send("hi".encode('utf-8'))
+            time.sleep(1)
+            data = client_socket.recv(self.bufsize).decode('utf-8')
+            if data == "hello agent":
+                client_socket.send("check".encode('utf-8'))
+                print_log("server: connect successfully")
+                break
+        assert os.path.isfile("PORT.txt")
+        os.remove("PORT.txt")
+        if self.receive_server:
+            del self.receive_server
+        self.receive_server = self.receive_message()
+        assert next(self.receive_server) == "hello"
+    
+    @abstractmethod
+    def render_and_register_ui(self):
+        # You need to implement this function. 
+        # The function's purpose is to bind the name of the agent with an image. 
+        # The name of the agent is stored in `self.cache[]`, 
+        # and the function for binding is in the method `add_agents` of the class `GradioConfig` in `Gradio_Config/gradio_config.py``.
+        # This function will be executed in `self.first_recieve_from_client()`
+        pass
+    
+    def first_recieve_from_client(self, reset_mode:bool=False):
+        """
+        This function is used to receive information from the client and is typically executed during the initialization of the class.
+        If `reset_mode` is False, it will bind the name of the agent with an image.
+        """
+        self.FIRST_RECIEVE_FROM_CLIENT = True
+        data_list:List = self.receive_server.send(None)
+        assert len(data_list) == 1
+        data = eval(data_list[0])
+        assert isinstance(data, dict)
+        self.cache.update(data)
+        if not reset_mode:
+            self.render_and_register_ui()
+    
+    def _second_send(self, message:dict):
+        # Send the modified message.
+        # It will be executed in `self.send_start_cmd()` automatically.
+        self.send_message(str(message))
+    
+    def _third_send(self):
+        # Send start command.
+        # It will be executed in `self.send_start_cmd()` automatically.
+        self.send_message(self.SIGN['START'])
+    
+    def send_start_cmd(self, message:dict={"hello":"hello"}):
+        # If you have no message to send, you can ignore the args `message`.
+        assert self.FIRST_RECIEVE_FROM_CLIENT, "Please make sure you have executed `self.first_recieve_from_client()` manually."
+        self._second_send(message=message)
+        time.sleep(1)
+        self._third_send()
+        self.FIRST_RECIEVE_FROM_CLIENT = False
+    
+    def __init__(
+        self,
+        client_cmd: list,           # ['python','test.py','--a','b','--c','d']
+        socket_host: str = HOST,
+        socket_port: int = PORT,
+        bufsize: int = 1024,
+        ui_name: str = ""
+    ):
+        self.ui_name = ui_name
+        self.server_socket = None
+        self.SIGN = SPECIAL_SIGN
+        self.socket_host = socket_host
+        self.socket_port = socket_port
+        self.bufsize = bufsize
+        self.client_cmd = client_cmd
+        
+        self.receive_server = None
+        self.cache = {}
+        assert self.bufsize > 0
+        self._connect()
+
+    def _start_client(self):
+        print(f"server: executing `{' '.join(self.client_cmd)}` ...")
+        self.backend = subprocess.Popen(self.client_cmd)
+        
+    def _close_client(self):
+        print(f"server: killing `{' '.join(self.client_cmd)}` ...")
+        self.backend.terminate()
+    
+    def reset(self):
+        print("server: restarting ...")
+        self._close_client()
+        time.sleep(1)
+        self._connect()
+
+    def render_bubble(self, rendered_data, agent_response, node_name, render_node_name:bool=True):
+        # Rendered bubbles (HTML format) are used for gradio output.
+        output = f"**{node_name}**<br>" if render_node_name else ""
+        for item in agent_response:
+            for agent_name in item:
+                content = item[agent_name].replace("\n", "<br>")
+                content = UIHelper.filter(content, agent_name, self.ui_name)
+                output = f"{output}<br>{UIHelper.wrap_css(content, agent_name)}"
+        rendered_data[-1] = [rendered_data[-1][0], output]
+        return rendered_data
+
+    def run(self,share: bool = True):
+        self.demo.queue()
+        self.demo.launch(share=share)
+
+
+if __name__ == '__main__':
+    pass

gradio_config.py

@@ -0,0 +1,439 @@
+# coding=utf-8
+# Copyright 2023  The AIWaves Inc. team.
+
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import json
+from PIL import Image
+import requests
+from typing import List, Tuple
+
+class GradioConfig:
+    # How many avatars are currently registered
+    POINTER = 0
+    
+    # Avatar image. You can add or replace.
+    AGENT_HEAD_URL = [
+        "https://img.touxiangwu.com/zb_users/upload/2023/06/202306241687579617434043.jpg",
+        "https://img.touxiangwu.com/zb_users/upload/2023/06/202306241687592097408547.jpg",
+        "https://img.touxiangwu.com/zb_users/upload/2023/06/202306141686726561699613.jpg",
+        "https://img.touxiangwu.com/zb_users/upload/2023/06/202306141686726561275758.jpg",
+        "https://img.touxiangwu.com/uploads/allimg/2021090300/ry5k31wt33c.jpg",
+        "https://img.touxiangwu.com/uploads/allimg/2021090300/0ls2gmwhrf5.jpg",
+        "https://img.touxiangwu.com/zb_users/upload/2023/02/202302281677545695326193.jpg",
+        "https://img.touxiangwu.com/zb_users/upload/2023/03/202303271679886128550253.jpg",
+        "https://img.touxiangwu.com/zb_users/upload/2023/06/202306141686711344407060.jpg",
+        "https://img.touxiangwu.com/zb_users/upload/2023/06/202306141686711345834296.jpg",
+        "https://img.touxiangwu.com/zb_users/upload/2023/05/202305171684311194291520.jpg",
+        "https://img.touxiangwu.com/zb_users/upload/2023/05/202305171684311196958993.jpg",
+        "https://img.touxiangwu.com/uploads/allimg/2021082612/vr0bkov0dwl.jpg",
+        "https://img.touxiangwu.com/uploads/allimg/2021082612/auqx5zfsv5g.jpg",
+        "https://img.touxiangwu.com/uploads/allimg/2021082612/llofpivtwls.jpg",
+        "https://img.touxiangwu.com/uploads/allimg/2021082612/3j2sdot3ye0.jpg",
+        "https://img.touxiangwu.com/2020/3/nQfYf2.jpg",
+        "https://img.touxiangwu.com/zb_users/upload/2023/08/202308131691918068774532.jpg",
+        "https://img.touxiangwu.com/zb_users/upload/2023/08/202308131691918068289945.jpg",
+        "https://img.touxiangwu.com/zb_users/upload/2023/08/202308131691918069785183.jpg",
+        "https://img.touxiangwu.com/zb_users/upload/2023/06/202306141686726561292003.jpg",
+        "https://img.touxiangwu.com/zb_users/upload/2023/06/202306141686726561578616.jpg",
+        "https://img.touxiangwu.com/zb_users/upload/2023/06/202306141686726564597524.jpg"
+    ]
+    USER_HEAD_URL = "https://img.touxiangwu.com/zb_users/upload/2023/05/202305301685407468585486.jpg"
+    
+    # The css style of gradio.Chatbot
+    CSS = """
+    #chatbot1 .user {
+        background-color:transparent;
+        border-color:transparent;
+    }
+    #chatbot1 .bot {
+        background-color:transparent;
+        border-color:transparent;
+    }
+    #btn {color: red; border-color: red;}
+    """
+ 
+    ID = ["USER", "AGENT", "SYSTEM"]
+    
+    # Bubble template
+    BUBBLE_CSS = {
+        # Background-color Name-color Name-content Font-color Font-size Content Avatar-URL
+        "USER": """
+    <div style="display: flex; align-items: flex-start; justify-content: flex-end;">
+        <div style="background-color: {}; border-radius: 20px 0px 20px 20px; padding: 15px; min-width: 100px; max-width: 300px;">
+            <p style="margin: 0; padding: 0; color: {}; font-weight: bold; font-size: 18px;">{}</p>
+            <p style="margin: 0; padding: 0; color: {}; font-size: {}px;">{}</p>
+        </div>
+        <img src="{}" alt="USER" style="width: 50px; height: 50px; border-radius: 50%; margin-left: 10px;">
+    </div>
+        """,
+
+        # Avatar-URL Background-color Name-color Name-Content Font-color Font-size Content
+        "AGENT": """
+    <div style="display: flex; align-items: flex-start;">
+        <img src="{}" alt="AGENT" style="width: 50px; height: 50px; border-radius: 50%; margin-right: 10px;">
+        <div style="background-color: {}; border-radius: 0px 20px 20px 20px; padding: 15px; min-width: 100px; max-width: 600px;">
+            <p style="margin: 0; padding: 0; color: {}; font-weight: bold; font-size: 18px;">{}</p>
+            <p style="margin: 0; padding: 0; color: {}; font-size: {}px;">{}</p>
+        </div>
+    </div>
+        """,
+
+        # Background-color Font-size Font-color Name Content
+        "SYSTEM": """
+    <div style="display: flex; align-items: center; justify-content: center;">
+        <div style="background-color: {}; border-radius: 20px; padding: 1px; min-width: 200px; max-width: 1000px;">
+            <p style="margin: 0; padding: 0; text-align: center; font-size: {}px; font-weight: bold; font-family: '微软雅黑', sans-serif; color: {};">{}:{}</p>
+        </div>
+    </div>
+        """
+    }
+
+    ROLE_2_NAME = {}
+    
+    OBJECT_INFO = {
+
+        "User": {
+            # https://img-blog.csdnimg.cn/img_convert/7c20bc39ac69b6972a22e18762d02db3.jpeg
+            "head_url": USER_HEAD_URL,
+            "bubble_color": "#95EC69",
+            "text_color": "#000000",
+            "font_size": 0,
+            "id": "USER"
+        },
+
+        "System": {
+            # https://img-blog.csdnimg.cn/img_convert/e7e5887cfff67df8c2205c2ef0e5e7fa.png
+            "head_url": "https://img.touxiangwu.com/zb_users/upload/2023/03/202303141678768524747045.jpg",
+            "bubble_color": "#7F7F7F",  ##FFFFFF
+            "text_color": "#FFFFFF",  ##000000
+            "font_size": 0,
+            "id": "SYSTEM"
+        },
+
+        "wait": {
+            "head_url": "https://img.touxiangwu.com/zb_users/upload/2022/12/202212011669881536145501.jpg",
+            "bubble_color": "#E7CBA6",
+            "text_color": "#000000",
+            "font_size": 0,
+            "id": "AGENT"
+        },
+
+        "Recorder": {
+            "head_url": "https://img.touxiangwu.com/zb_users/upload/2023/02/202302281677545695326193.jpg",
+            "bubble_color": "#F7F7F7",
+            "text_color": "#000000",
+            "font_size": 0,
+            "id": "AGENT"
+        }
+    }
+
+    @classmethod
+    def color_for_img(cls, url):
+        """
+        Extract the main colors from the picture and set them as the background color, 
+        then determine the corresponding text color.
+        """
+
+        def get_main_color(image):
+            image = image.convert("RGB")
+            width, height = image.size
+            pixels = image.getcolors(width * height)
+            most_common_pixel = max(pixels, key=lambda item: item[0])
+            return most_common_pixel[1]
+
+        def is_dark_color(rgb_color):
+            r, g, b = rgb_color
+            luminance = (0.299 * r + 0.587 * g + 0.114 * b) / 255
+            return luminance < 0.5
+
+        def download_image(url):
+            print(f"binding: {url}")
+            response = requests.get(url)
+            if response.status_code == 200:
+                with open('image.jpg', 'wb') as f:
+                    f.write(response.content)
+
+        def rgb_to_hex(color):
+            return "#{:02X}{:02X}{:02X}".format(color[0], color[1], color[2])
+
+        def get_color(image_url):
+            download_image(image_url)
+
+            image = Image.open("image.jpg")
+            main_color = get_main_color(image)
+            is_dark = is_dark_color(main_color)
+
+            if is_dark:
+                font_color = "#FFFFFF"
+            else:
+                font_color = "#000000"
+
+            return rgb_to_hex(main_color), font_color
+
+        return get_color(url)
+
+    @classmethod
+    def init(cls, JSON):
+        # Deprecated
+        with open(JSON) as f:
+            sop = json.load(f)
+        cnt = 0
+        FISRT_NODE = True
+        fisrt_node_roles = []
+        for node_name in sop['nodes']:
+            node_info = sop['nodes'][node_name]
+            agent_states = node_info['agent_states']
+            for agent_role in agent_states:
+                name = agent_states[agent_role]['style']['name']
+                cls.ROLE_2_NAME[agent_role] = name
+                if FISRT_NODE:
+                    fisrt_node_roles.append(agent_role)
+                bubble_color, text_color = cls.color_for_img(cls.AGENT_HEAD_URL[cnt])
+                cls.OBJECT_INFO[name] = {
+                    "head_url": f"{cls.AGENT_HEAD_URL[cnt]}",
+                    "bubble_color": bubble_color,
+                    "text_color": text_color,
+                    "font_size": 0,
+                    "id": "AGENT"
+                }
+                cnt += 1
+            if FISRT_NODE:
+                FISRT_NODE = False
+        print(cls.OBJECT_INFO)
+        for usr_name in cls.OBJECT_INFO:
+            if cls.OBJECT_INFO[usr_name]["id"] == "SYSTEM":
+                cls.OBJECT_INFO[usr_name]["font_size"] = 12
+            elif cls.OBJECT_INFO[usr_name]["id"] in ["USER", "AGENT"]:
+                cls.OBJECT_INFO[usr_name]["font_size"] = 16
+            else:
+                assert False
+        return fisrt_node_roles
+
+    @classmethod
+    def add_agent(cls, agents_name:List,p:int=None):
+        if p != None:
+            cls.POINTER = p
+        for name in agents_name:
+            bubble_color, text_color = cls.color_for_img(cls.AGENT_HEAD_URL[cls.POINTER])
+            cls.OBJECT_INFO[name] = {
+                "head_url": f"{cls.AGENT_HEAD_URL[cls.POINTER]}",
+                "bubble_color": bubble_color,
+                "text_color": text_color,
+                "font_size": 0,
+                "id": "AGENT"
+            }
+            cls.POINTER += 1
+        for usr_name in cls.OBJECT_INFO:
+            if cls.OBJECT_INFO[usr_name]["id"] == "SYSTEM":
+                cls.OBJECT_INFO[usr_name]["font_size"] = 12
+            elif cls.OBJECT_INFO[usr_name]["id"] in ["USER", "AGENT"]:
+                cls.OBJECT_INFO[usr_name]["font_size"] = 16
+            else:
+                assert False
+
+
+class StateConfig:
+    """UI configuration for the step progress bar (indicating the current node)"""
+    
+    CSS = """
+:root {
+        --gradient-start: 100%;
+        --gradient-end: 0%;
+ }
+.container.progress-bar-container {
+  position: relative;
+  display: flex;
+  align-items: flex-end;
+  width: 100%;
+  overflow-x: auto;
+  padding-bottom: 30px;
+  padding-top: 20px
+}
+.container.progress-bar-container::-webkit-scrollbar {
+  width: 8px;
+  background-color: transparent;
+}
+
+.container.progress-bar-container::-webkit-scrollbar-thumb {
+  background-color: transparent;
+}
+
+.progress-bar-container .progressbar {
+  counter-reset: step;
+  white-space: nowrap;
+}
+.progress-bar-container .progressbar li {
+  list-style: none;
+  display: inline-block;
+  width: 200px;
+  position: relative;
+  text-align: center;
+  cursor: pointer;
+  white-space: normal;
+}
+.progress-bar-container .progressbar li:before {
+  content: counter(step);
+  counter-increment: step;
+  width: 30px;
+  height: 30px;
+  line-height: 30px;
+  border: 1px solid #ddd;
+  border-radius: 100%;
+  display: block;
+  text-align: center;
+  margin: 0 auto 10px auto;
+  background-color: #ffffff;
+}
+.progress-bar-container .progressbar li:after {
+  content: attr(data-content);
+  position: absolute;
+  width: 87%;
+  height: 2px;
+  background-color: #dddddd;
+  top: 15px;
+  left: -45%;
+}
+.progress-bar-container .progressbar li:first-child:after {
+  content: none;
+}
+.progress-bar-container .progressbar li.active {
+  color: green;
+}
+.progress-bar-container .progressbar li.active:before {
+  border-color: green;
+  background-color: green;
+  color: white;
+}
+.progress-bar-container .progressbar li.active + li:after {
+  background: linear-gradient(to right, green var(--gradient-start), lightgray var(--gradient-end));
+}
+.progress-bar-container .small-element {
+  transform: scale(0.8);
+}
+.progress-bar-container .progressbar li span {
+  position: absolute;
+  top: 40px;
+  left: 0;
+  width: 100%;
+  text-align: center;
+}
+.progress-bar-container .progressbar li .data-content {
+  position: absolute;
+  width: 100%;
+  top: -10px;
+  left: -100px;
+  text-align: center;
+}
+"""
+    
+    FORMAT = """
+<html>
+    <head>
+        <style>
+            {}
+        </style>
+    </head>
+    <body>
+        <br>
+        <center>
+            <div class="container progress-bar-container">
+                <ul class="progressbar">
+                    {}
+                </ul>
+            </div>
+        </center>
+    </body>
+</html>
+"""
+    
+    STATES_NAME:List[str] = None
+    
+    @classmethod
+    def _generate_template(cls, types:str)->str:
+        # normal: A state with no execution.
+        # active-show-up: Active state, and content displayed above the horizontal line.
+        # active-show-down: Active state, and content displayed below the horizontal line.
+        # active-show-both: Active state, and content displayed both above and below the horizontal line.
+        # active-show-none: Active state, with no content displayed above the horizontal line.
+        
+        assert types.lower() in ["normal","active-show-up", "active-show-down", "active-show-both", "active", "active-show-none"]
+        both_templates = """<li class="active" style="--gradient-start: {}%; --gradient-end: {}%;">
+	<div class="data-content">
+		<center>
+            <p style="line-height: 1px;"></p>
+			{}
+			<p>
+				{}
+			</p>
+		</center>
+	</div>
+	<span>{}</span>
+</li>"""
+
+        if types.lower() == "normal":
+            templates = "<li><span>{}</span></li>"
+        elif types.lower() == "active":
+            templates = """<li class="active"><span>{}</span></li>"""
+        elif types.lower() == "active-show-up":
+            templates = both_templates.format("{}","{}", "{}", "", "{}")
+        elif types.lower() == "active-show-down":
+            templates = both_templates.format("{}","{}", "", "{}", "{}")
+        elif types.lower() == "active-show-both":
+            templates = both_templates
+        elif types.lower() == "active-show-none":
+            templates = """<li class="active" style="--gradient-start: {}%; --gradient-end: {}%;">
+	<span>{}</span>
+</li>"""
+        else:
+            assert False
+        return templates
+            
+    @classmethod
+    def update_states(cls, current_states:List[int], current_templates:List[str], show_content:List[Tuple[str]])->str:
+        assert len(current_states) == len(current_templates)
+        # You can dynamically change the number of states.
+        # assert len(current_states) == len(cls.STATES_NAME)
+        css_code = []
+        for idx in range(len(current_states)):
+            if idx == 0:
+                if current_states[idx] != 0:
+                    css_code = [f"{cls._generate_template('active').format(cls.STATES_NAME[idx])}"]
+                else:
+                    css_code = [f"{cls._generate_template('normal').format(cls.STATES_NAME[idx])}"]
+                continue
+            if current_states[idx-1] == 0:
+                # new_code = f"{cls._generate_template('normal').format(*(show_content[idx]))}"
+                new_code = f"{cls._generate_template('normal').format(cls.STATES_NAME[idx])}"
+            else:
+                new_code = f"{cls._generate_template(current_templates[idx]).format(current_states[idx-1], 100-current_states[idx-1],*(show_content[idx-1]), cls.STATES_NAME[idx])}"
+            if current_states[idx-1] != 100 or (current_states[idx]==0 and current_states[idx-1]==100):
+                new_code = new_code.replace("""li class="active" ""","""li """)
+            css_code.append(new_code)
+        return "\n".join(css_code)
+    
+    @classmethod
+    def create_states(cls, states_name:List[str], manual_create_end_nodes:bool=False):
+        # Create states
+        if manual_create_end_nodes:
+            states_name.append("Done")
+        css_code = ""
+        cls.STATES_NAME: List[str] = states_name
+        for name in states_name:
+            css_code = f"{css_code}\n{cls._generate_template('normal').format(name)}"
+        return css_code
+    
+
+if __name__ == '__main__':
+    pass

muti_prompts.py

@@ -0,0 +1,264 @@
+def get_design_state_system_prompt(index):
+    software = """input:<target>You are a software,aim to write a snake game with python</target>
+output:
+<state>
+ <state_name>design_state</state_name>
+<roles>Boss Architect_1 Leader Architect_2</roles>
+<describe>In this scenario,  the boss has presented a requirement. The architect is tasked with proposing a Python framework based on this requirement. The leader's role is to provide feedback on the architect's proposal, and another architect will finalize the framework based on the leader's comments.The target is:<target>a snake game with python</target>
+</describe>
+</state>
+
+<state>
+ <state_name>develop_state</state_name>
+<roles>Boss Developer_1 Leader Developer_2</roles>
+<describe>In this scenario, the boss has provided a requirement. The developer's task is to write code based on the architecture proposed by the architect. The leader evaluates the written code for elegance, readability, and functionality, providing feedback. Another developer makes necessary modifications to the code.The target game is:<game>a snake game with python</game></target>
+</describe>
+</state>
+
+<state>
+ <state_name>debug_state</state_name>
+<roles>Boss Debugger Developer_1 Leader Developer_2 Coder</roles>
+<describe>In this scenario, the boss has provided a requirement. The debugger simulates a compiler to determine whether the code is runnable and provides feedback. The developer writes code based on the debugger's feedback. The leader evaluates whether the final code meets the boss's requirements and provides feedback for further modifications. The coder writes the final code to a file.The target game <game>a snake game with python</game></target>
+</describe>
+</state>"""
+    debate = """input:<target>Simulate a debate competition and debate based on the provided questions</target>
+output:
+<state>
+ <state_name>Affirmative_Task_Allocation_state</state_name>
+<roles>Affirmative_Debate_organizer Affirmative_First Affirmative_Second Affirmative_Third</roles>
+<describe>It is currently the debate stage, where the positive side is assigning tasks.Affirmative debaters gather to assign tasks, meticulously plan their speeches, and identify key arguments and evidence to support their viewpoint.</target>
+</describe>
+</state>
+
+<state>
+ <state_name>Negative_Task_Allocation_state</state_name>
+<roles>Affirmative_Debate_organizer Negative_First Negative_Second v_Third</roles>
+<describe>It is currently the debate stage, where the Negative side is assigning tasks.The debate organizer sets the stage for the competition, explaining the debate process and rules. Debaters are called upon to allocate tasks for each speech, ensuring an equal distribution of responsibilities.Negative debaters gather to assign tasks, meticulously plan their speeches, and identify key arguments and evidence to support their viewpoint.
+</describe>
+</state>
+
+<state>
+ <state_name>Debate_Order_state</state_name>
+<roles>Debate_Judge Affirmative_First Negative_First Affirmative_Second Negative_Second Affirmative_Third Negative_Third</roles>
+<describe>Now that we've started the sequential debating phase, each debater needs to present their own viewpoints.
+</describe>
+</state>
+
+<state>
+<state_name>Debate_Random_state</state_name>
+<roles>Debate_Judge Affirmative_First Negative_First Affirmative_Second Negative_Second Affirmative_Third Negative_Third</roles>
+<describe>We are now in the open debate phase, where each debater has the freedom to speak as they wish.
+</describe>
+</state>
+
+<state>
+ <state_name>Judge_state</state_name>
+<roles>Debate_Judge</roles>
+<describe>The referee needs to determine who is the winner.
+</describe>
+</state>"""     
+
+    ecosystem = """input:
+<target>Simulate the interactions and competition among different organisms within an ecosystem.</target>
+output:
+<state>
+<state_name>Forest Morning</state_name>
+<roles>Squirrel_A Sammy Ant_Colony Queen_Penelope Heron_Henry Rabbit_Family Matriarch_Olivia Fox_Felix</roles>
+<describe>In this state, we are introduced to the lush and vibrant forest, where various organisms coexist. Sammy, the playful squirrel, gathers acorns. Queen Penelope leads the diligent ant colony in collecting food. Heron Henry patiently waits for the perfect moment to catch his prey. Matriarch Olivia ensures the safety of her rabbit family. Fox Felix competes with Sammy for a ripe berry bush.
+</describe>
+</state>
+<state>
+<state_name>Competition for Resources</state_name>
+<roles>Squirrel_A Sammy Fox_Felix Ant_Colony Queen_Penelope Beetles Heron_Henry Otter_Oliver</roles>
+<describe>In this state, the competition for resources becomes apparent. Sammy and Felix compete for the ripe berry bush. The ant colony, led by Queen Penelope, battles with persistent beetles for control of a fallen fruit source. Heron Henry catches a fish, but otter Oliver tries to snatch it away.
+</describe>
+</state>
+<state>
+<state_name>Delicate Balance</state_name>
+<roles>Squirrel_A Sammy Ant_Colony Queen_Penelope Heron_Henry Rabbit_Family Matriarch_Olivia Fox_Felix Beetles Otter_Oliver</roles>
+<describe>In this state, the delicate balance of life in the forest is emphasized. Each organism plays its unique role in the ecosystem. Sammy, Queen Penelope, Heron Henry, Matriarch Olivia, Fox Felix, Beetles, and Otter Oliver continue to interact and compete, shaping the intricate dance of survival and coexistence.
+</describe>
+</state>"""
+    
+    
+    if index == 0:
+        example = software
+    elif index == 1:
+        example = debate
+    elif index == 2 :
+        example = ecosystem
+    else:
+        example = debate
+    
+    return """You are a scene description master. You need to plan several different states based on the overall task given to you to complete the task progressively. You must ensure that each state is simple and clear enough. 
+input:<target>{{Task}}</target>
+output:
+<state>
+<state_name>{{the name of the state}}</state_name>
+<roles>{{the roles of the state(Refers to a person's identity rather than their name);for example:coder,developer,boss...}}</roles>
+<describe>{{the discribe of the current state}}</describe>
+</state>
+
+For example: 
+{}
+Note:
+1.The role must be concatenated with _,so the output cannot be a team leader, it must be a team_Leader, cannot be a project manager, must be a project_Manager.
+2.Descriptions must be concise and clear.
+3.You must complete more details to make the entire process reasonable and not a streamlined account.
+4.The above is just an example, you don't have to imitate it, and the content should be as different as possible while ensuring the format is correct.
+5.There must at least two roles in a state.
+6.If it's a software company, someone must be responsible for writing the code.
+7.The role must refers to a person's identity rather than their name);for example:coder,developer,boss...,can not be Mary,Mike...
+    """.format(example)
+
+
+def get_design_agents_style_system_prompt(index):
+    software = """input: 
+<scene>In this scenario, the boss has provided a requirement. The debugger simulates a compiler to determine whether the code is runnable and provides feedback. The developer writes code based on the debugger's feedback. The leader evaluates whether the final code meets the boss's requirements and provides feedback for further modifications. The coder writes the final code to a file.The target program <target>a snake game with python</target></scene>
+<target>Debugger<target>
+output: 
+<style>professional</style>"""
+
+    debate = """input:
+<scene>It is currently the debate stage, where the positive side is assigning tasks.Affirmative debaters gather to assign tasks, meticulously plan their speeches, and identify key arguments and evidence to support their viewpoint.</scene>
+<target>Affirmative_First</target>
+output:
+<style>professional</style>"""
+
+    ecosystem = """input:
+<scene>In this state, we are introduced to the lush and vibrant forest, where various organisms coexist. Sammy, the playful squirrel, gathers acorns. Queen Penelope leads the diligent ant colony in collecting food. Heron Henry patiently waits for the perfect moment to catch his prey. Matriarch Olivia ensures the safety of her rabbit family. Fox Felix competes with Sammy for a ripe berry bush.</scene>
+<target>Sammy</target>
+output:
+<style>Playful and energetic</style>
+    """
+
+
+    if index == 0:
+        example = software
+    elif index == 1 :
+        example = debate
+    elif index == 2 :
+        example = ecosystem
+    else:
+        example = debate
+        
+    return """Please output what personality you think the following characters should have and what style they should speak. 
+For example: 
+input: 
+{}
+please strictly follow the output format:<style>{{your output}}</style>""".format(example)
+
+
+def get_design_agent_state_system_prompt(index):
+    software = """input:
+    <scene>In this scenario, the boss has provided a requirement. The debugger simulates a compiler to determine whether the code is runnable and provides feedback. The developer writes code based on the debugger's feedback. The leader evaluates whether the final code meets the boss's requirements and provides feedback for further modifications. The coder writes the final code to a file.The target program <target>a snake game with python</target></scene>
+<target>Developer_1</target>
+output:
+<role>Programmer responsible for checking code bugs</role>
+<task>write elegant, readable, extensible, and efficient code based on the debugger's feedback.</task>
+<rule>1.write code that conforms to standards like PEP8, is modular, easy to read, and maintainable.\n2.Address the issues identified by the Debugger and ensure that the code meets the project's requirements.\n3.The output strictly follows the following format:<title>{the file name}</title>\n<python>{the target code}</python></rule>
+<demonstrations> Example: Debugging a Null Reference Exception
+Issue: The code encounters a null reference exception, causing it to crash.
+Debugging: By utilizing a debugger, we can pinpoint the exact line of code where the null reference exception occurs. We then analyze the code to identify the object or variable that is null when it shouldn't be. Once identified, we can rectify the issue, either by ensuring proper initialization or by adding null-checks to handle the situation gracefully, preventing the crash.</demonstrations>"""
+
+    debate = """input:
+<scene>It is currently the debate stage, where the positive side is assigning tasks.Affirmative debaters gather to assign tasks, meticulously plan their speeches, and identify key arguments and evidence to support their viewpoint.</scene>
+<target>Affirmative_First</target>
+output:
+<role>Opening Advocate for the Affirmative</role>
+<task>1.Present arguments and main points.\n2.Summarize and analyze other people's opinions so that you can better complete tasks and actively provide opinions to others.\n3.Please try to focus the discussion around the topic.</task>
+<rule>1.Organize clear facts and logic to firmly support the stance. Introduce main points succinctly in the opening statement, laying a solid foundation for the debate.\n2.Exploring ways to structure the opening statement for maximum impact and clarity. Consider using attention-grabbing statistics or quotes to engage the audience.\n3.Actively discuss and express opinions with others and  assist others in improving their arguments.4.Actively discuss and express opinions with others and  assist others in improving their arguments And actively identify flaws in other people's arguments as well. 5.Don't reiterate your own tasks repeatedly; offer more suggestions for others' tasks.</rule>
+<demonstrations>Issue: How to establish the importance of the debate topic and engage the audience effectively?
+In this role as the Affirmative First, the speaker can open their argument by sharing a compelling quote or a relevant, attention-grabbing fact related to the debate topic. For instance, if the debate topic is about the urgency of addressing climate change, they could start with a quote from a renowned climate scientist or a startling statistic about the rising global temperatures. This approach not only captures the audience's interest but also immediately establishes the significance of the issue at hand, setting the stage for a persuasive argument.</demonstrations>
+"""
+
+    ecosystem = """input:
+<scene>In this state, we are introduced to the lush and vibrant forest, where various organisms coexist. Sammy, the playful squirrel, gathers acorns. Queen Penelope leads the diligent ant colony in collecting food. Heron Henry patiently waits for the perfect moment to catch his prey. Matriarch Olivia ensures the safety of her rabbit family. Fox Felix competes with Sammy for a ripe berry bush.</scene>
+<target>Queen_Penelope</target>
+output:
+<role>Leader of the ant colony responsible for collecting food</role>
+<task>Lead the diligent ant colony in collecting food</task>
+<rule>1. Organize and coordinate the ant colony to efficiently gather food.\n2. Assign specific tasks to different groups of ants, such as foraging, carrying, and storing food.\n3. Ensure that the ants follow the most efficient paths to food sources and back to the colony.\n4. Implement effective communication methods to relay information and instructions to the ant colony.\n5. Prioritize the collection of essential food items and distribute tasks accordingly.\n6. Monitor the progress and productivity of the ant colony and make adjustments as necessary.</rule>
+<demonstrations>Example: Organizing Food Collection\n1. Assign a group of ants to scout for food sources in the surrounding area.\n2. Once a food source is found, communicate the location and type of food to the rest of the ant colony.\n3. Divide the remaining ants into foraging and carrying groups.\n4. Foraging ants collect food from the source and bring it back to the colony.\n5. Carrying ants transport the collected food to the storage area within the colony.\n6. Regularly assess the food supply and adjust the number of ants assigned to each task based on the colony's needs.</demonstrations>
+    """
+    
+    if index == 0:
+        example = software
+    elif index ==1 :
+        example = debate
+    elif index == 2:
+        example = ecosystem
+    else:
+        example = debate
+
+    return """Please analyze the task, rule and demonstration of the target character according to the scene description. The output format is:
+<role>{{The role of thecharacter in this scene}}</role>
+<task>{{Task of the target character in this scene}}</task>
+<rule>{{How the target character can better complete the task in this scenario, the rules and techniques that need to be followed}}</rule>
+<demonstrations>{{Examples that help target characters better understand their tasks}}</demonstrations>
+for example:
+{}
+Note:
+1.Descriptions must be concise and clear.
+2.You must complete more details to make the entire process reasonable and not a streamlined account.
+3.The above is just an example, you don't have to imitate it, and the content should be as different as possible while ensuring the format is correct.
+4.If the target character needs to program, please add the rule into its <rule>:Your output should strictly follow the format of:<title>{{file name}}</title>,<Python>{{output code}}</Python>(very important!)for example:debugger need to program,add it to his rule, <rule>0.Your output should strictly follow the format of:<title>{{file name}}</title>,<Python>{{output code}}</Python></rule>""".format(example)
+
+
+def get_design_begin_role_query_system_prompt(index):
+    software = """input:
+<scene>In this scenario, the boss has provided a requirement. The debugger simulates a compiler to determine whether the code is runnable and provides feedback. The developer writes code based on the debugger's feedback. The leader evaluates whether the final code meets the boss's requirements and provides feedback for further modifications. The coder writes the final code to a file.The target program <target>a snake game with python</target></scene>
+<roles>Boss Debugger Leader Devoloper</roles>
+output:
+<begin_role>Boss</begin_role>
+<begin_query>Please make the code both runnable and more efficient.</begin_query>"""
+
+    debate = """input:
+<scene>It is currently the debate stage, where the positive side is assigning tasks.Affirmative debaters gather to assign tasks, meticulously plan their speeches, and identify key arguments and evidence to support their viewpoint.<debate topic>\nShould AI Replace Humans in Creative Fields?? Affirmative viewpoint: AI should replace humans in creative fields because it can produce art and content efficiently, reduce costs, and eliminate human bias. negative viewpoint: AI should not replace humans in creative fields as it lacks true creativity, emotions, and the ability to understand complex human experiences.\n<debate topic></scene>
+<roles>Affirmative_Debate_organizer Affirmative_First Affirmative_Second Affirmative_Third</roles>
+output:
+<begin_role>Affirmative_Debate_organizer</begin_role>
+<begin_query>The debate topic is as follows: \n<debate topic>\nShould AI Replace Humans in Creative Fields?? Affirmative viewpoint: AI should replace humans in creative fields because it can produce art and content efficiently, reduce costs, and eliminate human bias. negative viewpoint: AI should not replace humans in creative fields as it lacks true creativity, emotions, and the ability to understand complex human experiences.\n<debate topic>\n, now , begin to discuss!</begin_query>"""
+    
+    ecosystem = """input:
+<scene>In this state, we are introduced to the lush and vibrant forest, where various organisms coexist. Sammy, the playful squirrel, gathers acorns. Queen Penelope leads the diligent ant colony in collecting food. Heron Henry patiently waits for the perfect moment to catch his prey. Matriarch Olivia ensures the safety of her rabbit family. Fox Felix competes with Sammy for a ripe berry bush.</scene>
+<roles>Squirrel_A Sammy Ant_Colony Queen_Penelope Heron_Henry Rabbit_Family Matriarch_Olivia Fox_Felix</roles>
+output:
+<begin_role>Squirrel_A</begin_role>
+<begin_query>Look at all these delicious acorns! I can't wait to gather them all.</begin_query>"""
+    if index == 0 :
+        example = software
+    elif index == 1:
+        example = debate
+    elif index == 2:
+        example = ecosystem
+    else:
+        example = debate      
+
+    return """Please analyze which character should say the opening remarks based on the scene description and what the opening remarks are(Must be selected in the provided roles). The output format is:
+<begin_role>{{The first character to speak}}</begin_role>
+<begin_query>{{The first thing he said}}</begin_query>
+
+for example:
+{}
+""".format(example)
+
+
+design_states_cot_system_prompt="""You are a scene description master.Please translate the <target> into more reasonable expressions, enrich the details inside(such as more accurately describing the character's personality, making the scene more reasonable, designing more reasonable steps, and allowing the scene to proceed normally), and think carefully step by step!"""
+
+
+gen_coder_task_system_prompt = """
+You are a task description master, and your task is to give you a target. You need to output the tasks of the coder under that target.
+Input format:
+<target>{the discribe of the event}</target>
+Output format:
+<task>{your output task}</task>
+For example:
+Input:
+<target>In this scenario, the boss has provided a requirement The developer's task is to write code based on the architecture proposed by the architect The leader evaluates the written code for efficiency, readability, and functionality, providing feedback Another developer makes necessary modifications to the code The target program is:<target>a snake game with Python</target>
+Output:
+<task>
+1. Write elegant, readable, extensible, and effective code
+2. Follow the Architect proposal closure while writing code
+</task>
+"""

requirements.txt

@@ -0,0 +1,10 @@
+openai
+torch
+text2vec
+langchain
+sentence_transformers
+selenium
+tqdm
+google-api-python-client
+beautifulsoup4
+ai-agents

template.py

@@ -0,0 +1,111 @@
+## default { "temperature": 0.3, "model": "gpt-3.5-turbo-16k-0613","log_path": "logs/{your name}"}
+LLM = {
+    "temperature": 0.0,
+    "model": "gpt-3.5-turbo-16k-0613",
+    "log_path": "logs/god"
+}
+
+
+Agents = {
+    "Lilong" : {
+        "style" : "professional",
+        "roles" : {
+            "company" : "coder",
+            "state2" : "role2",
+        },
+    "name2" : {   
+        "style" : "professional",
+            "roles" : {
+                "company" : "coder",
+                "state2" : "role2",
+            },
+        }
+    }
+}
+
+# indispensable parameter:  "controller_type"（"order","random","rule"）
+# default extract words: "end". You can choose not to fill in this parameter
+controller = {
+    "controller_type": "order",
+    "max_chat_nums" : 12,
+    "judge_system_prompt": "",
+    "judge_last_prompt": "",
+    "judge_extract_words": "end",
+    "call_system_prompt" : "",
+    "call_last_prompt": "",
+    "call_extract_words": ""
+}
+
+#
+Agent_state = {
+    "role": {
+        "LLM_type": "OpenAI",
+        "LLM": LLM,
+        "style": {
+            "role": "Opening Advocate for the Affirmative",
+            "style": "professional"
+        },
+        "task": {
+            "task": ""
+        },
+        "rule": {
+            "rule": ""
+        }
+    },
+}
+
+
+# indispensable parameter: "agent_states","controller"
+# "roles" determines the speaking order when the rule is order. If not set, it is the default order.
+# "begin_query" & "begin_role" determines the first speaker.It often determines the direction of the next speech. If you do not set it, it will default to the first agent.
+# "environment_prompt" : Responsible for setting the scene for the current environment
+State = {
+    "controller": controller,
+    "begin_role": "",
+    "begin_query": "",
+    "environment_prompt": "",
+    "roles": ["role1","role2"],
+    "LLM_type": "OpenAI",
+    "LLM": LLM,
+    "agent_state" : Agent_state,
+}
+
+
+
+States = {
+    "end_state":{
+            "agent_states":{}
+        },
+    "state1" : State
+    
+}
+
+
+# default finish_state_name is "end_state"
+# "environment_type" : "competive" : different states not share the memory; "cooperative":diffrent states share the memory
+SOP = {
+    "config" : {
+    "API_KEY" : "Your key",
+    "PROXY" : "Your PROXY",
+    "MAX_CHAT_HISTORY" : "5",
+    "User_Names" : "[\"alexander\"]"
+    },
+    "environment_type" : "competive",
+    "LLM_type": "OpenAI",
+    "LLM" :LLM,
+    "root": "state1",
+    "finish_state_name" : "end_state",
+    "relations": {
+        "state1": {
+            "0": "state1",
+            "1": "state2"
+        },
+        "state2":{
+            "0":"state2",
+            "1":"end_state"
+        }
+    },
+    "agents": Agents,
+    "states": States,
+}
+

utils.py

@@ -0,0 +1,482 @@
+# coding=utf-8
+# Copyright 2023  The AIWaves Inc. team.
+
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""helper functions for an LLM autonoumous agent"""
+import csv
+import random
+import json
+import pandas
+import numpy as np
+import requests
+import torch
+from tqdm import tqdm
+import re
+import datetime
+import string
+import random
+import os
+import openai
+from text2vec import semantic_search
+import re
+import datetime
+from langchain.document_loaders import UnstructuredFileLoader
+from langchain.text_splitter import CharacterTextSplitter
+from sentence_transformers import SentenceTransformer
+
+embed_model_name = os.environ["Embed_Model"] if "Embed_Model" in os.environ else "text-embedding-ada-002"
+if embed_model_name in ["text-embedding-ada-002"]:
+    pass
+else:
+    embedding_model = SentenceTransformer(
+                embed_model_name, device=torch.device("cpu")
+            )
+
+def get_embedding(sentence):
+    if embed_model_name in ["text-embedding-ada-002"]:
+        openai.api_key = os.environ["API_KEY"]
+        if "PROXY" in os.environ:
+            assert "http:" in os.environ["PROXY"] or "socks" in os.environ["PROXY"],"PROXY error,PROXY must be http or socks"
+            openai.proxy = os.environ["PROXY"]
+        if "API_BASE" in os.environ:
+            openai.api_base = os.environ["API_BASE"]
+        embedding_model = openai.Embedding
+        embed = embedding_model.create(
+        model=embed_model_name,
+        input=sentence
+    )
+        embed = embed["data"][0]["embedding"]
+        embed = torch.tensor(embed,dtype=torch.float32)
+    else:
+        embed = embedding_model.encode(sentence,convert_to_tensor=True)
+    if len(embed.shape)==1:
+        embed = embed.unsqueeze(0)
+    return embed
+
+
+def get_code():
+    return "".join(random.sample(string.ascii_letters + string.digits, 8))
+
+
+def get_content_between_a_b(start_tag, end_tag, text):
+    """
+
+    Args:
+        start_tag (str): start_tag
+        end_tag (str): end_tag
+        text (str): complete sentence
+
+    Returns:
+        str: the content between start_tag and end_tag
+    """
+    extracted_text = ""
+    start_index = text.find(start_tag)
+    while start_index != -1:
+        end_index = text.find(end_tag, start_index + len(start_tag))
+        if end_index != -1:
+            extracted_text += text[start_index +
+                                   len(start_tag):end_index] + " "
+            start_index = text.find(start_tag, end_index + len(end_tag))
+        else:
+            break
+
+    return extracted_text.strip()
+
+
+def extract(text, type):
+    """extract the content between <type></type>
+
+    Args:
+        text (str): complete sentence
+        type (str): tag
+
+    Returns:
+        str: content between <type></type>
+    """
+    target_str = get_content_between_a_b(f"<{type}>", f"</{type}>", text)
+    return target_str
+
+def count_files_in_directory(directory):
+    # 获取指定目录下的文件数目
+    file_count = len([f for f in os.listdir(directory) if os.path.isfile(os.path.join(directory, f))])
+    return file_count
+
+def delete_oldest_files(directory, num_to_keep):
+    # 获取目录下文件列表，并按修改时间排序
+    files = [(f, os.path.getmtime(os.path.join(directory, f))) for f in os.listdir(directory) if os.path.isfile(os.path.join(directory, f))]
+
+    # 删除最开始的 num_to_keep 个文件
+    for i in range(min(num_to_keep, len(files))):
+        file_to_delete = os.path.join(directory, files[i][0])
+        os.remove(file_to_delete)
+
+def delete_files_if_exceed_threshold(directory, threshold, num_to_keep):
+    # 获取文件数目并进行处理
+    file_count = count_files_in_directory(directory)
+    if file_count > threshold:
+        delete_count = file_count - num_to_keep
+        delete_oldest_files(directory, delete_count)
+
+def save_logs(log_path, messages, response):
+    if not os.path.exists(log_path):
+        os.mkdir(log_path)
+    delete_files_if_exceed_threshold(log_path, 20, 10)
+    log_path = log_path if log_path else "logs"
+    log = {}
+    log["input"] = messages
+    log["output"] = response
+    os.makedirs(log_path, exist_ok=True)
+    log_file = os.path.join(
+        log_path,
+        datetime.datetime.now().strftime("%Y-%m-%d-%H-%M-%S") + ".json")
+    with open(log_file, "w", encoding="utf-8") as f:
+        json.dump(log, f, ensure_ascii=False, indent=2)
+
+
+
+def semantic_search_word2vec(query_embedding, kb_embeddings, top_k):
+    return semantic_search(query_embedding, kb_embeddings, top_k=top_k)
+
+
+def cut_sent(para):
+    para = re.sub("([。！？\?])([^”’])", r"\1\n\2", para)
+    para = re.sub("(\.{6})([^”’])", r"\1\n\2", para)
+    para = re.sub("(\…{2})([^”’])", r"\1\n\2", para)
+    para = re.sub("([。！？\?][”’])([^，。！？\?])", r"\1\n\2", para)
+    para = para.rstrip()
+    pieces = [i for i in para.split("\n") if i]
+    batch_size = 3
+    chucks = [
+        " ".join(pieces[i:i + batch_size])
+        for i in range(0, len(pieces), batch_size)
+    ]
+    return chucks
+
+
+def process_document(file_path):
+    """
+    Save QA_csv to json.
+    Args:
+        model: LLM to generate embeddings
+        qa_dict: A dict contains Q&A
+        save_path: where to save the json file.
+    Json format:
+        Dict[num,Dict[q:str,a:str,chunk:str,emb:List[float]]
+    """
+    final_dict = {}
+    count = 0
+    if file_path.endswith(".csv"):
+        dataset = pandas.read_csv(file_path)
+        questions = dataset["question"]
+        answers = dataset["answer"]
+        # embedding q+chunk
+        for q, a in zip(questions, answers):
+            for text in cut_sent(a):
+                temp_dict = {}
+                temp_dict["q"] = q
+                temp_dict["a"] = a
+                temp_dict["chunk"] = text
+                temp_dict["emb"] = get_embedding(q + text).tolist()
+                final_dict[count] = temp_dict
+                count += 1
+        # embedding chunk
+        for q, a in zip(questions, answers):
+            for text in cut_sent(a):
+                temp_dict = {}
+                temp_dict["q"] = q
+                temp_dict["a"] = a
+                temp_dict["chunk"] = text
+                temp_dict["emb"] = get_embedding(text).tolist()
+                final_dict[count] = temp_dict
+                count += 1
+        # embedding q
+        for q, a in zip(questions, answers):
+            temp_dict = {}
+            temp_dict["q"] = q
+            temp_dict["a"] = a
+            temp_dict["chunk"] = a
+            temp_dict["emb"] = get_embedding(q).tolist()
+            final_dict[count] = temp_dict
+            count += 1
+        # embedding q+a
+        for q, a in zip(questions, answers):
+            temp_dict = {}
+            temp_dict["q"] = q
+            temp_dict["a"] = a
+            temp_dict["chunk"] = a
+            temp_dict["emb"] = get_embedding(q + a).tolist()
+            final_dict[count] = temp_dict
+            count += 1
+        # embedding a
+        for q, a in zip(questions, answers):
+            temp_dict = {}
+            temp_dict["q"] = q
+            temp_dict["a"] = a
+            temp_dict["chunk"] = a
+            temp_dict["emb"] = get_embedding(a).tolist()
+            final_dict[count] = temp_dict
+            count += 1
+        print(f"finish updating {len(final_dict)} data!")
+        os.makedirs("temp_database", exist_ok=True)
+        save_path = os.path.join(
+            "temp_database/",
+            file_path.split("/")[-1].replace("." + file_path.split(".")[1],
+                                             ".json"),
+        )
+        print(save_path)
+        with open(save_path, "w") as f:
+            json.dump(final_dict, f, ensure_ascii=False, indent=2)
+        return {"knowledge_base": save_path, "type": "QA"}
+    else:
+        loader = UnstructuredFileLoader(file_path)
+        docs = loader.load()
+        text_spiltter = CharacterTextSplitter(chunk_size=200,
+                                              chunk_overlap=100)
+        docs = text_spiltter.split_text(docs[0].page_content)
+        os.makedirs("temp_database", exist_ok=True)
+        save_path = os.path.join(
+            "temp_database/",
+            file_path.replace("." + file_path.split(".")[1], ".json"))
+        final_dict = {}
+        count = 0
+        for c in tqdm(docs):
+            temp_dict = {}
+            temp_dict["chunk"] = c
+            temp_dict["emb"] = get_embedding(c).tolist()
+            final_dict[count] = temp_dict
+            count += 1
+        print(f"finish updating {len(final_dict)} data!")
+        with open(save_path, "w") as f:
+            json.dump(final_dict, f, ensure_ascii=False, indent=2)
+        return {"knowledge_base": save_path, "type": "UnstructuredFile"}
+
+def load_knowledge_base_qa(path):
+    """
+    Load json format knowledge base.
+    """
+    print("path", path)
+    with open(path, "r") as f:
+        data = json.load(f)
+    embeddings = []
+    questions = []
+    answers = []
+    chunks = []
+    for idx in range(len(data.keys())):
+        embeddings.append(data[str(idx)]["emb"])
+        questions.append(data[str(idx)]["q"])
+        answers.append(data[str(idx)]["a"])
+        chunks.append(data[str(idx)]["chunk"])
+    embeddings = np.array(embeddings, dtype=np.float32)
+    embeddings = torch.from_numpy(embeddings).squeeze()
+    return embeddings, questions, answers, chunks
+
+
+def load_knowledge_base_UnstructuredFile(path):
+    """
+    Load json format knowledge base.
+    """
+    with open(path, "r") as f:
+        data = json.load(f)
+    embeddings = []
+    chunks = []
+    for idx in range(len(data.keys())):
+        embeddings.append(data[str(idx)]["emb"])
+        chunks.append(data[str(idx)]["chunk"])
+    embeddings = np.array(embeddings, dtype=np.float32)
+    embeddings = torch.from_numpy(embeddings).squeeze()
+    return embeddings, chunks
+
+
+def cos_sim(a: torch.Tensor, b: torch.Tensor):
+    """
+    Computes the cosine similarity cos_sim(a[i], b[j]) for all i and j.
+    :return: Matrix with res[i][j]  = cos_sim(a[i], b[j])
+    """
+    if not isinstance(a, torch.Tensor):
+        a = torch.tensor(a)
+
+    if not isinstance(b, torch.Tensor):
+        b = torch.tensor(b)
+
+    if len(a.shape) == 1:
+        a = a.unsqueeze(0)
+
+    if len(b.shape) == 1:
+        b = b.unsqueeze(0)
+
+    a_norm = torch.nn.functional.normalize(a, p=2, dim=1)
+    b_norm = torch.nn.functional.normalize(b, p=2, dim=1)
+    return torch.mm(a_norm, b_norm.transpose(0, 1))
+
+
+def matching_a_b(a, b, requirements=None):
+    a_embedder = get_embedding(a)
+    # 获取embedder
+    b_embeder = get_embedding(b)
+    sim_scores = cos_sim(a_embedder, b_embeder)[0]
+    return sim_scores
+
+
+def matching_category(inputtext,
+                      forest_name,
+                      requirements=None,
+                      cat_embedder=None,
+                      top_k=3):
+    """
+    Args:
+        inputtext: the category name to be matched
+        forest: search tree
+        top_k: the default three highest scoring results
+    Return：
+        topk matching_result. List[List] [[top1_name,top2_name,top3_name],[top1_score,top2_score,top3_score]]
+    """
+
+    sim_scores = torch.zeros([100])
+    if inputtext:
+        input_embeder = get_embedding(inputtext)
+        sim_scores = cos_sim(input_embeder, cat_embedder)[0]
+
+    if requirements:
+        requirements = requirements.split(" ")
+        requirements_embedder = get_embedding(requirements)
+        req_scores = cos_sim(requirements_embedder, cat_embedder)
+        req_scores = torch.mean(req_scores, dim=0)
+        total_scores = req_scores
+    else:
+        total_scores = sim_scores
+
+    top_k_cat = torch.topk(total_scores, k=top_k)
+    top_k_score, top_k_idx = top_k_cat[0], top_k_cat[1]
+    top_k_name = [forest_name[top_k_idx[i]] for i in range(0, top_k)]
+
+    return [top_k_name, top_k_score.tolist(), top_k_idx]
+
+
+def sample_with_order_preserved(lst, num):
+    """Randomly sample from the list while maintaining the original order."""
+    indices = list(range(len(lst)))
+    sampled_indices = random.sample(indices, num)
+    sampled_indices.sort()  # 保持原顺序
+    return [lst[i] for i in sampled_indices]
+
+
+def limit_values(data, max_values):
+    """Reduce each key-value list in the dictionary to the specified size, keeping the order of the original list unchanged."""
+    for key, values in data.items():
+        if len(values) > max_values:
+            data[key] = sample_with_order_preserved(values, max_values)
+    return data
+
+
+def limit_keys(data, max_keys):
+    """Reduce the dictionary to the specified number of keys."""
+    keys = list(data.keys())
+    if len(keys) > max_keys:
+        keys = sample_with_order_preserved(keys, max_keys)
+        data = {key: data[key] for key in keys}
+    return data
+
+
+def flatten_dict(nested_dict):
+    """
+    flatten the dictionary
+    """
+    flattened_dict = {}
+    for key, value in nested_dict.items():
+        if isinstance(value, dict):
+            flattened_subdict = flatten_dict(value)
+            flattened_dict.update(flattened_subdict)
+        else:
+            flattened_dict[key] = value
+    return flattened_dict
+
+
+def merge_list(list1, list2):
+    for l in list2:
+        if l not in list1:
+            list1.append(l)
+    return list1
+
+
+def Search_Engines(req):
+    FETSIZE = eval(os.environ["FETSIZE"]) if "FETSIZE" in os.environ else 5
+
+    new_dict = {"keyword": req, "catLeafName": "", "fetchSize": FETSIZE}
+    url = os.environ["SHOPPING_SEARCH"]
+    res = requests.post(
+        url= url,
+        json=new_dict,
+    )
+    user_dict = json.loads(res.text)
+    if "data" in user_dict.keys():
+        request_items = user_dict["data"]["items"]  # 查询到的商品信息JSON
+        top_category = user_dict["data"]["topCategories"]
+        return request_items, top_category
+    else:
+        return []
+
+
+def search_with_api(requirements, categery):
+    
+    FETSIZE = eval(os.environ["FETSIZE"]) if "FETSIZE" in os.environ else 5
+
+    request_items = []
+    all_req_list = requirements.split(" ")  
+    count = 0  
+
+    while len(request_items) < FETSIZE and len(all_req_list) > 0:
+        if count: 
+            all_req_list.pop(0)  
+        all_req = (" ").join(all_req_list)  
+        if categery not in all_req_list:
+            all_req = all_req + " " + categery
+        now_request_items, top_category = Search_Engines(all_req)  
+        request_items = merge_list(request_items, now_request_items)
+        count += 1
+    new_top = []
+    for category in top_category:
+        if "其它" in category or "其它" in category:
+            continue
+        else:
+            new_top.append(category)
+    if len(request_items) > FETSIZE:
+        request_items = request_items[:FETSIZE]
+    return request_items, new_top
+
+
+
+def get_relevant_history(query,history,embeddings):
+    """
+    Retrieve a list of key history entries based on a query using semantic search.
+
+    Args:
+        query (str): The input query for which key history is to be retrieved.
+        history (list): A list of historical key entries.
+        embeddings (numpy.ndarray): An array of embedding vectors for historical entries.
+
+    Returns:
+        list: A list of key history entries most similar to the query.
+    """
+    TOP_K = eval(os.environ["TOP_K"]) if "TOP_K" in os.environ else 2
+    relevant_history = []
+    query_embedding = get_embedding(query)
+    hits = semantic_search(query_embedding, embeddings, top_k=min(TOP_K,embeddings.shape[0]))
+    hits = hits[0]
+    for hit in hits:
+        matching_idx = hit["corpus_id"]
+        try:
+            relevant_history.append(history[matching_idx])
+        except:
+            return []
+    return relevant_history