import traceback from typing import Optional from asyncio import Queue import asyncio import logging import uuid import time import json import shlex import datetime import copy import sys from ..proto.agent_msg import AgentMsg from ..proto.ai_function import * from ..proto.agent_task import AgentTaskState,AgentTask,AgentTodo,AgentTodoResult from ..proto.compute_task import * from .agent_base import * from .llm_process import * from .chatsession import * from ..environment.workspace_env import WorkspaceEnvironment, TodoListType from ..frame.contact_manager import ContactManager,Contact,FamilyMember from ..frame.compute_kernel import ComputeKernel from ..frame.bus import AIBus from ..environment.environment import * from ..environment.workspace_env import WorkspaceEnvironment from ..storage.storage import AIStorage from ..knowledge import * from ..utils import video_utils, image_utils from ..proto.compute_task import ComputeTaskResult,ComputeTaskResultCode,LLMPrompt,LLMResult logger = logging.getLogger(__name__) class AIAgentTemplete: def __init__(self) -> None: self.llm_model_name:str = "gpt-4-0613" self.max_token_size:int = 0 self.template_id:str = None self.introduce:str = None self.author:str = None self.prompt:LLMPrompt = None def load_from_config(self,config:dict) -> bool: if config.get("llm_model_name") is not None: self.llm_model_name = config["llm_model_name"] if config.get("max_token_size") is not None: self.max_token_size = config["max_token_size"] if config.get("template_id") is not None: self.template_id = config["template_id"] if config.get("prompt") is not None: self.prompt = LLMPrompt() if self.prompt.load_from_config(config["prompt"]) is False: logger.error("load prompt from config failed!") return False class AIAgent(BaseAIAgent): def __init__(self) -> None: self.role_prompt:LLMPrompt = None self.agent_prompt:LLMPrompt = None self.agent_think_prompt:LLMPrompt = None self.llm_model_name:str = None self.max_token_size:int = 128000 self.agent_energy = 15 self.agent_task = None self.last_recover_time = time.time() self.enable_thread = False self.can_do_unassigned_task = True self.agent_id:str = None self.template_id:str = None self.fullname:str = None self.powerby = None self.enable = True self.enable_kb = False self.enable_timestamp = False self.guest_prompt_str = None self.owner_promp_str = None self.contact_prompt_str = None self.history_len = 10 self.read_report_prompt = None todo_prompts = {} todo_prompts[TodoListType.TO_WORK] = { "do": None, "check": None, "review": None, } todo_prompts[TodoListType.TO_LEARN] = { "do": None, "check": None, "review": None, } self.todo_prompts = todo_prompts self.chat_db = None self.unread_msg = Queue() # msg from other agent self.owenr_bus = None self.memory : AgentMemory = None self.prviate_workspace : AgentWorkspace = None self.behaviors:Dict[str,BaseLLMProcess] = {} async def initial(self,params:Dict = None): self.memory = AgentMemory(self.agent_id,self.chat_db) self.prviate_workspace = AgentWorkspace(self.agent_id) init_params = {} init_params["memory"] = self.memory init_params["workspace"] = self.prviate_workspace for process_name in self.behaviors.keys(): init_result = await self.behaviors[process_name].initial(init_params) if init_result is False: logger.error(f"llm process {process_name} initial failed! initial return False") return False self.wake_up() return True async def load_from_config(self,config:dict) -> bool: if config.get("instance_id") is None: logger.error("agent instance_id is None!") return False self.agent_id = config["instance_id"] if config.get("fullname") is None: logger.error(f"agent {self.agent_id} fullname is None!") return False self.fullname = config["fullname"] if config.get("enable_thread") is not None: self.enable_thread = bool(config["enable_thread"]) if config.get("powerby") is not None: self.powerby = config["powerby"] if config.get("template_id") is not None: self.template_id = config["template_id"] if config.get("llm_model_name") is not None: self.llm_model_name = config["llm_model_name"] if config.get("max_token_size") is not None: self.max_token_size = config["max_token_size"] if config.get("enable_function") is not None: self.enable_function_list = config["enable_function"] if config.get("enable_kb") is not None: self.enable_kb = bool(config["enable_kb"]) if config.get("enable_timestamp") is not None: self.enable_timestamp = bool(config["enable_timestamp"]) if config.get("history_len"): self.history_len = int(config.get("history_len")) #load all LLMProcess self.behaviors = {} behaviors = config.get("behavior") for process_config_name in behaviors.keys(): process_config = behaviors[process_config_name] real_config = {} real_config.update(config) real_config.update(process_config) load_result = await LLMProcessLoader.get_instance().load_from_config(real_config) if load_result: self.behaviors[process_config_name] = load_result else: logger.error(f"load LLMProcess {process_config_name} failed!") return False return True def get_id(self) -> str: return self.agent_id def get_fullname(self) -> str: return self.fullname def get_template_id(self) -> str: return self.template_id def get_llm_model_name(self) -> str: if self.llm_model_name is None: return AIStorage.get_instance().get_user_config().get_value("llm_model_name") return self.llm_model_name def get_max_token_size(self) -> int: return self.max_token_size def get_agent_role_prompt(self) -> LLMPrompt: return self.role_prompt def get_agent_prompt(self) -> LLMPrompt: return self.agent_prompt async def llm_process_msg(self,msg:AgentMsg) -> AgentMsg: need_process:bool = True if msg.msg_type == AgentMsgType.TYPE_GROUPMSG: need_process = False session_topic = msg.target + "#" + msg.topic chatsession = AIChatSession.get_session(self.agent_id,session_topic,self.chat_db) if msg.mentions is not None: if self.agent_id in msg.mentions: need_process = True logger.info(f"agent {self.agent_id} recv a group chat message from {msg.sender},but is not mentioned,ignore!") if need_process is not True: chatsession.append(msg) resp_msg = msg.create_group_resp_msg(self.agent_id,"") return resp_msg input_parms = { "msg":msg } msg_process = self.behaviors.get("on_message") llm_result : LLMResult = await msg_process.process(input_parms) if llm_result.state == LLMResultStates.ERROR: error_resp = msg.create_error_resp(llm_result.error_str) return error_resp elif llm_result.state == LLMResultStates.IGNORE: return None else: # OK resp_msg = llm_result.raw_result.get("_resp_msg") return resp_msg async def _process_msg(self,msg:AgentMsg,workspace = None) -> AgentMsg: msg.context_info = {} msg.context_info["location"] = "SanJose" msg.context_info["now"] = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S") msg.context_info["weather"] = "Partly Cloudy, 60°F" return await self.llm_process_msg(msg) async def llm_review_tasklist(self): llm_process : BaseLLMProcess = self.behaviors.get("review_task") if llm_process: if self.prviate_workspace: tasklist = await self.prviate_workspace.task_mgr.list_task() if tasklist: for agent_task in tasklist: if self.agent_energy <= 0: break if agent_task.state == AgentTaskState.TASK_STATE_WAIT: input_parms = { "task":agent_task } llm_result : LLMResult = await llm_process.process(input_parms) if llm_result.state == LLMResultStates.ERROR: logger.error(f"llm process review_task error:{llm_result.error_str}") continue elif llm_result.state == LLMResultStates.IGNORE: logger.info(f"llm process review_task ignore!") continue else: determine = llm_result.raw_result.get("determine") logger.info(f"llm process review_task ok!,think is:{determine}") self.agent_energy -= 1 async def _llm_run_todo_list(self, todo_list_type: TodoListType): workspace : WorkspaceEnvironment = self.get_workspace_by_msg(None) logger.info(f"agent {self.agent_id} do my work start!") # review todolist #if await self.need_review_todolist(): # await self._llm_review_todolist(workspace) todo_list = workspace.todo_list[todo_list_type] need_todo = await todo_list.get_todo_list(self.agent_id) check_count = 0 do_count = 0 review_count = 0 for todo in need_todo: if self.agent_energy <= 0: break do_prompts = self._can_do_todo(todo_list_type, todo) if do_prompts: prompt : LLMPrompt = LLMPrompt() prompt.append(self.agent_prompt) prompt.append(workspace.get_role_prompt(self.agent_id)) prompt.append(do_prompts) prompt.append(todo.to_prompt()) do_result : AgentTodoResult = await self._llm_do_todo(todo, prompt, workspace) todo.last_do_time = datetime.datetime.now().timestamp() todo.retry_count += 1 match do_result.result_code: case AgentTodoResult.TODO_RESULT_CODE_LLM_ERROR: continue case AgentTodoResult.TODO_RESULT_CODE_OK: todo.result = do_result await todo_list.update_todo(todo.todo_id,AgentTodo.TODO_STATE_WAITING_CHECK) case AgentTodoResult.TODO_RESULT_CODE_EXEC_OP_ERROR: await todo_list.update_todo(todo.todo_id,AgentTodo.TODO_STATE_EXEC_FAILED) await todo_list.append_worklog(todo,do_result) self.agent_energy -= 2 do_count += 1 # review_result = await self._llm_review_todo(todo,workspace) # todo.last_review_time = datetime.datetime.now().timestamp() continue check_prompts = self._can_check_todo(todo_list_type, todo) if check_prompts: prompt : LLMPrompt = LLMPrompt() prompt.append(self.agent_prompt) prompt.append(workspace.get_role_prompt(self.agent_id)) prompt.append(check_prompts) if todo.last_check_result: prompt.append(LLMPrompt(todo.last_check_result)) prompt.append(todo.detail) prompt.append(todo.result) check_result: AgentTodoResult = await self._llm_check_todo(todo, prompt, workspace) todo.last_check_time = datetime.datetime.now().timestamp() match check_result.result_code: case AgentTodoResult.TODO_RESULT_CODE_LLM_ERROR: continue case AgentTodoResult.TODO_RESULT_CODE_OK: await todo_list.update_todo(todo.todo_id,AgentTodo.TODO_STATE_DONE) case AgentTodoResult.TODO_RESULT_CODE_EXEC_OP_ERROR: await todo_list.update_todo(todo.todo_id,AgentTodo.TDDO_STATE_CHECKFAILED) await todo_list.append_worklog(todo, check_result) self.agent_energy -= 1 check_count += 1 continue review_prompts = self._can_review_todo(todo_list_type, todo) if review_prompts: prompt.append(workspace.get_prompt()) prompt.append(workspace.get_role_prompt(self.agent_id)) prompt.append(review_prompts) todo_tree = todo_list.get_todo_tree("/") prompt.append(LLMPrompt(todo_tree)) do_result : AgentTodoResult = await self._llm_review_todo(todo, prompt, workspace) todo.last_review_time = datetime.datetime.now().timestamp() match do_result.result_code: case AgentTodoResult.TODO_RESULT_CODE_LLM_ERROR: continue case AgentTodoResult.TODO_RESULT_CODE_EXEC_OP_ERROR: continue case AgentTodoResult.TODO_RESULT_CODE_OK: await todo_list.update_todo(todo.todo_id,AgentTodo.TODO_STATE_REVIEWED) await todo_list.append_worklog(todo,do_result) self.agent_energy -= 1 review_count += 1 continue logger.info(f"agent {self.agent_id} ,check:{check_count} todo,do:{do_count} todo.") def _can_review_todo(self, todo_list_type: TodoListType, todo:AgentTodo) -> LLMPrompt: do_prompts = self.todo_prompts[todo_list_type].get("review") if not do_prompts: return None if todo.can_review() is False: return None return do_prompts def _can_check_todo(self, todo_list_type: TodoListType, todo:AgentTodo) -> LLMPrompt: do_prompts = self.todo_prompts[todo_list_type].get("check") if not do_prompts: return None if todo.can_check() is False: return None if todo.checker is not None: if todo.checker != self.agent_id: return None else: if self.can_do_unassigned_task is False: return None else: todo.checker = self.agent_id return do_prompts def _can_do_todo(self, todo_list_type: TodoListType, todo:AgentTodo) -> LLMPrompt: do_prompts = self.todo_prompts[todo_list_type].get("do") if not do_prompts: return None if todo.can_do() is False: return None if todo.worker is not None: if todo.worker != self.agent_id: return None else: if self.can_do_unassigned_task is False: return None else: todo.worker = self.agent_id return do_prompts async def _llm_do_todo(self, todo: AgentTodo, prompt: LLMPrompt, workspace: WorkspaceEnvironment) -> AgentTodoResult: result = AgentTodoResult() task_result:ComputeTaskResult = await self.do_llm_complection(prompt, is_json_resp=True) if task_result.error_str is not None: logger.error(f"_llm_do compute error:{task_result.error_str}") result.result_code = AgentTodoResult.TODO_RESULT_CODE_LLM_ERROR result.error_str = task_result.error_str return result llm_result = LLMResult.from_str(task_result.result_str) # result_str is the explain of how to do this todo result.result_str = llm_result.resp result.op_list = llm_result.op_list if llm_result.post_msgs is not None: for msg in llm_result.post_msgs: msg.sender = self.agent_id msg.topic = f"{todo.title}##{todo.todo_id}" #msg.prev_msg_id = todo.todo_id chatsession = AIChatSession.get_session(self.agent_id,f"{msg.target}#{msg.topic}",self.chat_db) chatsession.append(msg) resp = await AIBus.get_default_bus().post_message(msg) logging.info(f"agent {self.agent_id} send msg to {msg.target} result:{resp}") result_str, have_error = await workspace.exec_op_list(llm_result.action_list, self.agent_id) if have_error: result.result_code = AgentTodoResult.TODO_RESULT_CODE_EXEC_OP_ERROR #result.error_str = error_str return result result.result_str = result_str return result async def _llm_check_todo(self, todo: AgentTodo, prompt: LLMPrompt, workspace: WorkspaceEnvironment) -> AgentTodoResult: result = AgentTodoResult() inner_functions,_ = BaseAIAgent.get_inner_functions(workspace) task_result:ComputeTaskResult = await self.do_llm_complection(prompt,inner_functions=inner_functions,is_json_resp=True) if task_result.error_str is not None: logger.error(f"_llm_do compute error:{task_result.error_str}") result.result_code = AgentTodoResult.TODO_RESULT_CODE_LLM_ERROR result.error_str = task_result.error_str return result result.result_str = task_result.result_str todo.last_check_result = task_result.result_str return result async def _llm_review_todo(self, todo:AgentTodo, prompt: LLMPrompt, workspace: WorkspaceEnvironment): inner_functions,_ = BaseAIAgent.get_inner_functions(workspace) task_result:ComputeTaskResult = await self.do_llm_complection(prompt,inner_functions=inner_functions) if task_result.result_code != ComputeTaskResultCode.OK: logger.error(f"_llm_review_todos compute error:{task_result.error_str}") return return # async def do_blance_knowledge_base(selft): # # 整理自己的知识库(让分类更平衡，更由于自己以后的工作)，并尝试更新学习目标 # current_path = "/" # current_list = kb.get_list(current_path) # self_assessment_with_goal = self.get_self_assessment_with_goal() # learn_goal = {} # llm_blance_knowledge_base(current_path,current_list,self_assessment_with_goal,learn_goal,learn_power) # # 主动学习 # # 方法目前只有使用搜索引擎一种？ # for goal in learn_goal.items(): # self.llm_learn_with_search_engine(kb,goal,learn_power) # if learn_power <= 0: # break async def do_self_think(self): session_id_list = AIChatSession.list_session(self.agent_id,self.chat_db) for session_id in session_id_list: if self.agent_energy <= 0: break used_energy = await self.think_chatsession(session_id) self.agent_energy -= used_energy # todo_logs = await self.get_todo_logs() # for todo_log in todo_logs: # if self.agent_energy <= 0: # break # used_energy = await self.think_todo_log(todo_log) # self.agent_energy -= used_energy return #async def think_todo_log(self,todo_log:AgentWorkLog): # pass def need_self_think(self) -> bool: return False def wake_up(self) -> None: if self.agent_task is None: self.agent_task = asyncio.create_task(self._on_timer()) else: logger.warning(f"agent {self.agent_id} is already wake up!") # agent loop async def _on_timer(self): while True: await asyncio.sleep(15) try: now = time.time() if self.last_recover_time is None: self.last_recover_time = now else: if now - self.last_recover_time > 60: self.agent_energy += (now - self.last_recover_time) / 60 self.last_recover_time = now if self.agent_energy <= 1: continue await self.llm_review_tasklist() # complete & check todo #await self._llm_run_todo_list(TodoListType.TO_WORK) ##await self._llm_run_todo_list(TodoListType.TO_LEARN) if self.need_self_think(): await self.do_self_think() # review other's todo # self.review_other_works() except Exception as e: tb_str = traceback.format_exc() logger.error(f"agent {self.agent_id} on timer error:{e},{tb_str}") continue