codefuse-chatbot/dev_opsgpt/connector/agents/base_agent.py

from pydantic import BaseModel
from typing import List, Union
import re
import copy
import json
import traceback
import uuid
from loguru import logger

from dev_opsgpt.connector.schema import (
    Memory, Task, Env, Role, Message, ActionStatus, CodeDoc, Doc
)
from configs.server_config import SANDBOX_SERVER
from dev_opsgpt.sandbox import PyCodeBox, CodeBoxResponse
from dev_opsgpt.tools import DDGSTool, DocRetrieval, CodeRetrieval
from dev_opsgpt.connector.configs.prompts import BASE_PROMPT_INPUT, QUERY_CONTEXT_DOC_PROMPT_INPUT, BEGIN_PROMPT_INPUT
from dev_opsgpt.connector.message_process import MessageUtils
from dev_opsgpt.connector.configs.agent_config import REACT_PROMPT_INPUT, QUERY_CONTEXT_PROMPT_INPUT, PLAN_PROMPT_INPUT

from dev_opsgpt.llm_models import getChatModel
from dev_opsgpt.connector.utils import parse_section



class BaseAgent:

    def __init__(
            self, 
            role: Role,
            task: Task = None,
            memory: Memory = None,
            chat_turn: int = 1,
            do_search: bool = False,
            do_doc_retrieval: bool = False,
            do_tool_retrieval: bool = False,
            temperature: float = 0.2,
            stop: Union[List[str], str] = None,
            do_filter: bool = True,
            do_use_self_memory: bool = True,
            focus_agents: List[str] = [],
            focus_message_keys: List[str] = [],
            # prompt_mamnger: PromptManager
            ):
        
        self.task = task
        self.role = role
        self.message_utils = MessageUtils()
        self.llm = self.create_llm_engine(temperature, stop)
        self.memory = self.init_history(memory)
        self.chat_turn = chat_turn
        self.do_search = do_search
        self.do_doc_retrieval = do_doc_retrieval
        self.do_tool_retrieval = do_tool_retrieval
        self.focus_agents = focus_agents
        self.focus_message_keys = focus_message_keys
        self.do_filter = do_filter
        self.do_use_self_memory = do_use_self_memory
        # self.prompt_manager = None

    def run(self, query: Message, history: Memory = None, background: Memory = None, memory_pool: Memory=None) -> Message:
        '''agent reponse from multi-message'''
        message = None
        for message in self.arun(query, history, background, memory_pool):
            pass
        return message
    
    def arun(self, query: Message, history: Memory = None, background: Memory = None, memory_pool: Memory=None) -> Message:
        '''agent reponse from multi-message'''
        # insert query into memory
        query_c = copy.deepcopy(query)
        
        self_memory = self.memory if self.do_use_self_memory else None
        # create your llm prompt
        prompt = self.create_prompt(query_c, self_memory, history, background, memory_pool=memory_pool)
        content = self.llm.predict(prompt)
        logger.debug(f"{self.role.role_name} prompt: {prompt}")
        logger.debug(f"{self.role.role_name} content: {content}")

        output_message = Message(
            role_name=self.role.role_name,
            role_type="ai", #self.role.role_type,
            role_content=content,
            role_contents=[content],
            step_content=content,
            input_query=query_c.input_query,
            tools=query_c.tools,
            parsed_output_list=[query.parsed_output]
            )
        # common parse llm' content to message
        output_message = self.message_utils.parser(output_message)
        if self.do_filter:
            output_message = self.message_utils.filter(output_message)

        # update self_memory
        self.append_history(query_c)
        self.append_history(output_message)
        # logger.info(f"{self.role.role_name} currenct question: {output_message.input_query}\nllm_step_run: {output_message.role_content}")
        output_message.input_query = output_message.role_content
        output_message.parsed_output_list.append(output_message.parsed_output)
        # update memory pool
        memory_pool.append(output_message)
        yield output_message

    def create_prompt(
            self, query: Message, memory: Memory =None, history: Memory = None, background: Memory = None, memory_pool: Memory=None, prompt_mamnger=None) -> str:
        '''
        prompt engineer, contains role\task\tools\docs\memory
        '''
        # 
        doc_infos = self.create_doc_prompt(query)
        code_infos = self.create_codedoc_prompt(query)
        # 
        formatted_tools, tool_names = self.create_tools_prompt(query)
        task_prompt = self.create_task_prompt(query)
        background_prompt = self.create_background_prompt(background, control_key="step_content")
        history_prompt = self.create_history_prompt(history)
        selfmemory_prompt = self.create_selfmemory_prompt(memory, control_key="step_content")
        
        # extra_system_prompt = self.role.role_prompt

        
        prompt = self.role.role_prompt.format(**{"formatted_tools": formatted_tools, "tool_names": tool_names})
        #
        memory_pool_select_by_agent_key = self.select_memory_by_agent_key(memory_pool)
        memory_pool_select_by_agent_key_context = '\n\n'.join([f"*{k}*\n{v}" for parsed_output in memory_pool_select_by_agent_key.get_parserd_output_list() for k, v in parsed_output.items() if k not in ['Action Status']])
        
        # input_query = query.input_query

        # # logger.debug(f"{self.role.role_name}  extra_system_prompt: {self.role.role_prompt}")
        # # logger.debug(f"{self.role.role_name}  input_query: {input_query}")
        # # logger.debug(f"{self.role.role_name}  doc_infos: {doc_infos}")
        # # logger.debug(f"{self.role.role_name}  tool_names: {tool_names}")
        # if "**Context:**" in self.role.role_prompt:
        #     # logger.debug(f"parsed_output_list: {query.parsed_output_list}")
        #     # input_query =  "'''" + "\n".join([f"###{k}###\n{v}" for i in query.parsed_output_list for k,v in i.items() if "Action Status" !=k]) + "'''"
        #     context =  "\n".join([f"*{k}*\n{v}" for i in query.parsed_output_list for k,v in i.items() if "Action Status" !=k])
        #     # context = history_prompt or '""'
        #     # logger.debug(f"parsed_output_list: {t}")
        #     prompt += "\n" + QUERY_CONTEXT_PROMPT_INPUT.format(**{"context": context, "query": query.origin_query})
        # else:
        #     prompt += "\n" + PLAN_PROMPT_INPUT.format(**{"query": input_query})

        task = query.task or self.task
        if task_prompt is not None:
            prompt += "\n" + task.task_prompt

        DocInfos = ""
        if doc_infos is not None and doc_infos!="" and doc_infos!="不存在知识库辅助信息":
            DocInfos += f"\nDocument Information: {doc_infos}"

        if code_infos is not None and code_infos!="" and code_infos!="不存在代码库辅助信息":
            DocInfos += f"\nCodeBase Infomation: {code_infos}"
            
        # if selfmemory_prompt:
        #     prompt += "\n" + selfmemory_prompt

        # if background_prompt:
        #     prompt += "\n" + background_prompt

        # if history_prompt:
        #     prompt += "\n" + history_prompt

        input_query = query.input_query

        # logger.debug(f"{self.role.role_name}  extra_system_prompt: {self.role.role_prompt}")
        # logger.debug(f"{self.role.role_name}  input_query: {input_query}")
        # logger.debug(f"{self.role.role_name}  doc_infos: {doc_infos}")
        # logger.debug(f"{self.role.role_name}  tool_names: {tool_names}")

        # extra_system_prompt = self.role.role_prompt
        input_keys = parse_section(self.role.role_prompt, 'Input Format')
        prompt = self.role.role_prompt.format(**{"formatted_tools": formatted_tools, "tool_names": tool_names})
        prompt += "\n" + BEGIN_PROMPT_INPUT
        for input_key in input_keys:
            if input_key == "Origin Query": 
                prompt += "\n**Origin Query:**\n" + query.origin_query
            elif input_key == "Context":
                context =  "\n".join([f"*{k}*\n{v}" for i in query.parsed_output_list for k,v in i.items() if "Action Status" !=k])
                if history:
                    context = history_prompt + "\n" + context
                if not context:
                    context = "there is no context"

                if self.focus_agents and memory_pool_select_by_agent_key_context:
                    context = memory_pool_select_by_agent_key_context
                prompt += "\n**Context:**\n" + context + "\n" + input_query
            elif input_key == "DocInfos":
                prompt += "\n**DocInfos:**\n" + DocInfos
            elif input_key == "Question":
                prompt += "\n**Question:**\n" + input_query

        # if "**Context:**" in self.role.role_prompt:
        #     # logger.debug(f"parsed_output_list: {query.parsed_output_list}")
        #     # input_query =  "'''" + "\n".join([f"###{k}###\n{v}" for i in query.parsed_output_list for k,v in i.items() if "Action Status" !=k]) + "'''"
        #     context =  "\n".join([f"*{k}*\n{v}" for i in query.parsed_output_list for k,v in i.items() if "Action Status" !=k])
        #     if history:
        #         context = history_prompt + "\n" + context

        #     if not context:
        #         context = "there is no context"

        #     # logger.debug(f"parsed_output_list: {t}")
        #     if "DocInfos" in prompt:
        #         prompt += "\n" + QUERY_CONTEXT_DOC_PROMPT_INPUT.format(**{"context": context, "query": query.origin_query, "DocInfos": DocInfos})
        #     else:
        #         prompt += "\n" + QUERY_CONTEXT_PROMPT_INPUT.format(**{"context": context, "query": query.origin_query, "DocInfos": DocInfos})
        # else:
        #     prompt += "\n" + BASE_PROMPT_INPUT.format(**{"query": input_query})

        # prompt = extra_system_prompt.format(**{"query": input_query, "doc_infos": doc_infos, "formatted_tools": formatted_tools, "tool_names": tool_names})
        while "{{" in prompt or "}}" in prompt:
            prompt = prompt.replace("{{", "{")
            prompt = prompt.replace("}}", "}")

        # logger.debug(f"{self.role.role_name}  prompt: {prompt}")
        return prompt

    def create_doc_prompt(self, message: Message) -> str: 
        ''''''
        db_docs = message.db_docs
        search_docs = message.search_docs
        doc_infos = "\n".join([doc.get_snippet() for doc in db_docs] + [doc.get_snippet() for doc in search_docs])
        return doc_infos or "不存在知识库辅助信息"
    
    def create_codedoc_prompt(self, message: Message) -> str: 
        ''''''
        code_docs = message.code_docs
        doc_infos = "\n".join([doc.get_code() for doc in code_docs])
        return doc_infos or "不存在代码库辅助信息"
    
    def create_tools_prompt(self, message: Message) -> str:
        tools = message.tools
        tool_strings = []
        for tool in tools:
            args_schema = re.sub("}", "}}}}", re.sub("{", "{{{{", str(tool.args)))
            tool_strings.append(f"{tool.name}: {tool.description}, args: {args_schema}")
        formatted_tools = "\n".join(tool_strings)
        tool_names = ", ".join([tool.name for tool in tools])
        return formatted_tools, tool_names
    
    def create_task_prompt(self, message: Message) -> str:
        task = message.task or self.task
        return "\n任务目标: " + task.task_prompt if task is not None else None
    
    def create_background_prompt(self, background: Memory, control_key="role_content") -> str:
        background_message = None if background is None else background.to_str_messages(content_key=control_key)
        # logger.debug(f"background_message: {background_message}")
        if background_message:
            background_message = re.sub("}", "}}", re.sub("{", "{{", background_message))
        return "\n背景信息: " + background_message if background_message else None
    
    def create_history_prompt(self, history: Memory, control_key="role_content") -> str:
        history_message = None if history is None else history.to_str_messages(content_key=control_key)
        if history_message:
            history_message = re.sub("}", "}}", re.sub("{", "{{", history_message))
        return "\n补充对话信息: " + history_message if history_message else None
    
    def create_selfmemory_prompt(self, selfmemory: Memory, control_key="role_content") -> str:
        selfmemory_message = None if selfmemory is None else selfmemory.to_str_messages(content_key=control_key)
        if selfmemory_message:
            selfmemory_message = re.sub("}", "}}", re.sub("{", "{{", selfmemory_message))
        return "\n补充自身对话信息: " + selfmemory_message if selfmemory_message else None
    
    def init_history(self, memory: Memory = None) -> Memory:
        return Memory(messages=[])
    
    def update_history(self, message: Message):
        self.memory.append(message)

    def append_history(self, message: Message):
        self.memory.append(message)
        
    def clear_history(self, ):
        self.memory.clear()
        self.memory = self.init_history()
    
    def create_llm_engine(self, temperature=0.2, stop=None):
        return getChatModel(temperature=temperature, stop=stop)

    # def filter(self, message: Message, stop=None) -> Message:

        # tool_params = self.parser_spec_key(message.role_content, "tool_params")
        # code_content = self.parser_spec_key(message.role_content, "code_content")
        # plan = self.parser_spec_key(message.role_content, "plan")
        # plans = self.parser_spec_key(message.role_content, "plans", do_search=False)
        # content = self.parser_spec_key(message.role_content, "content", do_search=False)

        # # logger.debug(f"tool_params: {tool_params}, code_content: {code_content}, plan: {plan}, plans: {plans}, content: {content}")
        # role_content = tool_params or code_content or plan or plans or content
        # message.role_content = role_content or message.role_content
        # return message
    
    def token_usage(self, ):
        '''calculate the usage of token'''
        pass

    def select_memory_by_key(self, memory: Memory) -> Memory:
        return Memory(
            messages=[self.select_message_by_key(message) for message in memory.messages 
                      if self.select_message_by_key(message) is not None]
                      )

    def select_memory_by_agent_key(self, memory: Memory) -> Memory:
        return Memory(
            messages=[self.select_message_by_agent_key(message) for message in memory.messages 
                      if self.select_message_by_agent_key(message) is not None]
                      )

    def select_message_by_agent_key(self, message: Message) -> Message:
        # assume we focus all agents
        if self.focus_agents == []:
            return message
        return None if message is None or message.role_name not in self.focus_agents else self.select_message_by_key(message)
    
    def select_message_by_key(self, message: Message) -> Message:
        # assume we focus all key contents
        if message is None:
            return message
        
        if self.focus_message_keys == []:
            return message
        
        message_c = copy.deepcopy(message)
        message_c.parsed_output = {k: v for k,v in message_c.parsed_output.items() if k in self.focus_message_keys}
        message_c.parsed_output_list = [{k: v for k,v in parsed_output.items() if k in self.focus_message_keys} for parsed_output in message_c.parsed_output_list]
        return message_c

    # def get_extra_infos(self, message: Message) -> Message:
    #     ''''''
    #     if self.do_search:
    #         message = self.get_search_retrieval(message)
        
    #     if self.do_doc_retrieval:
    #         message = self.get_doc_retrieval(message)

    #     if self.do_tool_retrieval:
    #         message = self.get_tool_retrieval(message)
        
    #     return message 
    
    # def get_search_retrieval(self, message: Message,) -> Message:
    #     SEARCH_ENGINES = {"duckduckgo": DDGSTool}
    #     search_docs = []
    #     for idx, doc in enumerate(SEARCH_ENGINES["duckduckgo"].run(message.role_content, 3)):
    #         doc.update({"index": idx})
    #         search_docs.append(Doc(**doc))
    #     message.search_docs = search_docs
    #     return message
    
    # def get_doc_retrieval(self, message: Message) -> Message:
    #     query = message.role_content
    #     knowledge_basename = message.doc_engine_name
    #     top_k = message.top_k
    #     score_threshold = message.score_threshold
    #     if knowledge_basename:
    #         docs = DocRetrieval.run(query, knowledge_basename, top_k, score_threshold)
    #         message.db_docs = [Doc(**doc) for doc in docs]
    #     return message
    
    # def get_code_retrieval(self, message: Message) -> Message:
    #     # DocRetrieval.run("langchain是什么", "DSADSAD")
    #     query = message.input_query
    #     code_engine_name = message.code_engine_name
    #     history_node_list = message.history_node_list
    #     code_docs = CodeRetrieval.run(code_engine_name, query, code_limit=message.top_k, history_node_list=history_node_list)
    #     message.code_docs = [CodeDoc(**doc) for doc in code_docs]
    #     return message
    
    # def get_tool_retrieval(self, message: Message) -> Message:
    #     return message
    
    # def step_router(self, message: Message) -> tuple[Message, ...]:
    #     ''''''
    #     # message = self.parser(message)
    #     # logger.debug(f"message.action_status: {message.action_status}")
    #     observation_message = None
    #     if message.action_status == ActionStatus.CODING:
    #         message, observation_message = self.code_step(message)
    #     elif message.action_status == ActionStatus.TOOL_USING:
    #         message, observation_message = self.tool_step(message)

    #     return message, observation_message

    # def code_step(self, message: Message) -> Message:
    #     '''execute code'''
    #     # logger.debug(f"message.role_content: {message.role_content}, message.code_content: {message.code_content}")
    #     code_answer = self.codebox.chat('```python\n{}```'.format(message.code_content))
    #     code_prompt = f"执行上述代码后存在报错信息为 {code_answer.code_exe_response}，需要进行修复" \
    #                 if code_answer.code_exe_type == "error" else f"执行上述代码后返回信息为 {code_answer.code_exe_response}"
        
    #     observation_message = Message(
    #             role_name="observation",
    #             role_type="func", #self.role.role_type,
    #             role_content="",
    #             step_content="",
    #             input_query=message.code_content,
    #             )
    #     uid = str(uuid.uuid1())
    #     if code_answer.code_exe_type == "image/png":
    #         message.figures[uid] = code_answer.code_exe_response
    #         message.code_answer = f"\n**Observation:**: 执行上述代码后生成一张图片, 图片名为{uid}\n"
    #         message.observation = f"\n**Observation:**: 执行上述代码后生成一张图片, 图片名为{uid}\n"
    #         message.step_content += f"\n**Observation:**: 执行上述代码后生成一张图片, 图片名为{uid}\n"
    #         message.step_contents += [f"\n**Observation:**: 执行上述代码后生成一张图片, 图片名为{uid}\n"]
    #         # message.role_content += f"\n**Observation:**:执行上述代码后生成一张图片, 图片名为{uid}\n"
    #         observation_message.role_content = f"\n**Observation:**: 执行上述代码后生成一张图片, 图片名为{uid}\n"
    #         observation_message.parsed_output = {"Observation": f"执行上述代码后生成一张图片, 图片名为{uid}"}
    #     else:
    #         message.code_answer = code_answer.code_exe_response
    #         message.observation = code_answer.code_exe_response
    #         message.step_content += f"\n**Observation:**: {code_prompt}\n"
    #         message.step_contents += [f"\n**Observation:**: {code_prompt}\n"]
    #         # message.role_content += f"\n**Observation:**: {code_prompt}\n"
    #         observation_message.role_content = f"\n**Observation:**: {code_prompt}\n"
    #         observation_message.parsed_output = {"Observation": code_prompt}
    #     # logger.info(f"**Observation:** {message.action_status}, {message.observation}")
    #     return message, observation_message

    # def tool_step(self, message: Message) -> Message:
    #     '''execute tool'''
    #     # logger.debug(f"{message}")
    #     observation_message = Message(
    #             role_name="observation",
    #             role_type="function", #self.role.role_type,
    #             role_content="\n**Observation:** there is no tool can execute\n"    ,
    #             step_content="",
    #             input_query=str(message.tool_params),
    #             tools=message.tools,
    #             )
    #     # logger.debug(f"message: {message.action_status}, {message.tool_name}, {message.tool_params}")
    #     tool_names = [tool.name for tool in message.tools]
    #     if message.tool_name not in tool_names:
    #         message.tool_answer = "\n**Observation:** there is no tool can execute\n"    
    #         message.observation = "\n**Observation:** there is no tool can execute\n"    
    #         # message.role_content += f"\n**Observation:**: 不存在可以执行的tool\n"
    #         message.step_content += f"\n**Observation:** there is no tool can execute\n"
    #         message.step_contents += [f"\n**Observation:** there is no tool can execute\n"]
    #         observation_message.role_content = f"\n**Observation:** there is no tool can execute\n"
    #         observation_message.parsed_output = {"Observation": "there is no tool can execute\n"}
    #     for tool in message.tools:
    #         if tool.name == message.tool_name:
    #             tool_res = tool.func(**message.tool_params.get("tool_params", {}))
    #             logger.debug(f"tool_res {tool_res}")
    #             message.tool_answer = tool_res    
    #             message.observation = tool_res
    #             # message.role_content += f"\n**Observation:**: {tool_res}\n"
    #             message.step_content += f"\n**Observation:** {tool_res}\n"
    #             message.step_contents += [f"\n**Observation:** {tool_res}\n"]
    #             observation_message.role_content = f"\n**Observation:** {tool_res}\n"
    #             observation_message.parsed_output = {"Observation": tool_res}
    #             break

    #     # logger.info(f"**Observation:** {message.action_status}, {message.observation}")
    #     return message, observation_message
    
    # def parser(self, message: Message) -> Message:
    #     ''''''
    #     content = message.role_content
    #     parser_keys = ["action", "code_content", "code_filename", "tool_params", "plans"]
    #     try:
    #         s_json = self._parse_json(content)
    #         message.action_status = s_json.get("action")
    #         message.code_content = s_json.get("code_content")
    #         message.tool_params = s_json.get("tool_params")
    #         message.tool_name = s_json.get("tool_name")
    #         message.code_filename = s_json.get("code_filename")
    #         message.plans = s_json.get("plans")
    #         # for parser_key in parser_keys:
    #         #     message.action_status = content.get(parser_key)
    #     except Exception as e:
    #         # logger.warning(f"{traceback.format_exc()}")
    #         def parse_text_to_dict(text):
    #             # Define a regular expression pattern to capture the key and value
    #             main_pattern = r"\*\*(.+?):\*\*\s*(.*?)\s*(?=\*\*|$)"
    #             list_pattern = r'```python\n(.*?)```'

    #             # Use re.findall to find all main matches in the text
    #             main_matches = re.findall(main_pattern, text, re.DOTALL)

    #             # Convert main matches to a dictionary
    #             parsed_dict = {key.strip(): value.strip() for key, value in main_matches}

    #             for k, v in parsed_dict.items():
    #                 for pattern in [list_pattern]:
    #                     if "PLAN" != k: continue
    #                     match_value = re.search(pattern, v, re.DOTALL)
    #                     if match_value:
    #                         # Add the code block to the dictionary
    #                         parsed_dict[k] = eval(match_value.group(1).strip())
    #                         break

    #             return parsed_dict
            
    #         def extract_content_from_backticks(text):
    #             code_blocks = []
    #             lines = text.split('\n')
    #             is_code_block = False
    #             code_block = ''
    #             language = ''
    #             for line in lines:
    #                 if line.startswith('```') and not is_code_block:
    #                     is_code_block = True
    #                     language = line[3:]
    #                     code_block = ''
    #                 elif line.startswith('```') and is_code_block:
    #                     is_code_block = False
    #                     code_blocks.append({language.strip(): code_block.strip()})
    #                 elif is_code_block:
    #                     code_block += line + '\n'
    #             return code_blocks
            
    #         def parse_dict_to_dict(parsed_dict):
    #             code_pattern = r'```python\n(.*?)```'
    #             tool_pattern = r'```tool_params\n(.*?)```'
                
    #             pattern_dict = {"code": code_pattern, "tool_params": tool_pattern}
    #             spec_parsed_dict = copy.deepcopy(parsed_dict)
    #             for key, pattern in pattern_dict.items():
    #                 for k, text in parsed_dict.items():
    #                     # Search for the code block
    #                     if not isinstance(text, str): continue
    #                     _match = re.search(pattern, text, re.DOTALL)
    #                     if _match:
    #                         # Add the code block to the dictionary
    #                         try:
    #                             spec_parsed_dict[key] = json.loads(_match.group(1).strip())
    #                         except:
    #                             spec_parsed_dict[key] = _match.group(1).strip()
    #                         break
    #             return spec_parsed_dict
            # def parse_dict_to_dict(parsed_dict):
            #     code_pattern = r'```python\n(.*?)```'
            #     tool_pattern = r'```json\n(.*?)```'
                
            #     pattern_dict = {"code": code_pattern, "json": tool_pattern}
            #     spec_parsed_dict = copy.deepcopy(parsed_dict)
            #     for key, pattern in pattern_dict.items():
            #         for k, text in parsed_dict.items():
            #             # Search for the code block
            #             if not isinstance(text, str): continue
            #             _match = re.search(pattern, text, re.DOTALL)
            #             if _match:
            #                 # Add the code block to the dictionary
            #                 logger.debug(f"dsadsa {text}")
            #                 try:
            #                     spec_parsed_dict[key] = json.loads(_match.group(1).strip())
            #                 except:
            #                     spec_parsed_dict[key] = _match.group(1).strip()
            #                 break
            #     return spec_parsed_dict

    #         parsed_dict = parse_text_to_dict(content)
    #         spec_parsed_dict = parse_dict_to_dict(parsed_dict)
    #         action_value = parsed_dict.get('Action Status')
    #         if action_value:
    #             action_value = action_value.lower()
    #         logger.info(f'{self.role.role_name}: action_value: {action_value}')
    #         # action_value = self._match(r"'action':\s*'([^']*)'", content) if "'action'" in content else self._match(r'"action":\s*"([^"]*)"', content)
            
            # code_content_value = spec_parsed_dict.get('code')
            # # code_content_value = self._match(r"'code_content':\s*'([^']*)'", content) if "'code_content'" in content else self._match(r'"code_content":\s*"([^"]*)"', content)
            # filename_value = self._match(r"'code_filename':\s*'([^']*)'", content) if "'code_filename'" in content else self._match(r'"code_filename":\s*"([^"]*)"', content)
            # tool_params_value = spec_parsed_dict.get('tool_params')
            # # tool_params_value = self._match(r"'tool_params':\s*(\{[^{}]*\})", content, do_json=True) if "'tool_params'" in content \
            # #                         else self._match(r'"tool_params":\s*(\{[^{}]*\})', content, do_json=True)
            # tool_name_value = self._match(r"'tool_name':\s*'([^']*)'", content) if "'tool_name'" in content else self._match(r'"tool_name":\s*"([^"]*)"', content)
            # plans_value = self._match(r"'plans':\s*(\[.*?\])", content, do_search=False) if "'plans'" in content else self._match(r'"plans":\s*(\[.*?\])', content, do_search=False, )
    #         # re解析
    #         message.action_status = action_value or "default"
    #         message.code_content = code_content_value
    #         message.code_filename = filename_value
    #         message.tool_params = tool_params_value
    #         message.tool_name = tool_name_value
    #         message.plans = plans_value
    #         message.parsed_output = parsed_dict
    #         message.spec_parsed_output = spec_parsed_dict
            # code_content_value = spec_parsed_dict.get('code')
            # # code_content_value = self._match(r"'code_content':\s*'([^']*)'", content) if "'code_content'" in content else self._match(r'"code_content":\s*"([^"]*)"', content)
            # filename_value = self._match(r"'code_filename':\s*'([^']*)'", content) if "'code_filename'" in content else self._match(r'"code_filename":\s*"([^"]*)"', content)
            # logger.debug(spec_parsed_dict)

            # if action_value == 'tool_using':
            #     tool_params_value = spec_parsed_dict.get('json')
            # else:
            #     tool_params_value = None
            # # tool_params_value = self._match(r"'tool_params':\s*(\{[^{}]*\})", content, do_json=True) if "'tool_params'" in content \
            # #                         else self._match(r'"tool_params":\s*(\{[^{}]*\})', content, do_json=True)
            # tool_name_value = self._match(r"'tool_name':\s*'([^']*)'", content) if "'tool_name'" in content else self._match(r'"tool_name":\s*"([^"]*)"', content)
            # plans_value = self._match(r"'plans':\s*(\[.*?\])", content, do_search=False) if "'plans'" in content else self._match(r'"plans":\s*(\[.*?\])', content, do_search=False, )
            # # re解析
            # message.action_status = action_value or "default"
            # message.code_content = code_content_value
            # message.code_filename = filename_value
            # message.tool_params = tool_params_value
            # message.tool_name = tool_name_value
            # message.plans = plans_value
            # message.parsed_output = parsed_dict
            # message.spec_parsed_output = spec_parsed_dict

    #     # logger.debug(f"确认当前的action: {message.action_status}")

    #     return message
    
    # def parser_spec_key(self, content, key, do_search=True, do_json=False) -> str:
    #     ''''''
    #     key2pattern = {
    #         "'action'": r"'action':\s*'([^']*)'", '"action"': r'"action":\s*"([^"]*)"',
    #         "'code_content'": r"'code_content':\s*'([^']*)'", '"code_content"': r'"code_content":\s*"([^"]*)"',
    #         "'code_filename'": r"'code_filename':\s*'([^']*)'", '"code_filename"': r'"code_filename":\s*"([^"]*)"',
    #         "'tool_params'": r"'tool_params':\s*(\{[^{}]*\})", '"tool_params"': r'"tool_params":\s*(\{[^{}]*\})',
    #         "'tool_name'": r"'tool_name':\s*'([^']*)'", '"tool_name"': r'"tool_name":\s*"([^"]*)"',
    #         "'plans'": r"'plans':\s*(\[.*?\])", '"plans"': r'"plans":\s*(\[.*?\])',
    #         "'content'": r"'content':\s*'([^']*)'", '"content"': r'"content":\s*"([^"]*)"',
    #         }
        
    #     s_json = self._parse_json(content)
    #     try:
    #         if s_json and key in s_json:
    #             return str(s_json[key])
    #     except:
    #         pass

    #     keystr = f"'{key}'" if f"'{key}'" in content else f'"{key}"'
    #     return self._match(key2pattern.get(keystr, fr"'{key}':\s*'([^']*)'"), content, do_search=do_search, do_json=do_json)
    
    # def _match(self, pattern, s, do_search=True, do_json=False):
    #     try:
    #         if do_search:
    #             match = re.search(pattern, s)
    #             if match:
    #                 value = match.group(1).replace("\\n", "\n")
    #                 if do_json:
    #                     value = json.loads(value)
    #             else:
    #                 value = None
    #         else:
    #             match = re.findall(pattern, s, re.DOTALL)
    #             if match:
    #                 value = match[0]
    #                 if do_json:
    #                     value = json.loads(value)
    #             else:
    #                 value = None
    #     except Exception as e:
    #         logger.warning(f"{traceback.format_exc()}")

    #     # logger.debug(f"pattern: {pattern}, s: {s}, match: {match}")
    #     return value
    
    # def _parse_json(self, s):
    #     try:
    #         pattern = r"```([^`]+)```"
    #         match = re.findall(pattern, s)
    #         if match:
    #             return eval(match[0])
    #     except:
    #         pass
        # return None

    
    def get_memory(self, content_key="role_content"):
        return self.memory.to_tuple_messages(content_key="step_content")
    
    def get_memory_str(self, content_key="role_content"):
        return "\n".join([": ".join(i) for i in self.memory.to_tuple_messages(content_key="step_content")])