281 lines
14 KiB
Python
281 lines
14 KiB
Python
from pydantic import BaseModel
|
|
from typing import List
|
|
import json
|
|
import re
|
|
from loguru import logger
|
|
import traceback
|
|
import uuid
|
|
import copy
|
|
|
|
from dev_opsgpt.connector.agents import BaseAgent
|
|
from dev_opsgpt.tools.base_tool import BaseTools, Tool
|
|
from dev_opsgpt.connector.shcema.memory import Memory
|
|
from dev_opsgpt.connector.connector_schema import (
|
|
Role, Message, ActionStatus, ChainConfig,
|
|
load_role_configs
|
|
)
|
|
from dev_opsgpt.sandbox import PyCodeBox, CodeBoxResponse
|
|
|
|
|
|
from configs.server_config import SANDBOX_SERVER
|
|
|
|
from dev_opsgpt.connector.configs.agent_config import AGETN_CONFIGS
|
|
role_configs = load_role_configs(AGETN_CONFIGS)
|
|
|
|
|
|
class BaseChain:
|
|
def __init__(
|
|
self,
|
|
chainConfig: ChainConfig,
|
|
agents: List[BaseAgent],
|
|
chat_turn: int = 1,
|
|
do_checker: bool = False,
|
|
do_code_exec: bool = False,
|
|
# prompt_mamnger: PromptManager
|
|
) -> None:
|
|
self.chainConfig = chainConfig
|
|
self.agents = agents
|
|
self.chat_turn = chat_turn
|
|
self.do_checker = do_checker
|
|
self.checker = BaseAgent(role=role_configs["checker"].role,
|
|
task = None,
|
|
memory = None,
|
|
do_search = role_configs["checker"].do_search,
|
|
do_doc_retrieval = role_configs["checker"].do_doc_retrieval,
|
|
do_tool_retrieval = role_configs["checker"].do_tool_retrieval,
|
|
do_filter=False, do_use_self_memory=False)
|
|
|
|
self.global_memory = Memory([])
|
|
self.local_memory = Memory([])
|
|
self.do_code_exec = do_code_exec
|
|
self.codebox = PyCodeBox(
|
|
remote_url=SANDBOX_SERVER["url"],
|
|
remote_ip=SANDBOX_SERVER["host"],
|
|
remote_port=SANDBOX_SERVER["port"],
|
|
token="mytoken",
|
|
do_code_exe=True,
|
|
do_remote=SANDBOX_SERVER["do_remote"],
|
|
do_check_net=False
|
|
)
|
|
|
|
def step(self, query: Message, history: Memory = None, background: Memory = None) -> Message:
|
|
'''execute chain'''
|
|
local_memory = Memory([])
|
|
input_message = copy.deepcopy(query)
|
|
step_nums = copy.deepcopy(self.chat_turn)
|
|
check_message = None
|
|
|
|
self.global_memory.append(input_message)
|
|
local_memory.append(input_message)
|
|
while step_nums > 0:
|
|
|
|
for agent in self.agents:
|
|
output_message = agent.run(input_message, history, background=background)
|
|
output_message = self.inherit_extrainfo(input_message, output_message)
|
|
# according the output to choose one action for code_content or tool_content
|
|
logger.info(f"{agent.role.role_name} message: {output_message.role_content}")
|
|
output_message = self.parser(output_message)
|
|
# output_message = self.step_router(output_message)
|
|
|
|
input_message = output_message
|
|
self.global_memory.append(output_message)
|
|
|
|
local_memory.append(output_message)
|
|
# when get finished signal can stop early
|
|
if output_message.action_status == ActionStatus.FINISHED:
|
|
break
|
|
|
|
if self.do_checker:
|
|
logger.debug(f"{self.checker.role.role_name} input global memory: {self.global_memory.to_str_messages(content_key='step_content')}")
|
|
check_message = self.checker.run(query, background=self.global_memory)
|
|
check_message = self.parser(check_message)
|
|
check_message = self.filter(check_message)
|
|
check_message = self.inherit_extrainfo(output_message, check_message)
|
|
logger.debug(f"{self.checker.role.role_name}: {check_message.role_content}")
|
|
|
|
if check_message.action_status == ActionStatus.FINISHED:
|
|
self.global_memory.append(check_message)
|
|
break
|
|
|
|
step_nums -= 1
|
|
|
|
return check_message or output_message, local_memory
|
|
|
|
def step_router(self, message: Message) -> Message:
|
|
''''''
|
|
# message = self.parser(message)
|
|
# logger.debug(f"message.action_status: {message.action_status}")
|
|
if message.action_status == ActionStatus.CODING:
|
|
message = self.code_step(message)
|
|
elif message.action_status == ActionStatus.TOOL_USING:
|
|
message = self.tool_step(message)
|
|
|
|
return 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))
|
|
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观察: 执行代码后获得输出一张图片, 文件名为{uid}\n"
|
|
message.observation = f"\n观察: 执行代码后获得输出一张图片, 文件名为{uid}\n"
|
|
message.step_content += f"\n观察: 执行代码后获得输出一张图片, 文件名为{uid}\n"
|
|
message.step_contents += [f"\n观察: 执行代码后获得输出一张图片, 文件名为{uid}\n"]
|
|
message.role_content += f"\n执行代码后获得输出一张图片, 文件名为{uid}\n"
|
|
else:
|
|
message.code_answer = code_answer.code_exe_response
|
|
message.observation = code_answer.code_exe_response
|
|
message.step_content += f"\n观察: 执行代码后获得输出是 {code_answer.code_exe_response}\n"
|
|
message.step_contents += [f"\n观察: 执行代码后获得输出是 {code_answer.code_exe_response}\n"]
|
|
message.role_content += f"\n观察: 执行代码后获得输出是 {code_answer.code_exe_response}\n"
|
|
logger.info(f"观察: {message.action_status}, {message.observation}")
|
|
return message
|
|
|
|
def tool_step(self, message: Message) -> Message:
|
|
'''execute tool'''
|
|
# 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 = "不存在可以执行的tool"
|
|
message.observation = "不存在可以执行的tool"
|
|
message.role_content += f"\n观察: 不存在可以执行的tool\n"
|
|
message.step_content += f"\n观察: 不存在可以执行的tool\n"
|
|
message.step_contents += [f"\n观察: 不存在可以执行的tool\n"]
|
|
for tool in message.tools:
|
|
if tool.name == message.tool_name:
|
|
tool_res = tool.func(**message.tool_params)
|
|
message.tool_answer = tool_res
|
|
message.observation = tool_res
|
|
message.role_content += f"\n观察: {tool_res}\n"
|
|
message.step_content += f"\n观察: {tool_res}\n"
|
|
message.step_contents += [f"\n观察: {tool_res}\n"]
|
|
return message
|
|
|
|
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 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()}")
|
|
action_value = self._match(r"'action':\s*'([^']*)'", content) if "'action'" in content else self._match(r'"action":\s*"([^"]*)"', content)
|
|
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 = 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
|
|
|
|
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 inherit_extrainfo(self, input_message: Message, output_message: Message):
|
|
output_message.db_docs = input_message.db_docs
|
|
output_message.search_docs = input_message.search_docs
|
|
output_message.code_docs = input_message.code_docs
|
|
output_message.figures.update(input_message.figures)
|
|
return output_message
|
|
|
|
def get_memory(self, do_all_memory=True, content_key="role_content") -> Memory:
|
|
memory = self.global_memory if do_all_memory else self.local_memory
|
|
return memory.to_tuple_messages(content_key=content_key)
|
|
|
|
def get_memory_str(self, do_all_memory=True, content_key="role_content") -> Memory:
|
|
memory = self.global_memory if do_all_memory else self.local_memory
|
|
# for i in memory.to_tuple_messages(content_key=content_key):
|
|
# logger.debug(f"{i}")
|
|
return "\n".join([": ".join(i) for i in memory.to_tuple_messages(content_key=content_key)])
|
|
|
|
def get_agents_memory(self, content_key="role_content"):
|
|
return [agent.get_memory(content_key=content_key) for agent in self.agents]
|
|
|
|
def get_agents_memory_str(self, content_key="role_content"):
|
|
return "************".join([f"{agent.role.role_name}\n" + agent.get_memory_str(content_key=content_key) for agent in self.agents]) |