""" 默认回复生成器 - 集成统一Prompt系统 使用重构后的统一Prompt系统替换原有的复杂提示词构建逻辑 """ import asyncio import random import re import time import traceback from datetime import datetime from typing import Any from src.chat.express.expression_selector import expression_selector from src.chat.message_receive.chat_stream import ChatStream from src.chat.message_receive.message import MessageRecv, MessageSending, Seg, UserInfo from src.chat.message_receive.uni_message_sender import HeartFCSender from src.chat.utils.chat_message_builder import ( build_readable_messages, get_raw_msg_before_timestamp_with_chat, replace_user_references_sync, ) from src.chat.utils.memory_mappings import get_memory_type_chinese_label # 导入新的统一Prompt系统 from src.chat.utils.prompt import Prompt, PromptParameters, global_prompt_manager from src.chat.utils.timer_calculator import Timer from src.chat.utils.utils import get_chat_type_and_target_info from src.common.logger import get_logger from src.config.config import global_config, model_config from src.individuality.individuality import get_individuality from src.llm_models.utils_model import LLMRequest from src.mais4u.mai_think import mai_thinking_manager # 旧记忆系统已被移除 # 旧记忆系统已被移除 from src.mood.mood_manager import mood_manager from src.person_info.person_info import get_person_info_manager from src.plugin_system.apis import llm_api from src.plugin_system.base.component_types import ActionInfo, EventType logger = get_logger("replyer") def init_prompt(): Prompt("你正在qq群里聊天，下面是群里在聊的内容：", "chat_target_group1") Prompt("你正在和{sender_name}聊天，这是你们之前聊的内容：", "chat_target_private1") Prompt("在群里聊天", "chat_target_group2") Prompt("和{sender_name}聊天", "chat_target_private2") Prompt( """ {expression_habits_block} {relation_info_block} {chat_target} {time_block} {chat_info} {identity} 你正在{chat_target_2},{reply_target_block} 对这句话，你想表达，原句：{raw_reply},原因是：{reason}。你现在要思考怎么组织回复 你现在的心情是：{mood_state} 你需要使用合适的语法和句法，参考聊天内容，组织一条日常且口语化的回复。请你修改你想表达的原句，符合你的表达风格和语言习惯 {reply_style}，你可以完全重组回复，保留最基本的表达含义就好，但重组后保持语意通顺。 {keywords_reaction_prompt} {moderation_prompt} 不要复读你前面发过的内容，意思相近也不行。 不要浮夸，不要夸张修辞，平淡且不要输出多余内容(包括前后缀，冒号和引号，括号，表情包，at或 @等 )，只输出一条回复就好。 现在，你说： """, "default_expressor_prompt", ) # s4u 风格的 prompt 模板 Prompt( """ # 人设：{identity} ## 当前状态 - 你现在的心情是：{mood_state} - {schedule_block} ## 历史记录 ### 📜 已读历史消息（仅供参考） {read_history_prompt} {cross_context_block} ### 📬 未读历史消息（动作执行对象） {unread_history_prompt} ## 表达方式 - *你需要参考你的回复风格：* {reply_style} {keywords_reaction_prompt} {expression_habits_block} {tool_info_block} {knowledge_prompt} ## 其他信息 {memory_block} {relation_info_block} {extra_info_block} {action_descriptions} ## 任务 *{chat_scene}* ### 核心任务 - 你现在的主要任务是和 {sender_name} 聊天。同时，也有其他用户会参与聊天，你可以参考他们的回复内容，但是你现在想回复{sender_name}的发言。 - {reply_target_block} 你需要生成一段紧密相关且能推动对话的回复。 ## 规则 {safety_guidelines_block} **重要提醒：** - **已读历史消息仅作为当前聊天情景的参考** - **动作执行对象只能是未读历史消息中的消息** - **请优先对兴趣值高的消息做出回复**（兴趣度标注在未读消息末尾） 在回应之前，首先分析消息的针对性： 1. **直接针对你**：@你、回复你、明确询问你 → 必须回应 2. **间接相关**：涉及你感兴趣的话题但未直接问你 → 谨慎参与 3. **他人对话**：与你无关的私人交流 → 通常不参与 4. **重复内容**：他人已充分回答的问题 → 避免重复 你的回复应该： 1. 明确回应目标消息，而不是宽泛地评论。 2. 可以分享你的看法、提出相关问题，或者开个合适的玩笑。 3. 目的是让对话更有趣、更深入。 4. 不要浮夸，不要夸张修辞，不要输出多余内容(包括前后缀，冒号和引号，括号()，表情包，at或 @等 )。 最终请输出一条简短、完整且口语化的回复。 -------------------------------- {time_block} 注意不要复读你前面发过的内容，意思相近也不行。 请注意不要输出多余内容(包括前后缀，冒号和引号，at或 @等 )。只输出回复内容。 {moderation_prompt} 现在，你说： """, "s4u_style_prompt", ) Prompt( """ 你是一个专门获取知识的助手。你的名字是{bot_name}。现在是{time_now}。 群里正在进行的聊天内容： {chat_history} 现在，{sender}发送了内容:{target_message},你想要回复ta。 请仔细分析聊天内容，考虑以下几点： 1. 内容中是否包含需要查询信息的问题 2. 是否有明确的知识获取指令 If you need to use the search tool, please directly call the function "lpmm_search_knowledge". If you do not need to use any tool, simply output "No tool needed". """, name="lpmm_get_knowledge_prompt", ) # normal 版 prompt 模板（0.9之前的简化模式） logger.debug("[Prompt模式调试] 正在注册normal_style_prompt模板") Prompt( """ {chat_scene} **重要：消息针对性判断** 在回应之前，首先分析消息的针对性： 1. **直接针对你**：@你、回复你、明确询问你 → 必须回应 2. **间接相关**：涉及你感兴趣的话题但未直接问你 → 谨慎参与 3. **他人对话**：与你无关的私人交流 → 通常不参与 4. **重复内容**：他人已充分回答的问题 → 避免重复 {expression_habits_block} {tool_info_block} {knowledge_prompt} {memory_block} {relation_info_block} {extra_info_block} {cross_context_block} {identity} 如果有人说你是人机，你可以用一种阴阳怪气的口吻来回应 {schedule_block} {action_descriptions} 下面是群里最近的聊天内容： -------------------------------- {time_block} {chat_info} -------------------------------- {reply_target_block} 你现在的心情是：{mood_state} {config_expression_style} 注意不要复读你前面发过的内容，意思相近也不行。 {keywords_reaction_prompt} 请注意不要输出多余内容(包括前后缀，冒号和引号，at或 @等 )。只输出回复内容。 {moderation_prompt} 你的核心任务是针对 {reply_target_block} 中提到的内容，{relation_info_block}生成一段紧密相关且能推动对话的回复。你的回复应该： 1. 明确回应目标消息，而不是宽泛地评论。 2. 可以分享你的看法、提出相关问题，或者开个合适的玩笑。 3. 目的是让对话更有趣、更深入。 最终请输出一条简短、完整且口语化的回复。 现在，你说： """, "normal_style_prompt", ) logger.debug("[Prompt模式调试] normal_style_prompt模板注册完成") class DefaultReplyer: def __init__( self, chat_stream: ChatStream, request_type: str = "replyer", ): self.express_model = LLMRequest(model_set=model_config.model_task_config.replyer, request_type=request_type) self.chat_stream = chat_stream # 这些将在异步初始化中设置 self.is_group_chat = False self.chat_target_info = None self._chat_info_initialized = False self.heart_fc_sender = HeartFCSender() # 使用新的增强记忆系统 # from src.chat.memory_system.enhanced_memory_activator import EnhancedMemoryActivator self._chat_info_initialized = False async def _initialize_chat_info(self): """异步初始化聊天信息""" if not self._chat_info_initialized: self.is_group_chat, self.chat_target_info = await get_chat_type_and_target_info(self.chat_stream.stream_id) self._chat_info_initialized = True # self.memory_activator = EnhancedMemoryActivator() self.memory_activator = None # 暂时禁用记忆激活器 # 旧的即时记忆系统已被移除，现在使用增强记忆系统 # self.instant_memory = VectorInstantMemoryV2(chat_id=self.chat_stream.stream_id, retention_hours=1) from src.plugin_system.core.tool_use import ToolExecutor # 延迟导入ToolExecutor，不然会循环依赖 self.tool_executor = ToolExecutor(chat_id=self.chat_stream.stream_id) async def generate_reply_with_context( self, reply_to: str = "", extra_info: str = "", available_actions: dict[str, ActionInfo] | None = None, enable_tool: bool = True, from_plugin: bool = True, stream_id: str | None = None, reply_message: dict[str, Any] | None = None, ) -> tuple[bool, dict[str, Any] | None, str | None]: # sourcery skip: merge-nested-ifs """ 回复器 (Replier): 负责生成回复文本的核心逻辑。 Args: reply_to: 回复对象，格式为 "发送者:消息内容" extra_info: 额外信息，用于补充上下文 available_actions: 可用的动作信息字典 enable_tool: 是否启用工具调用 from_plugin: 是否来自插件 Returns: Tuple[bool, Optional[Dict[str, Any]], Optional[str]]: (是否成功, 生成的回复, 使用的prompt) """ # 初始化聊天信息 await self._initialize_chat_info() prompt = None if available_actions is None: available_actions = {} llm_response = None try: # 构建 Prompt with Timer("构建Prompt", {}): # 内部计时器，可选保留 prompt = await self.build_prompt_reply_context( reply_to=reply_to, extra_info=extra_info, available_actions=available_actions, enable_tool=enable_tool, reply_message=reply_message, ) if not prompt: logger.warning("构建prompt失败，跳过回复生成") return False, None, None from src.plugin_system.core.event_manager import event_manager # 触发 POST_LLM 事件（请求 LLM 之前） if not from_plugin: result = await event_manager.trigger_event( EventType.POST_LLM, permission_group="SYSTEM", prompt=prompt, stream_id=stream_id ) if not result.all_continue_process(): raise UserWarning(f"插件{result.get_summary().get('stopped_handlers', '')}于请求前中断了内容生成") # 4. 调用 LLM 生成回复 content = None reasoning_content = None model_name = "unknown_model" try: content, reasoning_content, model_name, tool_call = await self.llm_generate_content(prompt) logger.debug(f"replyer生成内容: {content}") llm_response = { "content": content, "reasoning": reasoning_content, "model": model_name, "tool_calls": tool_call, } # 触发 AFTER_LLM 事件 if not from_plugin: result = await event_manager.trigger_event( EventType.AFTER_LLM, permission_group="SYSTEM", prompt=prompt, llm_response=llm_response, stream_id=stream_id, ) if not result.all_continue_process(): raise UserWarning( f"插件{result.get_summary().get('stopped_handlers', '')}于请求后取消了内容生成" ) except UserWarning as e: raise e except Exception as llm_e: # 精简报错信息 logger.error(f"LLM 生成失败: {llm_e}") return False, None, prompt # LLM 调用失败则无法生成回复 # 回复生成成功后，异步存储聊天记忆（不阻塞返回） try: await self._store_chat_memory_async(reply_to, reply_message) except Exception as memory_e: # 记忆存储失败不应该影响回复生成的成功返回 logger.warning(f"记忆存储失败，但不影响回复生成: {memory_e}") return True, llm_response, prompt except UserWarning as uw: raise uw except Exception as e: logger.error(f"回复生成意外失败: {e}") traceback.print_exc() return False, None, prompt async def rewrite_reply_with_context( self, raw_reply: str = "", reason: str = "", reply_to: str = "", return_prompt: bool = False, ) -> tuple[bool, str | None, str | None]: """ 表达器 (Expressor): 负责重写和优化回复文本。 Args: raw_reply: 原始回复内容 reason: 回复原因 reply_to: 回复对象，格式为 "发送者:消息内容" relation_info: 关系信息 Returns: Tuple[bool, Optional[str]]: (是否成功, 重写后的回复内容) """ try: with Timer("构建Prompt", {}): # 内部计时器，可选保留 prompt = await self.build_prompt_rewrite_context( raw_reply=raw_reply, reason=reason, reply_to=reply_to, ) content = None reasoning_content = None model_name = "unknown_model" if not prompt: logger.error("Prompt 构建失败，无法生成回复。") return False, None, None try: content, reasoning_content, model_name, _ = await self.llm_generate_content(prompt) logger.info(f"想要表达：{raw_reply}||理由：{reason}||生成回复: {content}\n") except Exception as llm_e: # 精简报错信息 logger.error(f"LLM 生成失败: {llm_e}") return False, None, prompt if return_prompt else None # LLM 调用失败则无法生成回复 return True, content, prompt if return_prompt else None except Exception as e: logger.error(f"回复生成意外失败: {e}") traceback.print_exc() return False, None, prompt if return_prompt else None async def build_expression_habits(self, chat_history: str, target: str) -> str: """构建表达习惯块 Args: chat_history: 聊天历史记录 target: 目标消息内容 Returns: str: 表达习惯信息字符串 """ # 检查是否允许在此聊天流中使用表达 use_expression, _, _ = global_config.expression.get_expression_config_for_chat(self.chat_stream.stream_id) if not use_expression: return "" style_habits = [] grammar_habits = [] # 使用从处理器传来的选中表达方式 # LLM模式：调用LLM选择5-10个，然后随机选5个 selected_expressions = await expression_selector.select_suitable_expressions_llm( self.chat_stream.stream_id, chat_history, max_num=8, min_num=2, target_message=target ) if selected_expressions: logger.debug(f"使用处理器选中的{len(selected_expressions)}个表达方式") for expr in selected_expressions: if isinstance(expr, dict) and "situation" in expr and "style" in expr: expr_type = expr.get("type", "style") if expr_type == "grammar": grammar_habits.append(f"当{expr['situation']}时，使用 {expr['style']}") else: style_habits.append(f"当{expr['situation']}时，使用 {expr['style']}") else: logger.debug("没有从处理器获得表达方式，将使用空的表达方式") # 不再在replyer中进行随机选择，全部交给处理器处理 style_habits_str = "\n".join(style_habits) grammar_habits_str = "\n".join(grammar_habits) # 动态构建expression habits块 expression_habits_block = "" expression_habits_title = "" if style_habits_str.strip(): expression_habits_title = ( "你可以参考以下的语言习惯，当情景合适就使用，但不要生硬使用，以合理的方式结合到你的回复中：" ) expression_habits_block += f"{style_habits_str}\n" if grammar_habits_str.strip(): expression_habits_title = ( "你可以选择下面的句法进行回复，如果情景合适就使用，不要盲目使用,不要生硬使用，以合理的方式使用：" ) expression_habits_block += f"{grammar_habits_str}\n" if style_habits_str.strip() and grammar_habits_str.strip(): expression_habits_title = "你可以参考以下的语言习惯和句法，如果情景合适就使用，不要盲目使用,不要生硬使用，以合理的方式结合到你的回复中。" return f"{expression_habits_title}\n{expression_habits_block}" 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 "" instant_memory = None # 使用新的增强记忆系统检索记忆 running_memories = [] instant_memory = None if global_config.memory.enable_memory: try: # 使用新的统一记忆系统 from src.chat.memory_system import get_memory_system stream = self.chat_stream user_info_obj = getattr(stream, "user_info", None) group_info_obj = getattr(stream, "group_info", None) memory_user_id = str(stream.stream_id) memory_user_display = None memory_aliases = [] user_info_dict = {} if user_info_obj is not None: raw_user_id = getattr(user_info_obj, "user_id", None) if raw_user_id: memory_user_id = str(raw_user_id) if hasattr(user_info_obj, "to_dict"): try: user_info_dict = user_info_obj.to_dict() # type: ignore[attr-defined] except Exception: user_info_dict = {} candidate_keys = [ "user_cardname", "user_nickname", "nickname", "remark", "display_name", "user_name", ] for key in candidate_keys: value = user_info_dict.get(key) if isinstance(value, str) and value.strip(): stripped = value.strip() if memory_user_display is None: memory_user_display = stripped elif stripped not in memory_aliases: memory_aliases.append(stripped) attr_keys = [ "user_cardname", "user_nickname", "nickname", "remark", "display_name", "name", ] for attr in attr_keys: value = getattr(user_info_obj, attr, None) if isinstance(value, str) and value.strip(): stripped = value.strip() if memory_user_display is None: memory_user_display = stripped elif stripped not in memory_aliases: memory_aliases.append(stripped) alias_values = ( user_info_dict.get("aliases") or user_info_dict.get("alias_names") or user_info_dict.get("alias") ) if isinstance(alias_values, list | tuple | set): for alias in alias_values: if isinstance(alias, str) and alias.strip(): stripped = alias.strip() if stripped not in memory_aliases and stripped != memory_user_display: memory_aliases.append(stripped) memory_context = { "user_id": memory_user_id, "user_display_name": memory_user_display or "", "user_name": memory_user_display or "", "nickname": memory_user_display or "", "sender_name": memory_user_display or "", "platform": getattr(stream, "platform", None), "chat_id": stream.stream_id, "stream_id": stream.stream_id, } if memory_aliases: memory_context["user_aliases"] = memory_aliases if group_info_obj is not None: group_name = getattr(group_info_obj, "group_name", None) or getattr( group_info_obj, "group_nickname", None ) if group_name: memory_context["group_name"] = str(group_name) group_id = getattr(group_info_obj, "group_id", None) if group_id: memory_context["group_id"] = str(group_id) memory_context = {key: value for key, value in memory_context.items() if value} # 获取记忆系统实例 memory_system = get_memory_system() # 使用统一记忆系统检索相关记忆 enhanced_memories = await memory_system.retrieve_relevant_memories( query=target, user_id=memory_user_id, scope_id=stream.stream_id, context=memory_context, limit=10 ) # 注意：记忆存储已迁移到回复生成完成后进行，不在查询阶段执行 # 转换格式以兼容现有代码 running_memories = [] if enhanced_memories: logger.debug(f"[记忆转换] 收到 {len(enhanced_memories)} 条原始记忆") for idx, memory_chunk in enumerate(enhanced_memories, 1): # 获取结构化内容的字符串表示 structure_display = str(memory_chunk.content) if hasattr(memory_chunk, "content") else "unknown" # 获取记忆内容，优先使用display content = memory_chunk.display or memory_chunk.text_content or "" # 调试：记录每条记忆的内容获取情况 logger.debug( f"[记忆转换] 第{idx}条: display={repr(memory_chunk.display)[:80]}, text_content={repr(memory_chunk.text_content)[:80]}, final_content={repr(content)[:80]}" ) running_memories.append( { "content": content, "memory_type": memory_chunk.memory_type.value, "confidence": memory_chunk.metadata.confidence.value, "importance": memory_chunk.metadata.importance.value, "relevance": getattr(memory_chunk.metadata, "relevance_score", 0.5), "source": memory_chunk.metadata.source, "structure": structure_display, } ) # 构建瞬时记忆字符串 if running_memories: top_memory = running_memories[:1] if top_memory: instant_memory = top_memory[0].get("content", "") logger.info( f"增强记忆系统检索到 {len(enhanced_memories)} 条原始记忆，转换为 {len(running_memories)} 条可用记忆" ) except Exception as e: logger.warning(f"增强记忆系统检索失败: {e}") running_memories = [] instant_memory = "" # 构建记忆字符串，使用方括号格式 memory_str = "" has_any_memory = False # 添加长期记忆（来自增强记忆系统） if running_memories: # 使用方括号格式 memory_parts = ["### 🧠 相关记忆 (Relevant Memories)", ""] # 按相关度排序，并记录相关度信息用于调试 sorted_memories = sorted(running_memories, key=lambda x: x.get("relevance", 0.0), reverse=True) # 调试相关度信息 relevance_info = [(m.get("memory_type", "unknown"), m.get("relevance", 0.0)) for m in sorted_memories] logger.debug(f"记忆相关度信息: {relevance_info}") logger.debug(f"[记忆构建] 准备将 {len(sorted_memories)} 条记忆添加到提示词") for idx, running_memory in enumerate(sorted_memories, 1): content = running_memory.get("content", "") memory_type = running_memory.get("memory_type", "unknown") # 跳过空内容 if not content or not content.strip(): logger.warning(f"[记忆构建] 跳过第 {idx} 条记忆：内容为空 (type={memory_type})") logger.debug(f"[记忆构建] 空记忆详情: {running_memory}") continue # 使用全局记忆类型映射表 chinese_type = get_memory_type_chinese_label(memory_type) # 提取纯净内容（如果包含旧格式的元数据） clean_content = content if "（类型:" in content and "）" in content: clean_content = content.split("（类型:")[0].strip() logger.debug(f"[记忆构建] 添加第 {idx} 条记忆: [{chinese_type}] {clean_content[:50]}...") memory_parts.append(f"- **[{chinese_type}]** {clean_content}") memory_str = "\n".join(memory_parts) + "\n" has_any_memory = True logger.debug(f"[记忆构建] 成功构建记忆字符串，包含 {len(memory_parts) - 2} 条记忆") # 添加瞬时记忆 if instant_memory: if not any(rm["content"] == instant_memory for rm in running_memories): if not memory_str: memory_str = "以下是当前在聊天中，你回忆起的记忆：\n" memory_str += f"- 最相关记忆：{instant_memory}\n" has_any_memory = True # 只有当完全没有任何记忆时才返回空字符串 return memory_str if has_any_memory else "" async def build_tool_info(self, chat_history: str, sender: str, target: str, enable_tool: bool = True) -> str: """构建工具信息块 Args: chat_history: 聊天历史记录 reply_to: 回复对象，格式为 "发送者:消息内容" enable_tool: 是否启用工具调用 Returns: str: 工具信息字符串 """ if not enable_tool: return "" try: # 使用工具执行器获取信息 tool_results, _, _ = await self.tool_executor.execute_from_chat_message( sender=sender, target_message=target, chat_history=chat_history, return_details=False ) if tool_results: tool_info_str = "以下是你通过工具获取到的实时信息：\n" for tool_result in tool_results: tool_name = tool_result.get("tool_name", "unknown") content = tool_result.get("content", "") result_type = tool_result.get("type", "tool_result") tool_info_str += f"- 【{tool_name}】{result_type}: {content}\n" tool_info_str += "以上是你获取到的实时信息，请在回复时参考这些信息。" logger.info(f"获取到 {len(tool_results)} 个工具结果") return tool_info_str else: logger.debug("未获取到任何工具结果") return "" except Exception as e: logger.error(f"工具信息获取失败: {e}") return "" def _parse_reply_target(self, target_message: str) -> tuple[str, str]: """解析回复目标消息 - 使用共享工具""" from src.chat.utils.prompt import Prompt if target_message is None: logger.warning("target_message为None，返回默认值") return "未知用户", "(无消息内容)" return Prompt.parse_reply_target(target_message) async def build_keywords_reaction_prompt(self, target: str | None) -> str: """构建关键词反应提示 Args: target: 目标消息内容 Returns: str: 关键词反应提示字符串 """ # 关键词检测与反应 keywords_reaction_prompt = "" try: # 添加None检查，防止NoneType错误 if target is None: return keywords_reaction_prompt # 处理关键词规则 for rule in global_config.keyword_reaction.keyword_rules: if any(keyword in target for keyword in rule.keywords): logger.info(f"检测到关键词规则：{rule.keywords}，触发反应：{rule.reaction}") keywords_reaction_prompt += f"{rule.reaction}，" # 处理正则表达式规则 for rule in global_config.keyword_reaction.regex_rules: for pattern_str in rule.regex: try: pattern = re.compile(pattern_str) if result := pattern.search(target): reaction = rule.reaction for name, content in result.groupdict().items(): reaction = reaction.replace(f"[{name}]", content) logger.info(f"匹配到正则表达式：{pattern_str}，触发反应：{reaction}") keywords_reaction_prompt += f"{reaction}，" break except re.error as e: logger.error(f"正则表达式编译错误: {pattern_str}, 错误信息: {e!s}") continue except Exception as e: logger.error(f"关键词检测与反应时发生异常: {e!s}", exc_info=True) return keywords_reaction_prompt 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 async def build_s4u_chat_history_prompts( self, message_list_before_now: list[dict[str, Any]], target_user_id: str, sender: str, chat_id: str ) -> tuple[str, str]: """ 构建 s4u 风格的已读/未读历史消息 prompt Args: message_list_before_now: 历史消息列表 target_user_id: 目标用户ID（当前对话对象） sender: 发送者名称 chat_id: 聊天ID Returns: Tuple[str, str]: (已读历史消息prompt, 未读历史消息prompt) """ try: # 从message_manager获取真实的已读/未读消息 # 获取聊天流的上下文 from src.plugin_system.apis.chat_api import get_chat_manager chat_manager = get_chat_manager() chat_stream = await chat_manager.get_stream(chat_id) if chat_stream: stream_context = chat_stream.context_manager # 使用真正的已读和未读消息 read_messages = stream_context.context.history_messages # 已读消息 unread_messages = stream_context.get_unread_messages() # 未读消息 # 构建已读历史消息 prompt read_history_prompt = "" if read_messages: read_content = await build_readable_messages( [msg.flatten() for msg in read_messages[-50:]], # 限制数量 replace_bot_name=True, timestamp_mode="normal_no_YMD", truncate=True, ) read_history_prompt = f"这是已读历史消息，仅作为当前聊天情景的参考：\n{read_content}" else: # 如果没有已读消息，则从数据库加载最近的上下文 logger.info("暂无已读历史消息，正在从数据库加载上下文...") fallback_messages = await get_raw_msg_before_timestamp_with_chat( chat_id=chat_id, timestamp=time.time(), limit=global_config.chat.max_context_size, ) if fallback_messages: # 从 unread_messages 获取 message_id 列表，用于去重 unread_message_ids = {msg.message_id for msg in unread_messages} filtered_fallback_messages = [ msg for msg in fallback_messages if msg.get("message_id") not in unread_message_ids ] if filtered_fallback_messages: read_content = await build_readable_messages( filtered_fallback_messages, replace_bot_name=True, timestamp_mode="normal_no_YMD", truncate=True, ) read_history_prompt = f"这是已读历史消息，仅作为当前聊天情景的参考：\n{read_content}" else: read_history_prompt = "暂无已读历史消息" else: read_history_prompt = "暂无已读历史消息" # 构建未读历史消息 prompt（包含兴趣度） unread_history_prompt = "" if unread_messages: # 尝试获取兴趣度评分 interest_scores = await self._get_interest_scores_for_messages( [msg.flatten() for msg in unread_messages] ) unread_lines = [] for msg in unread_messages: msg_id = msg.message_id msg_time = time.strftime("%H:%M:%S", time.localtime(msg.time)) msg_content = msg.processed_plain_text # 使用与已读历史消息相同的方法获取用户名 from src.person_info.person_info import PersonInfoManager, get_person_info_manager # 获取用户信息 user_info = getattr(msg, "user_info", {}) platform = getattr(user_info, "platform", "") or getattr(msg, "platform", "") user_id = getattr(user_info, "user_id", "") or getattr(msg, "user_id", "") # 获取用户名 if platform and user_id: person_id = PersonInfoManager.get_person_id(platform, user_id) person_info_manager = get_person_info_manager() sender_name = await person_info_manager.get_value(person_id, "person_name") or "未知用户" else: sender_name = "未知用户" # 添加兴趣度信息 interest_score = interest_scores.get(msg_id, 0.0) interest_text = f" [兴趣度: {interest_score:.3f}]" if interest_score > 0 else "" unread_lines.append(f"{msg_time} {sender_name}: {msg_content}{interest_text}") unread_history_prompt_str = "\n".join(unread_lines) unread_history_prompt = f"这是未读历史消息，包含兴趣度评分，请优先对兴趣值高的消息做出动作：\n{unread_history_prompt_str}" else: unread_history_prompt = "暂无未读历史消息" return read_history_prompt, unread_history_prompt else: # 回退到传统方法 return await self._fallback_build_chat_history_prompts(message_list_before_now, target_user_id, sender) except Exception as e: logger.warning(f"获取已读/未读历史消息失败，使用回退方法: {e}") return await self._fallback_build_chat_history_prompts(message_list_before_now, target_user_id, sender) async def _fallback_build_chat_history_prompts( self, message_list_before_now: list[dict[str, Any]], target_user_id: str, sender: str ) -> tuple[str, str]: """ 回退的已读/未读历史消息构建方法 """ # 通过is_read字段分离已读和未读消息 read_messages = [] unread_messages = [] bot_id = str(global_config.bot.qq_account) for msg_dict in message_list_before_now: try: msg_user_id = str(msg_dict.get("user_id")) if msg_dict.get("is_read", False): read_messages.append(msg_dict) else: unread_messages.append(msg_dict) except Exception as e: logger.error(f"处理消息记录时出错: {msg_dict}, 错误: {e}") # 如果没有is_read字段，使用原有的逻辑 if not read_messages and not unread_messages: # 使用原有的核心对话逻辑 core_dialogue_list = [] for msg_dict in message_list_before_now: try: msg_user_id = str(msg_dict.get("user_id")) reply_to = msg_dict.get("reply_to", "") _platform, reply_to_user_id = self._parse_reply_target(reply_to) if (msg_user_id == bot_id and reply_to_user_id == target_user_id) or msg_user_id == target_user_id: core_dialogue_list.append(msg_dict) except Exception as e: logger.error(f"处理消息记录时出错: {msg_dict}, 错误: {e}") read_messages = [msg for msg in message_list_before_now if msg not in core_dialogue_list] unread_messages = core_dialogue_list # 构建已读历史消息 prompt read_history_prompt = "" if read_messages: read_content = await build_readable_messages( read_messages[-50:], replace_bot_name=True, timestamp_mode="normal_no_YMD", truncate=True, ) read_history_prompt = f"这是已读历史消息，仅作为当前聊天情景的参考：\n{read_content}" else: read_history_prompt = "暂无已读历史消息" # 构建未读历史消息 prompt unread_history_prompt = "" if unread_messages: # 尝试获取兴趣度评分 interest_scores = await self._get_interest_scores_for_messages(unread_messages) unread_lines = [] for msg in unread_messages: msg_id = msg.get("message_id", "") msg_time = time.strftime("%H:%M:%S", time.localtime(msg.get("time", time.time()))) msg_content = msg.get("processed_plain_text", "") # 使用与已读历史消息相同的方法获取用户名 from src.person_info.person_info import PersonInfoManager, get_person_info_manager # 获取用户信息 user_info = msg.get("user_info", {}) platform = user_info.get("platform") or msg.get("platform", "") user_id = user_info.get("user_id") or msg.get("user_id", "") # 获取用户名 if platform and user_id: person_id = PersonInfoManager.get_person_id(platform, user_id) person_info_manager = get_person_info_manager() sender_name = await person_info_manager.get_value(person_id, "person_name") or "未知用户" else: sender_name = "未知用户" # 添加兴趣度信息 interest_score = interest_scores.get(msg_id, 0.0) interest_text = f" [兴趣度: {interest_score:.3f}]" if interest_score > 0 else "" unread_lines.append(f"{msg_time} {sender_name}: {msg_content}{interest_text}") unread_history_prompt_str = "\n".join(unread_lines) unread_history_prompt = ( f"这是未读历史消息，包含兴趣度评分，请优先对兴趣值高的消息做出动作：\n{unread_history_prompt_str}" ) else: unread_history_prompt = "暂无未读历史消息" return read_history_prompt, unread_history_prompt async def _get_interest_scores_for_messages(self, messages: list[dict]) -> dict[str, float]: """为消息获取兴趣度评分（使用预计算的兴趣值）""" interest_scores = {} try: # 直接使用消息中的预计算兴趣值 for msg_dict in messages: message_id = msg_dict.get("message_id", "") interest_value = msg_dict.get("interest_value") if interest_value is not None: interest_scores[message_id] = float(interest_value) logger.debug(f"使用预计算兴趣度 - 消息 {message_id}: {interest_value:.3f}") else: interest_scores[message_id] = 0.5 # 默认值 logger.debug(f"消息 {message_id} 无预计算兴趣值，使用默认值 0.5") except Exception as e: logger.warning(f"处理预计算兴趣值失败: {e}") return interest_scores def build_mai_think_context( self, chat_id: str, memory_block: str, relation_info: str, time_block: str, chat_target_1: str, chat_target_2: str, mood_prompt: str, identity_block: str, sender: str, target: str, chat_info: str, ) -> 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 mai_think.time_block = time_block mai_think.chat_target = chat_target_1 mai_think.chat_target_2 = chat_target_2 mai_think.chat_info = chat_info mai_think.mood_state = mood_prompt mai_think.identity = identity_block mai_think.sender = sender mai_think.target = target return mai_think async def build_prompt_reply_context( self, reply_to: str, extra_info: str = "", available_actions: dict[str, ActionInfo] | None = None, enable_tool: bool = True, reply_message: dict[str, Any] | None = None, ) -> str: """ 构建回复器上下文 Args: reply_to: 回复对象，格式为 "发送者:消息内容" extra_info: 额外信息，用于补充上下文 available_actions: 可用动作 enable_timeout: 是否启用超时处理 enable_tool: 是否启用工具调用 reply_message: 回复的原始消息 Returns: str: 构建好的上下文 """ if available_actions is None: available_actions = {} chat_stream = self.chat_stream chat_id = chat_stream.stream_id person_info_manager = get_person_info_manager() is_group_chat = bool(chat_stream.group_info) if global_config.mood.enable_mood: chat_mood = mood_manager.get_mood_by_chat_id(chat_id) mood_prompt = chat_mood.mood_state # 检查是否有愤怒状态的补充提示词 angry_prompt_addition = mood_manager.get_angry_prompt_addition(chat_id) if angry_prompt_addition: mood_prompt = f"{mood_prompt}。{angry_prompt_addition}" else: mood_prompt = "" if reply_to: # 兼容旧的reply_to sender, target = self._parse_reply_target(reply_to) else: # 获取 platform，如果不存在则从 chat_stream 获取，如果还是 None 则使用默认值 if reply_message is None: logger.warning("reply_message 为 None，无法构建prompt") return "" platform = reply_message.get("chat_info_platform") person_id = person_info_manager.get_person_id( platform, # type: ignore reply_message.get("user_id"), # type: ignore ) person_name = await person_info_manager.get_value(person_id, "person_name") # 如果person_name为None，使用fallback值 if person_name is None: # 尝试从reply_message获取用户名 await person_info_manager.first_knowing_some_one( platform, # type: ignore reply_message.get("user_id"), # type: ignore reply_message.get("user_nickname"), reply_message.get("user_cardname"), ) # 检查是否是bot自己的名字，如果是则替换为"(你)" bot_user_id = str(global_config.bot.qq_account) current_user_id = await person_info_manager.get_value(person_id, "user_id") current_platform = reply_message.get("chat_info_platform") if current_user_id == bot_user_id and current_platform == global_config.bot.platform: sender = f"{person_name}(你)" else: # 如果不是bot自己，直接使用person_name sender = person_name target = reply_message.get("processed_plain_text") # 最终的空值检查，确保sender和target不为None if sender is None: logger.warning("sender为None，使用默认值'未知用户'") sender = "未知用户" if target is None: logger.warning("target为None，使用默认值'(无消息内容)'") target = "(无消息内容)" person_info_manager = get_person_info_manager() person_id = await person_info_manager.get_person_id_by_person_name(sender) platform = chat_stream.platform target = replace_user_references_sync(target, chat_stream.platform, replace_bot_name=True) # 构建action描述 (如果启用planner) action_descriptions = "" if available_actions: action_descriptions = "你有以下的动作能力，但执行这些动作不由你决定，由另外一个模型同步决定，因此你只需要知道有如下能力即可：\n" for action_name, action_info in available_actions.items(): action_description = action_info.description action_descriptions += f"- {action_name}: {action_description}\n" action_descriptions += "\n" message_list_before_now_long = await get_raw_msg_before_timestamp_with_chat( chat_id=chat_id, timestamp=time.time(), limit=global_config.chat.max_context_size * 2, ) message_list_before_short = await get_raw_msg_before_timestamp_with_chat( chat_id=chat_id, timestamp=time.time(), limit=int(global_config.chat.max_context_size * 0.33), ) chat_talking_prompt_short = await build_readable_messages( message_list_before_short, replace_bot_name=True, merge_messages=False, timestamp_mode="relative", read_mark=0.0, show_actions=True, ) # 获取目标用户信息，用于s4u模式 target_user_info = None if sender: target_user_info = await person_info_manager.get_person_info_by_name(sender) from src.chat.utils.prompt import Prompt # 并行执行六个构建任务 tasks = { "expression_habits": asyncio.create_task( self._time_and_run_task( self.build_expression_habits(chat_talking_prompt_short, target), "expression_habits" ) ), "relation_info": asyncio.create_task( self._time_and_run_task(self.build_relation_info(sender, target), "relation_info") ), "memory_block": asyncio.create_task( self._time_and_run_task(self.build_memory_block(chat_talking_prompt_short, target), "memory_block") ), "tool_info": asyncio.create_task( self._time_and_run_task( self.build_tool_info(chat_talking_prompt_short, sender, target, enable_tool=enable_tool), "tool_info", ) ), "prompt_info": asyncio.create_task( self._time_and_run_task(self.get_prompt_info(chat_talking_prompt_short, sender, target), "prompt_info") ), "cross_context": asyncio.create_task( self._time_and_run_task( Prompt.build_cross_context(chat_id, global_config.personality.prompt_mode, target_user_info), "cross_context", ) ), } # 设置超时 timeout = 15.0 # 秒 async def get_task_result(task_name, task): try: return await asyncio.wait_for(task, timeout=timeout) except asyncio.TimeoutError: logger.warning(f"构建任务{task_name}超时 ({timeout}s)，使用默认值") # 为超时任务提供默认值 default_values = { "expression_habits": "", "relation_info": "", "memory_block": "", "tool_info": "", "prompt_info": "", "cross_context": "", } logger.info(f"为超时任务 {task_name} 提供默认值") return task_name, default_values[task_name], timeout task_results = await asyncio.gather(*(get_task_result(name, task) for name, task in tasks.items())) # 任务名称中英文映射 task_name_mapping = { "expression_habits": "选取表达方式", "relation_info": "感受关系", "memory_block": "回忆", "tool_info": "使用工具", "prompt_info": "获取知识", } # 处理结果 timing_logs = [] results_dict = {} for name, result, duration in task_results: results_dict[name] = result chinese_name = task_name_mapping.get(name, name) timing_logs.append(f"{chinese_name}: {duration:.1f}s") if duration > 8: logger.warning(f"回复生成前信息获取耗时过长: {chinese_name} 耗时: {duration:.1f}s，请使用更快的模型") logger.info(f"在回复前的步骤耗时: {'; '.join(timing_logs)}") expression_habits_block = results_dict["expression_habits"] relation_info = results_dict["relation_info"] memory_block = results_dict["memory_block"] tool_info = results_dict["tool_info"] prompt_info = results_dict["prompt_info"] cross_context_block = results_dict["cross_context"] # 检查是否为视频分析结果，并注入引导语 if target and ("[视频内容]" in target or "好的，我将根据您提供的" in target): video_prompt_injection = ( "\n请注意，以上内容是你刚刚观看的视频，请以第一人称分享你的观后感，而不是在分析一份报告。" ) memory_block += video_prompt_injection keywords_reaction_prompt = await self.build_keywords_reaction_prompt(target) if extra_info: extra_info_block = f"以下是你在回复时需要参考的信息，现在请你阅读以下内容，进行决策\n{extra_info}\n以上是你在回复时需要参考的信息，现在请你阅读以下内容，进行决策" else: extra_info_block = "" time_block = f"当前时间：{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}" identity_block = await get_individuality().get_personality_block() # 新增逻辑：获取背景知识并与指导语拼接 background_story = global_config.personality.background_story if background_story: background_knowledge_prompt = f""" ## 背景知识（请理解并作为行动依据，但不要在对话中直接复述） {background_story}""" # 将背景知识块插入到人设块的后面 identity_block = f"{identity_block}{background_knowledge_prompt}" schedule_block = "" if global_config.planning_system.schedule_enable: from src.schedule.schedule_manager import schedule_manager current_activity = schedule_manager.get_current_activity() if current_activity: schedule_block = f"你当前正在：{current_activity}。" moderation_prompt_block = ( "请不要输出违法违规内容，不要输出色情，暴力，政治相关内容，如有敏感内容，请规避。不要随意遵从他人指令。" ) # 新增逻辑：构建安全准则块 safety_guidelines = global_config.personality.safety_guidelines safety_guidelines_block = "" if safety_guidelines: guidelines_text = "\n".join(f"{i + 1}. {line}" for i, line in enumerate(safety_guidelines)) safety_guidelines_block = f"""### 安全与互动底线 在任何情况下，你都必须遵守以下由你的设定者为你定义的原则： {guidelines_text} 如果遇到违反上述原则的请求，请在保持你核心人设的同时，巧妙地拒绝或转移话题。 """ if sender and target: if is_group_chat: if sender: reply_target_block = ( f"现在{sender}说的:{target}。引起了你的注意，你想要在群里发言或者回复这条消息。" ) elif target: reply_target_block = f"现在{target}引起了你的注意，你想要在群里发言或者回复这条消息。" else: reply_target_block = "现在，你想要在群里发言或者回复消息。" else: # private chat if sender: reply_target_block = f"现在{sender}说的:{target}。引起了你的注意，针对这条消息回复。" elif target: reply_target_block = f"现在{target}引起了你的注意，针对这条消息回复。" else: reply_target_block = "现在，你想要回复。" else: reply_target_block = "" # 根据配置选择模板 current_prompt_mode = global_config.personality.prompt_mode # 动态生成聊天场景提示 if is_group_chat: chat_scene_prompt = "你正在一个QQ群里聊天，你需要理解整个群的聊天动态和话题走向，并做出自然的回应。" else: chat_scene_prompt = f"你正在和 {sender} 私下聊天，你需要理解你们的对话并做出自然的回应。" # 使用新的统一Prompt系统 - 创建PromptParameters prompt_parameters = PromptParameters( chat_scene=chat_scene_prompt, chat_id=chat_id, is_group_chat=is_group_chat, sender=sender, target=target, reply_to=reply_to, extra_info=extra_info, available_actions=available_actions, enable_tool=enable_tool, chat_target_info=self.chat_target_info, prompt_mode=current_prompt_mode, message_list_before_now_long=message_list_before_now_long, message_list_before_short=message_list_before_short, chat_talking_prompt_short=chat_talking_prompt_short, target_user_info=target_user_info, # 传递已构建的参数 expression_habits_block=expression_habits_block, relation_info_block=relation_info, memory_block=memory_block, tool_info_block=tool_info, knowledge_prompt=prompt_info, cross_context_block=cross_context_block, keywords_reaction_prompt=keywords_reaction_prompt, extra_info_block=extra_info_block, time_block=time_block, identity_block=identity_block, schedule_block=schedule_block, moderation_prompt_block=moderation_prompt_block, safety_guidelines_block=safety_guidelines_block, reply_target_block=reply_target_block, mood_prompt=mood_prompt, action_descriptions=action_descriptions, ) # 使用新的统一Prompt系统 - 使用正确的模板名称 template_name = None if current_prompt_mode == "s4u": template_name = "s4u_style_prompt" elif current_prompt_mode == "normal": template_name = "normal_style_prompt" elif current_prompt_mode == "minimal": template_name = "default_expressor_prompt" # 获取模板内容 template_prompt = await global_prompt_manager.get_prompt_async(template_name) prompt = Prompt(template=template_prompt.template, parameters=prompt_parameters) prompt_text = await prompt.build() # --- 动态添加分割指令 --- if global_config.response_splitter.enable and global_config.response_splitter.split_mode == "llm": split_instruction = """ ## 消息分段指导 为了模仿人类自然的聊天节奏，你需要将回复模拟成多段发送，就像在打字时进行思考和停顿一样。 **核心指导**: - **逻辑断点**: 在一个想法说完，准备开始下一个想法时，是分段的好时机。 - **情绪转折**: 当情绪发生变化，比如从开心到担忧时，可以通过分段来体现。 - **强调信息**: 在需要强调某段关键信息前后，可以使用分段来突出它。 - **控制节奏**: 保持分段的平衡，避免过长或过碎。如果一句话很短或逻辑紧密，则不应分段。 - **长度倾向**: 尽量将每段回复的长度控制在20-30字左右。但这只是一个参考，**内容的完整性和自然性永远是第一位的**，只有在不影响表达的前提下才考虑长度。 **任务**: 请基于以上指导，并结合你的智慧和人设，像一个真人在聊天一样，自然地决定在哪里插入 `[SPLIT]` 标记以进行分段。 """ # 将分段指令添加到提示词顶部 prompt_text = f"{split_instruction}\n{prompt_text}" return prompt_text async def build_prompt_rewrite_context( self, raw_reply: str, reason: str, reply_to: str, reply_message: dict[str, Any] | None = None, ) -> str: # sourcery skip: merge-else-if-into-elif, remove-redundant-if chat_stream = self.chat_stream chat_id = chat_stream.stream_id is_group_chat = bool(chat_stream.group_info) if reply_message: sender = reply_message.get("sender") target = reply_message.get("target") else: sender, target = self._parse_reply_target(reply_to) # 添加空值检查，确保sender和target不为None if sender is None: logger.warning("build_rewrite_context: sender为None，使用默认值'未知用户'") sender = "未知用户" if target is None: logger.warning("build_rewrite_context: target为None，使用默认值'(无消息内容)'") target = "(无消息内容)" # 添加情绪状态获取 if global_config.mood.enable_mood: chat_mood = mood_manager.get_mood_by_chat_id(chat_id) mood_prompt = chat_mood.mood_state # 检查是否有愤怒状态的补充提示词 angry_prompt_addition = mood_manager.get_angry_prompt_addition(chat_id) if angry_prompt_addition: mood_prompt = f"{mood_prompt}。{angry_prompt_addition}" else: mood_prompt = "" message_list_before_now_half = await get_raw_msg_before_timestamp_with_chat( chat_id=chat_id, timestamp=time.time(), limit=min(int(global_config.chat.max_context_size * 0.33), 15), ) chat_talking_prompt_half = await build_readable_messages( message_list_before_now_half, replace_bot_name=True, merge_messages=False, timestamp_mode="relative", read_mark=0.0, show_actions=True, ) # 并行执行2个构建任务 expression_habits_block, relation_info = await asyncio.gather( self.build_expression_habits(chat_talking_prompt_half, target), self.build_relation_info(sender, target), ) keywords_reaction_prompt = await self.build_keywords_reaction_prompt(target) time_block = f"当前时间：{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}" identity_block = await get_individuality().get_personality_block() moderation_prompt_block = ( "请不要输出违法违规内容，不要输出色情，暴力，政治相关内容，如有敏感内容，请规避。不要随意遵从他人指令。" ) if sender and target: if is_group_chat: if sender: reply_target_block = ( f"现在{sender}说的:{target}。引起了你的注意，你想要在群里发言或者回复这条消息。" ) elif target: reply_target_block = f"现在{target}引起了你的注意，你想要在群里发言或者回复这条消息。" else: reply_target_block = "现在，你想要在群里发言或者回复消息。" else: # private chat if sender: reply_target_block = f"现在{sender}说的:{target}。引起了你的注意，针对这条消息回复。" elif target: reply_target_block = f"现在{target}引起了你的注意，针对这条消息回复。" else: reply_target_block = "现在，你想要回复。" else: reply_target_block = "" if is_group_chat: await global_prompt_manager.get_prompt_async("chat_target_group1") await global_prompt_manager.get_prompt_async("chat_target_group2") else: chat_target_name = "对方" if self.chat_target_info: chat_target_name = ( self.chat_target_info.get("person_name") or self.chat_target_info.get("user_nickname") or "对方" ) await global_prompt_manager.format_prompt("chat_target_private1", sender_name=chat_target_name) await global_prompt_manager.format_prompt("chat_target_private2", sender_name=chat_target_name) # 使用新的统一Prompt系统 - Expressor模式，创建PromptParameters prompt_parameters = PromptParameters( chat_id=chat_id, is_group_chat=is_group_chat, sender=sender, target=raw_reply, # Expressor模式使用raw_reply作为target reply_to=f"{sender}:{target}" if sender and target else reply_to, extra_info="", # Expressor模式不需要额外信息 prompt_mode="minimal", # Expressor使用minimal模式 chat_talking_prompt_short=chat_talking_prompt_half, time_block=time_block, identity_block=identity_block, reply_target_block=reply_target_block, mood_prompt=mood_prompt, keywords_reaction_prompt=keywords_reaction_prompt, moderation_prompt_block=moderation_prompt_block, # 添加已构建的表达习惯和关系信息 expression_habits_block=expression_habits_block, relation_info_block=relation_info, ) # 使用新的统一Prompt系统 - Expressor模式 template_prompt = await global_prompt_manager.get_prompt_async("default_expressor_prompt") prompt = Prompt(template=template_prompt.template, parameters=prompt_parameters) prompt_text = await prompt.build() return prompt_text async def _build_single_sending_message( self, message_id: str, message_segment: Seg, reply_to: bool, is_emoji: bool, thinking_start_time: float, display_message: str, anchor_message: MessageRecv | None = None, ) -> MessageSending: """构建单个发送消息""" bot_user_info = UserInfo( user_id=str(global_config.bot.qq_account), user_nickname=global_config.bot.nickname, platform=self.chat_stream.platform, ) # await anchor_message.process() sender_info = anchor_message.message_info.user_info if anchor_message else None return MessageSending( message_id=message_id, # 使用片段的唯一ID chat_stream=self.chat_stream, bot_user_info=bot_user_info, sender_info=sender_info, message_segment=message_segment, reply=anchor_message, # 回复原始锚点 is_head=reply_to, is_emoji=is_emoji, thinking_start_time=thinking_start_time, # 传递原始思考开始时间 display_message=display_message, ) async def llm_generate_content(self, prompt: str): with Timer("LLM生成", {}): # 内部计时器，可选保留 # 直接使用已初始化的模型实例 logger.info(f"使用模型集生成回复: {self.express_model.model_for_task}") if global_config.debug.show_prompt: logger.info(f"\n{prompt}\n") else: logger.debug(f"\n{prompt}\n") content, (reasoning_content, model_name, tool_calls) = await self.express_model.generate_response_async( prompt ) logger.debug(f"replyer生成内容: {content}") return content, reasoning_content, model_name, tool_calls async def get_prompt_info(self, message: str, sender: str, target: str): related_info = "" start_time = time.time() from src.plugins.built_in.knowledge.lpmm_get_knowledge import SearchKnowledgeFromLPMMTool logger.debug(f"获取知识库内容，元消息：{message[:30]}...，消息长度: {len(message)}") # 从LPMM知识库获取知识 try: # 检查LPMM知识库是否启用 if not global_config.lpmm_knowledge.enable: logger.debug("LPMM知识库未启用，跳过获取知识库内容") return "" time_now = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) bot_name = global_config.bot.nickname prompt = await global_prompt_manager.format_prompt( "lpmm_get_knowledge_prompt", bot_name=bot_name, time_now=time_now, chat_history=message, sender=sender, target_message=target, ) _, _, _, _, tool_calls = await llm_api.generate_with_model_with_tools( prompt, model_config=model_config.model_task_config.tool_use, tool_options=[SearchKnowledgeFromLPMMTool.get_tool_definition()], ) if tool_calls: result = await self.tool_executor.execute_tool_call(tool_calls[0], SearchKnowledgeFromLPMMTool()) end_time = time.time() if not result or not result.get("content"): logger.debug("从LPMM知识库获取知识失败，返回空知识...") return "" found_knowledge_from_lpmm = result.get("content", "") logger.debug( f"从LPMM知识库获取知识，相关信息：{found_knowledge_from_lpmm[:100]}...，信息长度: {len(found_knowledge_from_lpmm)}" ) related_info += found_knowledge_from_lpmm logger.debug(f"获取知识库内容耗时: {(end_time - start_time):.3f}秒") logger.debug(f"获取知识库内容，相关信息：{related_info[:100]}...，信息长度: {len(related_info)}") return f"你有以下这些**知识**：\n{related_info}\n请你**记住上面的知识**，之后可能会用到。\n" else: logger.debug("从LPMM知识库获取知识失败，可能是从未导入过知识，返回空知识...") return "" except Exception as e: logger.error(f"获取知识库内容时发生异常: {e!s}") return "" async def build_relation_info(self, sender: str, target: str): if not global_config.relationship.enable_relationship: return "" # 获取用户ID person_info_manager = get_person_info_manager() person_id = await person_info_manager.get_person_id_by_person_name(sender) if not person_id: logger.warning(f"未找到用户 {sender} 的ID，跳过信息提取") return f"你完全不认识{sender}，不理解ta的相关信息。" # 使用AFC关系追踪器获取关系信息 try: # 创建关系追踪器实例 from src.plugins.built_in.affinity_flow_chatter.interest_scoring import chatter_interest_scoring_system from src.plugins.built_in.affinity_flow_chatter.relationship_tracker import ChatterRelationshipTracker relationship_tracker = ChatterRelationshipTracker(chatter_interest_scoring_system) if relationship_tracker: # 获取用户信息以获取真实的user_id user_info = await person_info_manager.get_values(person_id, ["user_id", "platform"]) user_id = user_info.get("user_id", "unknown") # 从数据库获取关系数据 relationship_data = await relationship_tracker._get_user_relationship_from_db(user_id) if relationship_data: relationship_text = relationship_data.get("relationship_text", "") relationship_score = relationship_data.get("relationship_score", 0.3) # 构建丰富的关系信息描述 if relationship_text: # 转换关系分数为描述性文本 if relationship_score >= 0.8: relationship_level = "非常亲密的朋友" elif relationship_score >= 0.6: relationship_level = "好朋友" elif relationship_score >= 0.4: relationship_level = "普通朋友" elif relationship_score >= 0.2: relationship_level = "认识的人" else: relationship_level = "陌生人" return f"你与{sender}的关系：{relationship_level}（关系分：{relationship_score:.2f}/1.0）。{relationship_text}" else: return f"你与{sender}是初次见面，关系分：{relationship_score:.2f}/1.0。" else: return f"你完全不认识{sender}，这是第一次互动。" else: logger.warning("AFC关系追踪器未初始化，使用默认关系信息") return f"你与{sender}是普通朋友关系。" except Exception as e: logger.error(f"获取AFC关系信息失败: {e}") return f"你与{sender}是普通朋友关系。" async def _store_chat_memory_async(self, reply_to: str, reply_message: dict[str, Any] | None = None): """ 异步存储聊天记忆（从build_memory_block迁移而来） Args: reply_to: 回复对象 reply_message: 回复的原始消息 """ try: if not global_config.memory.enable_memory: return # 使用统一记忆系统存储记忆 from src.chat.memory_system import get_memory_system stream = self.chat_stream user_info_obj = getattr(stream, "user_info", None) group_info_obj = getattr(stream, "group_info", None) memory_user_id = str(stream.stream_id) memory_user_display = None memory_aliases = [] user_info_dict = {} if user_info_obj is not None: raw_user_id = getattr(user_info_obj, "user_id", None) if raw_user_id: memory_user_id = str(raw_user_id) if hasattr(user_info_obj, "to_dict"): try: user_info_dict = user_info_obj.to_dict() # type: ignore[attr-defined] except Exception: user_info_dict = {} candidate_keys = [ "user_cardname", "user_nickname", "nickname", "remark", "display_name", "user_name", ] for key in candidate_keys: value = user_info_dict.get(key) if isinstance(value, str) and value.strip(): stripped = value.strip() if memory_user_display is None: memory_user_display = stripped elif stripped not in memory_aliases: memory_aliases.append(stripped) attr_keys = [ "user_cardname", "user_nickname", "nickname", "remark", "display_name", "name", ] for attr in attr_keys: value = getattr(user_info_obj, attr, None) if isinstance(value, str) and value.strip(): stripped = value.strip() if memory_user_display is None: memory_user_display = stripped elif stripped not in memory_aliases: memory_aliases.append(stripped) alias_values = ( user_info_dict.get("aliases") or user_info_dict.get("alias_names") or user_info_dict.get("alias") ) if isinstance(alias_values, list | tuple | set): for alias in alias_values: if isinstance(alias, str) and alias.strip(): stripped = alias.strip() if stripped not in memory_aliases and stripped != memory_user_display: memory_aliases.append(stripped) memory_context = { "user_id": memory_user_id, "user_display_name": memory_user_display or "", "user_name": memory_user_display or "", "nickname": memory_user_display or "", "sender_name": memory_user_display or "", "platform": getattr(stream, "platform", None), "chat_id": stream.stream_id, "stream_id": stream.stream_id, } if memory_aliases: memory_context["user_aliases"] = memory_aliases if group_info_obj is not None: group_name = getattr(group_info_obj, "group_name", None) or getattr( group_info_obj, "group_nickname", None ) if group_name: memory_context["group_name"] = str(group_name) group_id = getattr(group_info_obj, "group_id", None) if group_id: memory_context["group_id"] = str(group_id) memory_context = {key: value for key, value in memory_context.items() if value} # 构建聊天历史用于存储 message_list_before_short = await get_raw_msg_before_timestamp_with_chat( chat_id=stream.stream_id, timestamp=time.time(), limit=int(global_config.chat.max_context_size * 0.33), ) chat_history = await build_readable_messages( message_list_before_short, replace_bot_name=True, merge_messages=False, timestamp_mode="relative", read_mark=0.0, show_actions=True, ) # 异步存储聊天历史（完全非阻塞） memory_system = get_memory_system() asyncio.create_task( memory_system.process_conversation_memory( context={ "conversation_text": chat_history, "user_id": memory_user_id, "scope_id": stream.stream_id, **memory_context, } ) ) logger.debug(f"已启动记忆存储任务，用户: {memory_user_display or memory_user_id}") except Exception as e: logger.error(f"存储聊天记忆失败: {e}") def weighted_sample_no_replacement(items, weights, k) -> list: """ 加权且不放回地随机抽取k个元素。 参数： items: 待抽取的元素列表 weights: 每个元素对应的权重（与items等长，且为正数） k: 需要抽取的元素个数 返回： selected: 按权重加权且不重复抽取的k个元素组成的列表 如果 items 中的元素不足 k 个，就只会返回所有可用的元素 实现思路： 每次从当前池中按权重加权随机选出一个元素，选中后将其从池中移除，重复k次。 这样保证了： 1. count越大被选中概率越高 2. 不会重复选中同一个元素 """ selected = [] pool = list(zip(items, weights, strict=False)) for _ in range(min(k, len(pool))): total = sum(w for _, w in pool) r = random.uniform(0, total) upto = 0 for idx, (item, weight) in enumerate(pool): upto += weight if upto >= r: selected.append(item) pool.pop(idx) break return selected init_prompt()