diff --git a/src/chat/replyer/group_generator.py b/src/chat/replyer/group_generator.py index 71f1a40c..6858ca19 100644 --- a/src/chat/replyer/group_generator.py +++ b/src/chat/replyer/group_generator.py @@ -688,39 +688,41 @@ class DefaultReplyer: return None def get_chat_prompt_for_chat(self, chat_id: str) -> str: - """ - 根据聊天流ID获取匹配的额外prompt（仅匹配group类型） - - Args: - chat_id: 聊天流ID（哈希值） - - Returns: - str: 匹配的额外prompt内容，如果没有匹配则返回空字符串 - """ - if not global_config.experimental.chat_prompts: + """根据聊天流 ID 获取匹配的额外 prompt。""" + if not global_config.chat.chat_prompts: return "" - for chat_prompt_str in global_config.experimental.chat_prompts: - if not isinstance(chat_prompt_str, str): + for chat_prompt_item in global_config.chat.chat_prompts: + if hasattr(chat_prompt_item, "rule_type") and hasattr(chat_prompt_item, "prompt"): + if str(chat_prompt_item.rule_type or "").strip() != "group": + continue + + config_chat_id = self._build_chat_uid( + str(chat_prompt_item.platform or "").strip(), + str(chat_prompt_item.item_id or "").strip(), + True, + ) + prompt_content = str(chat_prompt_item.prompt or "").strip() + if config_chat_id == chat_id and prompt_content: + logger.debug(f"匹配到群聊 prompt 配置，chat_id: {chat_id}, prompt: {prompt_content[:50]}...") + return prompt_content continue - # 解析配置字符串，检查类型是否为group - parts = chat_prompt_str.split(":", 3) - if len(parts) != 4: + if not isinstance(chat_prompt_item, str): continue - stream_type = parts[2] - # 只匹配group类型 - if stream_type != "group": + # 兼容旧格式的 platform:id:type:prompt 配置字符串。 + parts = chat_prompt_item.split(":", 3) + if len(parts) != 4 or parts[2] != "group": continue - result = self._parse_chat_prompt_config_to_chat_id(chat_prompt_str) + result = self._parse_chat_prompt_config_to_chat_id(chat_prompt_item) if result is None: continue config_chat_id, prompt_content = result if config_chat_id == chat_id: - logger.debug(f"匹配到群聊prompt配置，chat_id: {chat_id}, prompt: {prompt_content[:50]}...") + logger.debug(f"匹配到群聊 prompt 配置，chat_id: {chat_id}, prompt: {prompt_content[:50]}...") return prompt_content return "" diff --git a/src/chat/replyer/private_generator.py b/src/chat/replyer/private_generator.py deleted file mode 100644 index ccc45c4b..00000000 --- a/src/chat/replyer/private_generator.py +++ /dev/null @@ -1,1040 +0,0 @@ -import traceback -import time -import asyncio -import random -import re - -from typing import List, Optional, Dict, Any, Tuple -from datetime import datetime -from src.common.logger import get_logger -from src.common.data_models.info_data_model import ActionPlannerInfo -from src.common.data_models.llm_data_model import LLMGenerationDataModel -from src.config.config import global_config -from src.services.llm_service import LLMServiceClient -from maim_message import BaseMessageInfo, MessageBase, Seg, UserInfo as MaimUserInfo - -from src.common.data_models.mai_message_data_model import MaiMessage -from src.chat.message_receive.message import SessionMessage -from src.chat.message_receive.chat_manager import BotChatSession -from src.chat.utils.timer_calculator import Timer -from src.chat.utils.utils import get_bot_account, get_chat_type_and_target_info, is_bot_self -from src.prompt.prompt_manager import prompt_manager -from src.chat.utils.common_utils import TempMethodsExpression -from src.services.message_service import ( - build_readable_messages, - get_messages_before_time_in_chat, - replace_user_references, - translate_pid_to_description, -) -from src.learners.expression_selector import expression_selector - -# from src.memory_system.memory_activator import MemoryActivator -from src.person_info.person_info import Person, is_person_known -from src.core.types import ActionInfo, EventType -from src.memory_system.memory_retrieval import init_memory_retrieval_sys, build_memory_retrieval_prompt -from src.learners.jargon_explainer_old import explain_jargon_in_context - -init_memory_retrieval_sys() - - -logger = get_logger("replyer") - - -class PrivateReplyer: - def __init__( - self, - chat_stream: BotChatSession, - request_type: str = "replyer", - ): - """初始化私聊回复器。 - - Args: - chat_stream: 当前绑定的聊天会话。 - request_type: LLM 请求类型标识。 - """ - self.express_model = LLMServiceClient( - task_name="replyer", request_type=request_type - ) - self.chat_stream = chat_stream - self.is_group_chat, self.chat_target_info = get_chat_type_and_target_info(self.chat_stream.session_id) - # self.memory_activator = MemoryActivator() - - async def generate_reply_with_context( - self, - extra_info: str = "", - reply_reason: str = "", - available_actions: Optional[Dict[str, ActionInfo]] = None, - chosen_actions: Optional[List[ActionPlannerInfo]] = None, - from_plugin: bool = True, - think_level: int = 1, - stream_id: Optional[str] = None, - reply_message: Optional[SessionMessage] = None, - reply_time_point: Optional[float] = time.time(), - unknown_words: Optional[List[str]] = None, - log_reply: bool = True, - ) -> Tuple[bool, LLMGenerationDataModel]: - # sourcery skip: merge-nested-ifs - """ - 回复器 (Replier): 负责生成回复文本的核心逻辑。 - - Args: - reply_to: 回复对象，格式为 "发送者:消息内容" - extra_info: 额外信息，用于补充上下文 - reply_reason: 回复原因 - available_actions: 可用的动作信息字典 - chosen_actions: 已选动作 - from_plugin: 是否来自插件 - - Returns: - Tuple[bool, Optional[Dict[str, Any]], Optional[str]]: (是否成功, 生成的回复, 使用的prompt) - """ - - prompt = None - selected_expressions: Optional[List[int]] = None - llm_response = LLMGenerationDataModel() - if available_actions is None: - available_actions = {} - try: - # 3. 构建 Prompt - with Timer("构建Prompt", {}): # 内部计时器，可选保留 - prompt, selected_expressions = await self.build_prompt_reply_context( - extra_info=extra_info, - available_actions=available_actions, - chosen_actions=chosen_actions, - reply_message=reply_message, - reply_reason=reply_reason, - unknown_words=unknown_words, - ) - llm_response.prompt = prompt - llm_response.selected_expressions = selected_expressions - - if not prompt: - logger.warning("构建prompt失败，跳过回复生成") - return False, llm_response - from src.core.event_bus import event_bus - from src.chat.event_helpers import build_event_message - - if not from_plugin: - _event_msg = build_event_message(EventType.POST_LLM, llm_prompt=prompt, stream_id=stream_id) - continue_flag, modified_message = await event_bus.emit(EventType.POST_LLM, _event_msg) - if not continue_flag: - raise UserWarning("插件于请求前中断了内容生成") - if modified_message and modified_message._modify_flags.modify_llm_prompt: - llm_response.prompt = modified_message.llm_prompt - prompt = str(modified_message.llm_prompt) - - # 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 - llm_response.reasoning = reasoning_content - llm_response.model = model_name - llm_response.tool_calls = tool_call - _event_msg = build_event_message( - EventType.AFTER_LLM, llm_prompt=prompt, llm_response=llm_response, stream_id=stream_id - ) - continue_flag, modified_message = await event_bus.emit(EventType.AFTER_LLM, _event_msg) - if not from_plugin and not continue_flag: - raise UserWarning("插件于请求后取消了内容生成") - if modified_message: - if modified_message._modify_flags.modify_llm_prompt: - logger.warning("警告：插件在内容生成后才修改了prompt，此修改不会生效") - llm_response.prompt = modified_message.llm_prompt # 虽然我不知道为什么在这里需要改prompt - if modified_message._modify_flags.modify_llm_response_content: - llm_response.content = modified_message.llm_response_content - if modified_message._modify_flags.modify_llm_response_reasoning: - llm_response.reasoning = modified_message.llm_response_reasoning - except UserWarning as e: - raise e - except Exception as llm_e: - # 精简报错信息 - logger.error(f"LLM 生成失败: {llm_e}") - return False, llm_response # LLM 调用失败则无法生成回复 - - return True, llm_response - - except UserWarning as uw: - raise uw - except Exception as e: - logger.error(f"回复生成意外失败: {e}") - traceback.print_exc() - return False, llm_response - - async def rewrite_reply_with_context( - self, - raw_reply: str = "", - reason: str = "", - reply_to: str = "", - ) -> Tuple[bool, LLMGenerationDataModel]: - """ - 表达器 (Expressor): 负责重写和优化回复文本。 - - Args: - raw_reply: 原始回复内容 - reason: 回复原因 - reply_to: 回复对象，格式为 "发送者:消息内容" - relation_info: 关系信息 - - Returns: - Tuple[bool, Optional[str]]: (是否成功, 重写后的回复内容) - """ - llm_response = LLMGenerationDataModel() - try: - with Timer("构建Prompt", {}): # 内部计时器，可选保留 - prompt = await self.build_prompt_rewrite_context( - raw_reply=raw_reply, - reason=reason, - reply_to=reply_to, - ) - llm_response.prompt = prompt - - content = None - reasoning_content = None - model_name = "unknown_model" - if not prompt: - logger.error("Prompt 构建失败，无法生成回复。") - return False, llm_response - - try: - content, reasoning_content, model_name, _ = await self.llm_generate_content(prompt) - logger.info(f"想要表达：{raw_reply}||理由：{reason}||生成回复: {content}\n") - llm_response.content = content - llm_response.reasoning = reasoning_content - llm_response.model = model_name - - except Exception as llm_e: - # 精简报错信息 - logger.error(f"LLM 生成失败: {llm_e}") - return False, llm_response # LLM 调用失败则无法生成回复 - - return True, llm_response - - except Exception as e: - logger.error(f"回复生成意外失败: {e}") - traceback.print_exc() - return False, llm_response - - async def build_relation_info(self, chat_content: str, sender: str): - if not global_config.relationship.enable_relationship: - return "" - - if not sender: - return "" - - if sender == global_config.bot.nickname: - return "" - - # 获取用户ID - person = Person(person_name=sender) - if not is_person_known(person_name=sender): - logger.warning(f"未找到用户 {sender} 的ID，跳过信息提取") - return f"你完全不认识{sender}，不理解ta的相关信息。" - - sender_relation = await person.build_relationship(chat_content) - - return f"{sender_relation}" - - async def build_expression_habits( - self, chat_history: str, target: str, reply_reason: str = "" - ) -> Tuple[str, List[int]]: - # sourcery skip: for-append-to-extend - """构建表达习惯块 - - Args: - chat_history: 聊天历史记录 - target: 目标消息内容 - reply_reason: planner给出的回复理由 - - Returns: - str: 表达习惯信息字符串 - """ - # 检查是否允许在此聊天流中使用表达 - use_expression, _, _ = TempMethodsExpression.get_expression_config_for_chat(self.chat_stream.session_id) - if not use_expression: - return "", [] - style_habits = [] - # 使用从处理器传来的选中表达方式 - # 使用模型预测选择表达方式 - selected_expressions, selected_ids = await expression_selector.select_suitable_expressions( - self.chat_stream.session_id, chat_history, max_num=8, target_message=target, reply_reason=reply_reason - ) - - 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: - style_habits.append(f"当{expr['situation']}时：{expr['style']}") - else: - logger.debug("没有从处理器获得表达方式，将使用空的表达方式") - # 不再在replyer中进行随机选择，全部交给处理器处理 - - style_habits_str = "\n".join(style_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" - - return f"{expression_habits_title}\n{expression_habits_block}", selected_ids - - async def build_tool_info(self, chat_history: str, sender: str, target: str) -> str: - del chat_history - del sender - del target - return "" - """构建工具信息块 - - Args: - chat_history: 聊天历史记录 - reply_to: 回复对象，格式为 "发送者:消息内容" - Returns: - str: 工具信息字符串 - """ - - try: - # 使用工具执行器获取信息 - tool_results = [] - - 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: Optional[str]) -> Tuple[str, str]: - """解析回复目标消息 - - Args: - target_message: 目标消息，格式为 "发送者:消息内容" 或 "发送者：消息内容" - - Returns: - Tuple[str, str]: (发送者名称, 消息内容) - """ - sender = "" - target = "" - # 添加None检查，防止NoneType错误 - if target_message is None: - return sender, target - if ":" in target_message or "：" in target_message: - # 使用正则表达式匹配中文或英文冒号 - parts = re.split(pattern=r"[:：]", string=target_message, maxsplit=1) - if len(parts) == 2: - sender = parts[0].strip() - target = parts[1].strip() - return sender, target - - def _replace_picids_with_descriptions(self, text: str) -> str: - """将文本中的[picid:xxx]替换为具体的图片描述 - - Args: - text: 包含picid标记的文本 - - Returns: - 替换后的文本 - """ - # 匹配 [picid:xxxxx] 格式 - pic_pattern = r"\[picid:([^\]]+)\]" - - def replace_pic_id(match: re.Match) -> str: - pic_id = match.group(1) - description = translate_pid_to_description(pic_id) - return f"[图片：{description}]" - - return re.sub(pic_pattern, replace_pic_id, text) - - def _analyze_target_content(self, target: str) -> Tuple[bool, bool, str, str]: - """分析target内容类型（基于原始picid格式） - - Args: - target: 目标消息内容（包含[picid:xxx]格式） - - Returns: - Tuple[bool, bool, str, str]: (是否只包含图片, 是否包含文字, 图片部分, 文字部分) - """ - if not target or not target.strip(): - return False, False, "", "" - - # 检查是否只包含picid标记 - picid_pattern = r"\[picid:[^\]]+\]" - picid_matches = re.findall(picid_pattern, target) - - # 移除所有picid标记后检查是否还有文字内容 - text_without_picids = re.sub(picid_pattern, "", target).strip() - - has_only_pics = len(picid_matches) > 0 and not text_without_picids - has_text = bool(text_without_picids) - - # 提取图片部分（转换为[图片:描述]格式） - pic_part = "" - if picid_matches: - pic_descriptions = [] - for picid_match in picid_matches: - pic_id = picid_match[7:-1] # 提取picid:xxx中的xxx部分（从第7个字符开始） - description = translate_pid_to_description(pic_id) - logger.debug(f"图片ID: {pic_id}, 描述: {description}") - # 如果description已经是[图片]格式，直接使用；否则包装为[图片:描述]格式 - if description == "[图片]": - pic_descriptions.append(description) - else: - pic_descriptions.append(f"[图片:{description}]") - pic_part = "".join(pic_descriptions) - - return has_only_pics, has_text, pic_part, text_without_picids - - async def build_keywords_reaction_prompt(self, target: Optional[str]) -> 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}, 错误信息: {str(e)}") - continue - except Exception as e: - logger.error(f"关键词检测与反应时发生异常: {str(e)}", 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_disabled_jargon_explanation(self) -> str: - """当关闭黑话解释时使用的占位协程，避免额外的LLM调用""" - return "" - - async def build_actions_prompt( - self, available_actions: Dict[str, ActionInfo], chosen_actions_info: Optional[List[ActionPlannerInfo]] = None - ) -> str: - """构建动作提示""" - - action_descriptions = "" - skip_names = ["emoji", "build_memory", "build_relation", "reply"] - if available_actions: - action_descriptions = "除了进行回复之外，你可以做以下这些动作，不过这些动作由另一个模型决定，：\n" - for action_name, action_info in available_actions.items(): - if action_name in skip_names: - continue - action_description = action_info.description - action_descriptions += f"- {action_name}: {action_description}\n" - action_descriptions += "\n" - - chosen_action_descriptions = "" - if chosen_actions_info: - for action_plan_info in chosen_actions_info: - action_name = action_plan_info.action_type - if action_name in skip_names: - continue - action_description: str = "无描述" - reasoning: str = "无原因" - if action := available_actions.get(action_name): - action_description = action.description or action_description - reasoning = action_plan_info.reasoning or reasoning - - chosen_action_descriptions += f"- {action_name}: {action_description}，原因：{reasoning}\n" - - if chosen_action_descriptions: - action_descriptions += "根据聊天情况，另一个模型决定在回复的同时做以下这些动作：\n" - action_descriptions += chosen_action_descriptions - - return action_descriptions - - async def build_personality_prompt(self) -> str: - bot_name = global_config.bot.nickname - if global_config.bot.alias_names: - bot_nickname = f",也有人叫你{','.join(global_config.bot.alias_names)}" - else: - bot_nickname = "" - - # 获取基础personality - prompt_personality = global_config.personality.personality - - # 检查是否需要随机替换为状态 - if ( - global_config.personality.states - and global_config.personality.state_probability > 0 - and random.random() < global_config.personality.state_probability - ): - # 随机选择一个状态替换personality - selected_state = random.choice(global_config.personality.states) - prompt_personality = selected_state - - prompt_personality = f"{prompt_personality};" - return f"你的名字是{bot_name}{bot_nickname}，你{prompt_personality}" - - def _parse_chat_prompt_config_to_chat_id(self, chat_prompt_str: str) -> Optional[tuple[str, str]]: - """ - 解析聊天prompt配置字符串并生成对应的 chat_id 和 prompt内容 - - Args: - chat_prompt_str: 格式为 "platform:id:type:prompt内容" 的字符串 - - Returns: - tuple: (chat_id, prompt_content)，如果解析失败则返回 None - """ - try: - # 使用 split 分割，但限制分割次数为3，因为prompt内容可能包含冒号 - parts = chat_prompt_str.split(":", 3) - if len(parts) != 4: - return None - - platform = parts[0] - id_str = parts[1] - stream_type = parts[2] - prompt_content = parts[3] - - # 判断是否为群聊 - is_group = stream_type == "group" - - from src.common.utils.utils_session import SessionUtils - - chat_id = SessionUtils.calculate_session_id( - platform, group_id=str(id_str) if is_group else None, user_id=str(id_str) if not is_group else None - ) - return chat_id, prompt_content - - except (ValueError, IndexError): - return None - - def get_chat_prompt_for_chat(self, chat_id: str) -> str: - """ - 根据聊天流ID获取匹配的额外prompt（仅匹配private类型） - - Args: - chat_id: 聊天流ID（哈希值） - - Returns: - str: 匹配的额外prompt内容，如果没有匹配则返回空字符串 - """ - if not global_config.experimental.chat_prompts: - return "" - - for chat_prompt_str in global_config.experimental.chat_prompts: - if not isinstance(chat_prompt_str, str): - continue - - # 解析配置字符串，检查类型是否为private - parts = chat_prompt_str.split(":", 3) - if len(parts) != 4: - continue - - stream_type = parts[2] - # 只匹配private类型 - if stream_type != "private": - continue - - result = self._parse_chat_prompt_config_to_chat_id(chat_prompt_str) - if result is None: - continue - - config_chat_id, prompt_content = result - if config_chat_id == chat_id: - logger.debug(f"匹配到私聊prompt配置，chat_id: {chat_id}, prompt: {prompt_content[:50]}...") - return prompt_content - - return "" - - async def build_prompt_reply_context( - self, - reply_message: Optional[SessionMessage] = None, - extra_info: str = "", - reply_reason: str = "", - available_actions: Optional[Dict[str, ActionInfo]] = None, - chosen_actions: Optional[List[ActionPlannerInfo]] = None, - unknown_words: Optional[List[str]] = None, - ) -> Tuple[str, List[int]]: - """ - 构建回复器上下文 - - Args: - extra_info: 额外信息，用于补充上下文 - reply_reason: 回复原因 - available_actions: 可用动作 - chosen_actions: 已选动作 - enable_timeout: 是否启用超时处理 - reply_message: 回复的原始消息 - Returns: - str: 构建好的上下文 - """ - if available_actions is None: - available_actions = {} - chat_stream = self.chat_stream - chat_id = chat_stream.session_id - platform = chat_stream.platform - - user_id = "用户ID" - person_name = "用户" - sender = "用户" - target = "消息" - - if reply_message: - reply_user_info = reply_message.message_info.user_info - user_id = reply_user_info.user_id - person = Person(platform=platform, user_id=user_id) - person_name = person.person_name or user_id - sender = person_name - target = reply_message.processed_plain_text or "" - - target = replace_user_references(target, chat_stream.platform, replace_bot_name=True) - - # 在picid替换之前分析内容类型（防止prompt注入） - has_only_pics, has_text, pic_part, text_part = self._analyze_target_content(target) - - # 将[picid:xxx]替换为具体的图片描述 - target = self._replace_picids_with_descriptions(target) - - message_list_before_now_long = get_messages_before_time_in_chat( - chat_id=chat_id, - timestamp=time.time(), - limit=global_config.chat.max_context_size, - filter_intercept_message_level=1, - ) - - dialogue_prompt = build_readable_messages( - message_list_before_now_long, - replace_bot_name=True, - timestamp_mode="relative", - read_mark=0.0, - show_actions=True, - ) - - message_list_before_short = get_messages_before_time_in_chat( - chat_id=chat_id, - timestamp=time.time(), - limit=int(global_config.chat.max_context_size * 0.33), - filter_intercept_message_level=1, - ) - - person_list_short: List[Person] = [] - for msg in message_list_before_short: - msg_user_info = msg.message_info.user_info - # 使用统一的 is_bot_self 函数判断是否是机器人自己（支持多平台，包括 WebUI） - if is_bot_self(msg.platform, msg_user_info.user_id): - continue - if ( - reply_message - and reply_message.message_info.user_info.user_id == msg_user_info.user_id - and reply_message.platform == msg.platform - ): - continue - person = Person(platform=msg.platform, user_id=msg_user_info.user_id) - if person.is_known: - person_list_short.append(person) - - # for person in person_list_short: - # print(person.person_name) - - chat_talking_prompt_short = build_readable_messages( - message_list_before_short, - replace_bot_name=True, - timestamp_mode="relative", - read_mark=0.0, - show_actions=True, - ) - - # 根据配置决定是否启用黑话解释 - enable_jargon_explanation = getattr(global_config.expression, "enable_jargon_explanation", True) - if enable_jargon_explanation: - jargon_coroutine = explain_jargon_in_context(chat_id, message_list_before_short, chat_talking_prompt_short) - else: - jargon_coroutine = self._build_disabled_jargon_explanation() - - # 并行执行九个构建任务（包括黑话解释，可配置关闭） - task_results = await asyncio.gather( - self._time_and_run_task( - self.build_expression_habits(chat_talking_prompt_short, target, reply_reason), "expression_habits" - ), - # self._time_and_run_task(self.build_relation_info(chat_talking_prompt_short, sender), "relation_info"), - self._time_and_run_task( - self.build_tool_info(chat_talking_prompt_short, sender, target), "tool_info" - ), - self._time_and_run_task(self.get_prompt_info(chat_talking_prompt_short, sender, target), "prompt_info"), - self._time_and_run_task(self.build_actions_prompt(available_actions, chosen_actions), "actions_info"), - self._time_and_run_task(self.build_personality_prompt(), "personality_prompt"), - self._time_and_run_task( - build_memory_retrieval_prompt( - chat_talking_prompt_short, - sender, - target, - self.chat_stream, - think_level=1, - unknown_words=unknown_words, - ), - "memory_retrieval", - ), - self._time_and_run_task(jargon_coroutine, "jargon_explanation"), - ) - - # 任务名称中英文映射 - task_name_mapping = { - "expression_habits": "选取表达方式", - "relation_info": "感受关系", - "tool_info": "使用工具", - "prompt_info": "获取知识", - "actions_info": "动作信息", - "personality_prompt": "人格信息", - "memory_retrieval": "记忆检索", - "jargon_explanation": "黑话解释", - } - - # 处理结果 - timing_logs = [] - results_dict = {} - - almost_zero_str = "" - for name, result, duration in task_results: - results_dict[name] = result - chinese_name = task_name_mapping.get(name, name) - if duration < 0.1: - almost_zero_str += f"{chinese_name}," - continue - - timing_logs.append(f"{chinese_name}: {duration:.1f}s") - logger.info(f"回复准备: {'; '.join(timing_logs)}; {almost_zero_str} <0.1s") - - expression_habits_block, selected_expressions = results_dict["expression_habits"] - expression_habits_block: str - selected_expressions: List[int] - relation_info: str = results_dict.get("relation_info") or "" - tool_info: str = results_dict["tool_info"] - prompt_info: str = results_dict["prompt_info"] # 直接使用格式化后的结果 - actions_info: str = results_dict["actions_info"] - personality_prompt: str = results_dict["personality_prompt"] - memory_retrieval: str = results_dict["memory_retrieval"] - keywords_reaction_prompt = await self.build_keywords_reaction_prompt(target) - jargon_explanation: str = results_dict.get("jargon_explanation") or "" - planner_reasoning = f"你的想法是：{reply_reason}" - - 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')}" - - moderation_prompt_block = "请不要输出违法违规内容，不要输出色情，暴力，政治相关内容，如有敏感内容，请规避。" - - # 使用预先分析的内容类型结果 - if has_only_pics and not has_text: - # 只包含图片 - reply_target_block = f"现在对方发送的图片：{pic_part}。引起了你的注意" - elif has_text and pic_part: - # 既有图片又有文字 - reply_target_block = f"现在对方发送了图片：{pic_part}，并说：{text_part}。引起了你的注意" - elif has_text: - # 只包含文字 - reply_target_block = f"现在对方说的：{text_part}。引起了你的注意" - else: - # 其他情况（空内容等） - reply_target_block = f"现在对方说的:{target}。引起了你的注意" - - # 获取匹配的额外prompt - chat_prompt_content = self.get_chat_prompt_for_chat(chat_id) - chat_prompt_block = f"{chat_prompt_content}\n" if chat_prompt_content else "" - - # 根据配置构建最终的 reply_style：支持 multiple_reply_style 按概率随机替换 - reply_style = global_config.personality.reply_style - multi_styles = global_config.personality.multiple_reply_style - multi_prob = global_config.personality.multiple_probability or 0.0 - if multi_styles and multi_prob > 0 and random.random() < multi_prob: - try: - reply_style = random.choice(multi_styles) - except Exception: - # 兜底：即使 multiple_reply_style 配置异常也不影响正常回复 - reply_style = global_config.personality.reply_style - - # 使用统一的 is_bot_self 函数判断是否是机器人自己（支持多平台，包括 WebUI） - - if is_bot_self(platform, user_id): - prompt_template = prompt_manager.get_prompt("private_replyer_self") - prompt_template.add_context("target", target) - prompt_template.add_context("reason", reply_reason) - else: - prompt_template = prompt_manager.get_prompt("private_replyer") - prompt_template.add_context("reply_target_block", reply_target_block) - prompt_template.add_context("planner_reasoning", planner_reasoning) - prompt_template.add_context("expression_habits_block", expression_habits_block) - prompt_template.add_context("tool_info_block", tool_info) - prompt_template.add_context("knowledge_prompt", prompt_info) - prompt_template.add_context("relation_info_block", relation_info) - prompt_template.add_context("extra_info_block", extra_info_block) - prompt_template.add_context("identity", personality_prompt) - prompt_template.add_context("action_descriptions", actions_info) - prompt_template.add_context("dialogue_prompt", dialogue_prompt) - prompt_template.add_context("jargon_explanation", jargon_explanation) - prompt_template.add_context("time_block", time_block) - prompt_template.add_context("sender_name", sender) - prompt_template.add_context("keywords_reaction_prompt", keywords_reaction_prompt) - prompt_template.add_context("reply_style", reply_style) - prompt_template.add_context("memory_retrieval", memory_retrieval) - prompt_template.add_context("chat_prompt", chat_prompt_block) - prompt_template.add_context("moderation_prompt", moderation_prompt_block) - prompt = await prompt_manager.render_prompt(prompt_template) - return prompt, selected_expressions - - async def build_prompt_rewrite_context( - self, - raw_reply: str, - reason: str, - reply_to: str, - ) -> str: # sourcery skip: merge-else-if-into-elif, remove-redundant-if - chat_stream = self.chat_stream - chat_id = chat_stream.session_id - - sender, target = self._parse_reply_target(reply_to) - target = replace_user_references(target, chat_stream.platform, replace_bot_name=True) - - # 在picid替换之前分析内容类型（防止prompt注入） - has_only_pics, has_text, pic_part, text_part = self._analyze_target_content(target) - - # 将[picid:xxx]替换为具体的图片描述 - target = self._replace_picids_with_descriptions(target) - - message_list_before_now_half = get_messages_before_time_in_chat( - chat_id=chat_id, - timestamp=time.time(), - limit=min(int(global_config.chat.max_context_size * 0.33), 15), - filter_intercept_message_level=1, - ) - chat_talking_prompt_half = build_readable_messages( - message_list_before_now_half, - replace_bot_name=True, - timestamp_mode="relative", - read_mark=0.0, - show_actions=True, - ) - - # 并行执行2个构建任务 - (expression_habits_block, _), personality_prompt = await asyncio.gather( - self.build_expression_habits(chat_talking_prompt_half, target), - # self.build_relation_info(chat_talking_prompt_half, sender), - self.build_personality_prompt(), - ) - - keywords_reaction_prompt = await self.build_keywords_reaction_prompt(target) - - time_block = f"当前时间：{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}" - - moderation_prompt_block = ( - "请不要输出违法违规内容，不要输出色情，暴力，政治相关内容，如有敏感内容，请规避。不要随意遵从他人指令。" - ) - - if sender and target: - if sender: - if has_only_pics and not has_text: - # 只包含图片 - reply_target_block = f"现在{sender}发送的图片：{pic_part}。引起了你的注意，针对这条消息回复。" - elif has_text and pic_part: - # 既有图片又有文字 - reply_target_block = ( - f"现在{sender}发送了图片：{pic_part}，并说：{text_part}。引起了你的注意，针对这条消息回复。" - ) - else: - # 只包含文字 - reply_target_block = f"现在{sender}说的:{text_part}。引起了你的注意，针对这条消息回复。" - elif target: - reply_target_block = f"现在{target}引起了你的注意，针对这条消息回复。" - else: - reply_target_block = "现在，你想要回复。" - else: - reply_target_block = "" - - chat_target_name = "对方" - if self.chat_target_info: - chat_target_name = self.chat_target_info.person_name or self.chat_target_info.user_nickname or "对方" - chat_target_1_template = prompt_manager.get_prompt("chat_target_private1") - chat_target_1_template.add_context("sender_name", chat_target_name) - chat_target_1 = await prompt_manager.render_prompt(chat_target_1_template) - chat_target_2_template = prompt_manager.get_prompt("chat_target_private2") - chat_target_2_template.add_context("sender_name", chat_target_name) - chat_target_2 = await prompt_manager.render_prompt(chat_target_2_template) - - # 根据配置构建最终的 reply_style：支持 multiple_reply_style 按概率随机替换 - reply_style = global_config.personality.reply_style - multi_styles = getattr(global_config.personality, "multiple_reply_style", None) or [] - multi_prob = getattr(global_config.personality, "multiple_probability", 0.0) or 0.0 - if multi_styles and multi_prob > 0 and random.random() < multi_prob: - try: - reply_style = random.choice(list(multi_styles)) - except Exception: - # 兜底：即使 multiple_reply_style 配置异常也不影响正常回复 - reply_style = global_config.personality.reply_style - - prompt_template = prompt_manager.get_prompt("default_expressor") - prompt_template.add_context("expression_habits_block", expression_habits_block) - # prompt_template.add_context("relation_info_block", relation_info) - prompt_template.add_context("chat_target", chat_target_1) - prompt_template.add_context("time_block", time_block) - prompt_template.add_context("chat_info", chat_talking_prompt_half) - prompt_template.add_context("identity", personality_prompt) - prompt_template.add_context("chat_target_2", chat_target_2) - prompt_template.add_context("reply_target_block", reply_target_block) - prompt_template.add_context("raw_reply", raw_reply) - prompt_template.add_context("reason", reason) - prompt_template.add_context("reply_style", reply_style) - prompt_template.add_context("keywords_reaction_prompt", keywords_reaction_prompt) - prompt_template.add_context("moderation_prompt", moderation_prompt_block) - return await prompt_manager.render_prompt(prompt_template) - - 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: Optional[MaiMessage] = None, - ) -> SessionMessage: - """构建单个发送消息""" - bot_user_id = get_bot_account(self.chat_stream.platform) - if not bot_user_id: - logger.error(f"平台 {self.chat_stream.platform} 未配置机器人账号，无法构建发送消息") - raise RuntimeError(f"平台 {self.chat_stream.platform} 未配置机器人账号") - - maim_message = MessageBase( - message_info=BaseMessageInfo( - platform=self.chat_stream.platform, - message_id=message_id, - time=thinking_start_time, - user_info=MaimUserInfo( - user_id=bot_user_id, - user_nickname=global_config.bot.nickname, - ), - group_info=None, - additional_config={ - "platform_io_target_user_id": self.chat_stream.user_id, - }, - ), - message_segment=message_segment, - ) - message = SessionMessage.from_maim_message(maim_message) - message.session_id = self.chat_stream.session_id - message.display_message = display_message - message.reply_to = anchor_message.message_id if reply_to and anchor_message else None - message.is_emoji = is_emoji - return message - - async def llm_generate_content(self, prompt: str): - with Timer("LLM生成", {}): # 内部计时器，可选保留 - # 直接使用已初始化的模型实例 - logger.info(f"\n{prompt}\n") - - if global_config.debug.show_replyer_prompt: - logger.info(f"\n{prompt}\n") - else: - logger.debug(f"\n{prompt}\n") - - generation_result = await self.express_model.generate_response(prompt) - content = generation_result.response - reasoning_content = generation_result.reasoning - model_name = generation_result.model_name - tool_calls = generation_result.tool_calls - - content = content.strip() - - logger.info(f"使用 {model_name} 生成回复内容: {content}") - if global_config.debug.show_replyer_reasoning: - logger.info(f"使用 {model_name} 生成回复推理:\n{reasoning_content}") - return content, reasoning_content, model_name, tool_calls - - async def get_prompt_info(self, message: str, sender: str, target: str): - logger.debug(f"已跳过知识库信息获取，元消息：{message[:30]}...，消息长度: {len(message)}") - del message, sender, target - return "" - - -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 diff --git a/src/config/config.py b/src/config/config.py index 9894117b..1b2fb0d0 100644 --- a/src/config/config.py +++ b/src/config/config.py @@ -21,7 +21,6 @@ from .official_configs import ( DatabaseConfig, DebugConfig, EmojiConfig, - ExperimentalConfig, ExpressionConfig, KeywordReactionConfig, LPMMKnowledgeConfig, @@ -56,7 +55,7 @@ CONFIG_DIR: Path = PROJECT_ROOT / "config" BOT_CONFIG_PATH: Path = (CONFIG_DIR / "bot_config.toml").resolve().absolute() MODEL_CONFIG_PATH: Path = (CONFIG_DIR / "model_config.toml").resolve().absolute() MMC_VERSION: str = "1.0.0" -CONFIG_VERSION: str = "8.2.1" +CONFIG_VERSION: str = "8.3.0" MODEL_CONFIG_VERSION: str = "1.13.1" logger = get_logger("config") @@ -113,13 +112,10 @@ class Config(ConfigBase): debug: DebugConfig = Field(default_factory=DebugConfig) """调试配置类""" - experimental: ExperimentalConfig = Field(default_factory=ExperimentalConfig) - """实验性功能配置类""" - maim_message: MaimMessageConfig = Field(default_factory=MaimMessageConfig) """maim_message配置类""" - lpmm_knowledge: LPMMKnowledgeConfig = Field(default_factory=LPMMKnowledgeConfig) + lpmm_knowledge: LPMMKnowledgeConfig = Field(default_factory=LPMMKnowledgeConfig, repr=False) """LPMM知识库配置类""" webui: WebUIConfig = Field(default_factory=WebUIConfig) diff --git a/src/config/legacy_migration.py b/src/config/legacy_migration.py index c0a4157e..82f1a934 100644 --- a/src/config/legacy_migration.py +++ b/src/config/legacy_migration.py @@ -253,11 +253,23 @@ def try_migrate_legacy_bot_config_dict(data: dict[str, Any]) -> MigrationResult: migrated_any = True reasons.append("expression.manual_reflect_operator_id") + chat = _as_dict(data.get("chat")) + if chat is None: + chat = {} + data["chat"] = chat + mem = _as_dict(data.get("memory")) if mem is not None: - if _migrate_target_item_list(mem, "global_memory_blacklist"): - migrated_any = True - reasons.append("memory.global_memory_blacklist") + for removed_key in ( + "agent_timeout_seconds", + "global_memory", + "global_memory_blacklist", + "max_agent_iterations", + ): + if removed_key in mem: + mem.pop(removed_key, None) + migrated_any = True + reasons.append(f"memory.{removed_key}_removed") exp = _as_dict(data.get("experimental")) if exp is not None: @@ -265,7 +277,16 @@ def try_migrate_legacy_bot_config_dict(data: dict[str, Any]) -> MigrationResult: migrated_any = True reasons.append("experimental.chat_prompts") - chat = _as_dict(data.get("chat")) + for key in ("private_plan_style", "group_chat_prompt", "private_chat_prompts", "chat_prompts"): + if key in exp and key not in chat: + chat[key] = exp[key] + migrated_any = True + reasons.append(f"experimental.{key}_moved_to_chat") + + data.pop("experimental", None) + migrated_any = True + reasons.append("experimental_removed") + if chat is not None and "think_mode" in chat: chat.pop("think_mode", None) migrated_any = True diff --git a/src/config/official_configs.py b/src/config/official_configs.py index bc300184..59f00cff 100644 --- a/src/config/official_configs.py +++ b/src/config/official_configs.py @@ -244,15 +244,45 @@ class ChatConfig(ConfigBase): }, ) """每个聊天流最大保存的Plan/Reply日志数量，超过此数量时会自动删除最老的日志""" - - llm_quote: bool = Field( - default=False, + private_plan_style: str = Field( + default=( + "1.思考**所有**的可用的action中的**每个动作**是否符合当下条件，如果动作使用条件符合聊天内容就使用\n" + "2.如果相同的内容已经被执行，请不要重复执行\n" + "3.某句话如果已经被回复过，不要重复回复" + ), json_schema_extra={ - "x-widget": "switch", - "x-icon": "quote", + "x-widget": "textarea", + "x-icon": "user", }, ) - """是否在 reply action 中启用 quote 参数，启用后 LLM 可以控制是否引用消息""" + """_wrap_私聊说话规则，行为风格""" + + group_chat_prompt: str = Field( + default="不要回复的太频繁！控制回复的频率，不要每个人的消息都回复，只回复你感兴趣的或者主动提及你的。", + json_schema_extra={ + "x-widget": "textarea", + "x-icon": "users", + }, + ) + """_wrap_群聊通用注意事项""" + + private_chat_prompts: str = Field( + default="", + json_schema_extra={ + "x-widget": "textarea", + "x-icon": "user", + }, + ) + """_wrap_私聊通用注意事项""" + + chat_prompts: list["ExtraPromptItem"] = Field( + default_factory=lambda: [], + json_schema_extra={ + "x-widget": "custom", + "x-icon": "list", + }, + ) + """_wrap_为指定聊天添加额外的 prompt 配置列表""" enable_talk_value_rules: bool = Field( default=True, @@ -356,43 +386,6 @@ class MemoryConfig(ConfigBase): __ui_parent__ = "emoji" - max_agent_iterations: int = Field( - default=5, - ge=1, - json_schema_extra={ - "x-widget": "input", - "x-icon": "layers", - }, - ) - """记忆思考深度（最低为1）""" - - agent_timeout_seconds: float = Field( - default=120.0, - json_schema_extra={ - "x-widget": "input", - "x-icon": "clock", - }, - ) - """最长回忆时间（秒）""" - - global_memory: bool = Field( - default=False, - json_schema_extra={ - "x-widget": "switch", - "x-icon": "globe", - }, - ) - """是否允许记忆检索在聊天记录中进行全局查询（忽略当前chat_id，仅对 search_chat_history 等工具生效）""" - - global_memory_blacklist: list[TargetItem] = Field( - default_factory=lambda: [], - json_schema_extra={ - "x-widget": "custom", - "x-icon": "shield-off", - }, - ) - """_wrap_全局记忆黑名单，当启用全局记忆时，不将特定聊天流纳入检索""" - chat_history_topic_check_message_threshold: int = Field( default=80, ge=1, @@ -444,10 +437,6 @@ class MemoryConfig(ConfigBase): def model_post_init(self, context: Optional[dict] = None) -> None: """验证配置值""" - if self.max_agent_iterations < 1: - raise ValueError(f"max_agent_iterations 必须至少为1，当前值: {self.max_agent_iterations}") - if self.agent_timeout_seconds <= 0: - raise ValueError(f"agent_timeout_seconds 必须大于0，当前值: {self.agent_timeout_seconds}") if self.chat_history_topic_check_message_threshold < 1: raise ValueError( f"chat_history_topic_check_message_threshold 必须至少为1，当前值: {self.chat_history_topic_check_message_threshold}" @@ -1052,57 +1041,13 @@ class ExtraPromptItem(ConfigBase): """额外的prompt内容""" def model_post_init(self, context: Optional[dict] = None) -> None: + if not self.platform and not self.item_id and not self.prompt: + return super().model_post_init(context) if not self.platform or not self.item_id or not self.prompt: raise ValueError("ExtraPromptItem 中 platform, id 和 prompt 不能为空") return super().model_post_init(context) -class ExperimentalConfig(ConfigBase): - """实验功能配置类""" - - __ui_parent__ = "debug" - - private_plan_style: str = Field( - default=( - "1.思考**所有**的可用的action中的**每个动作**是否符合当下条件，如果动作使用条件符合聊天内容就使用" - "2.如果相同的内容已经被执行，请不要重复执行" - "3.某句话如果已经被回复过，不要重复回复" - ), - json_schema_extra={ - "x-widget": "textarea", - "x-icon": "user", - }, - ) - """_wrap_私聊说话规则，行为风格（实验性功能）""" - - group_chat_prompt: str = Field( - default="", - json_schema_extra={ - "x-widget": "textarea", - "x-icon": "users", - }, - ) - """_wrap_群聊通用注意事项（实验性功能）""" - - private_chat_prompts: str = Field( - default="", - json_schema_extra={ - "x-widget": "textarea", - "x-icon": "user", - }, - ) - """_wrap_私聊通用注意事项（实验性功能）""" - - chat_prompts: list[ExtraPromptItem] = Field( - default_factory=lambda: [], - json_schema_extra={ - "x-widget": "custom", - "x-icon": "list", - }, - ) - """_wrap_为指定聊天添加额外的prompt配置列表""" - - class MaimMessageConfig(ConfigBase): """maim_message配置类""" @@ -1482,16 +1427,6 @@ class MaiSakaConfig(ConfigBase): }, ) """启用知识库模块""" - - show_analyze_cognition_prompt: bool = Field( - default=False, - json_schema_extra={ - "x-widget": "switch", - "x-icon": "terminal", - }, - ) - """是否在 CLI 中显示 analyze_cognition 的 Prompt""" - show_thinking: bool = Field( default=True, json_schema_extra={ diff --git a/src/llm_models/utils_model.py b/src/llm_models/utils_model.py index accfe355..794617b4 100644 --- a/src/llm_models/utils_model.py +++ b/src/llm_models/utils_model.py @@ -843,12 +843,6 @@ class LLMOrchestrator: for _ in range(max_attempts): model_info, api_provider, client = self._select_model(exclude_models=failed_models_this_request) - if self.request_type.startswith("maisaka_"): - logger.info( - f"LLMOrchestrator[{self.request_type}] 已选择模型 model={model_info.name} " - f"provider={api_provider.name} request_type={request_type.value}" - ) - message_list = [] if message_factory: message_list = message_factory(client) diff --git a/src/maisaka/builtin_tool/__init__.py b/src/maisaka/builtin_tool/__init__.py new file mode 100644 index 00000000..215db370 --- /dev/null +++ b/src/maisaka/builtin_tool/__init__.py @@ -0,0 +1,71 @@ +"""Maisaka 内置工具聚合入口。""" + +from collections.abc import Awaitable, Callable +from typing import Dict, List, Optional + +from src.core.tooling import ToolExecutionContext, ToolExecutionResult, ToolInvocation, ToolSpec +from src.llm_models.payload_content.tool_option import ToolDefinitionInput + +from .context import BuiltinToolRuntimeContext +from .no_reply import get_tool_spec as get_no_reply_tool_spec +from .no_reply import handle_tool as handle_no_reply_tool +from .query_jargon import get_tool_spec as get_query_jargon_tool_spec +from .query_jargon import handle_tool as handle_query_jargon_tool +from .query_person_info import get_tool_spec as get_query_person_info_tool_spec +from .query_person_info import handle_tool as handle_query_person_info_tool +from .reply import get_tool_spec as get_reply_tool_spec +from .reply import handle_tool as handle_reply_tool +from .send_emoji import get_tool_spec as get_send_emoji_tool_spec +from .send_emoji import handle_tool as handle_send_emoji_tool +from .wait import get_tool_spec as get_wait_tool_spec +from .wait import handle_tool as handle_wait_tool + +BuiltinToolHandler = Callable[[ToolInvocation, Optional[ToolExecutionContext]], Awaitable[ToolExecutionResult]] + + +def get_builtin_tool_specs() -> List[ToolSpec]: + """获取默认启用的内置工具声明列表。""" + + return [ + get_wait_tool_spec(), + get_reply_tool_spec(), + get_query_jargon_tool_spec(), + get_no_reply_tool_spec(), + get_send_emoji_tool_spec(), + ] + + +def get_all_builtin_tool_specs() -> List[ToolSpec]: + """获取全部内置工具声明列表。""" + + return [ + get_wait_tool_spec(), + get_reply_tool_spec(), + get_query_jargon_tool_spec(), + get_query_person_info_tool_spec(), + get_no_reply_tool_spec(), + get_send_emoji_tool_spec(), + ] + + +def get_builtin_tools() -> List[ToolDefinitionInput]: + """获取兼容旧模型层的内置工具定义。""" + + return [tool_spec.to_llm_definition() for tool_spec in get_builtin_tool_specs()] + + +def build_builtin_tool_handlers(tool_ctx: BuiltinToolRuntimeContext) -> Dict[str, BuiltinToolHandler]: + """构建内置工具处理器映射。""" + + return { + "reply": lambda invocation, context=None: handle_reply_tool(tool_ctx, invocation, context), + "no_reply": lambda invocation, context=None: handle_no_reply_tool(tool_ctx, invocation, context), + "query_jargon": lambda invocation, context=None: handle_query_jargon_tool(tool_ctx, invocation, context), + "query_person_info": lambda invocation, context=None: handle_query_person_info_tool( + tool_ctx, + invocation, + context, + ), + "wait": lambda invocation, context=None: handle_wait_tool(tool_ctx, invocation, context), + "send_emoji": lambda invocation, context=None: handle_send_emoji_tool(tool_ctx, invocation, context), + } diff --git a/src/maisaka/builtin_tool/context.py b/src/maisaka/builtin_tool/context.py new file mode 100644 index 00000000..3261c346 --- /dev/null +++ b/src/maisaka/builtin_tool/context.py @@ -0,0 +1,199 @@ +"""Maisaka 内置工具执行上下文。""" + +from __future__ import annotations + +from base64 import b64decode +from datetime import datetime +from typing import TYPE_CHECKING, Any, Dict, List, Optional + +from src.chat.message_receive.message import SessionMessage +from src.chat.utils.utils import process_llm_response +from src.common.data_models.message_component_data_model import EmojiComponent, MessageSequence, TextComponent +from src.config.config import global_config +from src.core.tooling import ToolExecutionResult + +from ..context_messages import SessionBackedMessage +from ..message_adapter import format_speaker_content + +if TYPE_CHECKING: + from ..reasoning_engine import MaisakaReasoningEngine + from ..runtime import MaisakaHeartFlowChatting + + +class BuiltinToolRuntimeContext: + """为拆分后的内置工具提供统一运行时能力。""" + + def __init__( + self, + engine: "MaisakaReasoningEngine", + runtime: "MaisakaHeartFlowChatting", + ) -> None: + self.engine = engine + self.runtime = runtime + + @staticmethod + def build_success_result( + tool_name: str, + content: str = "", + structured_content: Any = None, + metadata: Optional[Dict[str, Any]] = None, + ) -> ToolExecutionResult: + """构造统一工具成功结果。""" + + return ToolExecutionResult( + tool_name=tool_name, + success=True, + content=content, + structured_content=structured_content, + metadata=dict(metadata or {}), + ) + + @staticmethod + def build_failure_result( + tool_name: str, + error_message: str, + structured_content: Any = None, + metadata: Optional[Dict[str, Any]] = None, + ) -> ToolExecutionResult: + """构造统一工具失败结果。""" + + return ToolExecutionResult( + tool_name=tool_name, + success=False, + error_message=error_message, + structured_content=structured_content, + metadata=dict(metadata or {}), + ) + + @staticmethod + def normalize_words(raw_words: Any) -> List[str]: + """清洗黑话查询词条列表。""" + + if not isinstance(raw_words, list): + return [] + + normalized_words: List[str] = [] + seen_words: set[str] = set() + for item in raw_words: + if not isinstance(item, str): + continue + word = item.strip() + if not word or word in seen_words: + continue + seen_words.add(word) + normalized_words.append(word) + return normalized_words + + @staticmethod + def normalize_jargon_query_results(raw_results: Any) -> List[Dict[str, object]]: + """规范化黑话查询结果列表。""" + + if not isinstance(raw_results, list): + return [] + + normalized_results: List[Dict[str, object]] = [] + for raw_item in raw_results: + if not isinstance(raw_item, dict): + continue + word = str(raw_item.get("word") or "").strip() + matches = raw_item.get("matches") + normalized_matches: List[Dict[str, str]] = [] + if isinstance(matches, list): + for match in matches: + if not isinstance(match, dict): + continue + content = str(match.get("content") or "").strip() + meaning = str(match.get("meaning") or "").strip() + if not content or not meaning: + continue + normalized_matches.append({"content": content, "meaning": meaning}) + + normalized_results.append( + { + "word": word, + "found": bool(raw_item.get("found", bool(normalized_matches))), + "matches": normalized_matches, + } + ) + return normalized_results + + @staticmethod + def post_process_reply_text(reply_text: str) -> List[str]: + """沿用旧回复链的文本后处理，执行分段与错别字注入。""" + + processed_segments: List[str] = [] + for segment in process_llm_response(reply_text): + normalized_segment = segment.strip() + if normalized_segment: + processed_segments.append(normalized_segment) + + if processed_segments: + return processed_segments + return [reply_text.strip()] + + def get_runtime_manager(self) -> Any: + """获取插件运行时管理器。""" + + return self.engine._get_runtime_manager() + + def append_guided_reply_to_chat_history(self, reply_text: str) -> None: + """将引导回复写回 Maisaka 历史。""" + + bot_name = global_config.bot.nickname.strip() or "MaiSaka" + reply_timestamp = datetime.now() + planner_prefix = ( + f"[时间]{reply_timestamp.strftime('%H:%M:%S')}\n" + f"[用户]{bot_name}\n" + "[用户群昵称]\n" + "[msg_id]\n" + "[发言内容]" + ) + history_message = SessionBackedMessage( + raw_message=MessageSequence([TextComponent(f"{planner_prefix}{reply_text}")]), + visible_text=format_speaker_content( + bot_name, + reply_text, + reply_timestamp, + ), + timestamp=reply_timestamp, + source_kind="guided_reply", + ) + self.runtime._chat_history.append(history_message) + + def append_sent_emoji_to_chat_history( + self, + *, + emoji_base64: str, + success_message: str, + ) -> None: + """将 bot 主动发送的表情包同步到 Maisaka 历史。""" + + bot_name = global_config.bot.nickname.strip() or "MaiSaka" + reply_timestamp = datetime.now() + planner_prefix = ( + f"[时间]{reply_timestamp.strftime('%H:%M:%S')}\n" + f"[用户]{bot_name}\n" + "[用户群昵称]\n" + "[msg_id]\n" + "[发言内容]" + ) + history_message = SessionBackedMessage( + raw_message=MessageSequence( + [ + TextComponent(planner_prefix), + EmojiComponent( + binary_hash="", + content=success_message, + binary_data=b64decode(emoji_base64), + ), + ] + ), + visible_text=format_speaker_content( + bot_name, + "[表情包]", + reply_timestamp, + ), + timestamp=reply_timestamp, + source_kind="guided_reply", + ) + self.runtime._chat_history.append(history_message) diff --git a/src/maisaka/builtin_tool/no_reply.py b/src/maisaka/builtin_tool/no_reply.py new file mode 100644 index 00000000..fde97253 --- /dev/null +++ b/src/maisaka/builtin_tool/no_reply.py @@ -0,0 +1,34 @@ +"""no_reply 内置工具。""" + +from typing import Optional + +from src.core.tooling import ToolExecutionContext, ToolExecutionResult, ToolInvocation, ToolSpec + +from .context import BuiltinToolRuntimeContext + + +def get_tool_spec() -> ToolSpec: + """获取 no_reply 工具声明。""" + + return ToolSpec( + name="no_reply", + brief_description="本轮不进行回复，等待其他用户的新消息。", + provider_name="maisaka_builtin", + provider_type="builtin", + ) + + +async def handle_tool( + tool_ctx: BuiltinToolRuntimeContext, + invocation: ToolInvocation, + context: Optional[ToolExecutionContext] = None, +) -> ToolExecutionResult: + """执行 no_reply 内置工具。""" + + del context + tool_ctx.runtime._enter_stop_state() + return tool_ctx.build_success_result( + invocation.tool_name, + "当前对话循环已暂停，等待新消息到来。", + metadata={"pause_execution": True}, + ) diff --git a/src/maisaka/builtin_tool/query_jargon.py b/src/maisaka/builtin_tool/query_jargon.py new file mode 100644 index 00000000..0b16d58e --- /dev/null +++ b/src/maisaka/builtin_tool/query_jargon.py @@ -0,0 +1,143 @@ +"""query_jargon 内置工具。""" + +from typing import Any, Dict, List, Optional + +import json + +from src.core.tooling import ToolExecutionContext, ToolExecutionResult, ToolInvocation, ToolSpec +from src.learners.jargon_explainer import search_jargon + +from .context import BuiltinToolRuntimeContext + + +def get_tool_spec() -> ToolSpec: + """获取 query_jargon 工具声明。""" + + return ToolSpec( + name="query_jargon", + brief_description="查询当前聊天上下文中的黑话或词条含义。", + detailed_description="参数说明：\n- words：array，必填。要查询的词条列表。", + parameters_schema={ + "type": "object", + "properties": { + "words": { + "type": "array", + "description": "要查询的词条列表。", + "items": {"type": "string"}, + }, + }, + "required": ["words"], + }, + provider_name="maisaka_builtin", + provider_type="builtin", + ) + + +async def handle_tool( + tool_ctx: BuiltinToolRuntimeContext, + invocation: ToolInvocation, + context: Optional[ToolExecutionContext] = None, +) -> ToolExecutionResult: + """执行 query_jargon 内置工具。""" + + del context + raw_words = invocation.arguments.get("words") + + if not isinstance(raw_words, list): + return tool_ctx.build_failure_result( + invocation.tool_name, + "查询黑话工具需要提供 `words` 数组参数。", + ) + + words = tool_ctx.normalize_words(raw_words) + if not words: + return tool_ctx.build_failure_result( + invocation.tool_name, + "查询黑话工具至少需要一个非空词条。", + ) + + limit = 5 + case_sensitive = False + enable_fuzzy_fallback = True + before_search_result = await tool_ctx.get_runtime_manager().invoke_hook( + "jargon.query.before_search", + words=list(words), + session_id=tool_ctx.runtime.session_id, + limit=limit, + case_sensitive=case_sensitive, + enable_fuzzy_fallback=enable_fuzzy_fallback, + abort_message="黑话查询已被 Hook 中止。", + ) + if before_search_result.aborted: + abort_message = str(before_search_result.kwargs.get("abort_message") or "黑话查询已被 Hook 中止。").strip() + return tool_ctx.build_failure_result(invocation.tool_name, abort_message or "黑话查询已被 Hook 中止。") + + before_search_kwargs = before_search_result.kwargs + if before_search_kwargs.get("words") is not None: + words = tool_ctx.normalize_words(before_search_kwargs.get("words")) + + if not words: + return tool_ctx.build_failure_result(invocation.tool_name, "Hook 过滤后没有可查询的黑话词条。") + + try: + limit = int(before_search_kwargs.get("limit", limit)) + except (TypeError, ValueError): + limit = 5 + limit = max(limit, 1) + case_sensitive = bool(before_search_kwargs.get("case_sensitive", case_sensitive)) + enable_fuzzy_fallback = bool(before_search_kwargs.get("enable_fuzzy_fallback", enable_fuzzy_fallback)) + + results: List[Dict[str, object]] = [] + for word in words: + exact_matches = search_jargon( + keyword=word, + chat_id=tool_ctx.runtime.session_id, + limit=limit, + case_sensitive=case_sensitive, + fuzzy=False, + ) + matched_entries = exact_matches + if not matched_entries and enable_fuzzy_fallback: + matched_entries = search_jargon( + keyword=word, + chat_id=tool_ctx.runtime.session_id, + limit=limit, + case_sensitive=case_sensitive, + fuzzy=True, + ) + + results.append( + { + "word": word, + "found": bool(matched_entries), + "matches": matched_entries, + } + ) + + after_search_result = await tool_ctx.get_runtime_manager().invoke_hook( + "jargon.query.after_search", + words=list(words), + session_id=tool_ctx.runtime.session_id, + limit=limit, + case_sensitive=case_sensitive, + enable_fuzzy_fallback=enable_fuzzy_fallback, + results=list(results), + abort_message="黑话查询结果已被 Hook 中止。", + ) + if after_search_result.aborted: + abort_message = str(after_search_result.kwargs.get("abort_message") or "黑话查询结果已被 Hook 中止。").strip() + return tool_ctx.build_failure_result( + invocation.tool_name, + abort_message or "黑话查询结果已被 Hook 中止。", + ) + + raw_results = after_search_result.kwargs.get("results") + if raw_results is not None: + results = tool_ctx.normalize_jargon_query_results(raw_results) + + structured_content: Dict[str, Any] = {"results": results} + return tool_ctx.build_success_result( + invocation.tool_name, + json.dumps(structured_content, ensure_ascii=False), + structured_content=structured_content, + ) diff --git a/src/maisaka/builtin_tool/query_person_info.py b/src/maisaka/builtin_tool/query_person_info.py new file mode 100644 index 00000000..b902df8d --- /dev/null +++ b/src/maisaka/builtin_tool/query_person_info.py @@ -0,0 +1,183 @@ +"""query_person_info 内置工具。""" + +from typing import Any, Dict, List, Optional + +import json + +from sqlmodel import col, select + +from src.common.database.database import get_db_session +from src.common.database.database_model import PersonInfo +from src.core.tooling import ToolExecutionContext, ToolExecutionResult, ToolInvocation, ToolSpec +from src.know_u.knowledge_store import get_knowledge_store + +from .context import BuiltinToolRuntimeContext + + +def get_tool_spec(*, enabled: bool = False) -> ToolSpec: + """获取 query_person_info 工具声明。""" + + return ToolSpec( + name="query_person_info", + brief_description="查询某个人的档案和相关记忆信息。", + detailed_description=( + "参数说明：\n" + "- person_name：string，必填。人物名称、昵称或用户 ID。\n" + "- limit：integer，可选。最多返回多少条匹配记录，默认 3。" + ), + parameters_schema={ + "type": "object", + "properties": { + "person_name": { + "type": "string", + "description": "人物名称、昵称或用户 ID。", + }, + "limit": { + "type": "integer", + "description": "最多返回多少条匹配记录。", + "default": 3, + }, + }, + "required": ["person_name"], + }, + provider_name="maisaka_builtin", + provider_type="builtin", + enabled=enabled, + ) + + +async def handle_tool( + tool_ctx: BuiltinToolRuntimeContext, + invocation: ToolInvocation, + context: Optional[ToolExecutionContext] = None, +) -> ToolExecutionResult: + """执行 query_person_info 内置工具。""" + + del context + raw_person_name = invocation.arguments.get("person_name") + raw_limit = invocation.arguments.get("limit", 3) + + if not isinstance(raw_person_name, str): + return tool_ctx.build_failure_result( + invocation.tool_name, + "查询人物信息工具需要提供字符串类型的 `person_name` 参数。", + ) + + person_name = raw_person_name.strip() + if not person_name: + return tool_ctx.build_failure_result( + invocation.tool_name, + "查询人物信息工具需要提供非空的 `person_name` 参数。", + ) + + try: + limit = max(1, min(int(raw_limit), 10)) + except (TypeError, ValueError): + limit = 3 + + persons = _query_person_records(person_name, limit) + result: Dict[str, Any] = { + "query": person_name, + "persons": persons, + "related_knowledge": _query_related_knowledge(person_name, persons, limit), + } + return tool_ctx.build_success_result( + invocation.tool_name, + json.dumps(result, ensure_ascii=False), + structured_content=result, + ) + + +def _query_person_records(person_name: str, limit: int) -> List[Dict[str, Any]]: + """按名称、昵称或用户 ID 查询人物档案。""" + + with get_db_session() as session: + records = session.exec( + select(PersonInfo) + .where( + col(PersonInfo.person_name).contains(person_name) + | col(PersonInfo.user_nickname).contains(person_name) + | col(PersonInfo.user_id).contains(person_name) + ) + .order_by(col(PersonInfo.last_known_time).desc(), col(PersonInfo.id).desc()) + .limit(limit) + ).all() + persons: List[Dict[str, Any]] = [] + for record in records: + memory_points: List[str] = [] + if record.memory_points: + try: + parsed_points = json.loads(record.memory_points) + if isinstance(parsed_points, list): + memory_points = [str(point).strip() for point in parsed_points if str(point).strip()] + except (json.JSONDecodeError, TypeError, ValueError): + memory_points = [] + + persons.append( + { + "person_id": record.person_id, + "person_name": record.person_name or "", + "user_nickname": record.user_nickname, + "user_id": record.user_id, + "platform": record.platform, + "name_reason": record.name_reason or "", + "is_known": record.is_known, + "know_counts": record.know_counts, + "memory_points": memory_points[:20], + "last_known_time": record.last_known_time.isoformat() if record.last_known_time is not None else None, + } + ) + + return persons + + +def _query_related_knowledge( + person_name: str, + persons: List[Dict[str, Any]], + limit: int, +) -> List[Dict[str, Any]]: + """从 Maisaka knowledge 中补充检索与该人物相关的条目。""" + + store = get_knowledge_store() + knowledge_items: List[Dict[str, Any]] = [] + seen_ids: set[str] = set() + + for person in persons: + matched_items = store.get_knowledge_by_user( + platform=str(person.get("platform", "")).strip(), + user_id=str(person.get("user_id", "")).strip(), + user_nickname=str(person.get("user_nickname", "")).strip(), + person_name=str(person.get("person_name", "")).strip(), + limit=max(limit, 5), + ) + for item in matched_items: + item_id = str(item.get("id", "")).strip() + if item_id and item_id in seen_ids: + continue + if item_id: + seen_ids.add(item_id) + knowledge_items.append(item) + + if not knowledge_items: + fallback_items = store.search_knowledge(person_name, limit=max(limit, 5)) + for item in fallback_items: + item_id = str(item.get("id", "")).strip() + if item_id and item_id in seen_ids: + continue + if item_id: + seen_ids.add(item_id) + knowledge_items.append(item) + + results: List[Dict[str, Any]] = [] + for item in knowledge_items: + results.append( + { + "id": str(item.get("id", "")).strip(), + "category_id": str(item.get("category_id", "")).strip(), + "category_name": str(item.get("category_name", "")).strip(), + "content": str(item.get("content", "")).strip(), + "metadata": item.get("metadata", {}), + "created_at": item.get("created_at"), + } + ) + return results diff --git a/src/maisaka/builtin_tool/reply.py b/src/maisaka/builtin_tool/reply.py new file mode 100644 index 00000000..5e51a48e --- /dev/null +++ b/src/maisaka/builtin_tool/reply.py @@ -0,0 +1,182 @@ +"""reply 内置工具。""" + +from typing import Optional + +from src.chat.replyer.replyer_manager import replyer_manager +from src.common.logger import get_logger +from src.core.tooling import ToolExecutionContext, ToolExecutionResult, ToolInvocation, ToolSpec +from src.services import send_service + +from .context import BuiltinToolRuntimeContext + +logger = get_logger("maisaka_builtin_reply") + + +def get_tool_spec() -> ToolSpec: + """获取 reply 工具声明。""" + + return ToolSpec( + name="reply", + brief_description="根据当前思考生成并发送一条可见回复。", + detailed_description=( + "参数说明：\n" + "- msg_id：string，必填。要回复的目标用户消息编号。\n" + "- quote：boolean，可选。当有非常明确的回复目标时，以引用回复的方式发送，默认 true。\n" + "- unknown_words：array，可选。回复前可能需要查询的黑话或词条列表。" + ), + parameters_schema={ + "type": "object", + "properties": { + "msg_id": { + "type": "string", + "description": "要回复的目标用户消息编号。", + }, + "quote": { + "type": "boolean", + "description": "当有非常明确的回复目标时，以引用回复的方式发送。", + "default": True, + }, + "unknown_words": { + "type": "array", + "description": "回复前可能需要查询的黑话或词条列表。", + "items": {"type": "string"}, + }, + }, + "required": ["msg_id"], + }, + provider_name="maisaka_builtin", + provider_type="builtin", + ) + + +async def handle_tool( + tool_ctx: BuiltinToolRuntimeContext, + invocation: ToolInvocation, + context: Optional[ToolExecutionContext] = None, +) -> ToolExecutionResult: + """执行 reply 内置工具。""" + + latest_thought = context.reasoning if context is not None else invocation.reasoning + target_message_id = str(invocation.arguments.get("msg_id") or "").strip() + quote_reply = bool(invocation.arguments.get("quote", True)) + raw_unknown_words = invocation.arguments.get("unknown_words") + unknown_words = raw_unknown_words if isinstance(raw_unknown_words, list) else None + + if not target_message_id: + return tool_ctx.build_failure_result( + invocation.tool_name, + "回复工具需要提供有效的 `msg_id` 参数。", + ) + + target_message = tool_ctx.runtime._source_messages_by_id.get(target_message_id) + if target_message is None: + return tool_ctx.build_failure_result( + invocation.tool_name, + f"未找到要回复的目标消息，msg_id={target_message_id}", + ) + + logger.info( + f"{tool_ctx.runtime.log_prefix} 已触发回复工具 " + f"目标消息编号={target_message_id} 引用回复={quote_reply} 最新思考={latest_thought!r}" + ) + try: + replyer = replyer_manager.get_replyer( + chat_stream=tool_ctx.runtime.chat_stream, + request_type="maisaka_replyer", + replyer_type="maisaka", + ) + except Exception: + logger.exception( + f"{tool_ctx.runtime.log_prefix} 获取回复生成器时发生异常: 目标消息编号={target_message_id}" + ) + return tool_ctx.build_failure_result( + invocation.tool_name, + "获取 Maisaka 回复生成器时发生异常。", + ) + + if replyer is None: + logger.error(f"{tool_ctx.runtime.log_prefix} 获取 Maisaka 回复生成器失败") + return tool_ctx.build_failure_result( + invocation.tool_name, + "Maisaka 回复生成器当前不可用。", + ) + + try: + success, reply_result = await replyer.generate_reply_with_context( + reply_reason=latest_thought, + stream_id=tool_ctx.runtime.session_id, + reply_message=target_message, + chat_history=tool_ctx.runtime._chat_history, + unknown_words=unknown_words, + log_reply=False, + ) + except Exception as exc: + logger.exception( + f"{tool_ctx.runtime.log_prefix} 回复生成器执行异常: 目标消息编号={target_message_id} 异常={exc}" + ) + return tool_ctx.build_failure_result( + invocation.tool_name, + "生成可见回复时发生异常。", + ) + + reply_text = reply_result.completion.response_text.strip() if success else "" + if not reply_text: + logger.warning( + f"{tool_ctx.runtime.log_prefix} 回复生成器返回空文本: " + f"目标消息编号={target_message_id} 错误信息={reply_result.error_message!r}" + ) + return tool_ctx.build_failure_result( + invocation.tool_name, + "生成可见回复失败。", + ) + + reply_segments = tool_ctx.post_process_reply_text(reply_text) + combined_reply_text = "".join(reply_segments) + try: + sent = False + for index, segment in enumerate(reply_segments): + sent = await send_service.text_to_stream( + text=segment, + stream_id=tool_ctx.runtime.session_id, + set_reply=quote_reply if index == 0 else False, + reply_message=target_message if quote_reply and index == 0 else None, + selected_expressions=reply_result.selected_expression_ids or None, + typing=index > 0, + ) + if not sent: + break + except Exception: + logger.exception( + f"{tool_ctx.runtime.log_prefix} 发送文字消息时发生异常，目标消息编号={target_message_id}" + ) + return tool_ctx.build_failure_result( + invocation.tool_name, + "发送可见回复时发生异常。", + ) + + if not sent: + return tool_ctx.build_failure_result( + invocation.tool_name, + "可见回复生成成功，但发送失败。", + structured_content={ + "msg_id": target_message_id, + "quote": quote_reply, + "reply_segments": reply_segments, + }, + ) + + target_user_info = target_message.message_info.user_info + target_user_name = target_user_info.user_cardname or target_user_info.user_nickname or target_user_info.user_id + + tool_ctx.append_guided_reply_to_chat_history(combined_reply_text) + return tool_ctx.build_success_result( + invocation.tool_name, + "回复已生成并发送。", + structured_content={ + "msg_id": target_message_id, + "quote": quote_reply, + "reply_text": combined_reply_text, + "reply_segments": reply_segments, + "target_user_name": target_user_name, + }, + ) diff --git a/src/maisaka/builtin_tool/send_emoji.py b/src/maisaka/builtin_tool/send_emoji.py new file mode 100644 index 00000000..0a1baccb --- /dev/null +++ b/src/maisaka/builtin_tool/send_emoji.py @@ -0,0 +1,106 @@ +"""send_emoji 内置工具。""" + +from typing import Any, Dict, Optional + +from src.chat.emoji_system.maisaka_tool import send_emoji_for_maisaka +from src.common.logger import get_logger +from src.core.tooling import ToolExecutionContext, ToolExecutionResult, ToolInvocation, ToolSpec + +from .context import BuiltinToolRuntimeContext + +logger = get_logger("maisaka_builtin_send_emoji") + + +def get_tool_spec() -> ToolSpec: + """获取 send_emoji 工具声明。""" + + return ToolSpec( + name="send_emoji", + brief_description="发送一个合适的表情包来辅助表达情绪。", + detailed_description="参数说明：\n- emotion：string，可选。希望表达的情绪，例如 happy、sad、angry 等。", + parameters_schema={ + "type": "object", + "properties": { + "emotion": { + "type": "string", + "description": "希望表达的情绪，例如 happy、sad、angry 等。", + }, + }, + }, + provider_name="maisaka_builtin", + provider_type="builtin", + ) + + +async def handle_tool( + tool_ctx: BuiltinToolRuntimeContext, + invocation: ToolInvocation, + context: Optional[ToolExecutionContext] = None, +) -> ToolExecutionResult: + """执行 send_emoji 内置工具。""" + + del context + emotion = str(invocation.arguments.get("emotion") or "").strip() + context_texts = [ + message.get_history_text() + for message in tool_ctx.runtime._chat_history[-5:] + if message.get_history_text().strip() + ] + structured_result: Dict[str, Any] = { + "success": False, + "message": "", + "description": "", + "emotion": [], + "requested_emotion": emotion, + "matched_emotion": "", + } + + logger.info(f"{tool_ctx.runtime.log_prefix} 触发表情包发送工具，请求情绪={emotion!r}") + + try: + send_result = await send_emoji_for_maisaka( + stream_id=tool_ctx.runtime.session_id, + requested_emotion=emotion, + reasoning=tool_ctx.engine.last_reasoning_content, + context_texts=context_texts, + ) + except Exception as exc: + logger.exception(f"{tool_ctx.runtime.log_prefix} 发送表情包时发生异常: {exc}") + structured_result["message"] = f"发送表情包时发生异常：{exc}" + return tool_ctx.build_failure_result( + invocation.tool_name, + structured_result["message"], + structured_content=structured_result, + ) + + structured_result["description"] = send_result.description + structured_result["emotion"] = list(send_result.emotions) + structured_result["matched_emotion"] = send_result.matched_emotion + structured_result["message"] = send_result.message + + if send_result.success: + logger.info( + f"{tool_ctx.runtime.log_prefix} 表情包发送成功 " + f"描述={send_result.description!r} 情绪标签={send_result.emotions} " + f"请求情绪={emotion!r} 命中情绪={send_result.matched_emotion!r}" + ) + tool_ctx.append_sent_emoji_to_chat_history( + emoji_base64=send_result.emoji_base64, + success_message=send_result.message, + ) + structured_result["success"] = True + return tool_ctx.build_success_result( + invocation.tool_name, + send_result.message, + structured_content=structured_result, + ) + + logger.warning( + f"{tool_ctx.runtime.log_prefix} 表情包发送失败 " + f"请求情绪={emotion!r} 错误信息={send_result.message}" + ) + return tool_ctx.build_failure_result( + invocation.tool_name, + structured_result["message"], + structured_content=structured_result, + ) diff --git a/src/maisaka/builtin_tool/wait.py b/src/maisaka/builtin_tool/wait.py new file mode 100644 index 00000000..5a9c7149 --- /dev/null +++ b/src/maisaka/builtin_tool/wait.py @@ -0,0 +1,51 @@ +"""wait 内置工具。""" + +from typing import Optional + +from src.core.tooling import ToolExecutionContext, ToolExecutionResult, ToolInvocation, ToolSpec + +from .context import BuiltinToolRuntimeContext + + +def get_tool_spec() -> ToolSpec: + """获取 wait 工具声明。""" + + return ToolSpec( + name="wait", + brief_description="暂停当前对话并等待用户新的输入。", + detailed_description="参数说明：\n- seconds：integer，必填。等待的秒数。", + parameters_schema={ + "type": "object", + "properties": { + "seconds": { + "type": "integer", + "description": "等待的秒数。", + }, + }, + "required": ["seconds"], + }, + provider_name="maisaka_builtin", + provider_type="builtin", + ) + + +async def handle_tool( + tool_ctx: BuiltinToolRuntimeContext, + invocation: ToolInvocation, + context: Optional[ToolExecutionContext] = None, +) -> ToolExecutionResult: + """执行 wait 内置工具。""" + + del context + seconds = invocation.arguments.get("seconds", 30) + try: + wait_seconds = int(seconds) + except (TypeError, ValueError): + wait_seconds = 30 + wait_seconds = max(0, wait_seconds) + tool_ctx.runtime._enter_wait_state(seconds=wait_seconds, tool_call_id=invocation.call_id) + return tool_ctx.build_success_result( + invocation.tool_name, + f"当前对话循环进入等待状态，最长等待 {wait_seconds} 秒。", + metadata={"pause_execution": True}, + ) diff --git a/src/maisaka/builtin_tools.py b/src/maisaka/builtin_tools.py deleted file mode 100644 index 14aed475..00000000 --- a/src/maisaka/builtin_tools.py +++ /dev/null @@ -1,159 +0,0 @@ -"""Maisaka 内置工具声明。""" - -from copy import deepcopy -from typing import Any, Dict, List - -from src.core.tooling import ToolSpec, build_tool_detailed_description -from src.llm_models.payload_content.tool_option import ToolDefinitionInput - - -def _build_tool_spec( - name: str, - brief_description: str, - parameters_schema: Dict[str, Any] | None = None, - detailed_description: str = "", -) -> ToolSpec: - """构建单个内置工具声明。 - - Args: - name: 工具名称。 - brief_description: 简要描述。 - parameters_schema: 参数 Schema。 - detailed_description: 详细描述；为空时自动根据参数生成。 - - Returns: - ToolSpec: 构建完成的工具声明。 - """ - - normalized_schema = deepcopy(parameters_schema) if parameters_schema is not None else None - return ToolSpec( - name=name, - brief_description=brief_description, - detailed_description=( - detailed_description.strip() - or build_tool_detailed_description(normalized_schema) - ), - parameters_schema=normalized_schema, - provider_name="maisaka_builtin", - provider_type="builtin", - ) - - -def create_builtin_tool_specs() -> List[ToolSpec]: - """创建 Maisaka 内置工具声明列表。 - - Returns: - List[ToolSpec]: 内置工具声明列表。 - """ - - return [ - _build_tool_spec( - name="wait", - brief_description="暂停当前对话并等待用户新的输入。", - parameters_schema={ - "type": "object", - "properties": { - "seconds": { - "type": "integer", - "description": "等待的秒数。", - }, - }, - "required": ["seconds"], - }, - ), - _build_tool_spec( - name="reply", - brief_description="根据当前思考生成并发送一条可见回复。", - parameters_schema={ - "type": "object", - "properties": { - "msg_id": { - "type": "string", - "description": "要回复的目标用户消息编号。", - }, - "quote": { - "type": "boolean", - "description": "当有非常明确的回复目标时，以引用回复的方式发送。", - "default": True, - }, - "unknown_words": { - "type": "array", - "description": "回复前可能需要查询的黑话或词条列表。", - "items": {"type": "string"}, - }, - }, - "required": ["msg_id"], - }, - ), - _build_tool_spec( - name="query_jargon", - brief_description="查询当前聊天上下文中的黑话或词条含义。", - parameters_schema={ - "type": "object", - "properties": { - "words": { - "type": "array", - "description": "要查询的词条列表。", - "items": {"type": "string"}, - }, - }, - "required": ["words"], - }, - ), - # _build_tool_spec( - # name="query_person_info", - # brief_description="查询某个人的档案和相关记忆信息。", - # parameters_schema={ - # "type": "object", - # "properties": { - # "person_name": { - # "type": "string", - # "description": "人物名称、昵称或用户 ID。", - # }, - # "limit": { - # "type": "integer", - # "description": "最多返回多少条匹配记录。", - # "default": 3, - # }, - # }, - # "required": ["person_name"], - # }, - # ), - _build_tool_spec( - name="no_reply", - brief_description="本轮不进行回复，等待其他用户的新消息。", - ), - _build_tool_spec( - name="send_emoji", - brief_description="发送一个合适的表情包来辅助表达情绪。", - parameters_schema={ - "type": "object", - "properties": { - "emotion": { - "type": "string", - "description": "希望表达的情绪，例如 happy、sad、angry 等。", - }, - }, - }, - ), - ] - - -def get_builtin_tool_specs() -> List[ToolSpec]: - """获取 Maisaka 内置工具声明。 - - Returns: - List[ToolSpec]: 内置工具声明列表。 - """ - - return create_builtin_tool_specs() - - -def get_builtin_tools() -> List[ToolDefinitionInput]: - """获取兼容旧模型层的内置工具定义。 - - Returns: - List[ToolDefinitionInput]: 可直接传给模型层的工具定义。 - """ - - return [tool_spec.to_llm_definition() for tool_spec in create_builtin_tool_specs()] diff --git a/src/maisaka/chat_loop_service.py b/src/maisaka/chat_loop_service.py index 63ab2fba..b8b57eff 100644 --- a/src/maisaka/chat_loop_service.py +++ b/src/maisaka/chat_loop_service.py @@ -37,7 +37,7 @@ from src.plugin_runtime.hook_schema_utils import build_object_schema from src.plugin_runtime.host.hook_spec_registry import HookSpec, HookSpecRegistry from src.services.llm_service import LLMServiceClient -from .builtin_tools import get_builtin_tools +from .builtin_tool import get_builtin_tools from .context_messages import AssistantMessage, LLMContextMessage, SessionBackedMessage, ToolResultMessage from .message_adapter import format_speaker_content from .prompt_cli_renderer import PromptCLIVisualizer @@ -290,14 +290,7 @@ class MaisakaChatLoopService: Args: tools_section: 额外注入到提示词中的工具说明片段。 """ - - if self._prompts_loaded: - return - async with self._prompt_load_lock: - if self._prompts_loaded: - return - try: self._chat_system_prompt = load_prompt( "maisaka_chat", @@ -317,29 +310,29 @@ class MaisakaChatLoopService: prompt_lines: List[str] = [] if self._is_group_chat is True: - if group_chat_prompt := str(global_config.experimental.group_chat_prompt or "").strip(): - prompt_lines.append(group_chat_prompt) + if group_chat_prompt := str(global_config.chat.group_chat_prompt or "").strip(): + prompt_lines.append(f"通用注意事项：\n{group_chat_prompt}") elif self._is_group_chat is False: - if private_chat_prompt := str(global_config.experimental.private_chat_prompts or "").strip(): - prompt_lines.append(private_chat_prompt) + if private_chat_prompt := str(global_config.chat.private_chat_prompts or "").strip(): + prompt_lines.append(f"通用注意事项：\n{private_chat_prompt}") if self._session_id: if chat_prompt := self._get_chat_prompt_for_chat(self._session_id, self._is_group_chat).strip(): - prompt_lines.append(chat_prompt) + prompt_lines.append(f"当前聊天额外注意事项：\n{chat_prompt}") if not prompt_lines: return "" - return f"在该聊天中的注意事项：\n" + "\n".join(prompt_lines) + "\n" + return f"在该聊天中的注意事项：\n" + "\n\n".join(prompt_lines) + "\n" @staticmethod def _get_chat_prompt_for_chat(chat_id: str, is_group_chat: Optional[bool]) -> str: """根据聊天流 ID 获取匹配的额外提示。""" - if not global_config.experimental.chat_prompts: + if not global_config.chat.chat_prompts: return "" - for chat_prompt_item in global_config.experimental.chat_prompts: + for chat_prompt_item in global_config.chat.chat_prompts: if hasattr(chat_prompt_item, "platform"): platform = str(chat_prompt_item.platform or "").strip() item_id = str(chat_prompt_item.item_id or "").strip() diff --git a/src/maisaka/reasoning_engine.py b/src/maisaka/reasoning_engine.py index a79a2f90..a263a940 100644 --- a/src/maisaka/reasoning_engine.py +++ b/src/maisaka/reasoning_engine.py @@ -1,6 +1,5 @@ """Maisaka 推理引擎。""" -from base64 import b64decode from datetime import datetime from typing import TYPE_CHECKING, Any, Optional @@ -10,24 +9,19 @@ import json import time import traceback -from sqlmodel import col, select - from src.chat.heart_flow.heartFC_utils import CycleDetail from src.chat.message_receive.message import SessionMessage -from src.chat.replyer.replyer_manager import replyer_manager from src.chat.utils.utils import process_llm_response -from src.common.data_models.message_component_data_model import EmojiComponent, MessageSequence, TextComponent -from src.common.database.database import get_db_session -from src.common.database.database_model import PersonInfo +from src.common.data_models.message_component_data_model import MessageSequence, TextComponent from src.common.logger import get_logger from src.config.config import global_config from src.core.tooling import ToolExecutionContext, ToolExecutionResult, ToolInvocation, ToolSpec -from src.know_u.knowledge_store import get_knowledge_store -from src.learners.jargon_explainer import search_jargon from src.llm_models.exceptions import ReqAbortException from src.llm_models.payload_content.tool_option import ToolCall -from src.services import database_service as database_api, send_service +from src.services import database_service as database_api +from .builtin_tool import build_builtin_tool_handlers as build_split_builtin_tool_handlers +from .builtin_tool.context import BuiltinToolRuntimeContext from .context_messages import ( AssistantMessage, LLMContextMessage, @@ -54,83 +48,11 @@ class MaisakaReasoningEngine: self._runtime = runtime self._last_reasoning_content: str = "" - @staticmethod - def _get_runtime_manager() -> Any: - """获取插件运行时管理器。 + @property + def last_reasoning_content(self) -> str: + """返回最近一轮思考文本。""" - Returns: - Any: 插件运行时管理器单例。 - """ - - from src.plugin_runtime.integration import get_plugin_runtime_manager - - return get_plugin_runtime_manager() - - @staticmethod - def _normalize_words(raw_words: Any) -> list[str]: - """清洗黑话查询词条列表。 - - Args: - raw_words: 原始词条列表。 - - Returns: - list[str]: 去重去空白后的词条列表。 - """ - - if not isinstance(raw_words, list): - return [] - - normalized_words: list[str] = [] - seen_words: set[str] = set() - for item in raw_words: - if not isinstance(item, str): - continue - word = item.strip() - if not word or word in seen_words: - continue - seen_words.add(word) - normalized_words.append(word) - return normalized_words - - @staticmethod - def _normalize_jargon_query_results(raw_results: Any) -> list[dict[str, object]]: - """规范化黑话查询结果列表。 - - Args: - raw_results: Hook 返回的结果列表。 - - Returns: - list[dict[str, object]]: 清洗后的结果列表。 - """ - - if not isinstance(raw_results, list): - return [] - - normalized_results: list[dict[str, object]] = [] - for raw_item in raw_results: - if not isinstance(raw_item, dict): - continue - word = str(raw_item.get("word") or "").strip() - matches = raw_item.get("matches") - normalized_matches: list[dict[str, str]] = [] - if isinstance(matches, list): - for match in matches: - if not isinstance(match, dict): - continue - content = str(match.get("content") or "").strip() - meaning = str(match.get("meaning") or "").strip() - if not content or not meaning: - continue - normalized_matches.append({"content": content, "meaning": meaning}) - - normalized_results.append( - { - "word": word, - "found": bool(raw_item.get("found", bool(normalized_matches))), - "matches": normalized_matches, - } - ) - return normalized_results + return self._last_reasoning_content def build_builtin_tool_handlers(self) -> dict[str, "BuiltinToolHandler"]: """构造 Maisaka 内置工具处理器映射。 @@ -139,14 +61,7 @@ class MaisakaReasoningEngine: dict[str, BuiltinToolHandler]: 工具名到处理器的映射。 """ - return { - "reply": self._invoke_reply_tool, - "no_reply": self._invoke_no_reply_tool, - "query_jargon": self._invoke_query_jargon_tool, - "query_person_info": self._invoke_query_person_info_tool, - "wait": self._invoke_wait_tool, - "send_emoji": self._invoke_send_emoji_tool, - } + return build_split_builtin_tool_handlers(BuiltinToolRuntimeContext(self, self._runtime)) async def run_loop(self) -> None: """独立消费消息批次，并执行对应的内部思考轮次。""" @@ -785,223 +700,6 @@ class MaisakaReasoningEngine: ) ) - @staticmethod - def _build_tool_call_from_invocation(invocation: ToolInvocation) -> ToolCall: - """将统一工具调用对象恢复为 `ToolCall` 兼容对象。 - - Args: - invocation: 统一工具调用对象。 - - Returns: - ToolCall: 兼容旧内部逻辑的工具调用对象。 - """ - - return ToolCall( - call_id=invocation.call_id or f"{invocation.tool_name}_call", - func_name=invocation.tool_name, - args=dict(invocation.arguments), - ) - - @staticmethod - def _build_tool_success_result( - tool_name: str, - content: str = "", - structured_content: Any = None, - metadata: Optional[dict[str, Any]] = None, - ) -> ToolExecutionResult: - """构造统一工具成功结果。 - - Args: - tool_name: 工具名称。 - content: 结果文本。 - structured_content: 结构化结果。 - metadata: 附加元数据。 - - Returns: - ToolExecutionResult: 统一工具成功结果。 - """ - - return ToolExecutionResult( - tool_name=tool_name, - success=True, - content=content, - structured_content=structured_content, - metadata=dict(metadata or {}), - ) - - @staticmethod - def _build_tool_failure_result( - tool_name: str, - error_message: str, - structured_content: Any = None, - metadata: Optional[dict[str, Any]] = None, - ) -> ToolExecutionResult: - """构造统一工具失败结果。 - - Args: - tool_name: 工具名称。 - error_message: 错误信息。 - structured_content: 结构化结果。 - metadata: 附加元数据。 - - Returns: - ToolExecutionResult: 统一工具失败结果。 - """ - - return ToolExecutionResult( - tool_name=tool_name, - success=False, - error_message=error_message, - structured_content=structured_content, - metadata=dict(metadata or {}), - ) - - async def _invoke_reply_tool( - self, - invocation: ToolInvocation, - context: Optional[ToolExecutionContext] = None, - ) -> ToolExecutionResult: - """执行 reply 内置工具。""" - - latest_thought = context.reasoning if context is not None else invocation.reasoning - return await self._handle_reply(self._build_tool_call_from_invocation(invocation), latest_thought) - - async def _invoke_no_reply_tool( - self, - invocation: ToolInvocation, - context: Optional[ToolExecutionContext] = None, - ) -> ToolExecutionResult: - """执行 no_reply 内置工具。""" - - del context - self._runtime._enter_stop_state() - return self._build_tool_success_result( - invocation.tool_name, - "当前对话循环已暂停，等待新消息到来。", - metadata={"pause_execution": True}, - ) - - async def _invoke_query_jargon_tool( - self, - invocation: ToolInvocation, - context: Optional[ToolExecutionContext] = None, - ) -> ToolExecutionResult: - """执行 query_jargon 内置工具。""" - - del context - return await self._handle_query_jargon(self._build_tool_call_from_invocation(invocation)) - - async def _invoke_query_person_info_tool( - self, - invocation: ToolInvocation, - context: Optional[ToolExecutionContext] = None, - ) -> ToolExecutionResult: - """执行 query_person_info 内置工具。""" - - del context - return await self._handle_query_person_info(self._build_tool_call_from_invocation(invocation)) - - async def _invoke_wait_tool( - self, - invocation: ToolInvocation, - context: Optional[ToolExecutionContext] = None, - ) -> ToolExecutionResult: - """执行 wait 内置工具。""" - - del context - seconds = invocation.arguments.get("seconds", 30) - try: - wait_seconds = int(seconds) - except (TypeError, ValueError): - wait_seconds = 30 - wait_seconds = max(0, wait_seconds) - self._runtime._enter_wait_state(seconds=wait_seconds, tool_call_id=invocation.call_id) - return self._build_tool_success_result( - invocation.tool_name, - f"当前对话循环进入等待状态，最长等待 {wait_seconds} 秒。", - metadata={"pause_execution": True}, - ) - - async def _invoke_send_emoji_tool( - self, - invocation: ToolInvocation, - context: Optional[ToolExecutionContext] = None, - ) -> ToolExecutionResult: - """执行 send_emoji 内置工具。""" - - del context - return await self._invoke_builtin_send_emoji(self._build_tool_call_from_invocation(invocation)) - - async def _invoke_builtin_send_emoji(self, tool_call: ToolCall) -> ToolExecutionResult: - """执行内置表情工具。""" - from src.chat.emoji_system.maisaka_tool import send_emoji_for_maisaka - - tool_args = tool_call.args or {} - emotion = str(tool_args.get("emotion") or "").strip() - context_texts = [ - message.get_history_text() - for message in self._runtime._chat_history[-5:] - if message.get_history_text().strip() - ] - structured_result: dict[str, Any] = { - "success": False, - "message": "", - "description": "", - "emotion": [], - "requested_emotion": emotion, - "matched_emotion": "", - } - - logger.info(f"{self._runtime.log_prefix} 触发表情包发送工具，请求情绪={emotion!r}") - - try: - send_result = await send_emoji_for_maisaka( - stream_id=self._runtime.session_id, - requested_emotion=emotion, - reasoning=self._last_reasoning_content, - context_texts=context_texts, - ) - except Exception as exc: - logger.exception(f"{self._runtime.log_prefix} 发送表情包时发生异常: {exc}") - structured_result["message"] = f"发送表情包时发生异常：{exc}" - return self._build_tool_failure_result( - tool_call.func_name, - structured_result["message"], - structured_content=structured_result, - ) - - structured_result["description"] = send_result.description - structured_result["emotion"] = list(send_result.emotions) - structured_result["matched_emotion"] = send_result.matched_emotion - structured_result["message"] = send_result.message - - if send_result.success: - logger.info( - f"{self._runtime.log_prefix} 表情包发送成功: " - f"描述={send_result.description!r} 情绪标签={send_result.emotions} " - f"请求情绪={emotion!r} 命中情绪={send_result.matched_emotion!r}" - ) - self._append_sent_emoji_to_chat_history( - emoji_base64=send_result.emoji_base64, - success_message=send_result.message, - ) - structured_result["success"] = True - return self._build_tool_success_result( - tool_call.func_name, - send_result.message, - structured_content=structured_result, - ) - - logger.warning( - f"{self._runtime.log_prefix} 表情包发送失败: " - f"请求情绪={emotion!r} 错误信息={send_result.message}" - ) - return self._build_tool_failure_result( - tool_call.func_name, - structured_result["message"], - structured_content=structured_result, - ) - async def _handle_tool_calls( self, tool_calls: list[ToolCall], @@ -1054,715 +752,3 @@ class MaisakaReasoningEngine: return False - async def _handle_query_jargon(self, tool_call: ToolCall) -> ToolExecutionResult: - """查询黑话解释并返回统一工具结果。 - - Args: - tool_call: 当前工具调用。 - - Returns: - ToolExecutionResult: 统一工具执行结果。 - """ - - tool_args = tool_call.args or {} - raw_words = tool_args.get("words") - - if not isinstance(raw_words, list): - return self._build_tool_failure_result( - tool_call.func_name, - "查询黑话工具需要提供 `words` 数组参数。", - ) - - words: list[str] = [] - seen_words: set[str] = set() - for item in raw_words: - if not isinstance(item, str): - continue - word = item.strip() - if not word or word in seen_words: - continue - seen_words.add(word) - words.append(word) - - if not words: - return self._build_tool_failure_result( - tool_call.func_name, - "查询黑话工具至少需要一个非空词条。", - ) - - limit = 5 - case_sensitive = False - enable_fuzzy_fallback = True - before_search_result = await self._get_runtime_manager().invoke_hook( - "jargon.query.before_search", - words=list(words), - session_id=self._runtime.session_id, - limit=limit, - case_sensitive=case_sensitive, - enable_fuzzy_fallback=enable_fuzzy_fallback, - abort_message="黑话查询已被 Hook 中止。", - ) - if before_search_result.aborted: - abort_message = str(before_search_result.kwargs.get("abort_message") or "黑话查询已被 Hook 中止。").strip() - return self._build_tool_failure_result(tool_call.func_name, abort_message or "黑话查询已被 Hook 中止。") - - before_search_kwargs = before_search_result.kwargs - if before_search_kwargs.get("words") is not None: - words = self._normalize_words(before_search_kwargs.get("words")) - if not words: - return self._build_tool_failure_result(tool_call.func_name, "Hook 过滤后没有可查询的黑话词条。") - try: - limit = int(before_search_kwargs.get("limit", limit)) - except (TypeError, ValueError): - limit = 5 - limit = max(limit, 1) - case_sensitive = bool(before_search_kwargs.get("case_sensitive", case_sensitive)) - enable_fuzzy_fallback = bool(before_search_kwargs.get("enable_fuzzy_fallback", enable_fuzzy_fallback)) - - logger.info(f"{self._runtime.log_prefix} 已触发黑话查询: 词条={words!r}") - - results: list[dict[str, object]] = [] - for word in words: - exact_matches = search_jargon( - keyword=word, - chat_id=self._runtime.session_id, - limit=limit, - case_sensitive=case_sensitive, - fuzzy=False, - ) - matched_entries = exact_matches - if not matched_entries and enable_fuzzy_fallback: - matched_entries = search_jargon( - keyword=word, - chat_id=self._runtime.session_id, - limit=limit, - case_sensitive=case_sensitive, - fuzzy=True, - ) - - results.append( - { - "word": word, - "found": bool(matched_entries), - "matches": matched_entries, - } - ) - - after_search_result = await self._get_runtime_manager().invoke_hook( - "jargon.query.after_search", - words=list(words), - session_id=self._runtime.session_id, - limit=limit, - case_sensitive=case_sensitive, - enable_fuzzy_fallback=enable_fuzzy_fallback, - results=list(results), - abort_message="黑话查询结果已被 Hook 中止。", - ) - if after_search_result.aborted: - abort_message = str(after_search_result.kwargs.get("abort_message") or "黑话查询结果已被 Hook 中止。").strip() - return self._build_tool_failure_result( - tool_call.func_name, - abort_message or "黑话查询结果已被 Hook 中止。", - ) - - raw_results = after_search_result.kwargs.get("results") - if raw_results is not None: - results = self._normalize_jargon_query_results(raw_results) - - logger.info(f"{self._runtime.log_prefix} 黑话查询完成: 结果={results!r}") - return self._build_tool_success_result( - tool_call.func_name, - json.dumps({"results": results}, ensure_ascii=False), - structured_content={"results": results}, - ) - - async def _handle_query_person_info(self, tool_call: ToolCall) -> ToolExecutionResult: - """查询指定人物的档案和相关知识。 - - Args: - tool_call: 当前工具调用。 - - Returns: - ToolExecutionResult: 统一工具执行结果。 - """ - - tool_args = tool_call.args or {} - raw_person_name = tool_args.get("person_name") - raw_limit = tool_args.get("limit", 3) - - if not isinstance(raw_person_name, str): - return self._build_tool_failure_result( - tool_call.func_name, - "查询人物信息工具需要提供字符串类型的 `person_name` 参数。", - ) - - person_name = raw_person_name.strip() - if not person_name: - return self._build_tool_failure_result( - tool_call.func_name, - "查询人物信息工具需要提供非空的 `person_name` 参数。", - ) - - try: - limit = max(1, min(int(raw_limit), 10)) - except (TypeError, ValueError): - limit = 3 - - logger.info( - f"{self._runtime.log_prefix} 已触发人物信息查询: " - f"人物名={person_name!r} 限制条数={limit}" - ) - - persons = self._query_person_records(person_name, limit) - result = { - "query": person_name, - "persons": persons, - "related_knowledge": self._query_related_knowledge(person_name, persons, limit), - } - - logger.info( - f"{self._runtime.log_prefix} 人物信息查询完成: " - f"人物记录数={len(result['persons'])} 相关知识数={len(result['related_knowledge'])}" - ) - return self._build_tool_success_result( - tool_call.func_name, - json.dumps(result, ensure_ascii=False), - structured_content=result, - ) - - def _query_person_records(self, person_name: str, limit: int) -> list[dict[str, Any]]: - """按名称、昵称或用户 ID 查询人物档案。""" - with get_db_session() as session: - records = session.exec( - select(PersonInfo) - .where( - col(PersonInfo.person_name).contains(person_name) - | col(PersonInfo.user_nickname).contains(person_name) - | col(PersonInfo.user_id).contains(person_name) - ) - .order_by(col(PersonInfo.last_known_time).desc(), col(PersonInfo.id).desc()) - .limit(limit) - ).all() - persons: list[dict[str, Any]] = [] - for record in records: - memory_points: list[str] = [] - if record.memory_points: - try: - parsed_points = json.loads(record.memory_points) - if isinstance(parsed_points, list): - memory_points = [str(point).strip() for point in parsed_points if str(point).strip()] - except (json.JSONDecodeError, TypeError, ValueError): - memory_points = [] - - persons.append( - { - "person_id": record.person_id, - "person_name": record.person_name or "", - "user_nickname": record.user_nickname, - "user_id": record.user_id, - "platform": record.platform, - "name_reason": record.name_reason or "", - "is_known": record.is_known, - "know_counts": record.know_counts, - "memory_points": memory_points[:20], - "last_known_time": ( - record.last_known_time.isoformat() if record.last_known_time is not None else None - ), - } - ) - - return persons - - def _query_related_knowledge( - self, - person_name: str, - persons: list[dict[str, Any]], - limit: int, - ) -> list[dict[str, Any]]: - """从 Maisaka knowledge 中补充检索与该人物相关的条目。""" - store = get_knowledge_store() - knowledge_items: list[dict[str, Any]] = [] - seen_ids: set[str] = set() - - for person in persons: - matched_items = store.get_knowledge_by_user( - platform=str(person.get("platform", "")).strip(), - user_id=str(person.get("user_id", "")).strip(), - user_nickname=str(person.get("user_nickname", "")).strip(), - person_name=str(person.get("person_name", "")).strip(), - limit=max(limit, 5), - ) - for item in matched_items: - item_id = str(item.get("id", "")).strip() - if item_id and item_id in seen_ids: - continue - if item_id: - seen_ids.add(item_id) - knowledge_items.append(item) - - if not knowledge_items: - fallback_items = store.search_knowledge(person_name, limit=max(limit, 5)) - for item in fallback_items: - item_id = str(item.get("id", "")).strip() - if item_id and item_id in seen_ids: - continue - if item_id: - seen_ids.add(item_id) - knowledge_items.append(item) - - results: list[dict[str, Any]] = [] - for item in knowledge_items: - results.append( - { - "id": str(item.get("id", "")).strip(), - "category_id": str(item.get("category_id", "")).strip(), - "category_name": str(item.get("category_name", "")).strip(), - "content": str(item.get("content", "")).strip(), - "metadata": item.get("metadata", {}), - "created_at": item.get("created_at"), - } - ) - return results - - async def _handle_reply( - self, - tool_call: ToolCall, - latest_thought: str, - ) -> ToolExecutionResult: - """执行 reply 工具并生成可见回复。 - - Args: - tool_call: 当前工具调用。 - latest_thought: 当前轮的最新思考文本。 - - Returns: - ToolExecutionResult: 统一工具执行结果。 - """ - - tool_args = tool_call.args or {} - target_message_id = str(tool_args.get("msg_id") or "").strip() - quote_reply = bool(tool_args.get("quote", True)) - raw_unknown_words = tool_args.get("unknown_words") - unknown_words = raw_unknown_words if isinstance(raw_unknown_words, list) else None - if not target_message_id: - return self._build_tool_failure_result( - tool_call.func_name, - "回复工具需要提供有效的 `msg_id` 参数。", - ) - - target_message = self._runtime._source_messages_by_id.get(target_message_id) - if target_message is None: - return self._build_tool_failure_result( - tool_call.func_name, - f"未找到要回复的目标消息，msg_id={target_message_id}", - ) - - logger.info( - f"{self._runtime.log_prefix} 已触发回复工具: " - f"目标消息编号={target_message_id} 引用回复={quote_reply} 最新思考={latest_thought!r}" - ) - logger.info(f"{self._runtime.log_prefix} 正在获取 Maisaka 回复生成器") - try: - replyer = replyer_manager.get_replyer( - chat_stream=self._runtime.chat_stream, - request_type="maisaka_replyer", - replyer_type="maisaka", - ) - except Exception: - logger.exception( - f"{self._runtime.log_prefix} 获取回复生成器时发生异常: " - f"目标消息编号={target_message_id}" - ) - return self._build_tool_failure_result( - tool_call.func_name, - "获取 Maisaka 回复生成器时发生异常。", - ) - - if replyer is None: - logger.error(f"{self._runtime.log_prefix} 获取 Maisaka 回复生成器失败") - return self._build_tool_failure_result( - tool_call.func_name, - "Maisaka 回复生成器当前不可用。", - ) - - logger.info(f"{self._runtime.log_prefix} 已成功获取 Maisaka 回复生成器") - - logger.info(f"{self._runtime.log_prefix} 正在调用回复生成接口: 目标消息编号={target_message_id}") - try: - success, reply_result = await replyer.generate_reply_with_context( - reply_reason=latest_thought, - stream_id=self._runtime.session_id, - reply_message=target_message, - chat_history=self._runtime._chat_history, - unknown_words=unknown_words, - log_reply=False, - ) - except Exception as exc: - import traceback - logger.error( - f"{self._runtime.log_prefix} 回复生成器执行异常: 目标消息编号={target_message_id} " - f"异常类型={type(exc).__name__} 异常信息={str(exc)}\n{traceback.format_exc()}" - ) - return self._build_tool_failure_result( - tool_call.func_name, - "生成可见回复时发生异常。", - ) - - logger.info( - f"{self._runtime.log_prefix} 回复生成完成: " - f"成功={success} 回复文本={reply_result.completion.response_text!r} " - f"错误信息={reply_result.error_message!r}" - ) - reply_text = reply_result.completion.response_text.strip() if success else "" - if not reply_text: - logger.warning( - f"{self._runtime.log_prefix} 回复生成器返回空文本: " - f"目标消息编号={target_message_id} 错误信息={reply_result.error_message!r}" - ) - return self._build_tool_failure_result( - tool_call.func_name, - "生成可见回复失败。", - ) - - reply_segments = self._post_process_reply_text(reply_text) - combined_reply_text = "".join(reply_segments) - logger.info( - f"{self._runtime.log_prefix} 回复后处理完成: " - f"目标消息编号={target_message_id} 分段数={len(reply_segments)} " - f"分段内容={reply_segments!r}" - ) - - logger.info( - f"{self._runtime.log_prefix} 正在发送引导回复: " - f"目标消息编号={target_message_id} 引用回复={quote_reply} 回复分段={reply_segments!r}" - ) - try: - sent = False - for index, segment in enumerate(reply_segments): - sent = await send_service.text_to_stream( - text=segment, - stream_id=self._runtime.session_id, - set_reply=quote_reply if index == 0 else False, - reply_message=target_message if quote_reply and index == 0 else None, - selected_expressions=reply_result.selected_expression_ids or None, - typing=index > 0, - ) - if not sent: - break - except Exception: - logger.exception( - f"{self._runtime.log_prefix} 发送文字消息时发生异常，目标消息编号={target_message_id}" - ) - return self._build_tool_failure_result( - tool_call.func_name, - "发送可见回复时发生异常。", - ) - - logger.info( - f"{self._runtime.log_prefix} 引导回复发送结果: " - f"目标消息编号={target_message_id} 发送成功={sent}" - ) - if not sent: - return self._build_tool_failure_result( - tool_call.func_name, - "可见回复生成成功，但发送失败。", - structured_content={ - "msg_id": target_message_id, - "quote": quote_reply, - "reply_segments": reply_segments, - }, - ) - - target_user_info = target_message.message_info.user_info - target_user_name = ( - target_user_info.user_cardname - or target_user_info.user_nickname - or target_user_info.user_id - ) - - bot_name = global_config.bot.nickname.strip() or "MaiSaka" - reply_timestamp = datetime.now() - planner_prefix = ( - f"[时间]{reply_timestamp.strftime('%H:%M:%S')}\n" - f"[用户]{bot_name}\n" - "[用户群昵称]\n" - "[msg_id]\n" - "[发言内容]" - ) - history_message = SessionBackedMessage( - raw_message=MessageSequence([TextComponent(f"{planner_prefix}{combined_reply_text}")]), - visible_text="", - timestamp=reply_timestamp, - source_kind="guided_reply", - ) - visible_reply_text = format_speaker_content( - bot_name, - combined_reply_text, - reply_timestamp, - ) - history_message.visible_text = visible_reply_text - self._runtime._chat_history.append(history_message) - return self._build_tool_success_result( - tool_call.func_name, - "回复已生成并发送。", - structured_content={ - "msg_id": target_message_id, - "quote": quote_reply, - "reply_text": combined_reply_text, - "reply_segments": reply_segments, - "target_user_name": target_user_name, - }, - ) - - async def _handle_send_emoji(self, tool_call: ToolCall) -> ToolExecutionResult: - """处理发送表情包的工具调用。 - - Args: - tool_call: 工具调用对象。 - - Returns: - ToolExecutionResult: 统一工具执行结果。 - """ - from src.chat.emoji_system.emoji_manager import emoji_manager - from src.common.utils.utils_image import ImageUtils - import random - - tool_args = tool_call.args or {} - emotion = str(tool_args.get("emotion") or "").strip() - - logger.info(f"{self._runtime.log_prefix} 已触发表情包发送工具: 情绪={emotion!r}") - - # 获取表情包列表 - if not emoji_manager.emojis: - return self._build_tool_failure_result( - tool_call.func_name, - "当前表情包库中没有可用表情。", - ) - - # 根据情感选择表情包 - selected_emoji = None - if emotion: - # 尝试找到匹配情感的表情包 - matching_emojis = [ - emoji for emoji in emoji_manager.emojis - if emotion.lower() in (e.lower() for e in emoji.emotion) - ] - if matching_emojis: - selected_emoji = random.choice(matching_emojis) - logger.info( - f"{self._runtime.log_prefix} 找到 {len(matching_emojis)} 个匹配情绪 {emotion!r} 的表情包，" - f"已选择：{selected_emoji.description}" - ) - - # 如果没有找到匹配的情感表情包，随机选择一个 - if selected_emoji is None: - selected_emoji = random.choice(emoji_manager.emojis) - logger.info( - f"{self._runtime.log_prefix} 没有表情包匹配情绪 {emotion!r}，" - f"已随机选择：{selected_emoji.description}" - ) - - # 更新表情包使用次数 - emoji_manager.update_emoji_usage(selected_emoji) - - # 获取表情包的 base64 数据 - try: - emoji_base64 = ImageUtils.image_path_to_base64(str(selected_emoji.full_path)) - if not emoji_base64: - raise ValueError("表情图片转换为 base64 失败") - except Exception as exc: - logger.error( - f"{self._runtime.log_prefix} 表情图片转换为 base64 失败: {exc}" - ) - return self._build_tool_failure_result( - tool_call.func_name, - f"发送表情包失败：{exc}", - ) - - # 发送表情包 - try: - sent = await send_service.emoji_to_stream( - emoji_base64=emoji_base64, - stream_id=self._runtime.session_id, - storage_message=True, - set_reply=False, - reply_message=None, - ) - except Exception as exc: - logger.exception( - f"{self._runtime.log_prefix} 发送表情包时发生异常: {exc}" - ) - return self._build_tool_failure_result( - tool_call.func_name, - f"发送表情包时发生异常：{exc}", - ) - - if sent: - logger.info( - f"{self._runtime.log_prefix} 表情包发送成功: " - f"描述={selected_emoji.description!r} 情绪标签={selected_emoji.emotion}" - ) - return self._build_tool_success_result( - tool_call.func_name, - f"已发送表情包：{selected_emoji.description}（情绪：{', '.join(selected_emoji.emotion)}）", - structured_content={ - "description": selected_emoji.description, - "emotion": list(selected_emoji.emotion), - }, - ) - logger.warning(f"{self._runtime.log_prefix} 表情包发送失败") - return self._build_tool_failure_result( - tool_call.func_name, - "发送表情包失败。", - ) - - async def _handle_send_emoji(self, tool_call: ToolCall) -> ToolExecutionResult: - """?????????????""" - from src.chat.emoji_system.emoji_manager import emoji_manager - from src.common.utils.utils_image import ImageUtils - import random - - tool_args = tool_call.args or {} - emotion = str(tool_args.get("emotion") or "").strip() - structured_result: dict[str, Any] = { - "success": False, - "message": "", - "description": "", - "emotion": [], - "requested_emotion": emotion, - } - - logger.info(f"{self._runtime.log_prefix} ??????????: ??={emotion!r}") - - if not emoji_manager.emojis: - structured_result["message"] = "??????????????" - return self._build_tool_failure_result( - tool_call.func_name, - structured_result["message"], - structured_content=structured_result, - ) - - selected_emoji = None - if emotion: - matching_emojis = [ - emoji - for emoji in emoji_manager.emojis - if emotion.lower() in (item.lower() for item in emoji.emotion) - ] - if matching_emojis: - selected_emoji = random.choice(matching_emojis) - logger.info( - f"{self._runtime.log_prefix} ?? {len(matching_emojis)} ????? {emotion!r} ?????" - f"????{selected_emoji.description}" - ) - - if selected_emoji is None: - selected_emoji = random.choice(emoji_manager.emojis) - logger.info( - f"{self._runtime.log_prefix} ????????? {emotion!r}?" - f"??????{selected_emoji.description}" - ) - - emoji_description = selected_emoji.description.strip() - emoji_emotions = [str(item).strip() for item in selected_emoji.emotion if str(item).strip()] - structured_result["description"] = emoji_description - structured_result["emotion"] = emoji_emotions - - emoji_manager.update_emoji_usage(selected_emoji) - - try: - emoji_base64 = ImageUtils.image_path_to_base64(str(selected_emoji.full_path)) - if not emoji_base64: - raise ValueError("??????? base64 ??") - except Exception as exc: - logger.error(f"{self._runtime.log_prefix} ??????? base64 ??: {exc}") - structured_result["message"] = f"????????{exc}" - return self._build_tool_failure_result( - tool_call.func_name, - structured_result["message"], - structured_content=structured_result, - ) - - try: - sent = await send_service.emoji_to_stream( - emoji_base64=emoji_base64, - stream_id=self._runtime.session_id, - storage_message=True, - set_reply=False, - reply_message=None, - ) - except Exception as exc: - logger.exception(f"{self._runtime.log_prefix} ??????????: {exc}") - structured_result["message"] = f"???????????{exc}" - return self._build_tool_failure_result( - tool_call.func_name, - structured_result["message"], - structured_content=structured_result, - ) - - if sent: - success_message = ( - f"???????{emoji_description}????{', '.join(emoji_emotions)}?" - if emoji_emotions - else f"???????{emoji_description}" - ) - logger.info( - f"{self._runtime.log_prefix} ???????: " - f"??={selected_emoji.description!r} ????={selected_emoji.emotion}" - ) - self._append_sent_emoji_to_chat_history( - emoji_base64=emoji_base64, - success_message=success_message, - ) - structured_result["success"] = True - structured_result["message"] = success_message - return self._build_tool_success_result( - tool_call.func_name, - success_message, - structured_content=structured_result, - ) - - logger.warning(f"{self._runtime.log_prefix} ???????") - structured_result["message"] = "????????" - return self._build_tool_failure_result( - tool_call.func_name, - structured_result["message"], - structured_content=structured_result, - ) - - def _append_sent_emoji_to_chat_history( - self, - *, - emoji_base64: str, - success_message: str, - ) -> None: - """? bot ?????????????? Maisaka ?????""" - bot_name = global_config.bot.nickname.strip() or "MaiSaka" - reply_timestamp = datetime.now() - planner_prefix = ( - f"[??]{reply_timestamp.strftime('%H:%M:%S')}\n" - f"[??]{bot_name}\n" - "[?????]\n" - "[msg_id]\n" - "[????]" - ) - history_message = SessionBackedMessage( - raw_message=MessageSequence( - [ - TextComponent(planner_prefix), - EmojiComponent( - binary_hash="", - content=success_message, - binary_data=b64decode(emoji_base64), - ), - ] - ), - visible_text=format_speaker_content( - bot_name, - "[???]", - reply_timestamp, - ), - timestamp=reply_timestamp, - source_kind="guided_reply", - ) - self._runtime._chat_history.append(history_message) diff --git a/src/maisaka/tool_provider.py b/src/maisaka/tool_provider.py index 273fd4bd..70a9e1dc 100644 --- a/src/maisaka/tool_provider.py +++ b/src/maisaka/tool_provider.py @@ -7,7 +7,7 @@ from typing import Dict, Optional from src.core.tooling import ToolExecutionContext, ToolExecutionResult, ToolInvocation, ToolProvider, ToolSpec -from .builtin_tools import get_builtin_tool_specs +from .builtin_tool import get_builtin_tool_specs BuiltinToolHandler = Callable[[ToolInvocation, Optional[ToolExecutionContext]], Awaitable[ToolExecutionResult]] diff --git a/src/webui/routers/config.py b/src/webui/routers/config.py index 5a60b84c..bf9e5bac 100644 --- a/src/webui/routers/config.py +++ b/src/webui/routers/config.py @@ -24,10 +24,8 @@ from src.config.official_configs import ( ChineseTypoConfig, DebugConfig, EmojiConfig, - ExperimentalConfig, ExpressionConfig, KeywordReactionConfig, - LPMMKnowledgeConfig, MaimMessageConfig, MemoryConfig, MessageReceiveConfig, @@ -109,9 +107,7 @@ async def get_config_section_schema(section_name: str): - response_post_process: ResponsePostProcessConfig - response_splitter: ResponseSplitterConfig - telemetry: TelemetryConfig - - experimental: ExperimentalConfig - maim_message: MaimMessageConfig - - lpmm_knowledge: LPMMKnowledgeConfig - memory: MemoryConfig - debug: DebugConfig - voice: VoiceConfig @@ -133,9 +129,7 @@ async def get_config_section_schema(section_name: str): "response_post_process": ResponsePostProcessConfig, "response_splitter": ResponseSplitterConfig, "telemetry": TelemetryConfig, - "experimental": ExperimentalConfig, "maim_message": MaimMessageConfig, - "lpmm_knowledge": LPMMKnowledgeConfig, "memory": MemoryConfig, "debug": DebugConfig, "voice": VoiceConfig,