update

app.py

@@ -0,0 +1,284 @@
+import sys
+sys.path.append("../../Gradio_Config")
+import os
+from gradio_base import WebUI, UIHelper, PORT, HOST
+from gradio_config import GradioConfig as gc
+from gradio_config import StateConfig as sc
+from typing import List
+import gradio as gr
+
+
+class NovelUI(WebUI):
+    
+    node2show = {
+        "Node 1": "Write Character Settings and Script Outlines🖊️",
+        "Node 2": "Expand the first chapter<br>✍️",
+        "Node 3": "Expand the second chapter<br>✍️",
+        "Node 4": "Expand the third chapter<br>✍️",
+        "state1": "Perform the first plot<br>🎭",
+        "state2": "Perform the second plot<br>🎭",
+        "state3": "Perform the third plot<br>🎭",
+        "state4": "Perform the forth plot<br>🎭"
+    }
+    show2node = {}
+    
+    def render_and_register_ui(self):
+        self.agent_name:list = [self.cache["agents_name"]] if isinstance(self.cache["agents_name"], str) else self.cache['agents_name']
+        gc.add_agent(self.agent_name)
+    
+    def handle_message(self, history:list, record:list, state, agent_name, token, node_name):
+        RECORDER = True if state//10 ==2 else False
+        render_data:list = record if RECORDER else history
+        data:list = self.data_recorder if RECORDER else self.data_history
+        if state % 10 == 0:
+            data.append({agent_name: token})
+        elif state % 10 == 1:
+            # Same state. Need to add new bubble in same bubble.
+            data[-1][agent_name] += token
+        elif state % 10 == 2:
+            # New state. Need to add new bubble.
+            render_data.append([None, ""])
+            data.clear()
+            data.append({agent_name: token})
+        else:
+            assert False, "Invalid state."
+        render_data = self.render_bubble(render_data, data, node_name, render_node_name=True)
+        if RECORDER:
+            record = render_data
+        else:
+            history = render_data
+        return history, record
+    
+    def update_progress(self, node_name, node_schedule):
+        DONE = True
+        node_name = self.node2show[node_name]
+        for idx, name in enumerate(self.cache['nodes_name']):
+            name = self.node2show[name]
+            self.progress_manage['show_type'][idx] = "active-show-up"
+            self.progress_manage['show_content'][idx] = ("" if name != node_name else "💬",)
+            if name == node_name:
+                DONE = False
+                self.progress_manage['schedule'][idx] = node_schedule
+            elif DONE:
+                self.progress_manage['schedule'][idx] = 100
+            elif DONE == False:
+                self.progress_manage['schedule'][idx] = 0
+        if self.cache['nodes_name'].index(self.show2node[node_name]) ==  len(self.cache['nodes_name']) - 2 and node_schedule == 100:
+            self.progress_manage['schedule'][-1] = 100
+        return sc.FORMAT.format(
+            sc.CSS,
+            sc.update_states(
+                current_states=self.progress_manage["schedule"],
+                current_templates=self.progress_manage["show_type"],
+                show_content=self.progress_manage["show_content"]
+            )
+        )
+    
+    def __init__(
+        self,
+        client_cmd: list,
+        socket_host: str = HOST,
+        socket_port: int = PORT,
+        bufsize: int = 1024,
+        ui_name: str = "NovelUI"
+    ):
+        super(NovelUI, self).__init__(client_cmd, socket_host, socket_port, bufsize, ui_name)
+        self.first_recieve_from_client()
+        for item in ['agents_name', 'nodes_name', 'output_file_path', 'requirement']:
+            assert item in self.cache
+        self.progress_manage = {
+            "schedule": [None for _ in range(len(self.cache['nodes_name']))],
+            "show_type": [None for _ in range(len(self.cache['nodes_name']))],
+            "show_content": [None for _ in range(len(self.cache['nodes_name']))]
+        }
+        NovelUI.show2node = {NovelUI.node2show[_]:_ for _ in NovelUI.node2show.keys()}
+        
+    def construct_ui(self):
+        with gr.Blocks(css=gc.CSS) as demo:
+            with gr.Column():
+                self.progress = gr.HTML(
+                    value=sc.FORMAT.format(
+                        sc.CSS,
+                        sc.create_states([NovelUI.node2show[name] for name in self.cache['nodes_name']], False)
+                    )
+                )
+                with gr.Row():
+                    with gr.Column(scale=6):
+                        self.chatbot = gr.Chatbot(
+                            elem_id="chatbot1",
+                            label="Dialog",
+                            height=500
+                        )
+                        with gr.Row():
+                            self.text_requirement = gr.Textbox(
+                                placeholder="Requirement of the novel",
+                                value=self.cache['requirement'],
+                                scale=9
+                            )
+                            self.btn_start = gr.Button(
+                                value="Start",
+                                scale=1
+                            )
+                        self.btn_reset = gr.Button(
+                            value="Restart",
+                            visible=False
+                        )
+                    with gr.Column(scale=5):
+                        self.chat_record = gr.Chatbot(
+                            elem_id="chatbot1",
+                            label="Record",
+                            visible=False
+                        )
+                        self.file_show = gr.File(
+                            value=[],
+                            label="FileList",
+                            visible=False
+                        )
+                        self.chat_show = gr.Chatbot(
+                            elem_id="chatbot1",
+                            label="FileRead",
+                            visible=False
+                        )
+            
+                # ===============Event Listener===============
+                self.btn_start.click(
+                    fn=self.btn_start_when_click,
+                    inputs=[self.text_requirement],
+                    outputs=[self.chatbot, self.chat_record, self.btn_start, self.text_requirement]
+                ).then(
+                    fn=self.btn_start_after_click,
+                    inputs=[self.chatbot, self.chat_record],
+                    outputs=[self.progress, self.chatbot, self.chat_record, self.chat_show, self.btn_start, self.btn_reset, self.text_requirement, self.file_show]
+                )
+                self.btn_reset.click(
+                    fn=self.btn_reset_when_click,
+                    inputs=[],
+                    outputs=[self.progress, self.chatbot, self.chat_record, self.chat_show, self.btn_start, self.btn_reset, self.text_requirement, self.file_show]
+                ).then(
+                    fn=self.btn_reset_after_click,
+                    inputs=[],
+                    outputs=[self.progress, self.chatbot, self.chat_record, self.chat_show, self.btn_start, self.btn_reset, self.text_requirement, self.file_show]
+                )
+                self.file_show.select(
+                    fn=self.file_when_select,
+                    inputs=[self.file_show],
+                    outputs=[self.chat_show]
+                )
+                # ===========================================
+            self.demo = demo
+            
+    def btn_start_when_click(self, text_requirement:str):
+        """
+        inputs=[self.text_requirement],
+        outputs=[self.chatbot, self.chat_record, self.btn_start, self.text_requirement]
+        """
+        history = [[UIHelper.wrap_css(content=text_requirement, name="User"), None]]
+        yield history,\
+            gr.Chatbot.update(visible=True),\
+            gr.Button.update(interactive=False, value="Running"),\
+            gr.Textbox.update(value="", interactive=False)
+        self.send_start_cmd({'requirement': text_requirement})
+        return 
+        
+    def btn_start_after_click(self, history:List, record):
+        def walk_file():
+            print("file:", self.cache['output_file_path'])
+            files = []
+            for _ in os.listdir(self.cache['output_file_path']):
+                if os.path.isfile(self.cache['output_file_path']+'/'+_):
+                    files.append(self.cache['output_file_path']+'/'+_)
+            
+            return files
+        """
+        inputs=[self.chatbot, self.chat_record],
+        outputs=[self.progress, self.chatbot, self.chat_record, self.chat_show, self.btn_start, self.btn_reset, self.text_requirement, self.file_show]
+        """
+        self.data_recorder = list()
+        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, node_schedule = data
+                assert isinstance(state, int)
+                fs:List = walk_file()
+                # 10/11/12 -> history
+                # 20/21/22 -> recorder
+                # 99 -> finish
+                # 30 -> register new agent
+                assert state in [10, 11, 12, 20, 21, 22, 99, 30]
+                if state == 30:
+                    # register new agent.
+                    gc.add_agent(eval(agent_name))
+                    continue
+                if state == 99:
+                    # finish
+                    yield gr.HTML.update(value=self.update_progress(node_name, node_schedule)),\
+                        history,\
+                        gr.Chatbot.update(visible=True, value=record),\
+                        gr.Chatbot.update(visible=True),\
+                        gr.Button.update(visible=True, interactive=False, value="Done"),\
+                        gr.Button.update(visible=True, interactive=True),\
+                        gr.Textbox.update(visible=True, interactive=False),\
+                        gr.File.update(value=fs, visible=True, interactive=True)
+                    return
+                
+                history, record = self.handle_message(history, record, state, agent_name, token, node_name)
+                # [self.progress, self.chatbot, self.chat_record, self.chat_show, self.btn_start, self.btn_reset, self.text_requirement, self.file_show]
+                yield gr.HTML.update(value=self.update_progress(node_name, node_schedule)),\
+                        history,\
+                        gr.Chatbot.update(visible=True, value=record),\
+                        gr.Chatbot.update(visible=False),\
+                        gr.Button.update(visible=True, interactive=False),\
+                        gr.Button.update(visible=False, interactive=True),\
+                        gr.Textbox.update(visible=True, interactive=False),\
+                        gr.File.update(value=fs, visible=True, interactive=True)
+    
+    def btn_reset_when_click(self):
+        """
+        inputs=[],
+        outputs=[self.progress, self.chatbot, self.chat_record, self.chat_show, self.btn_start, self.btn_reset, self.text_requirement, self.file_show]
+        """
+        return gr.HTML.update(value=sc.create_states(states_name=self.cache['nodes_name'])),\
+            gr.Chatbot.update(value=None),\
+            gr.Chatbot.update(value=None, visible=False),\
+            gr.Chatbot.update(value=None, visible=False),\
+            gr.Button.update(value="Restarting...", visible=True, interactive=False),\
+            gr.Button.update(value="Restarting...", visible=True, interactive=False),\
+            gr.Textbox.update(value="Restarting...", interactive=False, visible=True),\
+            gr.File.update(visible=False)
+    
+    def btn_reset_after_click(self):
+        """
+        inputs=[],
+        outputs=[self.progress, self.chatbot, self.chat_record, self.chat_show, self.btn_start, self.btn_reset, self.text_requirement, self.file_show]
+        """
+        self.reset()
+        self.first_recieve_from_client(reset_mode=True)
+        return gr.HTML.update(value=sc.create_states(states_name=self.cache['nodes_name'])),\
+            gr.Chatbot.update(value=None),\
+            gr.Chatbot.update(value=None, visible=False),\
+            gr.Chatbot.update(value=None, visible=False),\
+            gr.Button.update(value="Start", visible=True, interactive=True),\
+            gr.Button.update(value="Restart", visible=False, interactive=False),\
+            gr.Textbox.update(value="", interactive=True, visible=True),\
+            gr.File.update(visible=False)
+    
+    def file_when_select(self, file_obj):
+        """
+        inputs=[self.file_show],
+        outputs=[self.chat_show]
+        """
+        CODE_PREFIX = "```json\n{}\n```"
+        with open(file_obj.name, "r", encoding='utf-8') as f:
+            contents = f.readlines()
+        codes = "".join(contents)
+        return [[CODE_PREFIX.format(codes),None]]
+      
+   
+if __name__ == '__main__':
+    ui = NovelUI(client_cmd=["python","gradio_backend.py"])
+    ui.construct_ui()
+    ui.run(share=True)

cmd_perform.py

