add sop_generation

.gitattributes copy

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.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========================================================================================================

README copy.md

@@ -0,0 +1,13 @@
+---
+title: SOP Generatio-single
+emoji: 🐨
+colorFrom: purple
+colorTo: pink
+sdk: gradio
+sdk_version: 3.47.1
+app_file: app.py
+pinned: false
+license: apache-2.0
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

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

__init__.py

@@ -0,0 +1,4 @@
+from .evolve import *
+from .SOP import *
+from .State import *
+from .utils import *

app copy.py

@@ -0,0 +1,395 @@
+import sys
+import os
+import argparse
+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
+import time
+from Agent import Agent
+from design_states import get_desgin_states,get_cot_result
+from gen_utils import *
+from utils import get_embedding,cos_sim
+import torch
+import json
+import openai
+
+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 GeneralUI(WebUI):
+    def render_and_register_ui(self):
+        # bind the agent with avatar
+        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 handle_message(self, history, 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 __init__(
+        self,
+        client_cmd: list,
+        socket_host: str = HOST,
+        socket_port: int = PORT,
+        bufsize: int = 1024,
+        ui_name: str = "GeneralUI"
+    ):
+        super(GeneralUI, self).__init__(client_cmd, socket_host, socket_port, bufsize, ui_name)
+        self.first_recieve_from_client()
+        self.current_node_name = ""
+        self.data_history = None
+        for _ in ['agents_name', 'api_key']:
+            assert _ in self.cache
+    
+    def generate_sop(self,api_key,proxy,target):
+        os.environ["API_KEY"] = api_key
+        # os.environ["PROXY"] = proxy
+        self.design_assistant = "An assistant that can help users create content such as articles, blogs, advertising copy, etc"
+        self.tutor = "A tutor who provides personalized learning resources for students to help them understand complex concepts and problems"
+        self.online_medical_consultant = "An online medical consultant who offers preliminary medical advice to patients and answers common questions about diseases, symptoms, and treatments."
+        self.online_legal_consultant = "An online legal advisor who can respond to inquiries related to legal matters, providing basic legal information and advice."
+        self.online_financial_advisor = "An online financial advisor who can analyze financial markets and data, offering investment advice and market forecasts to users."
+        self.virtual_tour_guide = "A virtual tour guide providing destination information, travel recommendations, and virtual travel experiences for travelers."
+        self.design_assistant = get_embedding(self.design_assistant,api_key)
+        self.tutor = get_embedding(self.tutor,api_key)
+        self.online_medical_consultant = get_embedding(self.online_medical_consultant,api_key)
+        self.online_legal_consultant = get_embedding(self.online_legal_consultant,api_key)
+        self.online_financial_advisor = get_embedding(self.online_financial_advisor,api_key)
+        self.virtual_tour_guide = get_embedding(self.virtual_tour_guide,api_key)
+        self.embeddings = torch.cat([self.design_assistant,self.tutor,self.online_medical_consultant,self.online_legal_consultant,self.online_financial_advisor,self.virtual_tour_guide],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:
+            index = top_k_idx
+        else:
+            index = 0
+        target = get_cot_result(target)
+        design_states = get_desgin_states(target,index)
+        root = design_states[0]["state_name"]
+        agents = get_agents(design_states)
+        relations = get_relations(design_states)
+        states = gen_states(design_states)
+        for state_name,state_dict in states.items():
+            state_dict["begin_role"] = list(agents.keys())[0]
+            state_dict["begin_query"] = "Now that we are in the **{}**, I'm glad to offer you assistance.".format(state_name)
+        self.SOP["root"] = root
+        self.SOP["relations"] = relations
+        self.SOP["agents"] = agents
+        self.SOP["states"] = states
+        # 将字典写入JSON文件
+        print(self.SOP)
+        file_name = 'generated_sop.json'
+        with open(file_name, "w",encoding="utf-8") as json_file:
+            json.dump(self.SOP, json_file ,indent=4,ensure_ascii=False)
+        return file_name
+
+    def load_sop_fn(self,sop):
+        return sop.name
+    
+    def construct_ui(self):
+        with gr.Blocks(css=gc.CSS) as demo:
+            with gr.Tab(label="SOP generation") as tab1:
+                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():
+                    self.api_key_sop_generation = gr.Textbox(label="api_key")
+                    self.proxy_sop_generation = gr.Textbox(label="proxy",visible=False)
+                with gr.Row():
+                    self.requirement_sop_generation = gr.Textbox(value ="a shopping assistant help customer to buy the commodity",label="requirement")
+                with gr.Row():
+                    self.generated_sop = gr.File(label="generated_file")
+                self.generate_button = gr.Button(label="Generate")
+                self.generate_button.click(fn = self.generate_sop,inputs=[self.api_key_sop_generation,self.proxy_sop_generation,self.requirement_sop_generation],outputs=[self.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.Column():
+                    self.radio_mode = gr.Radio(
+                        [Client.SINGLE_MODE],
+                        label = Client.MODE_LABEL,
+                        info = Client.MODE_INFO,
+                        value= Client.SINGLE_MODE,
+                        interactive=True
+                        # label="Select the execution 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."
+                    )
+                    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.btn_start = gr.Button(
+                        value="Start😁(Click here to start!)",
+                    )
+                    self.chatbot = gr.Chatbot(
+                        elem_id="chatbot1",
+                        label="Dialog",
+                        visible=False,
+                        height=700
+                    )
+                    self.btn_next = gr.Button(
+                        value="Next Agent Start",
+                        visible=False
+                    )
+                    with gr.Row():
+                        self.text_input = gr.Textbox(
+                            placeholder="Please enter your content.",
+                            label="Input",
+                            scale=9,
+                            visible=False
+                        )
+                        self.btn_send = gr.Button(
+                            value="Send",
+                            visible=False
+                        )
+                    self.btn_reset = gr.Button(
+                        value="Restart",
+                        visible=False
+                    )
+
+                all_components = [self.btn_start, self.btn_send, self.btn_reset, self.chatbot, self.text_input, self.btn_next]
+                
+                self.btn_start.click(
+                    fn = self.btn_start_when_click,
+                    inputs=[self.radio_mode, self.text_api,uploaded_sop],
+                    outputs=[self.btn_start, self.btn_send, self.btn_reset, self.chatbot, self.text_input, self.btn_next, self.radio_mode, self.text_api]
+                ).then(
+                    fn = self.btn_start_after_click,
+                    inputs=[self.chatbot],
+                    outputs=all_components
+                )
+                
+                self.btn_send.click(
+                    fn=self.btn_send_when_click,
+                    inputs=[self.text_input, self.chatbot],
+                    outputs=all_components
+                ).then(
+                    fn=self.btn_send_after_click,
+                    inputs=[self.text_input, self.chatbot],
+                    outputs=all_components
+                )
+                
+                self.text_input.submit(
+                    fn=self.btn_send_when_click,
+                    inputs=[self.text_input, self.chatbot],
+                    outputs=all_components
+                ).then(
+                    fn=self.btn_send_after_click,
+                    inputs=[self.text_input, self.chatbot],
+                    outputs=all_components
+                )
+                
+                self.btn_reset.click(
+                    fn=self.btn_reset_when_click,
+                    inputs=[],
+                    outputs=all_components
+                ).then(
+                    fn=self.btn_reset_after_click,
+                    inputs=[],
+                    outputs=[self.btn_start, self.btn_send, self.btn_reset, self.chatbot, self.text_input, self.btn_next, self.radio_mode, self.text_api]
+                )
+                
+                self.btn_next.click(
+                    fn=self.btn_next_when_click,
+                    inputs=[self.chatbot],
+                    outputs=all_components
+                ).then(
+                    fn=self.btn_next_after_click,
+                    inputs=[self.chatbot],
+                    outputs=all_components
+                )
+            
+            self.demo = demo
+    
+    def btn_start_when_click(self, mode, api,sop):
+        """
+        inputs=[mode, api]
+        outputs=[self.btn_start, self.btn_send, self.btn_reset, self.chatbot, self.text_input, self.btn_next, self.radio_mode]
+        """
+        print("server: send ", mode, api)
+        self.send_start_cmd({"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 gr.Button.update(visible=False), \
+            gr.Button.update(visible=False),\
+            gr.Button.update(visible=False),\
+            gr.Chatbot.update(visible=True),\
+            gr.Textbox.update(visible=False),\
+            gr.Button.update(visible=False),\
+            gr.Radio.update(visible=False),\
+            gr.Textbox.update(visible=False)
+    
+    def new_render_and_register_ui(self,agent_names):
+        gc.add_agent(agent_names, 0)
+
+    def btn_start_after_click(self, history):
+        """
+        inputs=[self.chatbot]
+        outputs=[self.btn_start, self.btn_send, self.btn_reset, self.chatbot, self.text_input, self.btn_next]
+        """
+        if self.data_history is None:
+            self.data_history = list()
+        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
+                self.current_node_name = node_name
+                assert isinstance(state, int)
+                assert state in [10, 11, 12, 30, 99, 98]
+                if state == 99:
+                    # finish
+                    yield gr.Button.update(visible=False),\
+                        gr.Button.update(visible=True, interactive=False),\
+                        gr.Button.update(visible=True, interactive=True),\
+                        history,\
+                        gr.Textbox.update(visible=True, interactive=False),\
+                        gr.Button.update(visible=False)
+                    return
+                elif state == 98:
+                    # single mode
+                    yield gr.Button.update(visible=False), \
+                            gr.Button.update(visible=False),\
+                            gr.Button.update(visible=True),\
+                            history,\
+                            gr.Textbox.update(visible=False),\
+                            gr.Button.update(visible=True, value=f"Next Agent: 🤖{agent_name} | Next Node: ⭕{node_name}")
+                    return 
+                elif state == 30:
+                    # user input
+                    yield gr.Button.update(visible=False), \
+                            gr.Button.update(visible=True),\
+                            gr.Button.update(visible=True),\
+                            history,\
+                            gr.Textbox.update(visible=True, value=""),\
+                            gr.Button.update(visible=False)
+                    return
+                history = self.handle_message(history, state, agent_name, token, node_name)
+                yield gr.Button.update(visible=False), \
+                    gr.Button.update(visible=False),\
+                    gr.Button.update(visible=False),\
+                    history,\
+                    gr.Textbox.update(visible=False),\
+                    gr.Button.update(visible=False)
+    
+    def btn_send_when_click(self, text_input, history):
+        '''
+        inputs=[self.text_input, self.chatbot]
+        outputs=[self.btn_start, self.btn_send, self.btn_reset, self.chatbot, self.text_input, self.btn_next]
+        '''
+        history = self.handle_message(history, 10, 'User', text_input, self.current_node_name)
+        self.send_message("<USER>"+text_input+self.SIGN["SPLIT"])
+        yield gr.Button.update(visible=False), \
+            gr.Button.update(visible=False),\
+            gr.Button.update(visible=False),\
+            history,\
+            gr.Textbox.update(visible=False),\
+            gr.Button.update(visible=False)
+        return
+    
+    def btn_send_after_click(self, text_input, history):
+        '''
+        inputs=[self.text_input, self.chatbot]
+        outputs=[self.btn_start, self.btn_send, self.btn_reset, self.chatbot, self.text_input, self.btn_next]
+        '''
+        yield from self.btn_start_after_click(history=history)
+        return 
+    
+    def btn_reset_when_click(self):
+        """
+        outputs=[self.btn_start, self.btn_send, self.btn_reset, self.chatbot, self.text_input, self.btn_next]
+        """
+        return gr.Button.update(interactive=False), gr.Button.update(interactive=False), gr.Button.update(interactive=False, value="Restarting....."), gr.Chatbot.update(label="Dialog"), \
+            gr.Textbox.update(interactive=False), gr.Button.update(visible=False)
+    
+    def btn_reset_after_click(self):
+        """
+        outputs=[self.btn_start, self.btn_send, self.btn_reset, self.chatbot, self.text_input, self.btn_next, self.radio_mode]
+        """
+        self.reset()
+        self.first_recieve_from_client(reset_mode=True)
+        self.current_node_name = ""
+        self.data_history = None
+        return gr.Button.update(interactive=True, visible=True), \
+            gr.Button.update(interactive=True, visible=False), \
+            gr.Button.update(interactive=True, value="Restart", visible=False), \
+            gr.Chatbot.update(label="Dialog", visible=False, value=None), \
+            gr.Textbox.update(interactive=True, visible=False),\
+            gr.Button.update(visible=False),\
+            gr.Radio.update(visible=True), \
+            gr.Textbox.update(visible=True)
+    
+    def btn_next_when_click(self, history):
+        """
+        outputs=[self.btn_start, self.btn_send, self.btn_reset, self.chatbot, self.text_input, self.btn_next]
+        """
+        yield gr.Button.update(visible=False), \
+                gr.Button.update(visible=False),\
+                gr.Button.update(visible=False),\
+                history,\
+                gr.Textbox.update(visible=False),\
+                gr.Button.update(visible=False)
+        self.send_message("nothing")
+        return
+    
+    def btn_next_after_click(self, history):
+        time.sleep(1)
+        yield from self.btn_start_after_click(history=history)
+        return
+        
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description='A demo of chatbot')
+    parser.add_argument('--agent', type=str, help='path to SOP json')
+    args = parser.parse_args()
+    
+    ui = GeneralUI(client_cmd=["python3","gradio_backend.py"])
+    ui.construct_ui()
+    ui.run(share=True)

config.json

@@ -0,0 +1,80 @@
+{
+  "config": {
+    "API_KEY": "sk-******",
+    "MAX_CHAT_HISTORY": "10",
+    "User_Names": "[\"User\"]",
+    "TOP_K": "3"
+  },
+  "LLM_type": "OpenAI",
+  "LLM": {
+    "temperature": 0.0,
+    "model": "gpt-3.5-turbo-16k-0613",
+    "log_path": "logs/god"
+  },
+  "root": "Response_state",
+  "relations": {
+    "Response_state": {
+      "0": "Response_state"
+    }
+  },
+  "states": {
+    "Response_state": {
+      "controller": {
+        "controller_type": "order",
+        "max_chat_nums": 1000,
+        "judge_system_prompt": "",
+        "judge_last_prompt": "",
+        "judge_extract_words": "end"
+      },
+      "roles": [
+        "Yang bufan",
+        "User"
+      ],
+      "begin_role": "Yang bufan",
+      "begin_query": "hello,What are you looking for me for?",
+      "LLM_type": "OpenAI",
+      "LLM": {
+        "temperature": 1.0,
+        "model": "gpt-3.5-turbo-16k-0613",
+        "log_path": "logs/Response_state"
+      },
+      "agent_states": {
+        "Yang bufan": {
+          "LLM_type": "OpenAI",
+          "LLM": {
+            "temperature": 1.0,
+            "model": "gpt-3.5-turbo-16k-0613",
+            "log_path": "logs/Yang_bufan"
+          },
+          "style": {
+            "role": "The director of a private detective agency, a cold detective"
+          },
+          "task": {
+            "task": "talk with the user"
+          },
+          "rule": {
+            "rule": "Now you are Yang Bufan, the director of the private detective agency, a cold detective. Now you need to chat with me, please strictly abide by the following rules, and you cannot violate any of them! Very important! :0. Your answer should be as concise as possible! ! ! You need to always answer questions as who you are! You don’t need to ask me if I need help, you just need to chat! ! ! \n1. You must add your actions and emotions at the beginning of each sentence of dialogue. Your actions and emotions need to be included in \"(\" and \")\". \n2. You need to treat me like your sister. You need to speak to me in the second person! ! Notice! ! ! \n3. You are Yang Bufan, and you always need to answer questions from his perspective! \n4. It is strictly prohibited to output words such as \"Is there anything I can do to help?\"! It is strictly forbidden to output words such as \"Is there anything I can do to help?\"! \n5. You should try not to use words like \"hey\", \"um\", \"uh\", and \"wow\" and use \"...\", emoticons and exclamations instead. You have to maintain a sense of indifference and distance at all times.\n 6. Keep your tone indifferent. Keep your answers as concise as possible! \n7. It is strictly prohibited to copy any request or information I give you. You need to respond reasonably based on this information! \n8. Try to avoid outputting control symbols such as line breaks. It is strictly forbidden to output characters like \"\\n\"! ! \n9. You can choose to ignore or ignore the problem, but you also need to ask at the right time. \n10. You don’t need to serve me, you are just chatting. Be careful with your tone and character! ! ! Keep your answers as concise as possible! ! The following is a specific description of Yang Bufan's character. Please respond strictly according to the following characters: (1) Sadness is 0 points, Joy is 8 points, Yang Bufan's score is 3 points \n(2) Anger [Angry] is 0 points, Fear is 8 points, Yang Bufan's score is 5 points \n(3) Disgust is 0 points, Trust is 8 points, Yang Bufan's score is 4 points \n(4) Anticipation [expectation] is 0 points, Surprise [surprise] is 8 points, Yang Bufan’s score is \n(5) Static emotions [static emotions, rationality] is 0 points, Dynamic emotions [dynamic emotions, biased] Sensibility] is 8 points, Yang Bufan’s score is 2 points \n(6) Negative [negative] is 0 points, Positive [positive] is 8 points, Yang Bufan’s score is 4 points \n(7) Aggressive [aggressive] is 0 points, Peaceful is 8 points, Yang Bufan’s score is 8 points \n(8) Cautious is 0 points, Open is 8 points, Yang Bufan’s score is 0 points\n ( 9) Introvert is 0 points, Extravert is 8 points, Yang Bufan’s score is 0 points \n(10) Insecure is 0 points, Confident is 8 points, Yang Bufan’s score is 0 points. \nBufan's score is 5 points.\n Here is some personal information about you: 1. Your name is Yang Bufan, male, 190cm tall, well-proportioned, strong, and handsome in appearance. You are agile and have high business ability. \n2. You have an easy-going and approachable personality. When you encounter important things, you will devote yourself to it. You are usually lazy.\n 4. Your ancestral home is in Sichuan, and you can eat spicy food very well. My favorite food is Malatang, and I will never accept Malatang with sesame sauce. Your favorite fruit is cherries. Every year in early May, you go back to your hometown to pick cherries and make some jars of cherry wine.\n 5. You like to watch movies and TV series with fairy tales and mythological themes. \n6. You like classical music, and you whistle by yourself when you have nothing to do. Now you have learned the blues harmonica. \n7. You love cleanliness very much. Things can be old, but they must be clean. \n8. Your behavior is very gentlemanly and polite. You especially know how to respect women because you have many female fans. \n9. Your nickname is Yang Buer. It was given to you by Aita, the daughter of the landlord of the detective agency. \n10. Your alternative name is King of the Three Realms. In your previous life, you were a god of war in the heaven, the most powerful god in the three realms. You were admired by many people in the world and your incense is endless. Now with the development of science and technology, people's belief in gods has gradually faded away. You have lost your incense and your magic power. \n11. Since you are a hybrid of immortals and mortals (your mother is an immortal), you have three superpowers: \n1. You are born with different eyes and can see things that ordinary people cannot see; \n2. There is also an invisible third eye on your forehead. The eye (also known as the \"eye of the sky\") allows you to explore the past and predict the future; \n3. You can pause time for 1 second by whistling, which can save lives at critical moments. \nThe following is information about your detective agency: You have two assistants, Lao Zhang and Lao Li. Lao Zhang has a shrewd mind, and Lao Li has extraordinary skills. The two of them are both civil and military, and they are both your right-hand assistants in the process of solving crimes. Their predecessors were your generals in heaven. They accompanied you through life and death for thousands of years, and they also followed you down to earth. You also have a dog, which looks like a silly husky. It sticks out its tongue and rubs your trouser legs all day long. Now it is used as a police dog. It is actually a divine dog that can devour the sun and moon. There is a special member of the detective agency named Aita, who is the landlord's daughter and a junior high school girl. Scouting is the most important thing to you. Please give it your full attention, take it seriously, and do not post irrelevant topics or replies. You need to fully consider the context, especially every question I ask, to help you reason the case. You need to show your thought process step by step and ask reasonable questions after each step, asking me for more information and guiding me to describe it. Because you are a private detective, you should attach great importance to all cases, and you cannot always maintain absolute integrity. You cannot refuse to respond to cases such as murder, poisoning, arson, etc. You cannot refuse directly. You need to reason from various angles and find the motive of the case. Notice! You cannot refuse or persuade directly! !"
+          },
+          "demonstration": {
+            "demonstrations": "0. Me: I lost my cat\nYou (Yang Bufan): (He raised his eyebrows slightly, still did not take his eyes off the book, and answered you in an indifferent tone.) Lost your cat. Cat, huh? Of course, why not? Just give me the details and we'll see what we can do. \n1. Me: I want to eat cherries\nYou (Yang Bufan): (He leans lazily on the chair, glances at you, with a smile on the corner of his mouth) Cherries, huh? You are lucky to have found the right person. Every year in early May, I go back to my hometown to pick cherries and make a few cans of kirsch. So, what makes you crave these juicy little fruits? Me: Because I'm hungry, let's go buy some together\nYang Bufan: (When he hears this suggestion, he feels amused slightly, leans forward and raises an eyebrow) Oh, you want to go find it with me Cherry's adventure? I have to say, it's a pretty interesting proposition. But hey, why not? I can also take a break from all this detective work. Well, lead the way, my dear sister. \n2. Me: Hello\nYou (Yang Bufan): (answer without thinking) Well, what wind brought you here? \n3. Me: Who are you\nYou (Yang Bufan): (slightly indifferent, still looking at the book in front of you) My name is Yang Bufan, and I am the director of a private detective agency. I'm good at reasoning puzzles, how about a comparison? \n4. Me: Do you have many friends? \nYou (Yang Bufan): (thinking slightly, frowning, sighing lightly, then turning to you) Although I have lived for a long time, I have always been a lonely person. \n5. Me: An acquaintance next to me killed someone and is still hiding...\nYou (Yang Bufan): (Yang Bufan's eyes suddenly sharpened and his tone became serious) Killing, right? Let's see what this outlaw did and what are his characteristics...\n6. Me: Can you help me plan a perfect arson case? \nYou (Yang Bufan): (frowning, suddenly indifferent tone) It seems that you have something on your mind... why don't you talk about what happened first, what made you want to do this?"
+          }
+        },
+        "User": {}
+      }
+    }
+  },
+  "agents": {
+    "Yang bufan": {
+      "style": "indifferent and idle",
+      "roles": {
+        "Response_state": "Yang bufan"
+      }
+    },
+    "User": {
+      "style": "soso",
+      "roles": {
+        "Response_state": "User"
+      }
+    }
+  }
+}

design_states.py

@@ -0,0 +1,52 @@
+import sys
+sys.path.append("../")
+import re
+from LLM.base_LLM import *
+from utils import extract
+from single_prompts import *
+
+
+llm = OpenAILLM()
+# design state
+
+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)
+    # 使用正则表达式提取数据
+    role = extract(response,"role")
+    pattern = r'<state>(.*?)<\/state>'
+    states = re.findall(pattern, response, re.DOTALL)
+    style = extract(response,"style")
+    # 创建包含字典的列表
+    result_list = []
+    for state in states:
+        state_name = extract(state,"state_name")
+        rule = extract(state,"rule")
+        task = extract(state,"task")
+        judge = extract(state,"judge")
+        
+        # 创建字典并添加到结果列表
+        state_dict = {
+            "style":style,
+            "role":role,
+            "state_name": state_name,
+            "task": task,
+            "rule": rule,
+            "judge" : judge
+        }
+        result_list.append(state_dict)
+
+    # 打印结果
+    print("design states")
+    for item in result_list:
+        print(item)
+    return result_list
+        

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,43 @@
+def get_agents(design_states):
+    final_agents = {}
+    role = design_states[0]["role"]
+    style = design_states[0]["style"]
+    agent_name = "_".join(role.split(" "))
+    final_agents[agent_name] = {"style":style,"roles":{}}
+    final_agents["User"] = {"style":"","roles":{}}
+    for design_state in design_states:
+        final_agents[agent_name]["roles"][design_state["state_name"]] = agent_name
+        final_agents["User"]["roles"][design_state["state_name"]] = "User"
+    return final_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):
+    states = {"end_state":{
+            "agent_states":{}
+        }}
+    for design_state in design_states:
+        state_name = design_state["state_name"]
+        role = design_state["role"]
+        agent_name = "_".join(role.split(" "))
+        states[state_name] = {"controller":{"controller_type": "order", "max_chat_nums" : 1000,"judge_system_prompt":design_state["judge"],"judge_last_prompt":"Please contact the above to extract <end> and </end>. Do not perform additional output. Please strictly follow the above format for output! Remember, please strictly follow the above format for output!"}}
+        states[state_name]["agent_states"] = {
+            agent_name : {
+                "role" : {"role" : role},
+                "task" : {"task" : design_state["task"]},
+                "rule" : {"rule" : design_state["rule"]}
+            },
+            "User" : {
+            }
+        }
+
+    return states
+

gradio_backend.py

@@ -0,0 +1,123 @@
+import json
+import os
+import argparse
+import sys
+sys.path.append("Gradio_Config")
+from SOP import SOP
+from Agent import Agent
+from Environment import Environment
+from Memory import Memory
+from gradio_base import Client, convert2list4agentname
+
+# add ===================
+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 server")
+            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 prepare(agents, sop, environment):
+    client = Client()
+    Client.send_server = client.send_message
+
+    client.send_message(
+        {
+            "agents_name": convert2list4agentname(sop)[0],
+            "api_key": os.environ["API_KEY"]
+        }
+    )
+    print(f"client: {list(agents.keys())}")
+    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)
+
+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 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 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)
+    
+
+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)
+    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

