diff --git a/src/chat/chat_loop/heartFC_chat.py b/src/chat/chat_loop/heartFC_chat.py index dafb1ecc0..5feae462a 100644 --- a/src/chat/chat_loop/heartFC_chat.py +++ b/src/chat/chat_loop/heartFC_chat.py @@ -254,6 +254,53 @@ class HeartFChatting: ) person_name = await person_info_manager.get_value(person_id, "person_name") return f"{person_name}:{message_data.get('processed_plain_text')}" + + async def _send_and_store_reply( + self, + response_set, + reply_to_str, + loop_start_time, + action_message, + cycle_timers, + thinking_id, + plan_result): + with Timer("回复发送", cycle_timers): + reply_text = await self._send_response(response_set, reply_to_str, loop_start_time, action_message) + + # 存储reply action信息 + person_info_manager = get_person_info_manager() + person_id = person_info_manager.get_person_id( + action_message.get("chat_info_platform", ""), + action_message.get("user_id", ""), + ) + person_name = await person_info_manager.get_value(person_id, "person_name") + action_prompt_display = f"你对{person_name}进行了回复：{reply_text}" + + await database_api.store_action_info( + chat_stream=self.chat_stream, + action_build_into_prompt=False, + action_prompt_display=action_prompt_display, + action_done=True, + thinking_id=thinking_id, + action_data={"reply_text": reply_text, "reply_to": reply_to_str}, + action_name="reply", + ) + + + # 构建循环信息 + loop_info = { + "loop_plan_info": { + "action_result": plan_result.get("action_result", {}), + }, + "loop_action_info": { + "action_taken": True, + "reply_text": reply_text, + "command": "", + "taken_time": time.time(), + }, + } + + return loop_info, reply_text,cycle_timers async def _observe(self, message_data: Optional[Dict[str, Any]] = None): # sourcery skip: hoist-statement-from-if, merge-comparisons, reintroduce-else @@ -319,7 +366,11 @@ class HeartFChatting: # 如果normal模式且不跳过规划器，开始一个回复生成进程，先准备好回复（其实是和planer同时进行的） if not skip_planner: reply_to_str = await self.build_reply_to_str(message_data) - gen_task = asyncio.create_task(self._generate_response(message_data, available_actions, reply_to_str, "chat.replyer.normal")) + gen_task = asyncio.create_task(self._generate_response( + message_data=message_data, + available_actions=available_actions, + reply_to=reply_to_str, + request_type="chat.replyer.normal")) if not skip_planner: with Timer("规划器", cycle_timers): @@ -360,33 +411,29 @@ class HeartFChatting: action_message: Dict[str, Any] = message_data or target_message # type: ignore - if action_type == "reply" or is_parallel: + if action_type == "reply": # 等待回复生成完毕 if self.loop_mode == ChatMode.NORMAL: # 只有在gen_task存在时才等待 - if gen_task is not None: - gather_timeout = global_config.chat.thinking_timeout - try: - response_set = await asyncio.wait_for(gen_task, timeout=gather_timeout) - except asyncio.TimeoutError: - logger.warning(f"{self.log_prefix} 回复生成超时>{global_config.chat.thinking_timeout}s，已跳过") - response_set = None + if not gen_task: + reply_to_str = await self.build_reply_to_str(message_data) + gen_task = asyncio.create_task(self._generate_response( + message_data=message_data, + available_actions=available_actions, + reply_to=reply_to_str, + request_type="chat.replyer.normal")) - # 模型炸了或超时，没有回复内容生成 - if not response_set: - logger.warning(f"{self.log_prefix}模型未生成回复内容") - return False - else: - # 如果没有预生成任务，直接生成回复 - if not reply_to_str: - reply_to_str = await self.build_reply_to_str(action_message) - - with Timer("回复生成", cycle_timers): - response_set = await self._generate_response(action_message, available_actions, reply_to_str, "chat.replyer.normal") - - if not response_set: - logger.warning(f"{self.log_prefix}模型未生成回复内容") - return False + gather_timeout = global_config.chat.thinking_timeout + try: + response_set = await asyncio.wait_for(gen_task, timeout=gather_timeout) + except asyncio.TimeoutError: + logger.warning(f"{self.log_prefix} 回复生成超时>{global_config.chat.thinking_timeout}s，已跳过") + response_set = None + + # 模型炸了或超时，没有回复内容生成 + if not response_set: + logger.warning(f"{self.log_prefix}模型未生成回复内容") + return False else: logger.info(f"{self.log_prefix}{global_config.bot.nickname} 决定进行回复 (focus模式)") @@ -395,90 +442,118 @@ class HeartFChatting: # 生成回复 with Timer("回复生成", cycle_timers): - response_set = await self._generate_response(action_message, available_actions, reply_to_str, request_type="chat.replyer.focus") + response_set = await self._generate_response( + message_data=action_message, + available_actions=available_actions, + reply_to=reply_to_str, + request_type="chat.replyer.focus") if not response_set: logger.warning(f"{self.log_prefix}模型未生成回复内容") return False - # 发送回复 - with Timer("回复发送", cycle_timers): - reply_text = await self._send_response(response_set, reply_to_str, loop_start_time, action_message) - - # 存储reply action信息 - person_info_manager = get_person_info_manager() - person_id = person_info_manager.get_person_id( - action_message.get("chat_info_platform", ""), - action_message.get("user_id", ""), - ) - person_name = await person_info_manager.get_value(person_id, "person_name") - action_prompt_display = f"你对{person_name}进行了回复：{reply_text}" - - await database_api.store_action_info( - chat_stream=self.chat_stream, - action_build_into_prompt=False, - action_prompt_display=action_prompt_display, - action_done=True, - thinking_id=thinking_id, - action_data={"reply_text": reply_text, "reply_to": reply_to_str}, - action_name="reply", - ) - - - # 构建循环信息 - loop_info = { - "loop_plan_info": { - "action_result": plan_result.get("action_result", {}), - }, - "loop_action_info": { - "action_taken": True, - "reply_text": reply_text, - "command": "", - "taken_time": time.time(), - }, - } - - success = True - command = "" + loop_info, reply_text,cycle_timers = await self._send_and_store_reply(response_set, reply_to_str, loop_start_time, action_message, cycle_timers, thinking_id, plan_result) return True else: - # 如果是并行执行且在normal模式下，需要等待预生成的回复任务完成 - # if self.loop_mode == ChatMode.NORMAL and is_parallel and gen_task: - # # 等待预生成的回复任务完成 - # gather_timeout = global_config.chat.thinking_timeout - # try: - # response_set = await asyncio.wait_for(gen_task, timeout=gather_timeout) - # if response_set: - # # 发送回复 - # with Timer("回复发送", cycle_timers): - # reply_text_parallel = await self._send_response(response_set, reply_to_str, loop_start_time, action_message) - # logger.info(f"{self.log_prefix} 并行执行：已发送回复内容") - # else: - # logger.warning(f"{self.log_prefix} 并行执行：预生成回复内容为空") - # except asyncio.TimeoutError: - # logger.warning(f"{self.log_prefix} 并行执行：回复生成超时>{global_config.chat.thinking_timeout}s，已跳过") - # except asyncio.CancelledError: - # logger.debug(f"{self.log_prefix} 并行执行：回复生成任务已被取消") + # 并行执行：同时进行回复发送和动作执行 + tasks = [] - # 动作执行计时 - with Timer("动作执行", cycle_timers): - success, reply_text, command = await self._handle_action( - action_type, reasoning, action_data, cycle_timers, thinking_id, action_message - ) + # 如果是并行执行且在normal模式下，需要等待预生成的回复任务完成并发送回复 + if self.loop_mode == ChatMode.NORMAL and is_parallel and gen_task: + async def handle_reply_task(): + # 等待预生成的回复任务完成 + gather_timeout = global_config.chat.thinking_timeout + try: + response_set = await asyncio.wait_for(gen_task, timeout=gather_timeout) + + except asyncio.TimeoutError: + logger.warning(f"{self.log_prefix} 并行执行：回复生成超时>{global_config.chat.thinking_timeout}s，已跳过") + return None, "", {} + except asyncio.CancelledError: + logger.debug(f"{self.log_prefix} 并行执行：回复生成任务已被取消") + return None, "", {} + + if not response_set: + logger.warning(f"{self.log_prefix} 模型超时或生成回复内容为空") + return None, "", {} + + reply_to_str = await self.build_reply_to_str(action_message) + loop_info, reply_text, cycle_timers_reply = await self._send_and_store_reply(response_set, reply_to_str, loop_start_time, action_message, cycle_timers, thinking_id, plan_result) + return loop_info, reply_text, cycle_timers_reply + + # 添加回复任务到并行任务列表 + tasks.append(asyncio.create_task(handle_reply_task())) + + # 动作执行任务 + async def handle_action_task(): + with Timer("动作执行", cycle_timers): + success, reply_text, command = await self._handle_action( + action_type, reasoning, action_data, cycle_timers, thinking_id, action_message + ) + return success, reply_text, command + + # 添加动作执行任务到并行任务列表 + tasks.append(asyncio.create_task(handle_action_task())) + + # 并行执行所有任务 + results = await asyncio.gather(*tasks, return_exceptions=True) + + # 处理结果 + reply_loop_info = None + reply_text_from_reply = "" + action_success = False + action_reply_text = "" + action_command = "" + + if len(tasks) == 2: # 有回复任务和动作任务 + # 处理回复任务结果 + reply_result = results[0] + if isinstance(reply_result, Exception): + logger.error(f"{self.log_prefix} 回复任务执行异常: {reply_result}") + elif reply_result and reply_result[0] is not None: + reply_loop_info, reply_text_from_reply, _ = reply_result + + # 处理动作任务结果 + action_result = results[1] + if isinstance(action_result, Exception): + logger.error(f"{self.log_prefix} 动作任务执行异常: {action_result}") + else: + action_success, action_reply_text, action_command = action_result + + else: # 只有动作任务 + action_result = results[0] + if isinstance(action_result, Exception): + logger.error(f"{self.log_prefix} 动作任务执行异常: {action_result}") + else: + action_success, action_reply_text, action_command = action_result - loop_info = { - "loop_plan_info": { - "action_result": plan_result.get("action_result", {}), - }, - "loop_action_info": { - "action_taken": success, - "reply_text": reply_text, - "command": command, + # 构建最终的循环信息 + if reply_loop_info: + # 如果有回复信息，使用回复的loop_info作为基础 + loop_info = reply_loop_info + # 更新动作执行信息 + loop_info["loop_action_info"].update({ + "action_taken": action_success, + "command": action_command, "taken_time": time.time(), - }, - } + }) + reply_text = reply_text_from_reply + else: + # 没有回复信息，构建纯动作的loop_info + loop_info = { + "loop_plan_info": { + "action_result": plan_result.get("action_result", {}), + }, + "loop_action_info": { + "action_taken": action_success, + "reply_text": action_reply_text, + "command": action_command, + "taken_time": time.time(), + }, + } + reply_text = action_reply_text if ENABLE_S4U: diff --git a/src/chat/express/expression_learner.py b/src/chat/express/expression_learner.py index 4ee2f2cbb..1870c470a 100644 --- a/src/chat/express/expression_learner.py +++ b/src/chat/express/expression_learner.py @@ -51,7 +51,7 @@ def init_prompt() -> None: 当"想说明某个具体的事实观点，但懒得明说，或者不便明说，或表达一种默契"，使用"懂的都懂" 当"当涉及游戏相关时，表示意外的夸赞，略带戏谑意味"时，使用"这么强！" -注意不要总结你自己（SELF）的发言 +请注意：不要总结你自己（SELF）的发言 现在请你概括 """ Prompt(learn_style_prompt, "learn_style_prompt") diff --git a/src/chat/express/expression_selector.py b/src/chat/express/expression_selector.py index 8358c7a2f..910b43c24 100644 --- a/src/chat/express/expression_selector.py +++ b/src/chat/express/expression_selector.py @@ -279,6 +279,7 @@ class ExpressionSelector: if not isinstance(result, dict) or "selected_situations" not in result: logger.error("LLM返回格式错误") + logger.info(f"LLM返回结果: \n{content}") return [] selected_indices = result["selected_situations"] diff --git a/src/chat/replyer/default_generator.py b/src/chat/replyer/default_generator.py index 0b411a8eb..cab6a2b41 100644 --- a/src/chat/replyer/default_generator.py +++ b/src/chat/replyer/default_generator.py @@ -158,7 +158,17 @@ class DefaultReplyer: enable_timeout: bool = False, ) -> Tuple[bool, Optional[str], Optional[str]]: """ - 回复器 (Replier): 核心逻辑，负责生成回复文本。 + 回复器 (Replier): 负责生成回复文本的核心逻辑。 + + Args: + reply_to: 回复对象，格式为 "发送者:消息内容" + extra_info: 额外信息，用于补充上下文 + available_actions: 可用的动作信息字典 + enable_tool: 是否启用工具调用 + enable_timeout: 是否启用超时处理 + + Returns: + Tuple[bool, Optional[str], Optional[str]]: (是否成功, 生成的回复内容, 使用的prompt) """ prompt = None if available_actions is None: @@ -219,25 +229,30 @@ class DefaultReplyer: async def rewrite_reply_with_context( self, - reply_data: Dict[str, Any], raw_reply: str = "", reason: str = "", reply_to: str = "", - relation_info: str = "", ) -> Tuple[bool, Optional[str]]: """ - 表达器 (Expressor): 核心逻辑，负责生成回复文本。 + 表达器 (Expressor): 负责重写和优化回复文本。 + + Args: + raw_reply: 原始回复内容 + reason: 回复原因 + reply_to: 回复对象，格式为 "发送者:消息内容" + relation_info: 关系信息 + + Returns: + Tuple[bool, Optional[str]]: (是否成功, 重写后的回复内容) """ try: - if not reply_data: - reply_data = { - "reply_to": reply_to, - "relation_info": relation_info, - } + with Timer("构建Prompt", {}): # 内部计时器，可选保留 prompt = await self.build_prompt_rewrite_context( - reply_data=reply_data, + raw_reply=raw_reply, + reason=reason, + reply_to=reply_to, ) content = None @@ -296,7 +311,16 @@ class DefaultReplyer: return await relationship_fetcher.build_relation_info(person_id, points_num=5) - async def build_expression_habits(self, chat_history, target): + async def build_expression_habits(self, chat_history: str, target: str) -> str: + """构建表达习惯块 + + Args: + chat_history: 聊天历史记录 + target: 目标消息内容 + + Returns: + str: 表达习惯信息字符串 + """ if not global_config.expression.enable_expression: return "" @@ -346,7 +370,16 @@ class DefaultReplyer: return expression_habits_block - async def build_memory_block(self, chat_history, target): + async def build_memory_block(self, chat_history: str, target: str) -> str: + """构建记忆块 + + Args: + chat_history: 聊天历史记录 + target: 目标消息内容 + + Returns: + str: 记忆信息字符串 + """ if not global_config.memory.enable_memory: return "" @@ -374,12 +407,13 @@ class DefaultReplyer: return memory_str - async def build_tool_info(self, chat_history, reply_to: str = "", enable_tool: bool = True): + async def build_tool_info(self, chat_history: str, reply_to: str = "", enable_tool: bool = True) -> str: """构建工具信息块 Args: - reply_data: 回复数据，包含要回复的消息内容 - chat_history: 聊天历史 + chat_history: 聊天历史记录 + reply_to: 回复对象，格式为 "发送者:消息内容" + enable_tool: 是否启用工具调用 Returns: str: 工具信息字符串 @@ -423,7 +457,15 @@ class DefaultReplyer: logger.error(f"工具信息获取失败: {e}") return "" - def _parse_reply_target(self, target_message: str) -> tuple: + def _parse_reply_target(self, target_message: str) -> Tuple[str, str]: + """解析回复目标消息 + + Args: + target_message: 目标消息，格式为 "发送者:消息内容" 或 "发送者：消息内容" + + Returns: + Tuple[str, str]: (发送者名称, 消息内容) + """ sender = "" target = "" # 添加None检查，防止NoneType错误 @@ -437,7 +479,15 @@ class DefaultReplyer: target = parts[1].strip() return sender, target - async def build_keywords_reaction_prompt(self, target): + async def build_keywords_reaction_prompt(self, target: Optional[str]) -> str: + """构建关键词反应提示 + + Args: + target: 目标消息内容 + + Returns: + str: 关键词反应提示字符串 + """ # 关键词检测与反应 keywords_reaction_prompt = "" try: @@ -471,15 +521,23 @@ class DefaultReplyer: return keywords_reaction_prompt - async def _time_and_run_task(self, coroutine, name: str): - """一个简单的帮助函数，用于计时和运行异步任务，返回任务名、结果和耗时""" + async def _time_and_run_task(self, coroutine, name: str) -> Tuple[str, Any, float]: + """计时并运行异步任务的辅助函数 + + Args: + coroutine: 要执行的协程 + name: 任务名称 + + Returns: + Tuple[str, Any, float]: (任务名称, 任务结果, 执行耗时) + """ start_time = time.time() result = await coroutine end_time = time.time() duration = end_time - start_time return name, result, duration - def build_s4u_chat_history_prompts(self, message_list_before_now: list, target_user_id: str) -> tuple[str, str]: + def build_s4u_chat_history_prompts(self, message_list_before_now: List[Dict[str, Any]], target_user_id: str) -> Tuple[str, str]: """ 构建 s4u 风格的分离对话 prompt @@ -488,7 +546,7 @@ class DefaultReplyer: target_user_id: 目标用户ID（当前对话对象） Returns: - tuple: (核心对话prompt, 背景对话prompt) + Tuple[str, str]: (核心对话prompt, 背景对话prompt) """ core_dialogue_list = [] background_dialogue_list = [] @@ -507,7 +565,7 @@ class DefaultReplyer: # 其他用户的对话 background_dialogue_list.append(msg_dict) except Exception as e: - logger.error(f"![1753364551656](image/default_generator/1753364551656.png)记录: {msg_dict}, 错误: {e}") + logger.error(f"处理消息记录时出错: {msg_dict}, 错误: {e}") # 构建背景对话 prompt background_dialogue_prompt = "" @@ -552,8 +610,25 @@ class DefaultReplyer: sender: str, target: str, chat_info: str, - ): - """构建 mai_think 上下文信息""" + ) -> Any: + """构建 mai_think 上下文信息 + + Args: + chat_id: 聊天ID + memory_block: 记忆块内容 + relation_info: 关系信息 + time_block: 时间块内容 + chat_target_1: 聊天目标1 + chat_target_2: 聊天目标2 + mood_prompt: 情绪提示 + identity_block: 身份块内容 + sender: 发送者名称 + target: 目标消息内容 + chat_info: 聊天信息 + + Returns: + Any: mai_think 实例 + """ mai_think = mai_thinking_manager.get_mai_think(chat_id) mai_think.memory_block = memory_block mai_think.relation_info_block = relation_info @@ -799,15 +874,14 @@ class DefaultReplyer: async def build_prompt_rewrite_context( self, - reply_data: Dict[str, Any], + raw_reply: str, + reason: str, + reply_to: str, ) -> str: chat_stream = self.chat_stream chat_id = chat_stream.stream_id is_group_chat = bool(chat_stream.group_info) - reply_to = reply_data.get("reply_to", "none") - raw_reply = reply_data.get("raw_reply", "") - reason = reply_data.get("reason", "") sender, target = self._parse_reply_target(reply_to) # 添加情绪状态获取 @@ -834,7 +908,7 @@ class DefaultReplyer: # 并行执行2个构建任务 expression_habits_block, relation_info = await asyncio.gather( self.build_expression_habits(chat_talking_prompt_half, target), - self.build_relation_info(reply_data), + self.build_relation_info(reply_to), ) keywords_reaction_prompt = await self.build_keywords_reaction_prompt(target) diff --git a/src/plugin_system/apis/generator_api.py b/src/plugin_system/apis/generator_api.py index 5ee9e4036..f911454c2 100644 --- a/src/plugin_system/apis/generator_api.py +++ b/src/plugin_system/apis/generator_api.py @@ -140,6 +140,7 @@ async def generate_reply( except Exception as e: logger.error(f"[GeneratorAPI] 生成回复时出错: {e}") + logger.error(traceback.format_exc()) return False, [], None @@ -150,15 +151,22 @@ async def rewrite_reply( enable_splitter: bool = True, enable_chinese_typo: bool = True, model_configs: Optional[List[Dict[str, Any]]] = None, + raw_reply: str = "", + reason: str = "", + reply_to: str = "", ) -> Tuple[bool, List[Tuple[str, Any]]]: """重写回复 Args: chat_stream: 聊天流对象（优先） - reply_data: 回复数据 + reply_data: 回复数据字典（备用，当其他参数缺失时从此获取） chat_id: 聊天ID（备用） enable_splitter: 是否启用消息分割器 enable_chinese_typo: 是否启用错字生成器 + model_configs: 模型配置列表 + raw_reply: 原始回复内容 + reason: 回复原因 + reply_to: 回复对象 Returns: Tuple[bool, List[Tuple[str, Any]]]: (是否成功, 回复集合) @@ -172,8 +180,18 @@ async def rewrite_reply( logger.info("[GeneratorAPI] 开始重写回复") + # 如果参数缺失，从reply_data中获取 + if reply_data: + raw_reply = raw_reply or reply_data.get("raw_reply", "") + reason = reason or reply_data.get("reason", "") + reply_to = reply_to or reply_data.get("reply_to", "") + # 调用回复器重写回复 - success, content = await replyer.rewrite_reply_with_context(reply_data=reply_data or {}) + success, content = await replyer.rewrite_reply_with_context( + raw_reply=raw_reply, + reason=reason, + reply_to=reply_to, + ) reply_set = [] if content: reply_set = await process_human_text(content, enable_splitter, enable_chinese_typo) diff --git a/template/template.env b/template/template.env index d86f23cd2..4718203d7 100644 --- a/template/template.env +++ b/template/template.env @@ -1,11 +1,17 @@ HOST=127.0.0.1 PORT=8000 -#key and url +# 密钥和url + +# 硅基流动 SILICONFLOW_BASE_URL=https://api.siliconflow.cn/v1/ +# DeepSeek官方 DEEP_SEEK_BASE_URL=https://api.deepseek.com/v1 -CHAT_ANY_WHERE_BASE_URL=https://api.chatanywhere.tech/v1 +# 阿里百炼 BAILIAN_BASE_URL = https://dashscope.aliyuncs.com/compatible-mode/v1 +# 火山引擎 +HUOSHAN_BASE_URL = +# xxxxx平台 xxxxxxx_BASE_URL=https://xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx # 定义你要用的api的key(需要去对应网站申请哦) @@ -13,4 +19,5 @@ DEEP_SEEK_KEY= CHAT_ANY_WHERE_KEY= SILICONFLOW_KEY= BAILIAN_KEY = -xxxxxxx_KEY= \ No newline at end of file +HUOSHAN_KEY = +xxxxxxx_KEY=