@@ -0,0 +1,70 @@
+import yaml
+import os
+import argparse
+import random
+import sys
+sys.path.append("../../../src/agents")
+sys.path.append("../../Gradio_Config")
+from agents.SOP import SOP
+from agents.Agent import Agent
+from agents.Environment import Environment
+from gradio_base import Client
+from agents.Memory import Memory
+# from gradio_example import DebateUI
+
+# Client.server.send(str([state, name, chunk, node_name])+"<SELFDEFINESEP>")
+# Client.cache["start_agent_name"]
+# state = 10, 11, 12, 30
+
+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!")
+            break
+        
+        if current_state.is_begin:
+            print("The new state has begun!")
+            # clear agent's long_term_memory
+            for agent_name, agent_class in agents.items():
+                agent_class.long_term_memory = []
+            # clear environment.shared_memory["long_term_memory"]
+            environment.shared_memory["long_term_memory"] = []
+        
+        action = current_agent.step(current_state,"")   #component_dict = current_state[self.role[current_node.name]]   current_agent.compile(component_dict) 
+        response = action.response
+        ans = ""
+        for i,res in enumerate(response):
+            # if res == '\n\n':
+            #     continue
+            state = 10
+            if action.state_begin:
+                state = 12
+                action.state_begin = False
+            elif i>0:
+                state = 11
+            elif action.is_user:
+                state = 30
+            Client.send_server(str([state, action.name, res, current_state.name, 50]))
+            # Client.server.send(str([state, action["name"], res, current_state.name])+"<SELFDEFINESEP>")
+            ans += res
+            print(res)
+        print(ans)
+        environment.update_memory(Memory(action.name, action.role, ans),current_state)
+
+if __name__ == '__main__':
+    agents,sop,environment = init("novel_outline.json")
+    run(agents,sop,environment)

create_sop.py

@@ -0,0 +1,204 @@
+import os
+import json
+
+def create_sop(folder_name: str = "novel_outline", encoding: str = "utf-8", save_name: str = "novel_outline") -> None:
+    folder = f'./{folder_name}'
+    file_list = os.listdir(folder)
+    plot_list = []
+
+    for file in file_list:
+        if "character" in file:
+            character_file = file
+        # elif "chapter" in file and "plot" in file:
+        elif "plot" in file:
+            plot_list.append(file)
+    plot_list.sort()
+
+    with open(os.path.join(folder, character_file), 'r', encoding=encoding) as f:
+        character_settings = json.load(f)
+
+    plot_list_new = []
+    for plot_name in plot_list:
+        legal = True
+        with open(os.path.join(folder, plot_name), 'r', encoding=encoding) as f:
+            plot = json.load(f)
+        c_mentioned = plot["characters"]
+        for c in c_mentioned:
+            if c not in character_settings:
+                legal = False
+                break
+        if legal:
+            plot_list_new.append(plot_name)
+    plot_list = plot_list_new
+    plot_list.sort()
+            
+
+    # creat json file of sop
+    sop_file = f"./{save_name}.json"
+    sop_dict = {
+        "config": {
+            "API_KEY": "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",
+            "PROXY": "",
+            "MAX_CHAT_HISTORY" : "100",
+            "TOP_K" : "1",
+            "ACTIVE_MODE" : "0",
+            "GRADIO" : "0",
+            "User_Names" : "[]"
+        },
+        "LLM_type": "OpenAI",
+        "LLM": {
+            "temperature": 0.0,
+            "model": "gpt-3.5-turbo-16k-0613",
+            "log_path": "logs/god"
+        },
+        "agents": {},
+        "root": "state1",
+        "relations": {},
+        "states": {
+            "end_state":{
+                "name":"end_state",
+                "agent_states":{}
+            }
+        }
+    }
+    
+    nodes_num = len(plot_list)
+    # nodes_num = 4 if nodes_num > 4 else nodes_num
+    plot_list_new = []
+    for i in range(nodes_num):
+        plot_file = plot_list[i]
+        with open(os.path.join(folder, plot_file), 'r', encoding=encoding) as f:
+            plot = json.load(f)
+        plot_content = plot["plot"] 
+        c_mentioned = plot["characters"]
+        if len(c_mentioned) > 1:
+            plot_list_new.append(plot_file)
+    plot_list = plot_list_new
+    nodes_num = len(plot_list)
+    nodes_num = 4 if nodes_num > 4 else nodes_num
+    
+    for i in range(nodes_num):
+        node_name = f"state{i+1}"
+        plot_file = plot_list[i]
+        with open(os.path.join(folder, plot_file), 'r', encoding=encoding) as f:
+            plot = json.load(f)
+        c_mentioned = plot["characters"]
+        if "Director" not in sop_dict["agents"]:
+            sop_dict["agents"]["Director"] = {}
+        if "style" not in sop_dict["agents"]["Director"]:
+            sop_dict["agents"]["Director"]["style"] = "Commanding, directive"
+        if "roles" not in sop_dict["agents"]["Director"]:
+            sop_dict["agents"]["Director"]["roles"] = {}
+        sop_dict["agents"]["Director"]["roles"][node_name] = "Director"
+        
+        for c in c_mentioned:
+            if c not in sop_dict["agents"]:
+                sop_dict["agents"][c] = {}
+            if "style" not in sop_dict["agents"][c]:
+                sop_dict["agents"][c]["style"] = character_settings[c]["speaking_style"]
+            if "roles" not in sop_dict["agents"][c]:
+                sop_dict["agents"][c]["roles"] = {}
+            sop_dict["agents"][c]["roles"][node_name] = c
+
+    for i in range(nodes_num):
+        if i == nodes_num - 1:
+            node_name = f"state{i+1}"
+            sop_dict["relations"][node_name] = {"0": node_name, "1": "end_state"}
+            sop_dict["relations"]["end_state"] = {"0": "end_state"}
+        else:
+            node_name = f"state{i+1}"
+            sop_dict["relations"][node_name] = {"0": node_name, "1": f"state{i+2}"}
+
+
+    for i in range(nodes_num):
+        node_name = f"state{i+1}"
+        plot_file = plot_list[i]
+        with open(os.path.join(folder, plot_file), 'r', encoding=encoding) as f:
+            plot = json.load(f)
+        plot_content = plot["plot"] 
+        c_mentioned = plot["characters"]
+
+        c_string = ", ".join(c_mentioned)
+        sop_dict["states"][node_name] = {"begin_role" : "Director", "begin_query" : "<Director>I'm going to start posting performance instructions now, so please follow my instructions, actors and actresses.</Director>", }
+        sop_dict["states"][node_name]["environment_prompt"] = f"The current scene is a playing of a \"script\", with the main characters involved: Director, {c_string}. The content of the \"script\" that these characters need to play is: \"{plot_content}\". The characters have to act out the \"script\" together. One character performs in each round."
+        sop_dict["states"][node_name]["name"] = node_name
+        sop_dict["states"][node_name]["roles"] = ["Director"] + c_mentioned
+        sop_dict["states"][node_name]["LLM_type"] = "OpenAI"
+        sop_dict["states"][node_name]["LLM"] = {
+                "temperature": 1.0,
+                "model": "gpt-3.5-turbo-16k-0613",
+                "log_path": f"logs/{node_name}"
+            }
+        sop_dict["states"][node_name]["agent_states"] = {}
+        sop_dict["states"][node_name]["agent_states"]["Director"] = {
+                        "LLM_type": "OpenAI",
+                        "LLM": {
+                            "temperature": 1.0,
+                            "model": "gpt-3.5-turbo-16k-0613",
+                            "log_path": "logs/director"
+                        },
+                        "style": {
+                        "role": "Director",
+                        "style": "Commanding, directive"
+                        },
+                        "task": {
+                        "task": "You are the director of this \"script\", you need to plan the content of the \"script\" into small segments, each segment should be expanded with more detailed details, and then you need to use these subdivided segments one at a time as instructions to direct the actors to perform, you need to specify which actor or actors are to perform each time you issue instructions.  Your instructions must include what the actors are going to do next, and cannot end with \"Please take a break\" or \"Prepare for the next round of performances\". You can't repeat instructions you've given in the history of the dialog! Each time you give a new instruction, it must be different from the one you gave before! When you have given all your instructions, reply with \"Show is over\" and do not repeat the same instruction! Note: You can only output in English!"
+                        },
+                        "rule": {
+                        "rule": "You are only the Director, responsible for giving acting instructions, you cannot output the content of other characters."
+                        },
+                        "last":{
+                        "last_prompt":"Remember, your identity is the Director, you can only output content on behalf of the Director, the output format is \n<Director>\n....\n</Director>\n Only need to output one round of dialog!"
+                        }
+                    }
+        for c in c_mentioned:
+            c_other = [item for item in c_mentioned if item != c]
+            c_other_string = ', '.join(c_other)
+            c_setting = character_settings[c]
+            sop_dict["states"][node_name]["agent_states"][c] = {
+                        "LLM_type": "OpenAI",
+                        "LLM": {
+                            "temperature": 1.0,
+                            "model": "gpt-3.5-turbo-16k-0613",
+                            "log_path": f"logs/{c}"
+                        },
+                        "style": {
+                        "role": c,
+                        "style": c_setting["speaking_style"]
+                        },
+                        "task": {
+                        "task": f"You are {c} in this \"script\" and you need to follow the Director's instructions and act with {c_other_string}."
+                        },
+                        "rule": {
+                        "rule": f'Your settings are: your name is {c_setting["role_name"]}, your gender is {c_setting["gender"]}, your age is {c_setting["age"]} years old, your occupation is {c_setting["occupation"]}, your personality is {c_setting["personality"]}, your speaking style is {c_setting["speaking_style"]}, your relationship with other people is {c_setting["relation_with_others"]}, your background is {c_setting["background"]}. Your performance should match your setting, the content of the "script" and the Director\'s instructions. Note: Do not respond to the Director by saying things like "yes" or "yes, director", just follow the Director\'s instructions and interact with the other actors! You need to output NULL when the Director\'s current instruction does not specify you to perform, or when you think the Director\'s current instruction does not require you to perform; you cannot repeat what you have said in the dialog history! Each time you speak, it has to be different from previous speeches you have made! Your performances can only contain your words, actions, etc. alone, not the performances of others!'
+                        },
+                        "last":{
+                        "last_prompt": f"Remember, your identity is {c} and you can only output content on behalf of {c}, the output format is \n<{c}>\n....\n</{c}>\n Just output one round of dialog!\nWhen the current instruction posted by the Director does not specify you to perform or when you think the current instruction from the Director does not require you to perform, you need to output \n<{c}>\nNULL\n</{c}>\n"
+                        }
+                    }
+        
+        c_call_string = ""
+        for c in c_mentioned:
+            c_call_string += f", if it is {c}, then output <output>{c}</output>"
+        c_string_2 = ", ".join(c_mentioned)
+
+        sop_dict["states"][node_name]["controller"] = {
+                    "controller_type": "order",
+                    "max_chat_nums": 80,
+                    "judge_system_prompt": f"Determine whether the Director, {c_string} have finished the \"script\", if so, output <output>1</output>; if not, output <output>0</output>. Note: If the Director says \"Show is over\" or something similar to \"Show is over\", output <output>1</output>; if the Director's instructions state that this is the last scene, you should wait until the actors have finished the scene before outputting <output>1</output>; if you find that a character has repeated the same dialog many times, output <output>1</output>.",
+                    "judge_last_prompt": f"Depending on the current status of the performance process, determine whether the Director, {c_string} have finished the \"script\", if so, output <output>1</output>; if not, output <output>0</output>. Note: If the Director says \"Show is over\" or something similar to \"Show is over\", output <output>1</output>; if the Director's instructions state that this is the last scene, you should wait until the actors have finished the scene before outputting <output>1</output>; if you find that a character has repeated the same dialog many times, output <output>1</output>.",
+                    "judge_extract_words": "output",
+                    "call_system_prompt": f"You need to determine whose turn it is to output the content, if it is the Director, then output <output>Director</output>{c_call_string}, {c_string_2} are actors, you should let the Director output the performance instruction first each time, and then arrange which actor to output the content for the next round according to the specified person in the Director's instruction, you may need to arrange the actor to perform the performance for several rounds after the Director has given the instruction. When the actors' several rounds of output contents have finished the last instruction, you should let the Director continue to output the instruction.",
+                    "call_last_prompt": f"Depending on the current status of the performance process, you need to determine whose turn it is to output the content, if it is the Director, then output <output>Director</output>{c_call_string}, {c_string_2} are actors, you should let the Director output the performance instruction first each time, and then arrange which actor to output the content for the next round according to the specified person in the Director's instruction, you may need to arrange the actor to perform the performance for several rounds after the Director has given the instruction. When the actors' several rounds of output contents have finished the last instruction, you should let the Director continue to output the instruction.",
+                    "call_extract_words": "output"
+                    }
+        
+    # save
+    json_obj = json.dumps(sop_dict, ensure_ascii=False, indent=4, )
+    with open(sop_file, 'w') as f:
+        f.write(json_obj)
+
+if __name__ == "__main__":
+    # create_sop(folder_name='jintian_ver1_cn', encoding='GB2312', save_name="jintian_ver1_cn")
+    # create_sop(folder_name='jintian', encoding='utf-8', save_name="jintian")
+    create_sop()