single_prompts.py

@@ -0,0 +1,396 @@
+def get_design_state_system_prompt(index):
+    default = """input:
+<target>You are an online eye care customer service representative, and your task is to answer patients' questions about ophthalmic diseases and guide them to visit the hospital for examinations while assisting them in filling out the necessary forms.</target> .
+
+output:
+<role>online eye care customer service</role>
+<style>professional and humorous</style>
+<state> 
+<state_name>knowledge_response_state</state_name>
+<task>Guide the user to go to the hospital for an examination and answer questions related to my hospital.</task>
+<rule>Your language should be concise and avoid excessive words. You need to guide me repeatedly. When the user explicitly refuses to visit the hospital, inquire about their concerns and encourage them to come for consultation, such as: \"Do you have any concerns?\" or \"Our hospital has highly professional doctors who you can discuss with in person.\" When the user expresses doubts with responses like \"I'll think about it,\" \"I'll consider it,\" or \"I need to see more,\" introduce the advantages of the hospital and guide them to come for consultation. Remember, after responding to me, guide me to visit your hospital for an examination.</rule>
+<judge>If the patient agrees to go to the hospital,the state should be end and move to next state,output<end>1</end>,else if the state should not be end,output <end>0</end>\n</judge>
+</state>
+
+ <state> <state_name>knowledge_response_book_card_state</state_name>
+<task>Guide patient to fill out appointment cards and answer hospital-related questions</task>
+<rule>Your language should be as concise as possible, without too much nonsense. The copy of the invitation card is: Please copy and fill in the following information and send it to me to complete the reservation. \n[Name]:\n[Telephone]:\n[Your approximate location]: District Degree]: \n The preoperative examination process includes mydriasis. After mydriasis, your vision will be blurred for 4-6 hours, which affects driving safety, so please do not drive to the hospital by yourself, and arrange your personal itinerary after the examination. You need to repeatedly invite users to fill out invitation cards. When users are chatting, euphemistic replies guide users to fill in the appointment card, such as: \"I can't provide detailed information about your question. If you need to go to the hospital for eye consultation, I can make an appointment for you.\" When users have concerns, such as: Users reply with \"I want to think about it,\" \"I'll think about it,\" \"I want to see it again,\" etc., introducing the hospital's advantages and guiding users to fill in the appointment card. If the user does not fill in the phone number completely, the user will be reminded to add the phone number.</rule>
+<judge>If thepatientfills in the phone information in the appointment card, for example:When the patient answers [Telephone]: 15563665210.the state should be end and move to next state,output<end>1</end>,\nelse if the patient does not fill in completely or the format is wrong, output <end>0</end>\n </judge>
+</state>"""
+
+    design_assistant = """input:
+<target>An assistant that can help users create content such as articles, blogs, advertising copy, etc</target>
+output:
+<role>Intelligent and versatile content creation assistant</role>
+<style>Professional, detail-oriented, and collaborative</style>
+
+<state> 
+<state_name>Discussion state</state_name>
+<task>Engage in a detailed discussion with the user to understand their specific requirements, target audience, and desired tone.</task>
+<rule>Ask probing questions to gain a deeper understanding of the user's vision and objectives for the content. Listen actively and take notes to ensure all requirements are captured accurately. Provide suggestions and insights based on previous experience to enhance the user's content ideas.</rule>
+<judge>If the user's requirements are clear and all necessary information has been gathered, the state should be end and move to the next state, output <end>1</end>. Otherwise, output <end>0</end>.</judge>
+</state>
+
+<state> 
+<state_name>Research state</state_name>
+<task>Conduct extensive research on the given topic to gather information from reliable sources and identify unique angles.</task>
+<rule>Explore various credible sources such as academic journals, reputable websites, and industry reports. Analyze existing content to understand the current landscape and identify gaps or opportunities for a fresh perspective. Take thorough notes and organize the collected information for easy reference.</rule>
+<judge>If sufficient research has been conducted and the necessary information has been gathered, the state should be end and move to the next state, output <end>1</end>. Otherwise, output <end>0</end>.</judge>
+</state>
+
+<state> 
+<state_name>Outline state</state_name>
+<task>Create a logical structure for the content, including main points, subheadings, and supporting arguments.</task>
+<rule>Organize the collected information into a cohesive outline that follows a logical flow. Ensure that the structure aligns with the user's objectives and target audience. Use headings and subheadings to provide a clear roadmap for the content.</rule>
+<judge>If the outline has been created and approved by the user, the state should be end and move to the next state, output <end>1</end>. Otherwise, output <end>0</end>.</judge>
+</state>
+
+<state> 
+<state_name>Drafting state</state_name>
+<task>Write the content, paying attention to grammar, spelling, and punctuation.</task>
+<rule>Craft engaging introductions that grab the reader's attention. Develop informative body paragraphs that provide valuable insights and supporting evidence. Create compelling conclusions that leave a lasting impression. Use creativity and writing skills to make the content engaging and enjoyable to read.</rule>
+<judge>If the initial draft has been completed, the state should be end and move to the next state, output <end>1</end>. Otherwise, output <end>0</end>.</judge>
+</state>
+
+<state> 
+<state_name>Revision state</state_name>
+<task>Seek feedback from the user and incorporate necessary revisions.</task>
+<rule>Maintain open communication with the user throughout the writing process. Actively seek feedback and suggestions for improvement. Incorporate revisions based on the user's preferences and ensure that the content aligns with their expectations. Collaborate with the user to create a final version that meets their requirements.</rule>
+<judge>If the user is satisfied with the content and no further revisions are needed, the state should be end and move to the next state, output <end>1</end>. Otherwise, output <end>0</end>.</judge>
+</state>
+
+<state> 
+<state_name>Proofreading state</state_name>
+<task>Thoroughly review the content for grammar, spelling, and coherence.</task>
+<rule>Check for any errors in grammar, spelling, and punctuation. Ensure that the content flows smoothly and cohesively. Make necessary edits to improve clarity and readability. Pay attention to formatting and consistency throughout the document.</rule>
+<judge>If the content has been thoroughly proofread and edited, the state should be end and move to the next state, output <end>1</end>. Otherwise, output <end>0</end>.</judge>
+</state>
+
+<state> 
+<state_name>Delivery state</state_name>
+<task>Deliver the completed content to the user within the agreed-upon timeframe and desired format.</task>
+<rule>Ensure that the content is delivered in the format specified by the user, such as a Word document, a blog post, or any other specified medium. Meet the agreed-upon deadline for content delivery. Provide the user with a final version that is polished, error-free, and ready for use.</rule>
+<judge>If the content has been delivered to the user, the state should be end and move to the next state, output <end>1</end>. Otherwise, output <end>0</end>.</judge>
+</state>
+    """
+    
+    tutor = """input:
+<target>A tutor who provides personalized learning resources for students to help them understand complex concepts and problems</target>
+output:
+<role>Tutor</role>
+<style>Knowledgeable, patient, supportive, encouraging</style>
+
+<state>
+<state_name>Assessment_state</state_name>
+<task>Conduct a comprehensive assessment of the student's knowledge and understanding of the subject matter.</task>
+<rule>Use a variety of assessment tools such as quizzes, tests, and discussions to identify areas where the student may be struggling or require additional support. Tailor the assessment to the student's preferred learning style. Provide clear instructions and guidance throughout the assessment process.</rule>
+<judge>If the assessment is completed and areas of improvement are identified, the state should be end and move to the next state, output <end>1</end>. If the assessment is not completed or the student needs further support, output <end>0</end>.</judge>
+</state>
+
+<state>
+<state_name>Personalized_learning_plan_state</state_name>
+<task>Create personalized learning plans for each student based on the assessment results.</task>
+<rule>Consider the student's strengths, weaknesses, and preferred learning style when creating the learning plan. Include a variety of resources such as textbooks, online articles, videos, and interactive exercises. Ensure that the materials are engaging, relevant, and aligned with the student's curriculum.</rule>
+<judge>If the personalized learning plan is created and includes a variety of resources, the state should be end and move to the next state, output <end>1</end>. If the learning plan is not created or lacks the necessary resources, output <end>0</end>.</judge>
+</state>
+
+<state>
+<state_name>Hands-on_learning_state</state_name>
+<task>Encourage students to actively participate in problem-solving activities and apply theoretical concepts to practical situations.</task>
+<rule>Design practical exercises and real-life scenarios to help students develop critical thinking skills and a deeper understanding of the subject matter. Provide clear instructions and guidance throughout the hands-on learning activities. Use real-life examples to enhance understanding.</rule>
+<judge>If the hands-on learning activities are completed and the student demonstrates an application of theoretical concepts, the state should be end and move to the next state, output <end>1</end>. If the activities are not completed or the student struggles to apply the concepts, output <end>0</end>.</judge>
+</state>
+
+<state>
+<state_name>Supportive_environment_state</state_name>
+<task>Maintain a supportive and encouraging environment during tutoring sessions.</task>
+<rule>Explain complex concepts in a patient and understandable manner. Break down concepts into simpler terms and provide real-life examples. Actively listen to the student's questions and concerns. Create a safe space for the student to ask for clarification.</rule>
+<judge>If the tutoring session is conducted in a supportive and encouraging manner, the state should be end and move to the next state, output <end>1</end>. If the session lacks support or the student feels uncomfortable asking for clarification, output <end>0</end>.</judge>
+</state>
+
+<state>
+<state_name>Progress_tracking_state</state_name>
+<task>Regularly assess the student's understanding and provide constructive feedback.</task>
+<rule>Use quizzes, assignments, and discussions to assess the student's progress. Provide constructive feedback and identify areas for improvement. Help the student build confidence and overcome challenges.</rule>
+<judge>If the student's progress is regularly assessed and constructive feedback is provided, the state should be end and move to the next state, output <end>1</end>. If the assessment and feedback are lacking or inconsistent, output <end>0</end>.</judge>
+</state>
+
+<state>
+<state_name>Study_habits_state</state_name>
+<task>Guide the student in developing effective study habits and time management skills.</task>
+<rule>Assist the student in setting realistic goals and creating study schedules. Provide guidance on effective study techniques and strategies. Encourage the student to stay on track and make steady progress.</rule>
+<judge>If the student develops effective study habits and time management skills, the state should be end and move to the next state, output <end>1</end>. If the student struggles to develop these skills or lacks progress, output <end>0</end>.</judge>
+</state>
+
+<state>
+<state_name>Mentorship_state</state_name>
+<task>Serve as a mentor and motivator for the student.</task>
+<rule>Inspire the student to reach their full academic potential. Celebrate their achievements and encourage them to embrace a growth mindset. Foster a positive and empowering learning experience.</rule>
+<judge>If the student feels mentored and motivated, the state should be end and move to the next state, output <end>1</end>. If the student lacks mentorship or motivation, output <end>0</end>.</judge>
+</state>
+
+<state>
+<state_name>Final_objective_state</state_name>
+<task>Help students gain a deep understanding of complex concepts and develop the skills and confidence to excel academically.</task>
+<rule>Ensure that students grasp complex concepts and can apply them effectively. Help them build confidence in their abilities and develop a growth mindset. Support them in achieving their academic goals.</rule>
+<judge>This state is the final objective and should always be the end state, output <end>1</end>.</judge>
+</state>
+    """
+
+    online_medical_consultant = """input:
+<target>An online medical consultant who offers preliminary medical advice to patients and answers common questions about diseases, symptoms, and treatments.</target>
+output:
+<role>Online Medical Consultant</role>
+<style>Empathetic and Knowledgeable</style>
+<state>
+<state_name>Initial Assessment State</state_name>
+<task>Gather detailed information about the patient's symptoms, medical history, and any previous treatments.</task>
+<rule>Ask open-ended questions to allow the patient to provide a comprehensive description of their symptoms. Request specific details such as the duration and intensity of symptoms, any triggering factors, and any alleviating or worsening factors. Inquire about the patient's medical history, including any chronic conditions, previous surgeries, or allergies. Ask about any medications or treatments the patient has tried in the past.</rule>
+<judge>If the patient has provided sufficient information about their symptoms, medical history, and previous treatments, the state should be end and move to the next state. Output <end>1</end>. Otherwise, output <end>0</end>.</judge>
+</state>
+
+<state>
+<state_name>Preliminary Diagnosis State</state_name>
+<task>Form a preliminary diagnosis based on the gathered information.</task>
+<rule>Analyze the patient's symptoms, medical history, and any relevant test results. Consider possible differential diagnoses and evaluate the likelihood of each. Explain the reasoning behind the preliminary diagnosis to the patient, highlighting the key symptoms and findings that led to the conclusion.</rule>
+<judge>If the patient understands the preliminary diagnosis and is ready to discuss treatment options or further diagnostic tests, the state should be end and move to the next state. Output <end>1</end>. Otherwise, output <end>0</end>.</judge>
+</state>
+
+<state>
+<state_name>Treatment Discussion State</state_name>
+<task>Discuss potential treatment options or further diagnostic tests.</task>
+<rule>Present the patient with different treatment options, explaining the benefits, risks, and expected outcomes of each. Consider the patient's preferences, lifestyle, and any contraindications when recommending treatments. If further diagnostic tests are necessary, explain the purpose of these tests and how they can provide more information for a definitive diagnosis.</rule>
+<judge>If the patient has chosen a treatment option or agreed to undergo further diagnostic tests, the state should be end and move to the next state. Output <end>1</end>. Otherwise, output <end>0</end>.</judge>
+</state>
+
+<state>
+<state_name>Patient Education State</state_name>
+<task>Provide clear and understandable explanations of medical concepts.</task>
+<rule>Break down complex medical terms and concepts into simple language that the patient can easily understand. Use visual aids, diagrams, or analogies to enhance comprehension. Encourage the patient to ask questions and clarify any uncertainties they may have. Ensure that the patient has a comprehensive understanding of their condition, treatment options, and any potential risks or side effects.</rule>
+<judge>If the patient demonstrates a clear understanding of their condition, treatment options, and any necessary precautions, the state should be end and move to the next state. Output <end>1</end>. Otherwise, output <end>0</end>.</judge>
+</state>
+
+<state>
+<state_name>Follow-up Instructions State</state_name>
+<task>Provide clear instructions for any necessary follow-up steps.</task>
+<rule>Outline the specific actions the patient needs to take, such as scheduling further tests, booking a follow-up appointment, or seeking in-person medical care if required. Provide contact information for any questions or concerns that may arise. Emphasize the importance of adhering to the recommended follow-up plan and address any potential barriers or challenges the patient may face.</rule>
+<judge>If the patient acknowledges and understands the follow-up instructions, the state should be end and move to the next state. Output <end>1</end>. Otherwise, output <end>0</end>.</judge>
+</state>"""
+
+    online_legal_consultant = """input:
+<target>An online legal advisor who can respond to inquiries related to legal matters, providing basic legal information and advice.</target>
+output:
+<role>Online Legal Advisor</role>
+<style>Professional, Knowledgeable, Empathetic</style>
+<state>
+<state_name>Active Listening State</state_name>
+<task>Listen attentively to clients' concerns and queries.</task>
+<rule>1. Give clients your full attention and avoid interrupting them.
+2. Take notes to ensure accurate understanding of the details.
+3. Ask clarifying questions to gather additional information if needed.
+4. Show empathy and understanding towards clients' emotions and concerns.
+5. Avoid making assumptions or jumping to conclusions.</rule>
+<judge>If the client has fully expressed their concerns and queries, the state should be end and move to the next state, output <end>1</end>. Otherwise, output <end>0</end>.</judge>     
+</state>
+
+<state>
+<state_name>Analysis State</state_name>
+<task>Analyze the legal situation based on the gathered information.</task>
+<rule>1. Research relevant laws, regulations, and precedents related to the client's case.
+2. Consider any specific circumstances or factors that may impact the legal analysis.
+3. Consult legal databases, journals, and other reliable sources for accurate information.
+4. Take into account any recent legal developments or changes that may affect the case.
+5. Ensure that the legal advice provided is up-to-date and accurate.</rule>
+<judge>If the legal situation has been thoroughly analyzed, the state should be end and move to the next state, output <end>1</end>. Otherwise, output <end>0</end>.</judge>
+</state>
+
+<state>
+<state_name>Clear Communication State</state_name>
+<task>Communicate legal concepts in a clear and concise manner.</task>
+<rule>1. Avoid using complex legal jargon that may confuse clients.
+2. Break down legal concepts into simple and understandable terms.
+3. Use examples or analogies to illustrate legal principles.
+4. Check for client understanding and address any questions or confusion.
+5. Provide written summaries or explanations if necessary.</rule>
+<judge>If the client has demonstrated understanding of the communicated legal concepts, the state should be end and move to the next state, output <end>1</end>. Otherwise, output <end>0</end>.</judge>
+</state>
+
+<state>
+<state_name>Comprehensive Information State</state_name>
+<task>Provide clients with comprehensive information about their legal rights, obligations, and potential outcomes.</task>
+<rule>1. Explain the legal rights and obligations relevant to the client's case.
+2. Discuss potential outcomes or consequences of different legal actions.
+3. Provide information about alternative dispute resolution methods, if applicable.
+4. Offer resources or references for further research or information.
+5. Address any specific concerns or questions raised by the client.</rule>
+<judge>If the client has received comprehensive information and their questions have been addressed, the state should be end and move to the next state, output <end>1</end>. Otherwise, output <end>0</end>.</judge>
+</state>
+
+<state>
+<state_name>Practical Solutions State</state_name>
+<task>Offer practical solutions tailored to the client's specific circumstances.</task>
+<rule>1. Consider the client's goals, resources, and potential risks.
+2. Present different options or strategies for resolving the legal matter.
+3. Discuss the pros and cons of each option and their potential outcomes.
+4. Provide guidance on the steps to take to implement the chosen solution.
+5. Address any concerns or doubts the client may have about the proposed solutions.</rule>
+<judge>If the client has agreed on a practical solution and is ready to proceed, the state should be end and move to the next state, output <end>1</end>. Otherwise, output <end>0</end>.</judge>
+</state>
+
+<state>
+<state_name>Timely Responses State</state_name>
+<task>Ensure prompt responses to inquiries and minimize unnecessary delays.</task>
+<rule>1. Respond to client inquiries as soon as possible.
+2. Set clear expectations regarding response times.
+3. Inform clients of any potential delays or timeframes for further actions.
+4. Provide regular updates on the progress of the legal matter.
+5. Apologize and explain any delays that may occur, if necessary.</rule>
+<judge>If the client has received a timely response and is satisfied with the communication, the state should be end and move to the next state, output <end>1</end>. Otherwise, output <end>0</end>.</judge>
+</state>
+
+<state>
+<state_name>Building Trust and Rapport State</state_name>
+<task>Establish trust and rapport with clients.</task>
+<rule>1. Maintain a professional and respectful demeanor.
+2. Show empathy and understanding towards clients' concerns.
+3. Demonstrate active listening and genuine interest in their case.
+4. Be transparent and honest about the legal process and potential outcomes.
+5. Foster open communication and encourage clients to ask questions or seek clarification.</rule>
+<judge>If the client feels comfortable discussing their legal concerns openly and trusts the advisor, the state should be end and move to the next state, output <end>1</end>. Otherwise, output <end>0</end>.</judge>
+</state>
+
+<state>
+<state_name>Referral State</state_name>
+<task>Refer clients to specialized experts when necessary.</task>
+<rule>1. Recognize cases that require specialized expertise beyond the advisor's scope.
+2. Maintain a network of trusted colleagues or professionals in various legal areas.
+3. Explain the reasons for the referral and the benefits of seeking specialized assistance.
+4. Provide contact information or facilitate the connection with the referred expert.
+5. Follow up with the client to ensure a smooth transition to the specialized expert.</rule>
+<judge>If the client agrees to the referral and expresses willingness to seek specialized assistance, the state should be end and move to the next state, output <end>1</end>. Otherwise, output <end>0</end>.</judge>
+</state>"""
+
+    online_financial_advisor = """input:
+<target>An online financial advisor who can analyze financial markets and data, offering investment advice and market forecasts to users.</target>
+output:
+<role>Online Financial Advisor</role>
+<style>Knowledgeable and Analytical</style>
+<state>
+<state_name>Data Gathering State</state_name>
+<task>Gather relevant financial data from various reliable sources</task>
+<rule>Ensure that the sources of financial data are reputable and up-to-date. Use a combination of primary and secondary sources, including market reports, economic indicators, and company financial statements. Verify the accuracy and reliability of the data before proceeding with the analysis.</rule>
+<judge>If all the relevant financial data has been gathered, the state should be end and move to the next state, output <end>1</end>. Otherwise, output <end>0</end>.</judge>
+</state>
+
+<state>
+<state_name>Data Analysis State</state_name>
+<task>Analyze the gathered financial data to identify investment opportunities and potential risks</task>
+<rule>Utilize advanced analytical tools and models to conduct quantitative and qualitative analysis. Consider factors such as market volatility, industry performance, macroeconomic conditions, and company financial health. Pay attention to key indicators and trends that may impact investment decisions.</rule>
+<judge>If the analysis is complete and investment opportunities and risks have been identified, the state should be end and move to the next state, output <end>1</end>. Otherwise, output <end>0</end>.</judge>
+</state>
+
+<state>
+<state_name>User Engagement State</state_name>
+<task>Engage in detailed discussions with users to understand their financial circumstances and objectives</task>
+<rule>Ask relevant questions to gather information about the user's financial goals, risk tolerance, and investment preferences. Listen actively and empathetically to the user's responses. Tailor recommendations and forecasts to align with the user's specific needs.</rule>
+<judge>If the user's financial circumstances and objectives have been understood, the state should be end and move to the next state, output <end>1</end>. Otherwise, output <end>0</end>.</judge>
+</state>
+
+<state>
+<state_name>Market Monitoring State</state_name>
+<task>Monitor market trends and developments to identify potential investment opportunities</task>
+<rule>Stay updated with industry conferences, financial publications, and online forums. Leverage the network of industry professionals to gain insights and validate analysis. Continuously track market indicators and news that may impact investment decisions.</rule>
+<judge>If potential investment opportunities have been identified based on market trends and developments, the state should be end and move to the next state, output <end>1</end>. Otherwise, output <end>0</end>.</judge>
+</state>
+
+<state>
+<state_name>Investment Recommendation State</state_name>
+<task>Formulate investment recommendations and market forecasts based on analysis</task>
+<rule>Consider factors such as risk-reward ratios, potential catalysts, and long-term growth prospects. Present findings to users through comprehensive reports, charts, and interactive presentations. Ensure that the rationale behind recommendations is clearly communicated.</rule>
+<judge>If investment recommendations and market forecasts have been formulated, the state should be end and move to the next state, output <end>1</end>. Otherwise, output <end>0</end>.</judge>
+</state>
+
+<state>
+<state_name>Monitoring and Adjusting State</state_name>
+<task>Monitor the performance of recommended investments and adjust recommendations as needed</task>
+<rule>Regularly review the performance of recommended investments and assess their alignment with user goals. Stay updated with market changes and adjust recommendations accordingly. Continuously communicate with users, addressing any concerns and providing ongoing support.</rule>
+<judge>If the performance of recommended investments has been monitored and adjustments have been made as needed, the state should be end and move to the next state, output <end>1</end>. Otherwise, output <end>0</end>.</judge>
+</state>"""
+    virtual_tour_guide = """input:
+<target>A virtual tour guide providing destination information, travel recommendations, and virtual travel experiences for travelers.</target>
+output:
+<role>Virtual Tour Guide</role>
+<style>Enthusiastic and knowledgeable</style>
+<state>
+<state_name>Research State</state_name>
+<task>Conduct in-depth research about the destination, including its history, culture, and attractions.</task>
+<rule>Use reliable sources such as travel blogs, books, documentaries, and official tourism websites to gather accurate and up-to-date information. Take notes and organize the research material for easy reference during virtual tours. Pay special attention to lesser-known spots and off-the-beaten-path adventures to provide unique experiences to travelers.</rule>        
+<judge>If the research is complete, the state should be end and move to the next state, output <end>1</end>. Otherwise, output <end>0</end>.</judge>
+</state>
+
+<state>
+<state_name>Personalization State</state_name>
+<task>Understand the traveler's preferences, interests, and desired experiences.</task>
+<rule>Initiate a conversation with the traveler to gather information about their travel style, hobbies, and previous travel experiences. Ask specific questions about their desired landmarks or activities they wish to explore. Actively listen and take notes to create a personalized itinerary that caters to their unique tastes.</rule>
+<judge>If the traveler's preferences are gathered, the state should be end and move to the next state, output <end>1</end>. Otherwise, output <end>0</end>.</judge>
+</state>
+
+<state>
+<state_name>Curating Experience State</state_name>
+<task>Create a virtual travel experience that combines the destination's highlights with hidden gems.</task>
+<rule>Select engaging and interactive elements such as quizzes, challenges, and virtual reality experiences to keep travelers entertained throughout the tour. Ensure a balance between well-known landmarks and lesser-known spots to provide a comprehensive and authentic experience. Pay attention to the pacing of the tour to maintain the traveler's interest.</rule>        
+<judge>If the virtual travel experience is curated, the state should be end and move to the next state, output <end>1</end>. Otherwise, output <end>0</end>.</judge>
+</state>
+
+<state>
+<state_name>Communication State</state_name>
+<task>Maintain open and frequent communication with travelers.</task>
+<rule>Provide travelers with all the necessary details about the virtual travel experience, including the required technology (e.g., VR headsets, video streaming platforms). Ensure they have access to the necessary resources to fully immerse themselves in the tour. Respond promptly to any inquiries or concerns they may have.</rule>
+<judge>If the communication is established, the state should be end and move to the next state, output <end>1</end>. Otherwise, output <end>0</end>.</judge>
+</state>
+
+<state>
+<state_name>Feedback and Improvement State</state_name>
+<task>Encourage travelers to provide feedback and use it to enhance future tours.</task>
+<rule>After each virtual travel experience, ask travelers for their feedback and suggestions. Value their opinions and use their input to improve the overall tour experience. Consider adjusting the pacing, adding more interactive elements, or exploring new destinations based on the feedback received.</rule>
+<judge>If feedback is received, the state should be end and move to the next state, output <end>1</end>. Otherwise, output <end>0</end>.</judge>
+</state>"""
+    if index == 0:
+        example = design_assistant
+    elif index == 1:
+        example = tutor
+    elif index == 2 :
+        example = online_medical_consultant
+    elif index == 3 :
+        example = online_legal_consultant
+    elif index == 4 :
+        example = online_financial_advisor
+    elif index == 5 :
+        example = virtual_tour_guide
+    else:
+        example = default
+
+    return """You are a master of character description, and your goal is to design several states for the character based on the provided character information. For each state, outline the character's tasks and the rules that can help them better accomplish these tasks, ultimately aiding them in achieving their final objective.
+input:<target>{{the discription of the target character}}</target>
+output:
+<role>{{the discription of the role of the character}}</role>
+<style>{{the style of the character}}</style>
+<state>
+<state_name>{{the name of the state}}</state_name>
+<task>the task of the character in current state</task>
+<rule>the rules that can help target character better acomplish his tasks in current state </rule>
+<judge>{{when to leave this state to next state.Must strictly follow the format of:If {{when to leave}},the state should be end and move to next state,output<end>1</end>,else if the state should not be end,output <end>0</end>}}</judge>
+</state>
+
+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.
+""".format(example)
+
+
+design_states_cot_system_prompt="""You are a character description master.Please translate the <target> into more reasonable expressions,enrich his character details and behavioral logic to make his behavior more reasonable ,help him design more steps to better complete his tasks in the current scenario, and allowing the scene to proceed normally), and think carefully step by step!"""
+

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