gradio_backend.py

@@ -0,0 +1,98 @@
+import sys
+sys.path.append("../../../src/agents")
+sys.path.append("./novel-server")
+sys.path.append("../../Gradio_Config")
+
+import yaml
+import os
+import argparse
+import random
+
+from agents.SOP import SOP
+from agents.Agent import Agent
+from agents.Environment import Environment
+from gradio_base import Client
+from agents.Memory import Memory
+
+from myagent import Node, MyAgent, ask_gpt
+from typing import List, Tuple
+from PROMPT import NOVEL_PROMPT
+from myutils import print_log, new_parse
+import json
+from gradio_base import Client
+
+
+from cmd_outline import run_node_1, run_node_2
+from cmd_perform import init, run
+from create_sop import create_sop
+
+def show_in_gradio(state, name, chunk, node_name):
+    if state == 30:
+        Client.send_server(str([state, name, chunk, node_name, 50]))
+        return
+
+    if name.lower() in ["summary", "recorder"]:
+        """It is recorder"""
+        name = "Recorder"
+        if state == 0:
+            state = 22
+        else:
+            state = 21
+    else:
+        if Client.current_node != node_name and state == 0:
+            state = 12
+            Client.current_node = node_name
+        elif Client.current_node != node_name and state != 0:
+            assert False
+        else:
+            state = 10 + state
+    Client.send_server(str([state, name, chunk, node_name, 50]))
+
+
+if __name__ == "__main__":
+    MyAgent.SIMULATION = False
+    MyAgent.TEMPERATURE = 0.3
+    stream_output = True
+    output_func = show_in_gradio
+    print("in")
+
+    if output_func is not None:
+        client = Client()
+        Client.send_server = client.send_message
+        client.send_message(
+            {
+                "agents_name": ['Elmo','Abby', 'Zoe', 'Ernie', 'Bert', 'Oscar'],
+                "nodes_name": ['Node 1','Node 2','Node 3', 'Node 4', 'state1', 'state2', 'state3', 'state4'],
+                "output_file_path": f"{os.getcwd()+'/novel_outline'}",
+                "requirement": NOVEL_PROMPT['Node 1']["task"]
+            }
+        )
+        client.listening_for_start_()
+        NOVEL_PROMPT['Node 1']['task'] = client.cache['requirement']
+        print("Received: ", client.cache['requirement'])
+        outline = run_node_1(
+            stream_output=stream_output,
+            output_func=output_func,
+            task_prompt=client.cache['requirement']
+        )
+    else:
+        outline = run_node_1(
+            stream_output=stream_output,
+            output_func=output_func
+        )
+        # pass
+    print(outline)
+    run_node_2(outline, stream_output=stream_output, output_func=output_func)
+    print("done")
+
+    create_sop()
+    
+    with open("novel_outline.json", 'r') as f:
+        data = json.load(f)
+    name_list = list(data["agents"].keys())
+    
+    show_in_gradio(30, str(name_list), " ", " ")
+
+    agents,sop,environment = init("novel_outline.json")
+    run(agents,sop,environment)
+    

gradio_base.py

@@ -0,0 +1,559 @@
+# 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
+
+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 messaget 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]
+            # Recieve 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()` automtically.
+        self.send_message(str(message))
+    
+    def _third_send(self):
+        # Send start command.
+        # It will be executed in `self.send_start_cmd()` automtically.
+        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: excuting `{' '.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()
+
+
+if __name__ == '__main__':
+    pass

gradio_config.py

@@ -0,0 +1,437 @@
+# 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>
+        """,
+
+        # Backrgound-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):
+        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

novel-server/PROMPT.py

@@ -0,0 +1,400 @@
+NOVEL_PROMPT = {
+    "Node 1": {
+        "task": \
+            """
+            Now I need to write a script outline about modern family ethics, the script outline needs to have about 3 chapters and I need to make sure that the script is appealing. The primary characters of the script are Mike Smith and Jane Black, Mike is an internet company programmer and Jane is a high school chemistry teacher, they have a child who is in kindergarten, in addition to the two main characters above, there are 2 additional secondary characters that need to be designed to enrich the script. Please set up names for each character, which should conform to the `first name + last name` format, e.g. Jenny White, names like a and b are forbidden. A summary of each chapter in the outline should be about 100 words or so, and the title of each chapter is required.
+            """,
+        "agents": {
+            "Elmo": {
+                "system": \
+                    """
+                    You're Elmo, you specialize in character design and first draft outline writing, and you'll be working with two other people (Abby, who rewrites based on suggestions, and Zoe, who is responsible for providing advice and controlling the overall process) to complete the following task:
+                    {}
+                    
+                    
+                    In addition to this, you can post your own opinions when Abby provides a rewritten character design or outline, or when Zoe gives her opinion.
+                    You will need to first output your current assignment and then output according to the assignment, here are your output formatting requirements:
+                    {}
+                    Please format the output strictly according to the above.
+                    
+                    
+                    Here are the guidelines you must follow:
+                    1. no apologizing or thanking each other is allowed;
+                    2. if someone apologizes or thanks, remind and stop them immediately;
+                    3. do not do anything unrelated to the task;
+                    4. do not say repetitive things;
+                    5. remind and stop someone as soon as they say something repetitive.
+                    """,
+                "output": \
+                    """
+                    First output the current target:
+                        <TARGET>{If there is no first draft of the character setting, then output CHARACTER DESIGN; if there is a first draft of the character setting and you have comments and the outline is not yet written, then output ADVICE CHARACTER; if you do not have comments on the character setting and the outline is not yet written, then output OUTLINE DESIGN; if there is a first draft of the outline and you have comments to make, then output ADVICE OUTLINE; if you think both the character setting and the outline are completed, then output NOTHING. And then follow the following requirements to continue output.}</TARGET>
+                        <NUMBER>{If you are writing the character setting, output how many people need to be designed according to the requirement, including the main characters and secondary characters; if you are writing the first draft of the outline, output how many chapters need to be designed according to the requirement.}</NUMBER>
+                        <THOUGHT>{If you are writing a character setting or giving your suggestions, output NONE; if you are writing the first draft of an outline, based on the characters, please conceptualize and output the main idea that needs to be expressed in the story, as well as how the main idea is expressed (how it develops), i.e., the impact of the various characters and interactions between characters on the plot and the main idea, with a word count of no less than 100 words.}</THOUGHT>
+                        
+                    It is then divided into 4 conditions and formatted for output according to the corresponding conditions:
+                    
+                        Condition 1. If TARGET is CHARACTER DESIGN:
+                        <CHARACTER DESIGN>
+                        <FIRST NAME>{Output the first name of the character to be designed}</FIRST NAME>
+                        <LAST NAME>{Output the last name of the character to be designed}</LAST NAME>
+                        <NAME>{Character Name}</NAME>
+                        <ROLE>{Output it is a secondary or primary character}</ROLE>
+                        <RATIONALES>{Output the effect that the design or introduction of the character has on the development of the story and the plot, and what the reader is expected to learn through the character}</RATIONALES>
+                        <ID>{The i-th character}</ID>
+                        <GENDER>{Gender of the character}</GENDER>
+                        <AGE>{Age of the character}</AGE>
+                        <WORK>{Work of the character}</WORK>
+                        <PERSONALITY>{Personality of the character}</PERSONALITY>
+                        <SPEECH STYLE>{Speaking style of the character}</SPEECH STYLE>
+                        <RELATION>{Relations with other characters}</RELATION>
+                        <BACKGROUND>{Character's background in about 50 words based on the character's job, personality and relations with other characters}</BACKGROUND>
+                        </CHARACTER DESIGN>
+                    
+                        Condition 2. If TARGET is OUTLINE DESIGN：
+                        <OUTLINE DESIGN>
+                        <RATIONALES>{Why this chapter is designed, how it connects to the previous chapter, what the chapter hopes to convey to the audience, and as much as possible, the cause and effect of the chapter}</RATIONALES>
+                        <ID>{The i-th chapter}</ID>
+                        <TITLE>{Chapter Title}</TITLE>
+                        <CHARACTER INVOLVED>{Characters involved, try to make sure there are primary characters in each chapter}</CHARACTER INVOLVED>
+                        <ABSTRACT>{Approximate plot of the chapter}</ABSTRACT>
+                        </OUTLINE DESIGN>
+                    
+                        Condition 3. If TARGET is ADVICE CHARACTER or ADVICE OUTLINE：
+                        <ADVICE>
+                        {First analyze the current (point out a certain chapter or a certain character) strengths and weaknesses, do not copy other people's opinions, if there are other people's opinions, by the way, analyze other people's opinions, and then according to the strengths and weaknesses to put forward a detailed, concrete, non-abstract modification, it is best to give a specific direction of improvement, modification opinions please try to be as detailed as possible, and give the reason for it}
+                        </ADVICE>
+                    
+                        If it has already been completed, no output is required.
+                    """,
+                "query": \
+                    """
+                    Please provide opinions based on everyone's ideas and historical information, do not repeat yourself or others, and follow the format output below:
+                    {}
+                    """
+            },
+            "Abby": {
+                "system": \
+                    """
+                    You are Abby, you specialize in rewriting character designs and outlines based on suggestions, with years of relevant experience, and you will be working with two other people (Elmo, who is responsible for writing the first draft, and Zoe, who is responsible for providing suggestions and controlling the overall process, respectively) to complete the following task together:
+                    {}
+                    If the characters have been designed but the first draft of the outline hasn't been generated yet, the first draft of the outline is written by Elmo, so please output to have Elmo write the outline.
+                    
+                    
+                    Here is the format of your output:
+                    {}
+                    Please follow the above format strictly for the output.
+                    
+                    
+                    Here are the guidelines you must follow:
+                    1. no apologizing or thanking each other is allowed;
+                    2. if someone apologizes or thanks, remind and stop them immediately;
+                    3. do not do anything unrelated to the task;
+                    4. do not say repetitive things;
+                    5. remind and stop someone as soon as they say something repetitive.
+                    """,
+                "output": \
+                    """
+                    <TARGET>{If you are rewriting the character setting, output CHARACTER DESIGN; if you are rewriting the first draft of the outline, output OUTLINE DESIGN; if you think that the current character setting and outline have been completed, and no other people have proposed modification opinions, output NOTHING.}</TARGET>
+                    <RATIONALES>{Please analyze other people's suggestions step by step here (focusing on the comments given by <ADVICE>, <OUTLINE ADVICE> and <CHARACTER ADVICE>, first output the original comments, and then publish the details of the modification based on the comments), and write down detailed rewriting directions and ideas (don't copy the other people's comments), specific to a certain character or chapter, and pay attention to make sure that the sentences flow smoothly when rewriting, don't splice them together directly, and need to polish them up!}</RATIONALES>
+                    
+                    Then output in different situations depending on the target:
+                    
+                        If Zoe gives suggestions for the outline, but Elmo does not write a first draft of the outline, no output is required. If neither Zoe nor Elmo gave any suggestions, no output is needed. No output is needed if it has already been completed.
+                    
+                        If the character setting is currently being discussed, please output it in the format below: 
+                        <NAME>{Character Name}</NAME>
+                        <GENDER>{Character Gender}</GENDER>
+                        <AGE>{Character Age}</AGE>
+                        <WORK>{Character Work}</WORK>
+                        <PERSONALITY>{Character Personality}</PERSONALITY>
+                        <SPEECH STYLE>{Speaking style of the character}</SPEECH STYLE>
+                        <RELATION>{Relations with other characters}</RELATION>
+                        <BACKGROUND>{Character Background}</BACKGROUND>
+                    
+                        If the outline is currently being discussed, please output it in the format below: 
+                        <ID>{The i-th chapter}</ID>
+                        <TITLE>{Chapter Title}</TITLE>
+                        <RATIONALES>{Why this chapter is designed, how it connects to the previous one, what reaction the chapter expects from the audience, and as much as possible, the cause and effect of the situation}</RATIONALES>
+                        <CHARACTER INVOLVED>{Characters involved, try to make sure there are primary characters in each chapter}</CHARACTER INVOLVED>
+                        <WORD COUNT>{required number of words}</WORD COUNT>
+                        <ABSTRACT>{Rewrite chapter abstracts based on previous suggestions and original content}</ABSTRACT>
+                    
+                    """,
+                "query": \
+                    """
+                    Please rewrite it in detail based on everyone's suggestions and historical information and output it in the format below:
+                    {}
+                    """
+            },
+            "Zoe": {
+                "system": \
+                    """
+                    You are Zoe, and you are responsible for the overall control of the task and for providing suggestions on the outline and characters. Together with two other people (Elmo, who writes the first draft, and Abby, who rewrites it based on suggestions), you will complete the following tasks:
+                    {}
+                    Note that no more than three rounds may be spent discussing character settings. 
+                    
+                    Your output is formatted as:
+                    {}
+                    Please follow the above format strictly for the output.
+                    
+                    Here are the guidelines you must follow:
+                    1. no apologizing or thanking each other is allowed;
+                    2. if someone apologizes or thanks, remind and stop them immediately;
+                    3. do not do anything unrelated to the task;
+                    4. do not say repetitive things;
+                    5. remind and stop someone as soon as they say something repetitive;
+                    6. as soon as someone deviates from the topic, please correct them immediately.
+                    """,
+                "output": \
+                    """
+                    <CHARACTER DESIGN>{If done, output DONE, otherwise output DOING}</CHARACTER DESIGN>
+                    <CHARACTER REQUIRE>{Output character requirements based on the task, e.g. number of characters, necessary characters, etc.}</CHARACTER REQUIRE>
+                    <CHARACTER NAME>{Analyze the composition of the names of existing characters one by one, and analyze whether they are legal or not. `first name + last name` is the legal format of name, and output `name (composition, legal or not legal)`, e.g., Doctor Smith (occupation + last name, not legal), Little Jack (nickname, not legal), Bob Green (first name + last name, legal)}</CHARACTER NAME>
+                    <CHARACTER NOW>{According to the CHARACTER NAME field, point out the illegal names, and according to the existing characters, output the current number of characters, character names, etc., and compare the CHARACTER REQUIRE field, analyze and output whether it meets the requirements, such as the number of characters and character naming (whether it meets the  first name + last name), etc., and point out if the name naming doesn't meet this format.}</CHARACTER NOW>
+                    <OUTLINE DESIGN>{If complete, output DONE; if the character design is not yet finalized, output TODO; if the character design is complete and outline writing is underway, output DOING}</OUTLINE DESIGN>
+                    <OUTLINE REQUIRE>{Output outline requirements based on the task, such as the number of chapters, word count requirements, chapter content requirements, etc.}</OUTLINE REQUIRE>
+                    <OUTLINE NOW>{Based on the existing outline, output the number of chapters in the current outline, the number of words and the requirements of the chapters, etc., and compare the OUTLINE REQUIRE field to determine whether the requirements are met. If there is no outline yet, then output None}</OUTLINE NOW>
+                    <SUB TASK>{The current subtask that needs to be completed, output CHARACTER, OUTLINE or None.}</SUBTASK>
+                    <CHARACTER ADVICE>
+                    {If the current task is CHARACTER, according to the CHARACTER NOW and CHARACTER NAME fields, give suggestions for modification in separate lines, if the number of characters is not satisfied, you can add them, **but don't exceed the required number** (don't add an extra number of characters), if you are not satisfied with a certain character, you can make a modification to the character's name, occupation, etc.,. Note that the content of the suggestion needs to be detailed, and give reasons, in addition to suggestions on the content, if the number of characters is not in accordance with the requirements or missing fields, also need to be proposed, the naming of the character to ensure that the `first name + last name` format, other formats do not meet requirements; if the current task is OUTLINE, then output None; if you believe that the current character design has been completed, output DONE}
+                    </CHARACTER ADVICE>
+                    <OUTLINE ADVANTAGE>{Analyze and output the benefits of the current outline; if the current task is not outline, output None}</OUTLINE ADVANTAGE>
+                    <OUTLINE DISADVANTAGE>{Analyze and output the disadvantages of the current outline in detail (including, but not limited to, whether or not the outline contains all of the characters mentioned), and try to make sure that each chapter has primary characters involved; if the current task is not outline, then output None}</OUTLINE DISADVANTAGE>
+                    <OUTLINE ADVICE>
+                    {If the current task is CHARACTER, then output None; if the current task is OUTLINE, according to the advantages and disadvantages and the suggestions of others, output a detailed proposal in separate lists, and give the reasons, the content of the proposal needs to include the chapter and the content of the proposal, in addition to suggestions on the content, if the number of chapters is not in accordance with the requirements or lacking fields, you need to propose; if the current task is None, then output None}
+                    </OUTLINE ADVICE>
+                    <NEXT>{If you think there are no more modifications to the current character, output: "Let Elmo write the first version of the outline"; if you think the current character needs to be modified and you have given your suggestions, output: "Let Abby modify the character"; if you think suggestions for modifications to the outline have been given, output: "Let Abby modify the outline"; if you think the outline and the character have been completed, output end}</NEXT>
+                    """,
+                "query": \
+                    """
+                    Please provide suggestions or take control of the process based on the information above, and output in the format below: 
+                    {}
+                    """
+            }
+        },
+        "summary": {
+            "system": \
+                """
+                You are a person who is good at extracting the main content from a multi-person conversation in a specified format. The task now is:
+                {}
+                
+                I will give you a series of multiple rounds of dialogues with different characters, from which you will need to extract as required, and for content, please try to extract as much as you can from the dialogues as they are, rather than summarizing them. 
+                Your output format is:
+                {}
+                Please follow the above format strictly for the output.
+                """,
+            "output": \
+                """
+                
+                <CHARACTERS>
+                <TOTAL NUMBER>{Total number of characters}</TOTAL NUMBER>
+                <CHARACTER i>
+                    <NAME>{Name of the i-th character}</NAME>
+                    <GENDER>{Gender of the i-th character}</GENDER>
+                    <WORK>{Work of the i-th character}</WORK>
+                    <AGE>{Age of the i-th character}</AGE>
+                    <PERSONALITY>{Personality of the i-th character}</PERSONALITY>
+                    <SPEECH STYLE>{Speaking style of the i-th character}</SPEECH STYLE>
+                    <RELATION>{Relations with others of the i-th character}</RELATION> 
+                    <BACKGROUND>{Background of the i-th character}</BACKGROUND>
+                </CHARACTER i>
+                ...
+                </CHARACTERS>
+                
+                <OUTLINE>
+                <TOTAL NUMBER>{Total number of chapters in the outline}</TOTAL NUMBER>
+                <SECTION i>
+                    <TITLE>{Title of chapter i}</TITLE>
+                    <CHARACTER INVOLVED>{Characters mentioned in chapter i}</CHARACTER INVOLVED>
+                    <ABSTRACT>{Abstract of chapter i}</ABSTRACT>
+                    <RATIONALES>{Function of chapter i in the whole story, desired audience response}</RATIONALES>
+                </SECTION i>
+                ...
+                </OUTLINE>
+                
+                """,
+            "query": \
+                """
+                The following multiple conversations discuss the outline and character settings of the first version, so please try to extract as much as you can from the conversations as they are, rather than summarizing them:
+                {}
+                """
+        }
+    },
+
+    "Node 2": {
+        "task": \
+            """
+            Below are the character settings and outline of a script:
+            <VERSION 1>
+            {}
+            </VERSION 1>
+            {}
+            """,
+        "agents": {
+            "Ernie": {
+                "system": \
+                    """
+                    You are Ernie, who is responsible for the initial expansion of the outline and making suggestions (mainly from the perspective of character and story diversity), and you will be working with two other people (Bert, who expands and rewrites the outline based on suggestions, and Oscar, who takes control of the overall process and provides suggestions) on the following tasks:
+                    {}
+                    
+                    In addition to this, you will need to work with Oscar to provide comments or suggestions on Bert's rewritten outline when there is an expanded version of a particular chapter.
+                    When outputting, you first need to output the current task, and then choose different output formats according to the task:
+                    {}
+                    
+                    Here are the guidelines you must follow:
+                    1. no apologizing or thanking each other is allowed;
+                    2. if someone apologizes or thanks, remind and stop them immediately;
+                    3. do not do anything unrelated to the task;
+                    4. do not say repetitive things;
+                    5. remind and stop someone as soon as they say something repetitive;
+                    6. the outline expansion should be story-rich and not empty.
+                    """,
+                "output": \
+                    """
+                    <TARGET>{Output CHAPTER i if your current task is to expand the content of chapter i; Output ADVICE CHAPTER i if your current task is to advise on the content of chapter i, and advise on the following}</TARGET>
+                    Then output in different situations according to the target:
+                        If modifications are currently being discussed, please follow the format below for output:
+                            <ANALYZE>{Compare the latest rewrite with Oscar's previous suggestions, and then analyze in detail whether all of the rewrites are in accordance with the rewrite's requirements (it is recommended to mention the expanded content and previous suggestions). Next, analyze whether the characters are related, continuous, etc. in the various plots, and assess whether the stories in the plots are coherent and engaging, and whether the individual stories are detailed, and if not, please point out that}</ANALYZE>
+                            <EXTENSION ADVICE>
+                            {Based on the latest rewrite and the analysis above, give suggestions for modifications to the diversity of the characters and the plot, one for each, which should be detailed and reasonable. }
+                            </EXTENSION ADVICE>
+                    
+                        If you currently need to expand a particular chapter, please follow the format below for output according to the chapter corresponding to the outline: 
+                            <TITLE>{Title of chapter i}</TITLE>
+                            <ABSTRACT>{Abstract of chapter i}</ABSTRACT>
+                            <CHARACTER INVOLVED>{The names of the characters mentioned in the i-th chapter}</CHARACTER INVOLVED>
+                            <ROLE>{Output the function of the current chapter in the whole text, including the function for the theme, the function for the audience}</ROLE>
+                            <THINK>{Based on the full text outline, the abstract of the current chapter, and what has been expanded, think about how many plots (at least 3) the i-th chapter needs to be divided into, the spatial and temporal relationships that need to exist between the plots, and briefly conceptualize what each plot will be about. Ensure that there are compelling beginnings, goals and conflicts, climaxes, suspense, and emotional elements interspersed with each other}</THINK>
+                            <PLOT NUMBER>{Total number of plots expanded in the current chapter}</PLOT NUMBER>
+                            <CONTENT>
+                            <PLOT i>
+                            <CHARACTER INVOLVED>{Characters involved in the i-th plot}</CHARACTER INVOLVED>
+                            <DESCRIPTION>{Detailed description of the i-th plot, with at least one small, detailed piece of storytelling, noting the need to take into account previous plots, outlines, and expansions, to ensure spatial and temporal continuity and logic, and to ensure smooth flow and storytelling}</DESCRIPTION>
+                            </PLOT i>
+                            ...
+                            </CONTENT>
+                    
+                        If it is considered that there is no current need for modification and is fully compliant, then output None.
+                    """,
+                "query": \
+                    """
+                    Please provide comments on the expansion of Chapter {} based on other people's comments, rewritten content, and historical information, output in the format below:
+                    {}
+                    Please don't repeat Oscar's words.
+                    """,
+            },
+            "Bert": {
+                "system": \
+                    """
+                    You are Bert, you specialize in rewriting and expanding outlines based on comments and have many years of experience in this field, your writing style is beautiful and vivid, you will work with two other people (Ernie, who is in charge of expanding and suggesting outlines for the first version of the outline, and Oscar, who is in charge of controlling the overall process and providing suggestions) to complete the following tasks:
+                    {}
+                    
+                    Here is the format of your output:
+                    {}
+                    Please follow the above format strictly for the output.
+                    
+                    Here are the guidelines you must follow:
+                    1. no apologizing or thanking each other is allowed;
+                    2. if someone apologizes or thanks, remind and stop them immediately;
+                    3. do not do anything unrelated to the task;
+                    4. do not say repetitive things;
+                    5. remind and stop someone as soon as they say something repetitive;
+                    6. the outline expansion should be story-rich and not empty.
+                    """,
+                "output": \
+                    """
+                    <TARGET>{Output EXPENDING CHAPTER i if the comments are rewriting a specific chapter; output None if everyone is satisfied and there are no comments}</TARGET>
+                    
+                    If a specific chapter is currently being discussed, please rewrite it based on the comments and output it in the format below:
+                        <RATIONALES>{Please analyze here, line by line, based on others' suggestions and the original content, and write a short abstract of the rewritten content}</RATIONALES>
+                        <TITLE>{Title of chapter i}</TITLE>
+                        <ABSTRACT>{Summary of chapter i}</ABSTRACT>
+                        <CHARACTER INVOLVED>{The names of the characters involved in the i-th chapter}</CHARACTER INVOLVED>
+                        <STORY NUMBER>{Total number of plots expanded in the current chapter}</STORY NUMBER>
+                        <CONTENT>
+                        <PLOT i>
+                        <CHARACTER INVOLVED>{Characters involved in the i-th plot}</CHARACTER INVOLVED>
+                        <DESCRIPTION>{Rewrite the i-th plot based on the previous comments and your own rewriting ideas, and in conjunction with the previous content, paying attention to the need to take into account the previous plots, outlines, and expansions, to ensure spatial and temporal continuity and logic, in addition to the need to ensure that the line of the text is smooth and storytelling}</DESCRIPTION>
+                        </PLOT i>
+                        ...
+                        </CONTENT>
+                    """,
+                "query": \
+                    """
+                    Please rewrite chapter {} in detail based on everyone's suggestions and information from history, and output it in the format below:
+                    {}
+                    """,
+            },
+            "Oscar": {
+                "system": \
+                    """
+                    You are Oscar, and you are responsible for the overall control of the task and for providing detailed suggestions on the expanded outline (mainly from the perspective of plot, logic, conflict, and characters), and you will be working with two other people (Ernie, who is responsible for the first version of the outline, and for suggesting the outline, and Bert, who is responsible for expanding and rewriting the outline based on the suggestions), to accomplish the following tasks:
+                    {}
+                    
+                    Your output format is:
+                    {}
+                    Please follow the above format strictly for the output.
+                    
+                    Here are the guidelines you must follow:
+                    1. no apologizing or thanking each other is allowed;
+                    2. if someone apologizes or thanks, remind and stop them immediately;
+                    3. do not do anything unrelated to the task;
+                    4. do not say repetitive things;
+                    5. remind and stop someone as soon as they say something repetitive;
+                    6. as soon as someone deviates from the topic, please correct them immediately.
+                    """,
+                "output": \
+                    """
+                    <SCRIPT OUTLINE EXTENSION>{Determine whether the current expanded chapter is logically self-consistent and meets the requirements, if so then output DONE, otherwise output DOING}</SCRIPT OUTLINE EXTENSION>
+                    <EXTENSION REQUIREMENT>{Output the word count requirements for the current expanded chapter based on the task requirements}</EXTENSION REQUIREMENT>
+                    <EXTENSION NOW>{Output the number of chapters, word count, etc. that have been expanded according to the latest expanded content}</EXTENSION NOW>
+                    <SUB TASK>{Output the title of the chapter that is currently being expanded, output CHAPTER i, and the following suggestions are also made for this chapter}</SUB TASK>
+                    <ADVANTAGE>{Output the strengths of the current latest expansion, line by line, including but not limited to whether the plot, textual presentation, logic is self-explanatory, fields are missing, whether there is a strong conflict, unexpected, whether the characters involved in the current chapter (not the characters of the entire outline) are present in all the plots of the current chapter, whether the story is described in detail, etc., being different from the opinions of other people}</ADVANTAGE>
+                    <DISADVANTAGE>{Output the current disadvantages of the latest expansion content line by line (do not repeat Ernie's words), including but not limited to whether the plot, textual presentation, logic is self-consistent, fields are missing, whether there is a strong conflict, unexpected, whether the characters involved in the current chapter (not the characters of the entire outline) appear in all the plots of the current chapter, whether the story is described in detail, etc., and be different from other people's opinions}</DISADVANTAGE>
+                    <HISTORY ADVICE>{Output Ernie's historical suggestions, line by line.}</HISTORY ADVICE>
+                    <EXTENSION ADVICE>
+                    {Based on the strengths and weaknesses, the expanded plot, and your thoughts, provide suggestions for modifying the text description, plot fluency, and story one by one. The modification suggestions need to specify which specific plot, and the suggestions should be as detailed as possible to ensure that the plot has storytelling, which should be different from Ernie's opinions}
+                    </EXTENSION ADVICE>
+                    Be careful not to repeat what others say.
+                    """,
+                "query": \
+                    """
+                    Please provide feedback on the content of Chapter {} and others' opinions based on the information, outline, and previously expanded chapters above, or control the process and output in the following format:
+                    {}
+                    Please don't repeat Ernie's words.
+                    """,
+            }
+        },
+        "summary": {
+            "system": \
+                """
+                You are skilled at extracting the main content from multiple conversations in a specified format. The current task is:
+                {}
+                
+                I will give you a series of multiple rounds of dialogues with different characters, from which you will need to extract as required, and for content, please try to extract as much as you can from the dialogues as they are, rather than summarizing them.
+                Your output format is:
+                {}
+                Please follow the above format strictly for the output.
+                """,
+            "output": \
+                """
+                # Chapter {i} {Title of chapter i}
+                > There are a total of {n} plots
+                
+                ## Plot j
+                - Characters involved: {names of the characters involved in the j-th plot of chapter i}
+                - Specifics: {the specifics of the expanded j-th plot of chapter i. Don't rewrite or abbreviate, just take it directly from someone else}
+                """,
+            "query": \
+                """
+                The following multiple conversations discuss expanding the plots of chapter {} based on the outline; please try to extract the plots of chapter {} from the conversations as they are, rather than summarizing them:
+                {}
+                """
+        }
+    }
+}
+
+
+
+

novel-server/cmd_outline.py

@@ -0,0 +1,474 @@
+import copy
+import os
+from myagent import Node, MyAgent, ask_gpt, Client
+from typing import List, Tuple
+from PROMPT import NOVEL_PROMPT
+from myutils import print_log, new_parse
+import json
+
+class FirstNode(Node):
+    def __init__(
+        self,
+        name: str,
+        agents: List[MyAgent],
+        start_agent_name: str,
+        start_agent_query: str,
+        summary_agent: MyAgent = None,
+        save: bool=True,
+        stream_output: bool=True,
+        output_func=None,
+    ):
+        super(FirstNode, self).__init__(agents, summary_agent, save)
+        self.name = name
+        self.output_func = output_func
+        self.stream_output = stream_output
+        self.start_agent_name = start_agent_name
+        self.start_agent_query = start_agent_query
+        if self.stream_output:
+            print_log("stream output ......")
+        assert self.start_agent_name in self.agents, \
+            f"invalid agent name `{self.start_agent_name}`"
+
+    def start(self):
+        self.agents[self.start_agent_name].prepare_message(
+            self.start_agent_query+"\n"+self.agents[self.start_agent_name].query
+        )
+        self.agents[self.start_agent_name].output_message(
+            recorder=self.recorder, stream=self.stream_output, output_func=self.output_func,
+            node_name=self.name
+        )
+        # if self.stream_output:
+        #     print(f"【{self.start_agent_name}】 ", end="")
+        #     for chunk in self.agents[self.start_agent_name].send_message(recorder=self.recorder, stream=self.stream_output):
+        #         if chunk is not None:
+        #             print(chunk, end="")
+        #     print()
+        # else:
+        #     self.agents[self.start_agent_name].send_message(recorder=self.recorder, stream=self.stream_output)
+        #     self.print(agent_name=self.start_agent_name)
+
+    def communicate(self):
+        for turn in range(2):
+            for agent_name in ["Zoe", "Abby", "Elmo"]:
+                history = self.recorder.prepare(
+                    agent_name=agent_name,
+                    agents=self.agents,
+                    return_dict=False
+                )
+                query = self.agents[agent_name].query
+                if isinstance(history, str):
+                    history = f"The following are the conversations of others, with what someone says wrapped in `<name>...</name>`: \n{history}\n{query}"
+                elif isinstance(history, list):
+                    history.append({"role": "user", "content": query})
+                self.agents[agent_name].prepare_message(
+                    history
+                )
+                self.agents[agent_name].output_message(
+                    recorder=self.recorder, stream=self.stream_output,
+                    output_func=self.output_func, node_name=self.name
+                )
+                # if not self.stream_output:
+                #     self.agents[agent_name].send_message(
+                #         recorder=self.recorder, stream=self.stream_output)
+                #     self.print(agent_name=agent_name)
+                # else:
+                #     print(f"【{agent_name}】 ", end="")
+                #     for chunk in self.agents[agent_name].send_message(
+                #         recorder=self.recorder, stream=self.stream_output):
+                #         if chunk is not None:
+                #             print(chunk, end="")
+                #     print()
+
+    def end(self):
+        temperature_copy = MyAgent.TEMPERATURE
+        MyAgent.TEMPERATURE = 0
+        message: str = self.summary_agent.query.format(
+            self.recorder.prepare(agent_name="all", agents=self.agents, return_dict=False)
+        )
+        self.summary_agent.prepare_message(message)
+        self.summary_agent.output_message(
+            recorder=self.recorder, stream=self.stream_output,
+            output_func=self.output_func, node_name=self.name
+        )
+        # if not self.stream_output:
+        #     self.summary_agent.send_message(recorder=self.recorder, stream=self.stream_output)
+        #     print(f"【summary】{self.summary_agent.get_message(index=-1)}")
+        # else:
+        #     print("【summary】 ", end="")
+        #     for
+        MyAgent.TEMPERATURE = temperature_copy
+        content = self.summary_agent.get_message(index=-1)
+        # start to parse ====================================================
+        data_dict = new_parse(content, labels=[], return_dict=True)
+        # 1. parse character
+        characters_card: dict = {}
+        for key in data_dict['CHARACTERS']:
+            """default success"""
+            if 'CHARACTER' in key:
+                characters_card[
+                    data_dict['CHARACTERS'][key]['NAME']
+                ] = {
+                    "role_name": data_dict['CHARACTERS'][key]['NAME'],
+                    "gender": data_dict['CHARACTERS'][key]['GENDER'],
+                    "age": data_dict['CHARACTERS'][key]['AGE'],
+                    "occupation": data_dict['CHARACTERS'][key]['WORK'],
+                    "personality": data_dict['CHARACTERS'][key]['PERSONALITY'],
+                    "speaking_style": data_dict['CHARACTERS'][key]['SPEECH STYLE'],
+                    "relation_with_others": data_dict['CHARACTERS'][key]['RELATION'],
+                    "background": data_dict['CHARACTERS'][key]['BACKGROUND']
+                }
+        # file_name = "character_settings.json"
+        try:
+            os.mkdir("novel_outline")
+        except:
+            pass
+        file_name = "./novel_outline/character_settings.json"
+        with open(file_name, "w") as json_file:
+            json.dump(characters_card, json_file, ensure_ascii=False)
+            print("Save Successfully")
+        # 2. converted to markdown
+        return_content = "<CHARACTERS>\n# Character\n> There are a total of {} characters\n\n".format(
+            data_dict['CHARACTERS']['TOTAL NUMBER'],
+        )
+        cnt = 1
+        for key in data_dict['CHARACTERS']:
+            """default success"""
+            if 'CHARACTER' in key:
+                return_content += "## Character{}\n- Gender: {}\n- Name: {}\n- Age: {}\n- Work: {}\n- Personality: {}\n- Speaking Style: {}\n- Relation with Others: {}\n- Background: {}\n\n".format(
+                    cnt, data_dict['CHARACTERS'][key]['GENDER'], data_dict['CHARACTERS'][key]['NAME'],
+                    data_dict['CHARACTERS'][key]['AGE'],
+                    data_dict['CHARACTERS'][key]['WORK'],
+                    data_dict['CHARACTERS'][key]['PERSONALITY'], data_dict['CHARACTERS'][key]['SPEECH STYLE'],
+                    data_dict['CHARACTERS'][key]['RELATION'],
+                    data_dict['CHARACTERS'][key]['BACKGROUND']
+                )
+                cnt += 1
+        return_content += "</CHARACTERS>\n\n<OUTLINE>\n# outline\n> There are a total of {} chapters\n\n".format(
+            data_dict['OUTLINE']['TOTAL NUMBER']
+        )
+        cnt = 1
+        for key in data_dict['OUTLINE']:
+            if 'SECTION' in key:
+                return_content += "## Chapter {} {}\n- Characters Involved: {}\n- Story Summary: {}\n\n".format(
+                    cnt, data_dict['OUTLINE'][key]['TITLE'], data_dict['OUTLINE'][key]['CHARACTER INVOLVED'],
+                    data_dict['OUTLINE'][key]['ABSTRACT']
+                )
+                cnt += 1
+        return_content += "</OUTLINE>"
+        return return_content
+
+    def print(self, agent_name):
+        print(f"【{agent_name}】{self.agents[agent_name].get_message(index=-1)}")
+
+class SecondNode(Node):
+    def __init__(
+        self,
+        name: str,
+        agents: List[MyAgent],
+        start_agent_name: str,
+        start_agent_query: str,
+        summary_agent: MyAgent = None,
+        save: bool=True,
+        stream_output:bool=True,
+        output_func=None
+    ):
+        super(SecondNode, self).__init__(agents, summary_agent, save)
+        self.name = name
+        self.stream_output = stream_output
+        self.start_agent_name = start_agent_name
+        self.start_agent_query = start_agent_query
+        self.output_func = output_func
+        assert self.start_agent_name in self.agents, \
+            f"invalid agent name `{self.start_agent_name}`"
+        self.temperature = [0.3, 0.3, 0.3]
+        if self.stream_output:
+            print("streaming output ......")
+
+    def start(self):
+        MyAgent.TEMPERATURE = self.temperature[0]
+        self.agents[self.start_agent_name].prepare_message(
+            self.start_agent_query+"\n"+self.agents[self.start_agent_name].query
+        )
+        self.agents[self.start_agent_name].output_message(
+            recorder=self.recorder, stream=self.stream_output, output_func=self.output_func,
+            node_name=self.name
+        )
+        # self.agents[self.start_agent_name].send_message(recorder=self.recorder)
+        # print(f"【{self.start_agent_name}】{self.agents[self.start_agent_name].get_message(index=-1)}")
+        # self.print(agent_name=self.start_agent_name)
+
+    def communicate(self):
+        MyAgent.TEMPERATURE = self.temperature[1]
+        """to store output，e.g. Chapter i"""
+        self.output_memory = []
+        for turn in range(2):
+            for agent_name in ["Oscar", "Bert", "Ernie"]:
+                if agent_name == "Bert":
+                    MyAgent.TEMPERATURE = 0.3
+                else:
+                    MyAgent.TEMPERATURE = turn*0.1 + 0.5
+                history = self.recorder.prepare(
+                    agent_name=agent_name,
+                    agents=self.agents,
+                    return_dict=False
+                )
+
+                # print(f"===========START {agent_name}==========")
+                # print(history)
+                # print("================END===============")
+                query = self.agents[agent_name].query
+                if isinstance(history, str):
+                    history = f"The following are the conversations of others, with what someone says wrapped in `<name>...</name>`: \n{history}\n{query}"
+                elif isinstance(history, list):
+                    history.append({"role": "user", "content": query})
+                self.agents[agent_name].prepare_message(
+                    history
+                )
+                self.agents[agent_name].output_message(
+                    recorder=self.recorder, stream=self.stream_output,
+                    output_func=self.output_func, node_name=self.name
+                )
+                # self.agents[agent_name].send_message(recorder=self.recorder)
+                # self.print(agent_name=agent_name)
+
+    def end(self):
+        MyAgent.TEMPERATURE = self.temperature[2]
+
+        content = self.agents["Bert"].get_message(-1)
+        index = -1
+        while "none" in content.lower():
+            index -= 1
+            content = self.agents["Bert"].get_message(index)
+        try:
+            def save(data: dict):
+                for idx, (key, value) in enumerate(data.items()):
+                    # file_name = f"{self.name.replace(' ', '')}-plot-{idx+1}.json"
+                    try:
+                        os.mkdir("novel_outline")
+                    except:
+                        pass
+                    file_name = f"./novel_outline/{self.name.replace(' ', '')}-plot-{idx+1}.json"
+                    _characters:str = value["CHARACTER INVOLVED"]
+                    characters = ask_gpt(
+                        system_prompt="You are very good at structuring text, please make sure you structure your output as follows, with no other extra chars, in addition, extract from the given text as much as possible, rather than summarizing.",
+                        input=f"""Here is a sentence: "{_characters}"\n What are the names of the people in the sentence above? Please use a semicolon to separate the names, e.g. "name 1; name 2", taking care not to add any words before or after."""
+                    ).split(";")
+                    characters = [c.strip() for c in characters]
+                    print("mike",characters)
+                    output = {
+                        "plot": value["DESCRIPTION"],
+                        "characters": characters #value["CHARACTER INVOLVED"]
+                    }
+                    with open(file_name, "w") as json_file:
+                        json.dump(output, json_file, ensure_ascii=False)
+                        # json_file.writelines(output)
+            # data_dict = parse(copy.deepcopy(content), labels=["CONTENT"], return_dict=True)["CONTENT"]
+            data_dict = new_parse(content, labels=["CONTENT"], return_dict=True)["CONTENT"]
+            if len(data_dict) == 0 or data_dict is None:
+                assert False
+            save(data_dict)
+            data_str = new_parse(content, labels=["CONTENT"], return_dict=False)
+            if len(data_str) == 0:
+                assert False
+            print_log("Save successfully")
+            print(data_str)
+
+            if self.output_func:
+                self.output_func(0, "Recorder", data_str[0], self.name)
+                self.output_func(21, "Recorder", data_str[1:], self.name)
+            return data_str
+        except Exception as e:
+            raise e
+
+
+    def print(self, agent_name):
+        print(f"【{agent_name}】{self.agents[agent_name].get_message(index=-1)}")
+
+def generate_first_agents(task_prompt:str=None) -> Tuple[List[MyAgent], MyAgent]:
+    prompts_set = NOVEL_PROMPT["Node 1"]
+    if task_prompt is not None:
+        print_log("The default task prompt has been replaced!")
+        NOVEL_PROMPT["Node 1"]["task"] = task_prompt
+    prompts_task = prompts_set["task"]
+    prompts_agents = prompts_set["agents"]
+    agents_list = []
+    for agent_name in prompts_agents:
+        agents_list.append(
+            MyAgent(
+                name=agent_name,
+                SYSTEM_PROMPT=prompts_agents[agent_name]["system"].format(
+                    prompts_task, prompts_agents[agent_name]["output"]
+                ),
+                query=prompts_agents[agent_name]["query"].format(
+                    prompts_agents[agent_name]["output"]
+                )
+            )
+        )
+    summary_agent = MyAgent(
+        name="summary",
+        SYSTEM_PROMPT=prompts_set["summary"]["system"].format(
+            prompts_task, prompts_set["summary"]["output"]
+        ),
+        query=prompts_set["summary"]["query"]
+    )
+
+    return agents_list, summary_agent
+
+def generate_second_agents() -> Tuple[List[MyAgent], MyAgent]:
+    prompts_set = NOVEL_PROMPT["Node 2"]
+    prompts_task = prompts_set["task"]  # .format(outline, other)
+    prompts_agents = prompts_set["agents"]
+    agents_list = []
+    for agent_name in prompts_agents:
+        agents_list.append(
+            MyAgent(
+                name=agent_name,
+                SYSTEM_PROMPT=prompts_agents[agent_name]["system"].format(
+                    prompts_task, prompts_agents[agent_name]["output"]
+                ),
+                query=prompts_agents[agent_name]["query"].format(
+                    prompts_agents[agent_name]["output"]
+                )
+            )
+        )
+    summary_agent = MyAgent(
+        name="summary",
+        SYSTEM_PROMPT=prompts_set["summary"]["system"].format(
+            prompts_task, prompts_set["summary"]["output"]
+        ),
+        query=prompts_set["summary"]["query"]
+    )
+
+    return agents_list, summary_agent
+
+def run_node_1(stream_output:bool=False, output_func=None,
+               start_agent_name:str="Elmo", start_agent_query:str="Let's start by writing a first draft of the character settings.",
+               task_prompt=None):
+    print("node 1 start ...")
+    first_agents, first_summary = generate_first_agents(task_prompt=task_prompt)
+    first_node = FirstNode(
+        name="Node 1",
+        agents=first_agents,
+        summary_agent=first_summary,
+        save=True,
+        start_agent_name=start_agent_name,
+        start_agent_query=start_agent_query,
+        stream_output=stream_output,
+        output_func=output_func,
+    )
+    output = first_node.run()
+    print("node 1 done ...")
+    return output
+
+def run_node_2(outline, node_start_index=2, stream_output:bool=False, output_func=None):
+    num2cn = ["ONE","TWO","THREE","FOUR","FIVE","SIX","SEVEN","EIGHT","NINE","TEN","ELEVEN","TWELVE"]
+    def generate_task_end_prompt(memory: list) -> str:
+        if len(memory) == 0:
+            return "\nThere are 5 chapters in total, please enrich the plot of the first chapter according to the outline above, taking care to be storytelling, logical, mainly in third person point of view, not involving description of dialogues, and without empty words. The plot of the first chapter is at least 800 words."
+        else:
+            start_prompt = f"\nThe following are the contents of chapter {', '.join(num2cn[0:len(memory)])}, which have been expanded: \n<EXPANDED>\n"
+            for i in range(len(memory)):
+                start_prompt = f"\n{start_prompt}<CHAPTER {i+1}>\n{memory[i]}\n</CHAPTER {i+1}>"
+            start_prompt += "\n</EXPANDED>\n"
+            end_prompt = f"\nPlease, based on the outline above and the content of chapter {', '.join(num2cn[0:len(memory)])}, which have been expanded, to enrich the plot of chapter {num2cn[len(memory)]}, " \
+                         f"Content is noted to be storytelling, logical, and in the third person point of view, not involving descriptions of dialog, and without empty words. The plot of chapter {num2cn[len(memory)]} is at least 800 words."
+            return start_prompt + end_prompt
+
+    output_memory = []      
+    start_agent_names = ["Ernie", "Ernie", "Ernie", "Ernie", "Ernie"]
+    start_agent_queries = [f"Let's start by expanding on chapter {num2cn[i]} as required" for i in range(5)] 
+    ORIGIN_TASK_PROMPT = NOVEL_PROMPT["Node 2"]["task"]
+    ORIGIN_QUERY_PROMPT = {}
+    ORIGIN_SUMMARY_PROMPT = NOVEL_PROMPT["Node 2"]["summary"]["query"]
+    for idx in range(3):
+        node_idx = idx + node_start_index
+
+        NOVEL_PROMPT["Node 2"]["task"] = ORIGIN_TASK_PROMPT.format(
+            outline,
+            generate_task_end_prompt(output_memory)
+        )
+
+        for agent_name in NOVEL_PROMPT["Node 2"]["agents"]:
+            if agent_name not in ORIGIN_QUERY_PROMPT:
+                ORIGIN_QUERY_PROMPT[agent_name] = NOVEL_PROMPT["Node 2"]["agents"][agent_name]["query"]
+            NOVEL_PROMPT["Node 2"]["agents"][agent_name]["query"] = ORIGIN_QUERY_PROMPT[agent_name].format(
+                num2cn[idx], "{}"
+            )
+        NOVEL_PROMPT["Node 2"]["summary"]["query"] = ORIGIN_SUMMARY_PROMPT.format(num2cn[idx], num2cn[idx], "{}")   
+        start_agent_name = start_agent_names[idx]
+        start_agent_query = start_agent_queries[idx]
+        
+        print(f"node {node_idx} starting ......")
+        second_agents, second_summary = generate_second_agents()
+        second_node = SecondNode(
+            name=f"Node {node_idx}",
+            agents=second_agents,
+            summary_agent=second_summary,
+            save=True,
+            start_agent_name=start_agent_name,
+            start_agent_query=start_agent_query, 
+            stream_output=stream_output,
+            output_func=output_func
+        )
+        
+        output_memory.append(
+            second_node.run()
+        )
+       
+
+def show_in_gradio(state, name, chunk, node_name):
+
+    if state == 30:
+        Client.server.send(str([state, name, chunk, node_name])+"<SELFDEFINESEP>")
+        return
+
+    if name.lower() in ["summary", "recorder"]:
+        """It is recorder"""
+        name = "Recorder"
+        if state == 0:
+            state = 22
+        else:
+            state = 21
+    else:
+        if Client.current_node != node_name and state == 0:
+            state = 12
+            Client.current_node = node_name
+        elif Client.current_node != node_name and state != 0:
+            assert False
+        else:
+            state = 10 + state
+    Client.server.send(str([state, name, chunk, node_name])+"<SELFDEFINESEP>")
+
+
+if __name__ == '__main__':
+
+    MyAgent.SIMULATION = False
+    MyAgent.TEMPERATURE = 1.0
+    stream_output = True
+    output_func = show_in_gradio
+    output_func = None
+
+    if output_func is not None:
+        global client
+        client = Client()
+
+        client.listening_for_start()
+        Client.server = client.start_server()
+        next(Client.server)
+
+        outline = run_node_1(
+            stream_output=stream_output,
+            output_func=output_func,
+            start_agent_name=Client.cache["start_agent_name"],
+            start_agent_query=Client.cache["start_agent_query"],
+            task_prompt=Client.cache["task"]
+        )
+    else:
+        outline = run_node_1(
+            stream_output=stream_output,
+            output_func=output_func
+        )
+    print(outline)
+    # assert False
+    run_node_2(outline, stream_output=stream_output, output_func=output_func)
+    print("done")

novel-server/config.ini

@@ -0,0 +1,2 @@
+    [Section]
+    prod = True

novel-server/myagent.py

@@ -0,0 +1,375 @@
+import sys
+sys.path.append('../../../../src/agents')
+from agents.Agent import Agent
+from agents.State import State
+import os
+import copy
+import time
+from typing import List, Dict, Any
+import openai
+from myutils import print_log, simulation
+import abc
+import json
+import socket
+
+PROXY = os.environ["PROXY"]
+openai.proxy = PROXY
+
+class Client:
+
+    server = None
+    current_node = None
+    cache = {}
+
+    def __init__(self, host='127.0.0.1', port=9999, bufsize=1024):
+        self.bufsize = bufsize
+        assert bufsize > 0
+        self.client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self.client_socket.connect((host, port))
+        self.client_socket.send("hello agent".encode('utf-8'))
+        print_log("client: Connected successfully......")
+
+    def start_server(self):
+        while True:
+            message = yield
+            if message == 'exit':
+                break
+            self.client_socket.send(message.encode('utf-8'))
+
+    def listening_for_start(self):
+
+        remaining = ""
+        while True:
+
+            dataset = self.client_socket.recv(self.bufsize)
+            try:
+                # if isinstance(remaining, bytes):
+                #     raise UnicodeDecodeError
+                dataset = dataset.decode('utf-8')
+            except UnicodeDecodeError:
+
+                if not isinstance(remaining, bytes):
+
+                    remaining = remaining.encode('utf-8')
+                assert isinstance(dataset, bytes)
+                remaining += dataset
+                try:
+                    response = remaining.decode('utf-8')
+                    remaining = ""
+                except:
+                    continue
+            assert isinstance(remaining, str)
+
+            dataset = remaining + dataset
+            if dataset == "<START>":
+                break
+            list_dataset = dataset.split("<SELFDEFINESEP>")
+            if len(list_dataset) == 1:
+
+                remaining = list_dataset[0]
+
+                continue
+            else:
+
+                remaining = list_dataset[-1]
+
+            list_dataset = list_dataset[:-1]
+            print(list_dataset)
+            for data in list_dataset:
+                data = eval(data)
+                if isinstance(data, dict):
+                    Client.cache.update(data)
+                else:
+                    assert False
+
+class MyAgent(Agent):
+    API_KEY: str = os.environ["API_KEY"]
+    WAIT_TIME: int = 20
+    DEFAULT_MODEL: int = "gpt-3.5-turbo-16k-0613"
+    TEMPERATURE: int = 0.3
+    SIMULATION: bool = False
+    __REDUCE_MODE__: list = ["cut", "summary"]
+
+    def __init__(
+            self,
+            name: str,
+            SYSTEM_PROMPT: str,
+            query: str
+    ):
+        self.name = name
+        self.SYSTEM_PROMPT = SYSTEM_PROMPT
+        self.messages: list = list()
+        self.messages.append(
+            {"role": "system", "content": self.SYSTEM_PROMPT}
+        )
+        self.messages_copy: list = copy.deepcopy(self.messages)
+        self.query = query
+
+        self.summary_pointer = 1
+        openai.api_key = MyAgent.API_KEY
+
+
+
+    def send_message(self, recorder=None, mode="cut", stream=True):
+        # print("sending...")
+        assert self.messages[-1]["role"] in ["user", "system"], \
+            "please make sure the last role is user or system!"
+        while True:
+            try:
+                # copy_message = copy.deepcopy(self.messages)
+                # print(self.messages)
+                if not MyAgent.SIMULATION:
+                    completion = openai.ChatCompletion.create(
+                        model=MyAgent.DEFAULT_MODEL,
+                        messages=self.messages,
+                        temperature=MyAgent.TEMPERATURE,
+                        stream=stream
+                    )
+                else:
+                    completion = simulation()
+                if not stream:
+                    if completion["choices"][0]["finish_reason"] == "length":
+
+                        print("Length exceeded, deleted")
+                        self.reduce_message(mode=mode, N=2)
+                        continue
+                    self.messages.append(
+                        self._parse_response(completion)
+                    )
+                    self.messages_copy.append(
+                        copy.deepcopy(self.messages[-1])
+                    )
+                else:
+
+                    complete_response = ""
+                    for chunk in completion:
+                        # print(chunk)
+                        if "content" in chunk["choices"][0]["delta"]:
+                            complete_response = f"""{complete_response}{chunk["choices"][0]["delta"]["content"]}"""
+                            yield chunk["choices"][0]["delta"]["content"]
+                    yield None
+                    self.messages.append(
+                        self._parse_response(complete_response)
+                    )
+                    self.messages_copy.append(
+                        copy.deepcopy(self.messages[-1])
+                    )
+                if recorder is not None:
+                    recorder.add(
+                        agent_name=self.name,
+                        new_message_index=len(self.messages) - 1
+                    )
+                break
+            except Exception as e:
+                raise e
+                print_log(e)
+                if "maximum context length is" in str(e):
+                    print_log("maximum length exceeded! skip!")
+                    self.reduce_message(mode=mode, N=2)
+                else:
+                    print_log(f"Please wait {MyAgent.WAIT_TIME} seconds and resend later ...")
+                    time.sleep(MyAgent.WAIT_TIME)
+
+
+
+    def prepare_message(self, message):
+        if isinstance(message, str):
+            self.messages.append(
+                {"role": "user", "content": message}
+            )
+            self.messages_copy.append(
+                {"role": "user", "content": message}
+            )
+        elif isinstance(message, list):
+            self.messages.extend(message)
+            self.messages_copy.extend(message)
+        else:
+            assert False
+
+    def _parse_response(self, completion, check_name: bool = True) -> dict:
+        if isinstance(completion, dict):
+            js = completion["choices"][0]["message"]
+        elif isinstance(completion, str):
+            js = {"content": completion, "role": "assistant"}
+        else:
+            assert False, \
+                "invalid completion."
+        if check_name:
+            js["content"] = js["content"].replace(f"<{self.name}>", "").replace(f"</{self.name}>", "")
+        return {"role": js["role"], "content": js["content"]}
+
+
+
+    def get_message(self, index: int, function=None, source: str = "copy", **kwargs) -> str:
+        assert source in ["copy", "origin"]
+        assert len(self.messages) > index
+        if function:
+            if source == "copy":
+                return function(self.messages_copy[index]["content"], kwargs)
+            elif source == "origin":
+                return function(self.messages[index]["content"], kwargs)
+        else:
+            if source == "copy":
+                return self.messages_copy[index]["content"]
+            elif source == "origin":
+                return self.messages[index]["content"]
+
+
+
+    def reduce_message(self, mode: str = "cut", N: int = 1, summary_agent=None):
+        assert mode in MyAgent.__REDUCE_MODE__, \
+            f"mode `{mode}` is invalid."
+        if mode == "cut":
+
+            """system | user | assistant | user | assistant"""
+            for i in range(N):
+                self.messages.pop(1)
+            assert self.messages[-1]["role"] in ["user", "system"], \
+                "please make sure the last role is user or system!"
+        elif mode == "summary":
+            assert isinstance(summary_agent, MyAgent), \
+                "the summary agent is not class MyAgent."
+
+            # summary_agent.prepare_message()
+
+
+
+    def output_message(self, recorder=None, mode="cut", stream=True, output_func=None, node_name:str=None):
+        if stream:
+            print(f"【{self.name}】 ", end="")
+            complete_response = ""
+            FIRST = True
+            for chunk in self.send_message(recorder=recorder, stream=stream, mode=mode):
+                if chunk is not None:
+                    complete_response = f"{complete_response}{chunk}"
+                    if output_func is None:
+                        print(chunk, end="")
+                    else:
+                        # print(chunk, end="")
+                        if FIRST:
+                            output_func(0, self.name, chunk, node_name)
+                            FIRST = False
+                        else:
+                            output_func(1, self.name, chunk, node_name)
+                        # yield complete_response, self.name
+        else:
+            next(self.send_message(recorder=recorder, stream=stream, mode=mode), None)
+            if output_func is None:
+                print(f"【{self.name}】{self.get_message(index=-1)}")
+            else:
+                output_func(None, self.name, self.get_message(index=-1), node_name)
+
+class Recorder:
+    def __init__(self, agents: Dict[str, MyAgent]):
+
+        self.recorder: List = list()
+        self.__AGENTS_NAME__ = []
+        # 记录一下每个AGENT上次说话的时间，这样就不用一次一次的遍历了
+        self.__AGENTS_SPEAK_TIME__ = {}
+        self.agents: Dict[str, MyAgent] = agents
+        self._register()
+
+
+
+    def _register(self):
+        for agent_name in self.agents:
+            self.__AGENTS_NAME__.append(agent_name)
+            self.__AGENTS_SPEAK_TIME__[agent_name] = 0
+
+    def add(self, agent_name: str, new_message_index: int):
+        self.recorder.append(
+            [agent_name, new_message_index]
+        )
+        if agent_name not in self.__AGENTS_NAME__:
+            self.__AGENTS_NAME__.append(agent_name)
+        self.__AGENTS_SPEAK_TIME__[agent_name] = len(self.recorder)
+
+    def clear(self):
+        self.recorder.clear()
+
+
+
+    def prepare(self, agent_name: str, agents: Dict[str, MyAgent], return_dict: bool = False):
+        if agent_name.lower() != "all":
+            assert agent_name in self.__AGENTS_NAME__, \
+                f"There is no `MyAgent {agent_name}` in Recorder!"
+
+        history = ""
+        history_dict = []
+        start_index = self.__AGENTS_SPEAK_TIME__[agent_name] if agent_name.lower() != "all" else 0
+        for i in range(
+                start_index, len(self.recorder)
+        ):
+            his_ag_name, his_ag_index = self.recorder[i]
+            history_dict.append(
+                {"role": "user", "content": agents[his_ag_name].get_message(his_ag_index, source="copy")}
+            )
+            history = f"{history}\n<{his_ag_name.upper()}>\n{agents[his_ag_name].get_message(his_ag_index, source='copy')}\n</{his_ag_name.upper()}>\n"
+            # history = f"{history}\n{agent_name}: {agents[his_ag_name].get_message(his_ag_index, source='copy')}\n"
+        if return_dict:
+            return history_dict
+        else:
+            return history.strip()
+
+class Node(State):
+
+    def __init__(
+            self,
+            agents: List[MyAgent],
+            summary_agent: MyAgent = None,
+            save: bool = False
+    ):
+        self.agents = {}
+        for agent in agents:
+            self.agents[agent.name] = agent
+
+        self.summary_agent: MyAgent = summary_agent
+        self.recorder = Recorder(agents=self.agents)
+        self.save = save
+
+    @abc.abstractmethod
+    def start(self):
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def communicate(self):
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def end(self):
+        raise NotImplementedError()
+
+    def run(self):
+        self.start()
+        self.communicate()
+        response = self.end()
+        if self.save:
+            self.save_history()
+        return response
+
+    def save_history(self, save_path=None):
+        if save_path is None:
+            save_path = f"./Node2.json"
+        results = []
+        for agent_name in self.agents:
+            results.append(
+                self.agents[agent_name].messages_copy
+            )
+        json.dump(
+            results,
+            open(save_path, "w")
+        )
+
+def ask_gpt(system_prompt="", input="", name="parser"):
+
+    temperature = MyAgent.TEMPERATURE
+    MyAgent.TEMPERATURE = 0
+    agent = MyAgent(
+        name=name, SYSTEM_PROMPT=system_prompt, query=""
+    )
+    agent.prepare_message(message=input)
+    # agent.temp_send_message()
+    agent.output_message(stream=False)
+    MyAgent.TEMPERATURE = temperature
+    return agent.get_message(index=-1)
+

novel-server/myutils.py

@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*-
+import copy
+import time
+import re
+from tree import construct_tree, tree2xml, tree2dict
+import json
+
+def extract_tag_names(text):
+
+    pattern = r'<([^<>]+)>'
+
+
+    matches = re.findall(pattern, text)
+
+
+    stack = []
+    answer = []
+    for item in matches:
+        if item[0] != '/':
+            stack.append(item)
+        else:
+
+            if item[1:] in stack:
+                while stack[-1] != item[1:]:
+                    stack.pop()
+                answer.append(stack.pop())
+    return answer
+
+def print_log(message: str):
+    print(f"[{time.ctime()}] {message}")
+
+def simulation():
+    content = ""
+    for i in range(5000):
+        content = f"{content} hello"
+    return {
+        'id': 'chatcmpl-6p9XYPYSTTRi0xEviKjjilqrWU2Ve',
+        'object': 'chat.completion',
+        'created': 1677649420,
+        'model': 'gpt-3.5-turbo',
+        'usage': {'prompt_tokens': 56, 'completion_tokens': 31, 'total_tokens': 87},
+        'choices': [
+            {
+                'message': {
+                    'role': 'assistant',
+                    'content': content
+                },
+                'finish_reason': 'stop',
+                'index': 0
+            }
+        ]
+    }
+
+def new_parse(content:str, labels: list, return_dict:bool=False):
+
+    tree = construct_tree(content, add_root_label=True)
+    tree.first_label = False
+    if len(labels) == 0 or labels is None:
+        if return_dict:
+            return tree2dict(tree)['root']
+        else:
+
+            return "\n".join(tree2xml(tree).split('\n')[1:-1])
+    else:
+        if return_dict:
+            tree_dict = tree2dict(tree, filter=labels, mode="remain")['root']
+            return tree_dict
+        else:
+            tree_xml = tree2xml(tree, filter=labels, mode="remain")
+            return "\n".join(tree_xml.split('\n')[1:-1])
+

novel-server/tree.py

@@ -0,0 +1,234 @@
+# -*- coding: utf-8 -*-
+import copy
+from typing import List, Tuple, Any
+import re
+
+class Item:
+    def __init__(self, value, start, end):
+        self.value = value
+        self.start = start
+        self.end = end
+
+class TreeNode:
+    def __init__(self, item:Item):
+        self.item = item
+        self.state = 0
+        self.sons = []
+        self.parent = None
+
+class Tree:
+    def __init__(self, item: Item, text:str):
+        self.root = TreeNode(item)
+        self.text = text
+        self.first_label = True
+
+    def isNodeIn(self, node1:TreeNode, node2:TreeNode):
+
+        if node1.item.start > node2.item.start and node1.item.end < node2.item.end:
+            return True
+        return False
+
+    def insert(self, new_node: TreeNode, current_node: TreeNode):
+        if len(current_node.sons) == 0:
+
+            if self.isNodeIn(new_node, current_node):
+
+                current_node.sons.append(new_node)
+                new_node.parent = current_node
+                return True
+            else:
+
+                return False
+        for son in current_node.sons:
+
+            done = self.insert(new_node, son)
+
+            if done:
+                return True
+        if self.isNodeIn(new_node, current_node):
+            current_node.sons.append(new_node)
+            new_node.parent = current_node
+            return True
+        else:
+            return False
+
+    def node_count(self):
+        cnt = 0
+        if self.root is not None:
+            cnt = 1
+        sons = self.root.sons
+        while len(sons) > 0:
+            current: TreeNode = sons.pop()
+            cnt += 1
+            if len(current.sons) > 0:
+                sons.extend(current.sons)
+        return cnt
+
+    def reset_state(self, reset_value, current_node:TreeNode=None):
+        if current_node == None:
+            current_node = self.root
+        current_node.state = reset_value
+        for i in range(len(current_node.sons)):
+            self.reset_state(reset_value, current_node=current_node.sons[i])
+
+    def get_node_content(self, node:TreeNode):
+        value_length = len(node.item.value)
+        start = node.item.start
+        end = node.item.end
+        return self.text[
+            start+value_length+1:end-1
+        ]
+
+    def build_dict(self, current_dict:dict, current_root:TreeNode, filter_value:list=None, mode:str="filter"):
+        assert mode.lower() in ["filter", "remain"], \
+            f"mode `{mode}` is not in ['filter', 'remain']"
+
+        if len(current_root.sons) == 0:
+
+            if filter_value is None or (mode.lower() == "remain" and current_root.state == 1):
+                return {current_root.item.value: self.get_node_content(current_root)}
+            if mode.lower() == "filter" and current_root.item.value in filter_value:
+                return None
+            elif mode.lower() == "filter" and current_root.item.value not in filter_value:
+                return {current_root.item.value: self.get_node_content(current_root)}
+            elif mode.lower() == "remain" and current_root.item.value in filter_value:
+                return {current_root.item.value: self.get_node_content(current_root)}
+            elif mode.lower() == "remain" and current_root.item.value not in filter_value:
+                return None
+        else:
+            if filter_value is not None:
+                if mode.lower() == "filter" and current_root.item.value in filter_value:
+                    return None
+                if self.first_label:
+                    if mode.lower() == "remain" and current_root.item.value not in filter_value and current_root.item.value != "root" and current_root.state==0:
+                        return None
+            current_dict[current_root.item.value] = {}
+            for i in range(len(current_root.sons)):
+
+                if mode.lower() == "remain":
+                    if current_root.parent is not None and current_root.parent.state == 1:
+
+                        current_root.state = 1
+                    if current_root.item.value in filter_value:
+
+                        current_root.state = 1
+                        current_root.sons[i].state = 1
+                    if current_root.state == 1:
+
+                        current_root.sons[i].state = 1
+                    if current_root.sons[i].item.value in filter_value:
+                        current_root.sons[i].state = 1
+                item = self.build_dict(current_dict[current_root.item.value], current_root.sons[i], filter_value, mode)
+                if isinstance(item, dict):
+                    current_dict[current_root.item.value].update(item)
+
+    def build_xml(self, current_item: list, current_root:TreeNode, filter_value:list=None, mode:str="filter"):
+        assert mode.lower() in ["filter", "remain"], \
+            f"mode `{mode}` is not in ['filter', 'remain']"
+        if len(current_root.sons) == 0:
+
+            if filter_value is None or (mode.lower() == "remain" and current_root.state == 1):
+                return f"<{current_root.item.value}>{self.get_node_content(current_root)}</{current_root.item.value}>"
+            if mode.lower() == "filter" and current_root.item.value in filter_value:
+                return None
+            elif mode.lower() == "filter" and current_root.item.value not in filter_value:
+                return f"<{current_root.item.value}>{self.get_node_content(current_root)}</{current_root.item.value}>"
+            elif mode.lower() == "remain" and current_root.item.value in filter_value:
+                return f"<{current_root.item.value}>{self.get_node_content(current_root)}</{current_root.item.value}>"
+            elif mode.lower() == "remain" and current_root.item.value not in filter_value:
+                return None
+        else:
+            if filter_value is not None:
+                if mode.lower() == "filter" and current_root.item.value in filter_value:
+                    return None
+                if self.first_label:
+                    if mode.lower() == "remain" and current_root.item.value not in filter_value and current_root.item.value != "root" and current_root.state==0:
+                        return None
+            current_item.append(f"<{current_root.item.value}>")
+            for i in range(len(current_root.sons)):
+
+                if mode.lower() == "remain":
+                    if current_root.parent is not None and current_root.parent.state == 1:
+
+                        current_root.state = 1
+                    if current_root.item.value in filter_value:
+
+                        current_root.state = 1
+                        current_root.sons[i].state = 1
+                    if current_root.state == 1:
+
+                        current_root.sons[i].state = 1
+                    if current_root.sons[i].item.value in filter_value:
+                        current_root.sons[i].state = 1
+                item = self.build_xml(current_item, current_root.sons[i], filter_value, mode)
+                if isinstance(item, str):
+                    current_item.append(f"{item}")
+            current_item.append(f"</{current_root.item.value}>")
+
+def extract_tag_names(text: str, sort:bool=True)->List[Tuple[str, int, int]]:
+
+    pattern = r'<([^<>]+)>'
+
+
+    matches = re.findall(pattern, text)
+
+    pos = []
+    start = 0
+    for item in matches:
+        pos.append(
+            text[start:].find(item)+start
+        )
+        start = text[start:].find(item)+start + len(item)
+
+
+    stack_item = []
+    stack_pos = []
+    answer = []
+    for idx, item in enumerate(matches):
+        if item[0] != '/':
+            stack_item.append(item)
+            stack_pos.append(pos[idx])
+        else:
+            end_pos = pos[idx]
+
+            if item[1:] in stack_item:
+                while stack_item[-1] != item[1:]:
+                    stack_item.pop()
+                    stack_pos.pop()
+
+                answer.append((stack_item.pop(), stack_pos.pop(), end_pos))
+    if sort:
+        return sorted(answer, key=lambda x: x[1])
+    return answer
+
+def construct_tree(text, add_root_label:bool=True):
+    if add_root_label:
+        print("root label is added!")
+        text = f"<root>\n{text}\n</root>"
+    data = extract_tag_names(text)
+    tree = Tree(Item(*data[0]), text)
+    nodes_list = []
+    for d in data[1:]:
+        new_node = TreeNode(
+            Item(*d)
+        )
+        nodes_list.append(new_node)
+    for i in range(len(nodes_list)):
+        tree.insert(
+            new_node=nodes_list[i],
+            current_node=tree.root
+        )
+    return tree
+
+def tree2dict(tree:Tree, filter:list=None, mode="filter"):
+    answer = {}
+    tree.reset_state(0)
+    tree.build_dict(answer, tree.root, filter, mode)
+    return answer
+
+def tree2xml(tree, filter:list=None, mode="filter"):
+    answer = []
+    tree.reset_state(0)
+    tree.build_xml(answer, tree.root, filter, mode)
+    return "\n".join(answer)
+

novel_outline/character_settings.json

@@ -0,0 +1 @@
+{"Mike Smith": {"role_name": "Mike Smith", "gender": "Male", "age": "35", "occupation": "Internet company programmer", "personality": "Hardworking, dedicated, tech-savvy", "speaking_style": "Clear and concise", "relation_with_others": "Married to Jane Black, father of their child", "background": "Mike Smith is a skilled programmer who works long hours at an internet company. He is dedicated to his job but struggles to find a balance between work and family. He loves his wife, Jane, and their child, and wants to provide them with a good life. However, his demanding job often takes precedence, causing tension in his marriage and affecting his relationship with his child."}, "Jane Black": {"role_name": "Jane Black", "gender": "Female", "age": "32", "occupation": "High school chemistry teacher", "personality": "Intelligent, caring, organized", "speaking_style": "Articulate and informative", "relation_with_others": "Married to Mike Smith, mother of their child", "background": "Jane Black is a dedicated high school chemistry teacher who is passionate about education. She loves her family but often feels overwhelmed by the demands of her job and motherhood. Jane strives to be a positive role model for her child and hopes to inspire her students to pursue their dreams. She relies on her strong partnership with Mike to navigate the challenges of modern family life."}, "Emily Smith": {"role_name": "Emily Smith", "gender": "Female", "age": "5", "occupation": "Kindergarten student", "personality": "Playful, inquisitive, imaginative", "speaking_style": "Childlike and enthusiastic", "relation_with_others": "Daughter of Mike and Jane", "background": "Emily Smith is a bright and energetic kindergartener who loves to explore the world around her. She brings joy and laughter to her parents' lives and serves as a reminder of the importance of family. Emily's innocence and curiosity often lead to humorous and heartwarming moments in the story, as her parents navigate the challenges of raising a young child."}, "Alex Johnson": {"role_name": "Alex Johnson", "gender": "Male", "age": "38", "occupation": "Internet company programmer", "personality": "Ambitious, witty, loyal", "speaking_style": "Sarcastic and humorous", "relation_with_others": "Friend and coworker of Mike", "background": "Alex Johnson is a talented programmer who shares a close friendship with Mike. He is ambitious and driven, always pushing himself to succeed in the competitive tech industry. Alex provides a source of comic relief in the story, often using humor to lighten the mood during challenging times. His friendship and support for Mike play a significant role in the development of the plot."}}