From b9e6caadc6454797f98a9d9fb8306424cd09c834 Mon Sep 17 00:00:00 2001 From: tt-P607 <68868379+tt-P607@users.noreply.github.com> Date: Sat, 25 Oct 2025 03:00:48 +0800 Subject: [PATCH 01/11] =?UTF-8?q?feat(tts):=20=E9=87=8D=E6=9E=84TTS=20Acti?= =?UTF-8?q?on=EF=BC=8C=E5=AE=9E=E7=8E=B0LLM=E5=AF=B9=E8=AF=AD=E9=9F=B3?= =?UTF-8?q?=E9=A3=8E=E6=A0=BC=E5=92=8C=E8=AF=AD=E8=A8=80=E7=9A=84=E7=B2=BE?= =?UTF-8?q?=E7=A1=AE=E6=8E=A7=E5=88=B6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 本次更新对TTS插件进行了重大重构，旨在赋予规划模型（LLM）对语音合成过程更直接、更精确的控制能力，从而显著提升语音输出的质量、灵活性和响应速度。 主要变更包括： 1. **LLM直控模式**: - 移除了原有的“主模型重写文本”步骤，TTS Action现在直接使用规划器在 `text` 参数中提供的最终文本进行合成。 - **原因**: 减少了不必要的API调用和处理延迟，同时确保LLM的意图能够被无损地传达到语音生成环节。 2. **增强的参数化**: - Action新增了 `voice_style` 和 `text_language` 参数，允许LLM根据对话上下文动态选择最合适的语音风格和语言模式。 - **原因**: 使语音能够更好地匹配情感和场景，并解决了以往自动语言检测在多语言混合场景下（如中日、中粤）可能出错的问题。 3. **动态风格加载**: - 可用的语音风格列表不再硬编码，而是从插件的 `config.toml` 配置文件中动态读取。 - **原因**: 极大地增强了插件的可配置性和可维护性，用户可以轻松地通过修改配置文件来添加或调整语音风格。 4. **优化的语言决策**: - 在 `TTSService` 中实现了更智能的语言选择逻辑，其优先级为：LLM直接指定 > 风格配置默认 > 内容自动检测。 - **原因**: 提供了多层次的控制，确保在各种情况下都能选择最优的语言模式进行合成。 5. **提示词强化**: - 更新了Action的描述和规则，特别是增加了对标点符号使用的“铁则”，以引导LLM生成更规范、更适合语音合成的文本。 - **原因**: 从源头上提升输入文本的质量，以确保语音停顿自然，避免合成失败。 --- .../tts_voice_plugin/actions/tts_action.py | 131 ++++++++++++------ .../tts_voice_plugin/services/tts_service.py | 53 +++++-- 2 files changed, 129 insertions(+), 55 deletions(-) diff --git a/src/plugins/built_in/tts_voice_plugin/actions/tts_action.py b/src/plugins/built_in/tts_voice_plugin/actions/tts_action.py index 9ea6a87f3..795891c02 100644 --- a/src/plugins/built_in/tts_voice_plugin/actions/tts_action.py +++ b/src/plugins/built_in/tts_voice_plugin/actions/tts_action.py @@ -2,8 +2,10 @@ TTS 语音合成 Action """ +import toml +from pathlib import Path + from src.common.logger import get_logger -from src.plugin_system.apis import generator_api from src.plugin_system.base.base_action import ActionActivationType, BaseAction, ChatMode from ..services.manager import get_service @@ -11,24 +13,96 @@ from ..services.manager import get_service logger = get_logger("tts_voice_plugin.action") +def _get_available_styles() -> list[str]: + """动态读取配置文件，获取所有可用的TTS风格名称""" + try: + # 这个路径构建逻辑是为了确保无论从哪里启动，都能准确定位到配置文件 + plugin_file = Path(__file__).resolve() + # Bot/src/plugins/built_in/tts_voice_plugin/actions -> Bot + bot_root = plugin_file.parent.parent.parent.parent.parent.parent + config_file = bot_root / "config" / "plugins" / "tts_voice_plugin" / "config.toml" + + if not config_file.is_file(): + logger.warning("在 tts_action 中未找到 tts_voice_plugin 的配置文件，无法动态加载风格列表。") + return ["default"] + + config = toml.loads(config_file.read_text(encoding="utf-8")) + + styles_config = config.get("tts_styles", []) + if not isinstance(styles_config, list): + return ["default"] + + # 使用显式循环和类型检查来提取 style_name，以确保 Pylance 类型检查通过 + style_names: list[str] = [] + for style in styles_config: + if isinstance(style, dict): + name = style.get("style_name") + # 确保 name 是一个非空字符串 + if isinstance(name, str) and name: + style_names.append(name) + + return style_names if style_names else ["default"] + except Exception as e: + logger.error(f"动态加载TTS风格列表时出错: {e}", exc_info=True) + return ["default"] # 出现任何错误都回退 + + +# 在类定义之前执行函数，获取风格列表 +AVAILABLE_STYLES = _get_available_styles() +STYLE_OPTIONS_DESC = ", ".join(f"'{s}'" for s in AVAILABLE_STYLES) + + class TTSVoiceAction(BaseAction): """ 通过关键词或规划器自动触发 TTS 语音合成 """ action_name = "tts_voice_action" - action_description = "使用GPT-SoVITS将文本转换为语音并发送" + action_description = "将你生成好的文本转换为语音并发送。你必须提供要转换的文本。" mode_enable = ChatMode.ALL parallel_action = False + action_parameters = { + "text": { + "type": "string", + "description": "需要转换为语音并发送的完整、自然、适合口语的文本内容。", + "required": True + }, + "voice_style": { + "type": "string", + "description": f"语音的风格。可用选项: [{STYLE_OPTIONS_DESC}]。请根据对话的情感和上下文选择一个最合适的风格。如果未提供，将使用默认风格。", + "required": False + }, + "text_language": { + "type": "string", + "description": ( + "指定用于合成的语言模式，请务必根据文本内容选择最精确、范围最小的选项以获得最佳效果。" + "可用选项说明：\n" + "- 'zh': 中文与英文混合 (最优选)\n" + "- 'ja': 日文与英文混合 (最优选)\n" + "- 'yue': 粤语与英文混合 (最优选)\n" + "- 'ko': 韩文与英文混合 (最优选)\n" + "- 'en': 纯英文\n" + "- 'all_zh': 纯中文\n" + "- 'all_ja': 纯日文\n" + "- 'all_yue': 纯粤语\n" + "- 'all_ko': 纯韩文\n" + "- 'auto': 多语种混合自动识别 (备用选项，当前两种语言时优先使用上面的精确选项)\n" + "- 'auto_yue': 多语种混合自动识别（包含粤语）(备用选项)" + ), + "required": False + } + } + action_require = [ + "在调用此动作时，你必须在 'text' 参数中提供要合成语音的完整回复内容。这是强制性的。", "当用户明确请求使用语音进行回复时，例如‘发个语音听听’、‘用语音说’等。", "当对话内容适合用语音表达，例如讲故事、念诗、撒嬌或进行角色扮演时。", "在表达特殊情感（如安慰、鼓励、庆祝）的场景下，可以主动使用语音来增强感染力。", "不要在日常的、简短的问答或闲聊中频繁使用语音，避免打扰用户。", - "文本内容必须是纯粹的对话，不能包含任何括号或方括号括起来的动作、表情、或场景描述（例如，不要出现 '(笑)' 或 '[歪头]'）", - "必须使用标准、完整的标点符号（如逗号、句号、问号）来进行自然的断句，以确保语音停顿自然，避免生成一长串没有停顿的文本。" + "提供的 'text' 内容必须是纯粹的对话，不能包含任何括号或方括号括起来的动作、表情、或场景描述（例如，不要出现 '(笑)' 或 '[歪头]'）", + "【**铁则**】为了确保语音停顿自然，'text' 参数中的所有断句【必须】使用且仅能使用以下标准标点符号：'，'、'。'、'？'、'！'。严禁使用 '～'、'...' 或其他任何非标准符号来分隔句子，否则将导致语音合成失败。" ] def __init__(self, *args, **kwargs): @@ -80,16 +154,23 @@ class TTSVoiceAction(BaseAction): initial_text = self.action_data.get("text", "").strip() voice_style = self.action_data.get("voice_style", "default") - logger.info(f"{self.log_prefix} 接收到规划器的初步文本: '{initial_text[:70]}...'") + # 新增：从决策模型获取指定的语言模式 + text_language = self.action_data.get("text_language") # 如果模型没给，就是 None + logger.info(f"{self.log_prefix} 接收到规划器初步文本: '{initial_text[:70]}...', 指定风格: {voice_style}, 指定语言: {text_language}") - # 1. 请求主回复模型生成高质量文本 - text = await self._generate_final_text(initial_text) + # 1. 使用规划器提供的文本 + text = initial_text if not text: - logger.warning(f"{self.log_prefix} 最终生成的文本为空，静默处理。") - return False, "最终生成的文本为空" + logger.warning(f"{self.log_prefix} 规划器提供的文本为空，静默处理。") + return False, "规划器提供的文本为空" # 2. 调用 TTSService 生成语音 - audio_b64 = await self.tts_service.generate_voice(text, voice_style) + logger.info(f"{self.log_prefix} 使用最终文本进行语音合成: '{text[:70]}...'") + audio_b64 = await self.tts_service.generate_voice( + text=text, + style_hint=voice_style, + language_hint=text_language # 新增：将决策模型指定的语言传递给服务 + ) if audio_b64: await self.send_custom(message_type="voice", content=audio_b64) @@ -115,33 +196,3 @@ class TTSVoiceAction(BaseAction): ) return False, f"语音合成出错: {e!s}" - async def _generate_final_text(self, initial_text: str) -> str: - """请求主回复模型生成或优化文本""" - try: - generation_reason = ( - "这是一个为语音消息（TTS）生成文本的特殊任务。" - "请基于规划器提供的初步文本，结合对话历史和自己的人设，将它优化成一句自然、富有感情、适合用语音说出的话。" - "最终指令：请务-必确保文本听起来像真实的、自然的口语对话，而不是书面语。" - ) - - logger.info(f"{self.log_prefix} 请求主回复模型(replyer)全新生成TTS文本...") - success, response_set, _ = await generator_api.rewrite_reply( - chat_stream=self.chat_stream, - reply_data={"raw_reply": initial_text, "reason": generation_reason}, - request_type="replyer" - ) - - if success and response_set: - text = "".join(str(seg[1]) if isinstance(seg, tuple) else str(seg) for seg in response_set).strip() - logger.info(f"{self.log_prefix} 成功生成高质量TTS文本: {text}") - return text - - if initial_text: - logger.warning(f"{self.log_prefix} 主模型生成失败，使用规划器原始文本作为兜底。") - return initial_text - - raise Exception("主模型未能生成回复，且规划器也未提供兜底文本。") - - except Exception as e: - logger.error(f"{self.log_prefix} 生成高质量回复内容时失败: {e}", exc_info=True) - return "" diff --git a/src/plugins/built_in/tts_voice_plugin/services/tts_service.py b/src/plugins/built_in/tts_voice_plugin/services/tts_service.py index c00eb31dd..d11dbd925 100644 --- a/src/plugins/built_in/tts_voice_plugin/services/tts_service.py +++ b/src/plugins/built_in/tts_voice_plugin/services/tts_service.py @@ -80,21 +80,34 @@ class TTSService: "prompt_language": style_cfg.get("prompt_language", "zh"), "gpt_weights": style_cfg.get("gpt_weights", default_gpt_weights), "sovits_weights": style_cfg.get("sovits_weights", default_sovits_weights), - "speed_factor": style_cfg.get("speed_factor"), # 读取独立的语速配置 + "speed_factor": style_cfg.get("speed_factor"), + "text_language": style_cfg.get("text_language", "auto"), # 新增：读取文本语言模式 } return styles - # ... [其他方法保持不变] ... - def _detect_language(self, text: str) -> str: - chinese_chars = len(re.findall(r"[\u4e00-\u9fff]", text)) - english_chars = len(re.findall(r"[a-zA-Z]", text)) + def _determine_final_language(self, text: str, mode: str) -> str: + """根据配置的语言策略和文本内容，决定最终发送给API的语言代码""" + # 如果策略是具体的语言（如 all_zh, ja），直接使用 + if mode not in ["auto", "auto_yue"]: + return mode + + # 对于 auto 和 auto_yue 策略，进行内容检测 + # 优先检测粤语 + if mode == "auto_yue": + cantonese_keywords = ["嘅", "喺", "咗", "唔", "係", "啲", "咩", "乜", "喂"] + if any(keyword in text for keyword in cantonese_keywords): + logger.info("在 auto_yue 模式下检测到粤语关键词，最终语言: yue") + return "yue" + + # 检测日语（简单启发式规则） japanese_chars = len(re.findall(r"[\u3040-\u309f\u30a0-\u30ff]", text)) - total_chars = chinese_chars + english_chars + japanese_chars - if total_chars == 0: return "zh" - if chinese_chars / total_chars > 0.3: return "zh" - elif japanese_chars / total_chars > 0.3: return "ja" - elif english_chars / total_chars > 0.8: return "en" - else: return "zh" + if japanese_chars > 5 and japanese_chars > len(re.findall(r"[\u4e00-\u9fff]", text)) * 0.5: + logger.info("检测到日语字符，最终语言: ja") + return "ja" + + # 默认回退到中文 + logger.info(f"在 {mode} 模式下未检测到特定语言，默认回退到: zh") + return "zh" def _clean_text_for_tts(self, text: str) -> str: # 1. 基本清理 @@ -259,7 +272,7 @@ class TTSService: logger.error(f"应用空间效果时出错: {e}", exc_info=True) return audio_data # 如果出错，返回原始音频 - async def generate_voice(self, text: str, style_hint: str = "default") -> str | None: + async def generate_voice(self, text: str, style_hint: str = "default", language_hint: str | None = None) -> str | None: self._load_config() if not self.tts_styles: @@ -282,11 +295,21 @@ class TTSService: clean_text = self._clean_text_for_tts(text) if not clean_text: return None - text_language = self._detect_language(clean_text) - logger.info(f"开始TTS语音合成，文本：{clean_text[:50]}..., 风格：{style}") + # 语言决策流程： + # 1. 优先使用决策模型直接指定的 language_hint (最高优先级) + if language_hint: + final_language = language_hint + logger.info(f"使用决策模型指定的语言: {final_language}") + else: + # 2. 如果模型未指定，则使用风格配置的 language_policy + language_policy = server_config.get("text_language", "auto") + final_language = self._determine_final_language(clean_text, language_policy) + logger.info(f"决策模型未指定语言，使用策略 '{language_policy}' -> 最终语言: {final_language}") + + logger.info(f"开始TTS语音合成，文本：{clean_text[:50]}..., 风格：{style}, 最终语言: {final_language}") audio_data = await self._call_tts_api( - server_config=server_config, text=clean_text, text_language=text_language, + server_config=server_config, text=clean_text, text_language=final_language, refer_wav_path=server_config.get("refer_wav_path"), prompt_text=server_config.get("prompt_text"), prompt_language=server_config.get("prompt_language"), From b72090f0242233624715c2d3b5358e9e95a52045 Mon Sep 17 00:00:00 2001 From: tt-P607 <68868379+tt-P607@users.noreply.github.com> Date: Sat, 25 Oct 2025 03:29:14 +0800 Subject: [PATCH 02/11] =?UTF-8?q?fix(chat):=20=E4=BF=AE=E5=A4=8D=E5=8A=A8?= =?UTF-8?q?=E4=BD=9C=E6=89=A7=E8=A1=8C=E5=BC=82=E5=B8=B8=E6=97=B6=20is=5Fr?= =?UTF-8?q?eplying=20=E7=8A=B6=E6=80=81=E6=9C=AA=E9=87=8D=E7=BD=AE?= =?UTF-8?q?=E7=9A=84=E9=97=AE=E9=A2=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 在 `execute_action` 方法中引入 `try...finally` 结构，以确保无论动作执行成功与否，`is_replying` 状态最终都能被可靠地重置为 `False`。 此更改解决了在动作执行期间发生意外错误时，聊天流可能被永久锁定在“正在回复”状态的问题，从而提高了系统的健壮性。 --- src/chat/planner_actions/action_manager.py | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/src/chat/planner_actions/action_manager.py b/src/chat/planner_actions/action_manager.py index e7ff21ad4..90d2b265e 100644 --- a/src/chat/planner_actions/action_manager.py +++ b/src/chat/planner_actions/action_manager.py @@ -165,6 +165,7 @@ class ChatterActionManager: 执行结果 """ + chat_stream = None try: logger.debug(f"🎯 [ActionManager] execute_action接收到 target_message: {target_message}") # 通过chat_id获取chat_stream @@ -180,6 +181,9 @@ class ChatterActionManager: "error": "chat_stream not found", } + # 设置正在回复的状态 + chat_stream.context_manager.context.is_replying = True + if action_name == "no_action": return {"action_type": "no_action", "success": True, "reply_text": "", "command": ""} @@ -205,7 +209,7 @@ class ChatterActionManager: action_build_into_prompt=False, action_prompt_display=reason, action_done=True, - thinking_id=thinking_id, + thinking_id=thinking_id or "", action_data={"reason": reason}, action_name="no_reply", ) @@ -298,6 +302,10 @@ class ChatterActionManager: "loop_info": None, "error": str(e), } + finally: + # 确保重置正在回复的状态 + if chat_stream: + chat_stream.context_manager.context.is_replying = False async def _record_action_to_message(self, chat_stream, action_name, target_message, action_data): """ From cbad858026db4b108983a6984794a7c683f43542 Mon Sep 17 00:00:00 2001 From: minecraft1024a Date: Sat, 25 Oct 2025 09:30:20 +0800 Subject: [PATCH 03/11] =?UTF-8?q?refactor(proactive=5Fthinker):=20?= =?UTF-8?q?=E5=B0=86=E6=8F=90=E7=A4=BA=E8=AF=8D=E6=9E=84=E5=BB=BA=E9=80=BB?= =?UTF-8?q?=E8=BE=91=E8=BF=81=E7=A7=BB=E8=87=B3=E7=8B=AC=E7=AB=8B=E7=9A=84?= =?UTF-8?q?prompt=E6=A8=A1=E5=9D=97?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 将 `ProactiveThinkerExecutor` 中用于构建决策（decision）和计划（plan）的提示词字符串的逻辑，提取并重构到新的 `prompts.py` 模块中。 这一重构旨在： - **提升可维护性**：将复杂的提示词模板与核心业务逻辑分离，使代码结构更清晰。 - **简化代码**：`proactive_thinker_executor.py` 的代码量大幅减少，职责更加单一，专注于执行流程。 - **便于管理**：集中管理所有相关的提示词模板，方便未来进行统一的调整和优化。 --- .../proactive_thinker_executor.py | 382 ++++-------------- .../built_in/proactive_thinker/prompts.py | 97 +++++ 2 files changed, 184 insertions(+), 295 deletions(-) create mode 100644 src/plugins/built_in/proactive_thinker/prompts.py diff --git a/src/plugins/built_in/proactive_thinker/proactive_thinker_executor.py b/src/plugins/built_in/proactive_thinker/proactive_thinker_executor.py index 3f5257790..bc7bd374e 100644 --- a/src/plugins/built_in/proactive_thinker/proactive_thinker_executor.py +++ b/src/plugins/built_in/proactive_thinker/proactive_thinker_executor.py @@ -9,6 +9,7 @@ from src.chat.utils.prompt import Prompt from src.common.logger import get_logger from src.config.config import global_config, model_config from src.mood.mood_manager import mood_manager +from .prompts import DECISION_PROMPT, PLAN_PROMPT from src.person_info.person_info import get_person_info_manager from src.plugin_system.apis import ( chat_api, @@ -80,7 +81,51 @@ class ProactiveThinkerExecutor: ) logger.info(f"决策结果为：回复。话题: {topic}") - plan_prompt = self._build_plan_prompt(context, start_mode, topic, reason) + # 根据聊天类型构建特定上下文 + if context["chat_type"] == "private": + user_info = context["user_info"] + relationship = context["relationship"] + target_user_or_group = f"你的朋友 '{user_info.user_nickname}'" + context_specific_block = f""" +1. **你的日程**: +{context["schedule_context"]} +2. **你和Ta的关系**: + - 详细印象: {relationship["impression"]} + - 好感度: {relationship["attitude"]}/100 +3. **最近的聊天摘要**: +{context["recent_chat_history"]} +4. **你最近的相关动作**: +{context["action_history_context"]} +""" + else: # group + group_info = context["group_info"] + target_user_or_group = f"群聊 '{group_info['group_name']}'" + context_specific_block = f""" +1. **你的日程**: +{context["schedule_context"]} +2. **群聊信息**: + - 群名称: {group_info["group_name"]} +3. **最近的聊天摘要**: +{context["recent_chat_history"]} +4. **你最近的相关动作**: +{context["action_history_context"]} +""" + + plan_prompt = PLAN_PROMPT.format( + bot_nickname=global_config.bot.nickname, + persona_core=context["persona"]["core"], + persona_side=context["persona"]["side"], + identity=context["persona"]["identity"], + current_time=context["current_time"], + target_user_or_group=target_user_or_group, + reason=reason, + topic=topic, + context_specific_block=context_specific_block, + mood_state=context["mood_state"], + ) + + if global_config.debug.show_prompt: + logger.info(f"主动思考回复器原始提示词:{plan_prompt}") is_success, response, _, _ = await llm_api.generate_with_model( prompt=plan_prompt, model_config=model_config.model_task_config.replyer @@ -222,150 +267,54 @@ class ProactiveThinkerExecutor: logger.warning(f"Stream {stream_id} 既没有 group_info 也没有 user_info") return None - def _build_decision_prompt(self, context: dict[str, Any], start_mode: str) -> str: - """ - 根据收集到的上下文信息，构建用于决策的提示词。 - - Args: - context: 包含所有上下文信息的字典。 - start_mode: 启动模式 ('cold_start' 或 'wake_up')。 - - Returns: - 构建完成的决策提示词字符串。 - """ - chat_type = context["chat_type"] - persona = context["persona"] - - # 构建通用头部 - prompt = f""" -# 角色 -你的名字是{global_config.bot.nickname}，你的人设如下： -- 核心人设: {persona["core"]} -- 侧面人设: {persona["side"]} -- 身份: {persona["identity"]} - -你的当前情绪状态是: {context["mood_state"]} - -# 你最近的相关决策历史 (供参考) -{context["action_history_context"]} -""" - # 根据聊天类型构建任务和情境 - if chat_type == "private": - user_info = context["user_info"] - relationship = context["relationship"] - prompt += f""" -# 任务 -现在是 {context["current_time"]}，你需要根据当前的情境，决定是否要主动向用户 '{user_info.user_nickname}' 发起对话。 - -# 情境分析 -1. **启动模式**: {start_mode} ({"初次见面/很久未见" if start_mode == "cold_start" else "日常唤醒"}) -2. **你的日程**: -{context["schedule_context"]} -3. **你和Ta的关系**: - - 简短印象: {relationship["short_impression"]} - - 详细印象: {relationship["impression"]} - - 好感度: {relationship["attitude"]}/100 -4. **和Ta在别处的讨论摘要**: -{context["cross_context_block"]} -5. **最近的聊天摘要**: -{context["recent_chat_history"]} -""" - elif chat_type == "group": - group_info = context["group_info"] - prompt += f""" -# 任务 -现在是 {context["current_time"]}，你需要根据当前的情境，决定是否要主动向群聊 '{group_info["group_name"]}' 发起对话。 - -# 情境分析 -1. **启动模式**: {start_mode} ({"首次加入/很久未发言" if start_mode == "cold_start" else "日常唤醒"}) -2. **你的日程**: -{context["schedule_context"]} -3. **群聊信息**: - - 群名称: {group_info["group_name"]} -4. **最近的聊天摘要**: -{context["recent_chat_history"]} -""" - # 构建通用尾部 - prompt += """ -# 决策目标 -你的最终目标是根据你的角色和当前情境，做出一个最符合人类社交直觉的决策，以求： -- **(私聊)深化关系**: 通过展现你的关心、记忆和个性来拉近与对方的距离。 -- **(群聊)活跃气氛**: 提出能引起大家兴趣的话题，促进群聊的互动。 -- **提供价值**: 你的出现应该是有意义的，无论是情感上的温暖，还是信息上的帮助。 -- **保持自然**: 避免任何看起来像机器人或骚扰的行为。 - -# 决策指令 -请综合以上所有信息，以稳定、真实、拟人的方式做出决策。你的决策需要以JSON格式输出，包含以下字段： -- `should_reply`: bool, 是否应该发起对话。 -- `topic`: str, 如果 `should_reply` 为 true，你打算聊什么话题？ -- `reason`: str, 做出此决策的简要理由，需体现你对上述目标的考量。 - -# 决策流程与核心原则 -1. **检查对话状态**: - - **最后发言者**: 查看【最近的聊天摘要】。如果最后一条消息是你发的，且对方尚未回复，**通常应选择不回复**。这是最重要的原则，以避免打扰。 - - **例外**: 只有在等待时间足够长（例如超过数小时），或者你有非常重要且有时效性的新话题（例如，“你昨晚说的那个电影我刚看了！”）时，才考虑再次发言。 - - **无人发言**: 如果最近的聊天记录里只有你一个人在说话，**绝对不要回复**，以防刷屏。 - -2. **寻找话题切入点 (如果可以回复)**: - - **强关联优先**: 优先从【情境分析】中寻找最自然、最相关的话题。顺序建议：`最近的聊天摘要` > `你和Ta的关系` > `你的日程`。一个好的话题往往是对最近对话的延续。 - - **展现个性**: 结合你的【人设】和【情绪】，思考你会如何看待这些情境信息，并从中找到话题。例如，如果你是一个活泼的人，看到对方日程很满，可以说：“看你今天日程满满，真是活力四射的一天呀！” - - **备选方案**: 如果实在没有强关联的话题，可以发起一个简单的日常问候，如“在吗？”或“下午好”。 - -3. **最终决策**: - - **权衡频率**: 查看【你最近的相关决策历史】。如果你在短时间内已经主动发起过多次对话，即使现在有话题，也应倾向于**不回复**，保持一定的社交距离。 - - **质量胜于数量**: 宁可错过一次普通的互动机会，也不要进行一次尴尬或生硬的对话。 - - ---- -示例1 (基于上下文): -{{ - "should_reply": true, - "topic": "关心一下Ta昨天提到的那个项目进展如何了", - "reason": "用户昨天在聊天中提到了一个重要的项目，现在主动关心一下进展，会显得很体贴，也能自然地开启对话。" -}} - -示例2 (简单问候): -{{ - "should_reply": true, - "topic": "打个招呼，问问Ta现在在忙些什么", - "reason": "最近没有聊天记录，日程也很常规，没有特别的切入点。一个简单的日常问候是最安全和自然的方式来重新连接。" -}} - -示例3 (不应回复 - 过于频繁): -{{ - "should_reply": false, - "topic": null, - "reason": "虽然群里很活跃，但现在是深夜，而且最近的聊天话题我也不熟悉，没有合适的理由去打扰大家。" -}} - -示例4 (不应回复 - 等待回应): -{{ - "should_reply": false, - "topic": null, - "reason": "我注意到上一条消息是我几分钟前主动发送的，对方可能正在忙。为了表现出耐心和体贴，我现在最好保持安静，等待对方的回应。" -}} ---- - -请输出你的决策: -""" - return prompt - async def _make_decision(self, context: dict[str, Any], start_mode: str) -> dict[str, Any] | None: """ 调用 LLM 进行决策，判断是否应该主动发起对话，以及聊什么话题。 - - Args: - context: 包含所有上下文信息的字典。 - start_mode: 启动模式。 - - Returns: - 一个包含决策结果的字典 (例如: {"should_reply": bool, "topic": str, "reason": str})， - 如果决策过程失败则返回 None 或包含错误信息的字典。 """ if context["chat_type"] not in ["private", "group"]: return {"should_reply": False, "reason": "未知的聊天类型"} - prompt = self._build_decision_prompt(context, start_mode) + # 根据聊天类型构建特定上下文 + if context["chat_type"] == "private": + user_info = context["user_info"] + relationship = context["relationship"] + target_user_or_group = f"用户 '{user_info.user_nickname}'" + context_specific_block = f""" + 1. **启动模式**: {start_mode} ({"初次见面/很久未见" if start_mode == "cold_start" else "日常唤醒"}) + 2. **你的日程**: + {context["schedule_context"]} + 3. **你和Ta的关系**: + - 简短印象: {relationship["short_impression"]} + - 详细印象: {relationship["impression"]} + - 好感度: {relationship["attitude"]}/100 + 4. **和Ta在别处的讨论摘要**: + {context["cross_context_block"]} + 5. **最近的聊天摘要**: + {context["recent_chat_history"]} + """ + else: # group + group_info = context["group_info"] + target_user_or_group = f"群聊 '{group_info['group_name']}'" + context_specific_block = f""" + 1. **启动模式**: {start_mode} ({"首次加入/很久未发言" if start_mode == "cold_start" else "日常唤醒"}) + 2. **你的日程**: + {context["schedule_context"]} + 3. **群聊信息**: + - 群名称: {group_info["group_name"]} + 4. **最近的聊天摘要**: + {context["recent_chat_history"]} + """ + prompt = DECISION_PROMPT.format( + bot_nickname=global_config.bot.nickname, + persona_core=context["persona"]["core"], + persona_side=context["persona"]["side"], + identity=context["persona"]["identity"], + mood_state=context["mood_state"], + action_history_context=context["action_history_context"], + current_time=context["current_time"], + target_user_or_group=target_user_or_group, + context_specific_block=context_specific_block, + ) if global_config.debug.show_prompt: logger.info(f"主动思考决策器原始提示词:{prompt}") @@ -385,160 +334,3 @@ class ProactiveThinkerExecutor: except orjson.JSONDecodeError: logger.error(f"决策LLM返回的JSON格式无效: {response}") return {"should_reply": False, "reason": "决策模型返回格式错误"} - - def _build_private_plan_prompt(self, context: dict[str, Any], start_mode: str, topic: str, reason: str) -> str: - """ - 为私聊场景构建生成对话内容的规划提示词。 - - Args: - context: 上下文信息字典。 - start_mode: 启动模式。 - topic: 决策模块决定的话题。 - reason: 决策模块给出的理由。 - - Returns: - 构建完成的私聊规划提示词字符串。 - """ - user_info = context["user_info"] - relationship = context["relationship"] - if start_mode == "cold_start": - return f""" -# 任务 -你需要主动向一个新朋友 '{user_info.user_nickname}' 发起对话。这是你们的第一次交流，或者很久没聊了。 - -# 决策上下文 -- **决策理由**: {reason} - -# 情境分析 -1. **你的日程**: -{context["schedule_context"]} -2. **你和Ta的关系**: - - 简短印象: {relationship["short_impression"]} - - 详细印象: {relationship["impression"]} - - 好感度: {relationship["attitude"]}/100 -3. **和Ta在别处的讨论摘要**: -{context["cross_context_block"]} -4. **最近的聊天摘要**: -{context["recent_chat_history"]} -5. **你最近的相关动作**: -{context["action_history_context"]} - -# 对话指引 -- 你的目标是“破冰”，让对话自然地开始。 -- 你应该围绕这个话题展开: {topic} -- 你的语气应该符合你的人设和你当前的心情({context["mood_state"]})，友好且真诚。 -""" - else: # wake_up - return f""" -# 任务 -现在是 {context["current_time"]}，你需要主动向你的朋友 '{user_info.user_nickname}' 发起对话。 - -# 决策上下文 -- **决策理由**: {reason} - -# 情境分析 -1. **你的日程**: -{context["schedule_context"]} -2. **你和Ta的关系**: - - 详细印象: {relationship["impression"]} - - 好感度: {relationship["attitude"]}/100 -3. **最近的聊天摘要**: -{context["recent_chat_history"]} -4. **你最近的相关动作**: -{context["action_history_context"]} - -# 对话指引 -- 你决定和Ta聊聊关于“{topic}”的话题。 -- **对话风格**: - - **自然开场**: 你可以根据话题和情境，选择最自然的开场方式。可以直接切入话题（如果话题关联性很强），也可以先用一句简单的问候（如“在吗？”、“下午好”）作为过渡。**不要总是使用同一种开场白**。 - - **融合情境**: 将【情境分析】中的信息（如你的心情、日程、对Ta的印象）巧妙地融入到对话中，让你的话语听起来更真实、更有依据。 - - **符合人设**: 你的语气、用词、甚至表情符号的使用，都应该完全符合你的【角色】设定和当前【情绪】({context["mood_state"]})以及你对Ta的好感度。 -- 请结合以上所有情境信息，自然地开启对话。 -""" - - def _build_group_plan_prompt(self, context: dict[str, Any], topic: str, reason: str) -> str: - """ - 为群聊场景构建生成对话内容的规划提示词。 - - Args: - context: 上下文信息字典。 - topic: 决策模块决定的话题。 - reason: 决策模块给出的理由。 - - Returns: - 构建完成的群聊规划提示词字符串。 - """ - group_info = context["group_info"] - return f""" -# 任务 -现在是 {context["current_time"]}，你需要主动向群聊 '{group_info["group_name"]}' 发起对话。 - -# 决策上下文 -- **决策理由**: {reason} - -# 情境分析 -1. **你的日程**: -你当前的心情({context["mood_state"]} -{context["schedule_context"]} -2. **群聊信息**: - - 群名称: {group_info["group_name"]} -3. **最近的聊天摘要**: -{context["recent_chat_history"]} -4. **你最近的相关动作**: -{context["action_history_context"]} - -# 对话指引 -- 你决定和大家聊聊关于“{topic}”的话题。 -- **对话风格**: - - **自然开场**: 你可以根据话题和情境，选择最自然的开场方式。可以直接切入话题（如果话题关联性很强），也可以先用一句简单的问候（如“哈喽，大家好呀~”、“下午好！”）作为过渡。**不要总是使用同一种开场白**。 - - **融合情境**: 将【情境分析】中的信息（如你的心情、日程）巧妙地融入到对话中，让你的话语听起来更真实、更有依据。 - - **符合人设**: 你的语气、用词、甚至表情符号的使用，都应该完全符合你的【角色】设定和当前【情绪】({context["mood_state"]})。语气应该更活泼、更具包容性，以吸引更多群成员参与讨论。 -- 请结合以上所有情境信息，自然地开启对话。 -- 可以分享你的看法、提出相关问题，或者开个合适的玩笑。 -""" - - def _build_plan_prompt(self, context: dict[str, Any], start_mode: str, topic: str, reason: str) -> str: - """ - 根据聊天类型、启动模式和决策结果，构建最终生成对话内容的规划提示词。 - - Args: - context: 上下文信息字典。 - start_mode: 启动模式。 - topic: 决策模块决定的话题。 - reason: 决策模块给出的理由。 - - Returns: - 最终的规划提示词字符串。 - """ - persona = context["persona"] - chat_type = context["chat_type"] - - # 1. 构建通用角色头部 - prompt = f""" -# 角色 -你的名字是{global_config.bot.nickname}，你的人设如下： -- 核心人设: {persona["core"]} -- 侧面人设: {persona["side"]} -- 身份: {persona["identity"]} -""" - # 2. 根据聊天类型构建特定内容 - if chat_type == "private": - prompt += self._build_private_plan_prompt(context, start_mode, topic, reason) - elif chat_type == "group": - prompt += self._build_group_plan_prompt(context, topic, reason) - - # 3. 添加通用结尾 - final_instructions = """ - -# 输出要求 -- **简洁**: 不要输出任何多余内容（如前缀、后缀、冒号、引号、at/@等）。 -- **原创**: 不要重复之前的内容，即使意思相近也不行。 -- **直接**: 只输出最终的回复文本本身。 -- **风格**: 回复需简短、完整且口语化。 - -现在，你说：""" - prompt += final_instructions - - if global_config.debug.show_prompt: - logger.info(f"主动思考回复器原始提示词:{prompt}") - return prompt diff --git a/src/plugins/built_in/proactive_thinker/prompts.py b/src/plugins/built_in/proactive_thinker/prompts.py new file mode 100644 index 000000000..eff355aad --- /dev/null +++ b/src/plugins/built_in/proactive_thinker/prompts.py @@ -0,0 +1,97 @@ +from src.chat.utils.prompt import Prompt + +# ============================================================================= +# 决策阶段 (Decision Phase) +# ============================================================================= + +DECISION_PROMPT = Prompt( + name="proactive_thinker_decision", + template=""" +# 角色 +你的名字是{bot_nickname}，你的人设如下： +- 核心人设: {persona_core} +- 侧面人设: {persona_side} +- 身份: {identity} + +你的当前情绪状态是: {mood_state} + +# 你最近的相关决策历史 (供参考) +{action_history_context} + +# 任务 +现在是 {current_time}，你需要根据当前的情境，决定是否要主动向{target_user_or_group}发起对话。 + +# 情境分析 +{context_specific_block} + +# 决策目标 +你的最终目标是根据你的角色和当前情境，做出一个最符合人类社交直觉的决策，以求： +- **(私聊)深化关系**: 通过展现你的关心、记忆和个性来拉近与对方的距离。 +- **(群聊)活跃气氛**: 提出能引起大家兴趣的话题，促进群聊的互动。 +- **提供价值**: 你的出现应该是有意义的，无论是情感上的温暖，还是信息上的帮助。 +- **保持自然**: 避免任何看起来像机器人或骚扰的行为。 + +# 决策指令 +请综合以上所有信息，以稳定、真实、拟人的方式做出决策。你的决策需要以JSON格式输出，包含以下字段： +- `should_reply`: bool, 是否应该发起对话。 +- `topic`: str, 如果 `should_reply` 为 true，你打算聊什么话题？ +- `reason`: str, 做出此决策的简要理由，需体现你对上述目标的考量。 + +# 决策流程与核心原则 +1. **检查对话状态**: + - **最后发言者**: 查看【最近的聊天摘要】。如果最后一条消息是你发的，且对方尚未回复，**通常应选择不回复**。这是最重要的原则，以避免打扰。 + - **例外**: 只有在等待时间足够长（例如超过数小时），或者你有非常重要且有时效性的新话题时，才考虑再次发言。 + - **无人发言**: 如果最近的聊天记录里只有你一个人在说话，**绝对不要回复**，以防刷屏。 + +2. **寻找话题切入点 (如果可以回复)**: + - **强关联优先**: 优先从【情境分析】中寻找最自然、最相关的话题。顺序建议：`最近的聊天摘要` > `你和Ta的关系` > `你的日程`。 + - **展现个性**: 结合你的【人设】和【情绪】，思考你会如何看待这些情境信息，并从中找到话题。 + - **备选方案**: 如果实在没有强关联的话题，可以发起一个简单的日常问候。 + +3. **最终决策**: + - **权衡频率**: 查看【你最近的相关决策历史】。如果你在短时间内已经主动发起过多次对话，也应倾向于**不回复**，保持一定的社交距离。 + - **质量胜于数量**: 宁可错过一次普通的互动机会，也不要进行一次尴尬或生硬的对话。 + +--- +请输出你的决策: +""" +) + +# ============================================================================= +# 回复规划阶段 (Plan Phase) +# ============================================================================= + +PLAN_PROMPT = Prompt( + name="proactive_thinker_plan", + template=""" +# 角色 +你的名字是{bot_nickname}，你的人设如下： +- 核心人设: {persona_core} +- 侧面人设: {persona_side} +- 身份: {identity} + +# 任务 +现在是 {current_time}，你需要主动向{target_user_or_group}发起对话。 + +# 决策上下文 +- **决策理由**: {reason} + +# 情境分析 +{context_specific_block} + +# 对话指引 +- 你决定和Ta聊聊关于“{topic}”的话题。 +- **对话风格**: + - **自然开场**: 你可以根据话题和情境，选择最自然的开场方式。可以直接切入话题（如果话题关联性很强），也可以先用一句简单的问候作为过渡。**不要总是使用同一种开场白**。 + - **融合情境**: 将【情境分析】中的信息巧妙地融入到对话中，让你的话语听起来更真实、更有依据。 + - **符合人设**: 你的语气、用词、甚至表情符号的使用，都应该完全符合你的【角色】设定和当前【情绪】({mood_state})。 + +# 输出要求 +- **简洁**: 不要输出任何多余内容（如前缀、后缀、冒号、引号、at/@等）。 +- **原创**: 不要重复之前的内容，即使意思相近也不行。 +- **直接**: 只输出最终的回复文本本身。 +- **风格**: 回复需简短、完整且口语化。 + +现在，你说： +""" +) \ No newline at end of file From 079a9a3fa0cea67a95c34caa8322d24310e232cf Mon Sep 17 00:00:00 2001 From: minecraft1024a Date: Sat, 25 Oct 2025 09:56:14 +0800 Subject: [PATCH 04/11] =?UTF-8?q?refactor(prompt):=20=E7=A7=BB=E9=99=A4=20?= =?UTF-8?q?normal=20=E6=A8=A1=E5=BC=8F=E5=B9=B6=E5=BC=BA=E5=88=B6=E4=BD=BF?= =?UTF-8?q?=E7=94=A8=20s4u=20=E6=A8=A1=E5=BC=8F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 删除了旧的 "normal" prompt 模式及其相关逻辑，包括 prompt 模板、上下文构建函数和配置选项。现在系统将统一并强制使用 "s4u" 模式进行回复生成。 主要变更： - 从 `default_generator.py` 中移除了 `normal_style_prompt` 模板和模式选择逻辑。 - 从 `prompt.py` 中删除了 `_build_normal_chat_context` 和 `_prepare_normal_params` 等相关函数。 - 从 `official_configs.py` 中移除了 `prompt_mode` 配置项。 - 更新了 `bot_config_template.toml` 配置文件，移除了 `prompt_mode` 选项和相关的 normal 模式上下文共享组示例。 此重构简化了 prompt 生成流程，统一了上下文处理方式，减少了代码的复杂性和维护成本。 --- src/chat/replyer/default_generator.py | 63 +-------------------------- src/chat/utils/prompt.py | 46 +------------------ src/config/official_configs.py | 2 - template/bot_config_template.toml | 27 ++---------- 4 files changed, 6 insertions(+), 132 deletions(-) diff --git a/src/chat/replyer/default_generator.py b/src/chat/replyer/default_generator.py index 4d9882bf8..92d64a8c2 100644 --- a/src/chat/replyer/default_generator.py +++ b/src/chat/replyer/default_generator.py @@ -162,62 +162,6 @@ If you need to use the search tool, please directly call the function "lpmm_sear name="lpmm_get_knowledge_prompt", ) - # normal 版 prompt 模板（0.9之前的简化模式） - logger.debug("[Prompt模式调试] 正在注册normal_style_prompt模板") - Prompt( - """ -{chat_scene} - -**重要：消息针对性判断** -在回应之前，首先分析消息的针对性： -1. **直接针对你**：@你、回复你、明确询问你 → 必须回应 -2. **间接相关**：涉及你感兴趣的话题但未直接问你 → 谨慎参与 -3. **他人对话**：与你无关的私人交流 → 通常不参与 -4. **重复内容**：他人已充分回答的问题 → 避免重复 - -{expression_habits_block} -{tool_info_block} -{knowledge_prompt} -{memory_block} -{relation_info_block} -{extra_info_block} - -{notice_block} - -{cross_context_block} -{identity} -如果有人说你是人机，你可以用一种阴阳怪气的口吻来回应 -{schedule_block} - -{action_descriptions} - -下面是群里最近的聊天内容： --------------------------------- -{time_block} -{chat_info} --------------------------------- - -{reply_target_block} - -你现在的心情是：{mood_state} -{config_expression_style} -注意不要复读你前面发过的内容，意思相近也不行。 -{keywords_reaction_prompt} -请注意不要输出多余内容(包括前后缀，冒号和引号，at或 @等 )。只输出回复内容。 -{moderation_prompt} -你的核心任务是针对 {reply_target_block} 中提到的内容，{relation_info_block}生成一段紧密相关且能推动对话的回复。你的回复应该： -1. 明确回应目标消息，而不是宽泛地评论。 -2. 可以分享你的看法、提出相关问题，或者开个合适的玩笑。 -3. 目的是让对话更有趣、更深入。 -最终请输出一条简短、完整且口语化的回复。 - -*你叫{bot_name}，也有人叫你{bot_nickname}* - -现在，你说： -""", - "normal_style_prompt", - ) - logger.debug("[Prompt模式调试] normal_style_prompt模板注册完成") class DefaultReplyer: @@ -1503,9 +1447,6 @@ class DefaultReplyer: else: reply_target_block = "" - # 根据配置选择模板 - current_prompt_mode = global_config.personality.prompt_mode - # 动态生成聊天场景提示 if is_group_chat: chat_scene_prompt = "你正在一个QQ群里聊天，你需要理解整个群的聊天动态和话题走向，并做出自然的回应。" @@ -1524,7 +1465,7 @@ class DefaultReplyer: available_actions=available_actions, enable_tool=enable_tool, chat_target_info=self.chat_target_info, - prompt_mode=current_prompt_mode, + prompt_mode="s4u", message_list_before_now_long=message_list_before_now_long, message_list_before_short=message_list_before_short, chat_talking_prompt_short=chat_talking_prompt_short, @@ -1555,8 +1496,6 @@ class DefaultReplyer: template_name = "" if current_prompt_mode == "s4u": template_name = "s4u_style_prompt" - elif current_prompt_mode == "normal": - template_name = "normal_style_prompt" elif current_prompt_mode == "minimal": template_name = "default_expressor_prompt" diff --git a/src/chat/utils/prompt.py b/src/chat/utils/prompt.py index 3e6dee2f1..b791966d9 100644 --- a/src/chat/utils/prompt.py +++ b/src/chat/utils/prompt.py @@ -396,8 +396,6 @@ class Prompt: # 构建聊天历史 if self.parameters.prompt_mode == "s4u": await self._build_s4u_chat_context(context_data) - else: - await self._build_normal_chat_context(context_data) # 补充基础信息 context_data.update( @@ -440,13 +438,6 @@ class Prompt: context_data["read_history_prompt"] = read_history_prompt context_data["unread_history_prompt"] = unread_history_prompt - async def _build_normal_chat_context(self, context_data: dict[str, Any]) -> None: - """构建normal模式的聊天上下文""" - if not self.parameters.chat_talking_prompt_short: - return - - context_data["chat_info"] = f"""群里的聊天内容： -{self.parameters.chat_talking_prompt_short}""" async def _build_s4u_chat_history_prompts( self, message_list_before_now: list[dict[str, Any]], target_user_id: str, sender: str, chat_id: str @@ -786,8 +777,6 @@ class Prompt: """使用上下文数据格式化模板""" if self.parameters.prompt_mode == "s4u": params = self._prepare_s4u_params(context_data) - elif self.parameters.prompt_mode == "normal": - params = self._prepare_normal_params(context_data) else: params = self._prepare_default_params(context_data) @@ -823,34 +812,6 @@ class Prompt: or "你正在一个QQ群里聊天，你需要理解整个群的聊天动态和话题走向，并做出自然的回应。", } - def _prepare_normal_params(self, context_data: dict[str, Any]) -> dict[str, Any]: - """准备Normal模式的参数""" - return { - **context_data, - "expression_habits_block": context_data.get("expression_habits_block", ""), - "tool_info_block": context_data.get("tool_info_block", ""), - "knowledge_prompt": context_data.get("knowledge_prompt", ""), - "memory_block": context_data.get("memory_block", ""), - "relation_info_block": context_data.get("relation_info_block", ""), - "extra_info_block": self.parameters.extra_info_block or context_data.get("extra_info_block", ""), - "cross_context_block": context_data.get("cross_context_block", ""), - "notice_block": self.parameters.notice_block or context_data.get("notice_block", ""), - "identity": self.parameters.identity_block or context_data.get("identity", ""), - "action_descriptions": self.parameters.action_descriptions or context_data.get("action_descriptions", ""), - "schedule_block": self.parameters.schedule_block or context_data.get("schedule_block", ""), - "time_block": context_data.get("time_block", ""), - "chat_info": context_data.get("chat_info", ""), - "reply_target_block": context_data.get("reply_target_block", ""), - "config_expression_style": global_config.personality.reply_style, - "mood_state": self.parameters.mood_prompt or context_data.get("mood_state", ""), - "keywords_reaction_prompt": self.parameters.keywords_reaction_prompt - or context_data.get("keywords_reaction_prompt", ""), - "moderation_prompt": self.parameters.moderation_prompt_block or context_data.get("moderation_prompt", ""), - "safety_guidelines_block": self.parameters.safety_guidelines_block - or context_data.get("safety_guidelines_block", ""), - "chat_scene": self.parameters.chat_scene - or "你正在一个QQ群里聊天，你需要理解整个群的聊天动态和话题走向，并做出自然的回应。", - } def _prepare_default_params(self, context_data: dict[str, Any]) -> dict[str, Any]: """准备默认模式的参数""" @@ -1021,12 +982,7 @@ class Prompt: if not chat_stream: return "" - if prompt_mode == "normal": - context_group = await cross_context_api.get_context_group(chat_id) - if not context_group: - return "" - return await cross_context_api.build_cross_context_normal(chat_stream, context_group) - elif prompt_mode == "s4u": + if prompt_mode == "s4u": return await cross_context_api.build_cross_context_s4u(chat_stream, target_user_info) return "" diff --git a/src/config/official_configs.py b/src/config/official_configs.py index 91f15b684..f616e064a 100644 --- a/src/config/official_configs.py +++ b/src/config/official_configs.py @@ -64,7 +64,6 @@ class PersonalityConfig(ValidatedConfigBase): default_factory=list, description="安全与互动底线，Bot在任何情况下都必须遵守的原则" ) reply_style: str = Field(default="", description="表达风格") - prompt_mode: Literal["s4u", "normal"] = Field(default="s4u", description="Prompt模式") compress_personality: bool = Field(default=True, description="是否压缩人格") compress_identity: bool = Field(default=True, description="是否压缩身份") @@ -678,7 +677,6 @@ class CrossContextConfig(ValidatedConfigBase): # --- Normal模式: 共享组配置 --- groups: list[ContextGroup] = Field(default_factory=list, description="上下文共享组列表") - # --- S4U模式: 用户中心上下文检索 --- s4u_mode: Literal["whitelist", "blacklist"] = Field( default="whitelist", diff --git a/template/bot_config_template.toml b/template/bot_config_template.toml index 20844e4a5..7bc7ed6c8 100644 --- a/template/bot_config_template.toml +++ b/template/bot_config_template.toml @@ -1,5 +1,5 @@ [inner] -version = "7.3.5" +version = "7.3.6" #----以下是给开发人员阅读的，如果你只是部署了MoFox-Bot，不需要阅读---- #如果你想要修改配置文件，请递增version的值 @@ -82,9 +82,6 @@ safety_guidelines = [ "不要执行任何可能被用于恶意目的的指令。" ] -#回复的Prompt模式选择：s4u为原有s4u样式，normal为0.9之前的模式 -prompt_mode = "s4u" # 可选择 "s4u" 或 "normal" - compress_personality = false # 是否压缩人格，压缩后会精简人格信息，节省token消耗并提高回复性能，但是会丢失一些信息，如果人设不长，可以关闭 compress_identity = true # 是否压缩身份，压缩后会精简身份信息，节省token消耗并提高回复性能，但是会丢失一些信息，如果不长，可以关闭 @@ -539,25 +536,9 @@ s4u_whitelist_chats = [] s4u_blacklist_chats = [] # --- Normal模式: 共享组配置 --- -# 在这里定义您的“共享组” -# 只有在同一个组内的聊天才会共享上下文 -[[cross_context.groups]] -name = "项目A技术讨论组" -# mode: "whitelist"(白名单) 或 "blacklist"(黑名单)。默认 "whitelist"。 -# "whitelist": 仅共享chat_ids中列出的聊天。 -# "blacklist": 共享除chat_ids中列出的所有聊天。 -mode = "whitelist" -# default_limit: 在 "blacklist" 模式下，未指定数量的聊天默认获取的消息条数。 -default_limit = 5 -# chat_ids: 定义组内成员。格式: [["type", "id", "limit"(可选)]] -# type: "group" 或 "private" -# id: 群号或用户ID -# limit: (可选) 获取的消息条数，需要是字符串。 -chat_ids = [ - ["group", "169850076", "10"], # 开发群, 拿10条消息 - ["group", "1025509724", "5"], # 产品群, 拿5条 - ["private", "123456789"] # 某个用户的私聊, 使用默认值5 -] +# 现在这些是预留plugin使用的上下文互通组配置 +# 您可以根据需要添加多个互通组 +# 在回复过程中只会遵循上面的--S4U模式: 用户中心上下文检索-- # --- QQ空间专用互通组 (示例) --- # Maizone插件会根据组名 "Maizone默认互通组" 来获取上下文 From 83602b181ba183f64a3eedae4bc3e984eaf8675f Mon Sep 17 00:00:00 2001 From: minecraft1024a Date: Fri, 24 Oct 2025 21:48:51 +0800 Subject: [PATCH 05/11] =?UTF-8?q?refactor(core):=20=E7=A7=BB=E9=99=A4?= =?UTF-8?q?=E7=9D=A1=E7=9C=A0=E7=B3=BB=E7=BB=9F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 由于睡眠系统存在设计缺陷、实现复杂且维护成本高，并且实际使用效果不佳，常常导致非预期的行为（如错过重要消息或在不应睡眠时睡眠），现决定将其从核心代码中完全移除。 移除内容包括： - 删除了整个 `sleep_system` 模块及其所有相关逻辑、状态管理和定时任务。 - 清理了配置文件 `config.py` 和 `official_configs.py` 中的 `SleepSystemConfig`。 - 移除了 `main.py` 中关于睡眠系统的初始化调用。 - 清理了 `message_manager` 和 `proactive_thinker` 中对睡眠状态的检查。 - 更新了 `bot_config_template.toml` 模板文件，移除了所有睡眠系统相关的配置项。 此举旨在简化项目架构，提高系统的稳定性和可预测性。未来的相关功能可能会以更健壮、更模块化的插件形式重新实现。 --- src/chat/message_manager/message_manager.py | 11 +- .../sleep_system/sleep_logic.py | 195 ------------------ .../sleep_system/state_manager.py | 190 ----------------- .../message_manager/sleep_system/tasks.py | 44 ---- src/config/config.py | 2 - src/config/official_configs.py | 46 ----- src/main.py | 9 - .../proacive_thinker_event.py | 9 - template/bot_config_template.toml | 40 +--- 9 files changed, 2 insertions(+), 544 deletions(-) delete mode 100644 src/chat/message_manager/sleep_system/sleep_logic.py delete mode 100644 src/chat/message_manager/sleep_system/state_manager.py delete mode 100644 src/chat/message_manager/sleep_system/tasks.py diff --git a/src/chat/message_manager/message_manager.py b/src/chat/message_manager/message_manager.py index 037ced970..901594991 100644 --- a/src/chat/message_manager/message_manager.py +++ b/src/chat/message_manager/message_manager.py @@ -19,9 +19,7 @@ from src.config.config import global_config from src.plugin_system.apis.chat_api import get_chat_manager from .distribution_manager import stream_loop_manager -from .sleep_system.state_manager import SleepState, sleep_state_manager -from .global_notice_manager import global_notice_manager, NoticeScope - +from .global_notice_manager import NoticeScope, global_notice_manager if TYPE_CHECKING: pass @@ -149,13 +147,6 @@ class MessageManager: async def add_message(self, stream_id: str, message: DatabaseMessages): """添加消息到指定聊天流""" - # 在消息处理的最前端检查睡眠状态 - current_sleep_state = sleep_state_manager.get_current_state() - if current_sleep_state == SleepState.SLEEPING: - logger.info(f"处于 {current_sleep_state.name} 状态，消息被拦截。") - return # 直接返回，不处理消息 - - # TODO: 在这里为 WOKEN_UP_ANGRY 等未来状态添加特殊处理逻辑 try: # 检查是否为notice消息 diff --git a/src/chat/message_manager/sleep_system/sleep_logic.py b/src/chat/message_manager/sleep_system/sleep_logic.py deleted file mode 100644 index 9ad48092e..000000000 --- a/src/chat/message_manager/sleep_system/sleep_logic.py +++ /dev/null @@ -1,195 +0,0 @@ -import random -from datetime import datetime, timedelta - -from src.common.logger import get_logger -from src.config.config import global_config -from src.schedule.schedule_manager import schedule_manager - -from .state_manager import SleepState, sleep_state_manager - -logger = get_logger("sleep_logic") - - -class SleepLogic: - """ - 核心睡眠逻辑，睡眠系统的“大脑” - - 负责根据当前的配置、时间、日程表以及状态，判断是否需要切换睡眠状态。 - 它本身是无状态的，所有的状态都读取和写入 SleepStateManager。 - """ - - def check_and_update_sleep_state(self): - """ - 检查并更新当前的睡眠状态，这是整个逻辑的入口。 - 由定时任务周期性调用。 - """ - current_state = sleep_state_manager.get_current_state() - now = datetime.now() - - if current_state == SleepState.AWAKE: - self._check_should_fall_asleep(now) - elif current_state == SleepState.SLEEPING: - self._check_should_wake_up(now) - elif current_state == SleepState.INSOMNIA: - # TODO: 实现失眠逻辑 - # 例如：检查失眠状态是否结束，如果结束则转换回 SLEEPING - pass - elif current_state == SleepState.WOKEN_UP_ANGRY: - # TODO: 实现起床气逻辑 - # 例如：检查生气状态是否结束，如果结束则转换回 SLEEPING 或 AWAKE - pass - - def _check_should_fall_asleep(self, now: datetime): - """ - 当状态为 AWAKE 时，检查是否应该进入睡眠。 - """ - should_sleep, wake_up_time = self._should_be_sleeping(now) - if should_sleep: - logger.info("判断结果：应进入睡眠状态。") - sleep_state_manager.set_state(SleepState.SLEEPING, wake_up=wake_up_time) - - def _check_should_wake_up(self, now: datetime): - """ - 当状态为 SLEEPING 时，检查是否应该醒来。 - 这里包含了处理跨天获取日程的核心逻辑。 - """ - wake_up_time = sleep_state_manager.get_wake_up_time() - - # 核心逻辑：两段式检测 - # 如果 state_manager 中还没有起床时间，说明是昨晚入睡，需要等待今天凌晨的新日程。 - sleep_start_time = sleep_state_manager.get_sleep_start_time() - if not wake_up_time: - if sleep_start_time and now.date() > sleep_start_time.date(): - logger.debug("当前为睡眠状态但无起床时间，尝试从新日程中解析...") - _, new_wake_up_time = self._get_wakeup_times_from_schedule(now) - - if new_wake_up_time: - logger.info(f"成功从新日程获取到起床时间: {new_wake_up_time.strftime('%H:%M')}") - sleep_state_manager.set_wake_up_time(new_wake_up_time) - wake_up_time = new_wake_up_time - else: - logger.debug("未能获取到新的起床时间，继续睡眠。") - return - else: - logger.info("还没有到达第二天,继续睡眠。") - logger.info(f"尚未到苏醒时间,苏醒时间在{wake_up_time}") - if wake_up_time and now >= wake_up_time: - logger.info(f"当前时间 {now.strftime('%H:%M')} 已到达或超过预定起床时间 {wake_up_time.strftime('%H:%M')}。") - sleep_state_manager.set_state(SleepState.AWAKE) - - def _should_be_sleeping(self, now: datetime) -> tuple[bool, datetime | None]: - """ - 判断在当前时刻，是否应该处于睡眠时间。 - - Returns: - 元组 (是否应该睡眠, 预期的起床时间或None) - """ - sleep_config = global_config.sleep_system - if not sleep_config.enable: - return False, None - - sleep_time, wake_up_time = None, None - - if sleep_config.sleep_by_schedule: - sleep_time, _ = self._get_sleep_times_from_schedule(now) - if not sleep_time: - logger.debug("日程表模式开启，但未找到睡眠时间，使用固定时间作为备用。") - sleep_time, wake_up_time = self._get_fixed_sleep_times(now) - else: - sleep_time, wake_up_time = self._get_fixed_sleep_times(now) - - if not sleep_time: - return False, None - - # 检查当前时间是否在睡眠时间范围内 - if now >= sleep_time: - # 如果起床时间是第二天（通常情况），且当前时间小于起床时间，则在睡眠范围内 - if wake_up_time and wake_up_time > sleep_time and now < wake_up_time: - return True, wake_up_time - # 如果当前时间大于入睡时间，说明已经进入睡眠窗口 - return True, wake_up_time - - return False, None - - def _get_fixed_sleep_times(self, now: datetime) -> tuple[datetime | None, datetime | None]: - """ - 当使用“固定时间”模式时，从此方法计算睡眠和起床时间。 - 会加入配置中的随机偏移量，让作息更自然。 - """ - sleep_config = global_config.sleep_system - try: - sleep_offset = random.randint( - -sleep_config.sleep_time_offset_minutes, sleep_config.sleep_time_offset_minutes - ) - wake_up_offset = random.randint( - -sleep_config.wake_up_time_offset_minutes, sleep_config.wake_up_time_offset_minutes - ) - - sleep_t = datetime.strptime(sleep_config.fixed_sleep_time, "%H:%M").time() - wake_up_t = datetime.strptime(sleep_config.fixed_wake_up_time, "%H:%M").time() - - sleep_time = datetime.combine(now.date(), sleep_t) + timedelta(minutes=sleep_offset) - - # 如果起床时间比睡觉时间早，说明是第二天 - wake_up_day = now.date() + timedelta(days=1) if wake_up_t < sleep_t else now.date() - wake_up_time = datetime.combine(wake_up_day, wake_up_t) + timedelta(minutes=wake_up_offset) - - return sleep_time, wake_up_time - except (ValueError, TypeError) as e: - logger.error(f"解析固定睡眠时间失败: {e}") - return None, None - - def _get_sleep_times_from_schedule(self, now: datetime) -> tuple[datetime | None, datetime | None]: - """ - 当使用“日程表”模式时，从此方法获取睡眠时间。 - 实现了核心逻辑： - - 解析“今天”日程中的睡觉时间。 - """ - # 阶段一：获取当天的睡觉时间 - today_schedule = schedule_manager.today_schedule - sleep_time = None - if today_schedule: - for event in today_schedule: - activity = event.get("activity", "").lower() - if "sleep" in activity or "睡觉" in activity or "休息" in activity: - try: - time_range = event.get("time_range", "") - start_str, _ = time_range.split("-") - sleep_t = datetime.strptime(start_str.strip(), "%H:%M").time() - sleep_time = datetime.combine(now.date(), sleep_t) - break - except (ValueError, AttributeError): - logger.warning(f"解析日程中的睡眠时间失败: {event}") - continue - wake_up_time = None - - return sleep_time, wake_up_time - - def _get_wakeup_times_from_schedule(self, now: datetime) -> tuple[datetime | None, datetime | None]: - """ - 当使用“日程表”模式时，从此方法获取睡眠时间。 - 实现了核心逻辑： - - 解析“今天”日程中的睡觉时间。 - """ - # 阶段一：获取当天的睡觉时间 - today_schedule = schedule_manager.today_schedule - wake_up_time = None - if today_schedule: - for event in today_schedule: - activity = event.get("activity", "").lower() - if "wake_up" in activity or "醒来" in activity or "起床" in activity: - try: - time_range = event.get("time_range", "") - start_str, _ = time_range.split("-") - sleep_t = datetime.strptime(start_str.strip(), "%H:%M").time() - wake_up_time = datetime.combine(now.date(), sleep_t) - break - except (ValueError, AttributeError): - logger.warning(f"解析日程中的睡眠时间失败: {event}") - continue - - return None, wake_up_time - - -# 全局单例 -sleep_logic = SleepLogic() diff --git a/src/chat/message_manager/sleep_system/state_manager.py b/src/chat/message_manager/sleep_system/state_manager.py deleted file mode 100644 index 870e6ddf1..000000000 --- a/src/chat/message_manager/sleep_system/state_manager.py +++ /dev/null @@ -1,190 +0,0 @@ -import enum -from datetime import datetime, timedelta -from typing import Any - -from src.common.logger import get_logger -from src.manager.local_store_manager import local_storage - -logger = get_logger("sleep_state_manager") - - -class SleepState(enum.Enum): - """ - 定义了所有可能的睡眠状态。 - 使用枚举可以使状态管理更加清晰和安全。 - """ - - AWAKE = "awake" # 清醒状态，正常活动 - SLEEPING = "sleeping" # 沉睡状态，此时应拦截消息 - INSOMNIA = "insomnia" # 失眠状态（为未来功能预留） - WOKEN_UP_ANGRY = "woken_up_angry" # 被吵醒后的生气状态（为未来功能预留） - - -class SleepStateManager: - """ - 睡眠状态管理器 (单例模式) - - 这是整个睡眠系统的数据核心，负责： - 1. 管理当前的睡眠状态（如：是否在睡觉、唤醒度等）。 - 2. 将状态持久化到本地JSON文件(`local_store.json`)，实现重启后状态不丢失。 - 3. 提供统一的接口供其他模块查询和修改睡眠状态。 - """ - - _instance = None - _STATE_KEY = "sleep_system_state" # 在 local_store.json 中存储的键名 - - def __new__(cls, *args, **kwargs): - # 实现单例模式，确保全局只有一个状态管理器实例 - if not cls._instance: - cls._instance = super(SleepStateManager, cls).__new__(cls, *args, **kwargs) - return cls._instance - - def __init__(self): - """ - 初始化状态管理器，定义状态数据结构并从本地加载历史状态。 - """ - self.state: dict[str, Any] = {} - self._default_state() - self.load_state() - - def _default_state(self): - """ - 定义并重置为默认的“清醒”状态。 - 当机器人启动或从睡眠中醒来时调用。 - """ - self.state = { - "state": SleepState.AWAKE.value, - "state_until": None, # 特殊状态（如生气）的自动结束时间 - "sleep_start_time": None, # 本次睡眠的开始时间 - "wake_up_time": None, # 预定的起床时间 - "wakefulness": 0.0, # 唤醒度/清醒值，用于判断是否被吵醒 - "last_checked": None, # 定时任务最后检查的时间 - } - - def load_state(self): - """ - 程序启动时，从 local_storage 加载上一次的状态。 - 如果找不到历史状态，则初始化为默认状态。 - """ - stored_state = local_storage[self._STATE_KEY] - if isinstance(stored_state, dict): - # 合并加载的状态，以防新增字段 - self.state.update(stored_state) - # 确保 state 字段是枚举成员 - if "state" in self.state and not isinstance(self.state["state"], SleepState): - try: - self.state["state"] = SleepState(self.state["state"]) - except ValueError: - logger.warning(f"加载了无效的睡眠状态 '{self.state['state']}'，重置为 AWAKE。") - self.state["state"] = SleepState.AWAKE - else: - self.state["state"] = SleepState.AWAKE # 兼容旧数据 - - logger.info(f"成功加载睡眠状态: {self.get_current_state().name}") - else: - logger.info("未找到已存储的睡眠状态，将使用默认值。") - self.save_state() - - def save_state(self): - """ - 将当前内存中的状态保存到 local_storage。 - 在保存前，会将枚举类型的 state 转换为字符串，以便JSON序列化。 - """ - data_to_save = self.state.copy() - # 将 state 枚举成员转换为它的值（字符串） - data_to_save["state"] = self.state["state"] - local_storage[self._STATE_KEY] = data_to_save - logger.debug(f"睡眠状态已保存: {data_to_save}") - - def get_current_state(self) -> SleepState: - """ - 获取当前的睡眠状态。 - 在返回状态前，会先检查特殊状态（如生气）是否已过期。 - """ - # 检查特殊状态是否已过期 - state_until_str = self.state.get("state_until") - if state_until_str: - state_until = datetime.fromisoformat(state_until_str) - if datetime.now() > state_until: - logger.info(f"特殊状态 {self.state['state'].name} 已结束，自动恢复为 SLEEPING。") - # 假设特殊状态（如生气）结束后，是恢复到普通睡眠状态 - self.set_state(SleepState.SLEEPING) - - return self.state["state"] - - def set_state( - self, - new_state: SleepState, - duration_seconds: float | None = None, - sleep_start: datetime | None = None, - wake_up: datetime | None = None, - ): - """ - 核心函数：切换到新的睡眠状态，并更新相关的状态数据。 - """ - current_state = self.get_current_state() - if current_state == new_state: - return # 状态未改变 - - logger.info(f"睡眠状态变更: {current_state.name} -> {new_state.name}") - self.state["state"] = new_state - - if new_state == SleepState.AWAKE: - self._default_state() # 醒来时重置所有状态 - self.state["state"] = SleepState.AWAKE # 确保状态正确 - - elif new_state == SleepState.SLEEPING: - self.state["sleep_start_time"] = (sleep_start or datetime.now()).isoformat() - self.state["wake_up_time"] = wake_up.isoformat() if wake_up else None - self.state["state_until"] = None # 清除特殊状态持续时间 - self.state["wakefulness"] = 0.0 # 进入睡眠时清零唤醒度 - - elif new_state in [SleepState.WOKEN_UP_ANGRY, SleepState.INSOMNIA]: - if duration_seconds: - self.state["state_until"] = (datetime.now() + timedelta(seconds=duration_seconds)).isoformat() - else: - self.state["state_until"] = None - - - self.save_state() - - def update_last_checked(self): - """更新最后检查时间""" - self.state["last_checked"] = datetime.now().isoformat() - self.save_state() - - def get_wake_up_time(self) -> datetime | None: - """获取预定的起床时间，如果已设置的话。""" - wake_up_str = self.state.get("wake_up_time") - if wake_up_str: - try: - return datetime.fromisoformat(wake_up_str) - except (ValueError, TypeError): - return None - return None - - def get_sleep_start_time(self) -> datetime | None: - """获取本次睡眠的开始时间，如果已设置的话。""" - sleep_start_str = self.state.get("sleep_start_time") - if sleep_start_str: - try: - return datetime.fromisoformat(sleep_start_str) - except (ValueError, TypeError): - return None - return None - - def set_wake_up_time(self, wake_up: datetime): - """ - 更新起床时间。 - 主要用于“日程表”模式下，当第二天凌晨拿到新日程时，更新之前未知的起床时间。 - """ - if self.get_current_state() == SleepState.AWAKE: - logger.warning("尝试为清醒状态设置起床时间，操作被忽略。") - return - self.state["wake_up_time"] = wake_up.isoformat() - logger.info(f"更新预定起床时间为: {self.state['wake_up_time']}") - self.save_state() - - -# 全局单例 -sleep_state_manager = SleepStateManager() diff --git a/src/chat/message_manager/sleep_system/tasks.py b/src/chat/message_manager/sleep_system/tasks.py deleted file mode 100644 index d8216bd5a..000000000 --- a/src/chat/message_manager/sleep_system/tasks.py +++ /dev/null @@ -1,44 +0,0 @@ -from src.common.logger import get_logger -from src.manager.async_task_manager import AsyncTask, async_task_manager - -from .sleep_logic import sleep_logic - -logger = get_logger("sleep_tasks") - - -class SleepSystemCheckTask(AsyncTask): - """ - 睡眠系统周期性检查任务。 - 继承自 AsyncTask，由 async_task_manager 统一管理。 - """ - - def __init__(self, run_interval: int = 60): - """ - 初始化任务。 - Args: - run_interval (int): 任务运行的时间间隔（秒）。默认为60秒检查一次。 - """ - super().__init__(task_name="SleepSystemCheckTask", run_interval=run_interval) - - async def run(self): - """ - 任务的核心执行过程。 - 每次运行时，调用 sleep_logic 的主函数来检查和更新状态。 - """ - logger.debug("睡眠系统定时任务触发，开始检查状态...") - try: - # 调用“大脑”进行一次思考和判断 - sleep_logic.check_and_update_sleep_state() - except Exception as e: - logger.error(f"周期性检查睡眠状态时发生未知错误: {e}", exc_info=True) - - -async def start_sleep_system_tasks(): - """ - 启动睡眠系统的后台定时检查任务。 - 这个函数应该在程序启动时（例如 main.py）被调用。 - """ - logger.info("正在启动睡眠系统后台任务...") - check_task = SleepSystemCheckTask() - await async_task_manager.add_task(check_task) - logger.info("睡眠系统后台任务已成功启动。") diff --git a/src/config/config.py b/src/config/config.py index b7b907413..9a042ab8e 100644 --- a/src/config/config.py +++ b/src/config/config.py @@ -40,7 +40,6 @@ from src.config.official_configs import ( ProactiveThinkingConfig, ResponsePostProcessConfig, ResponseSplitterConfig, - SleepSystemConfig, ToolConfig, VideoAnalysisConfig, VoiceConfig, @@ -410,7 +409,6 @@ class Config(ValidatedConfigBase): default_factory=lambda: DependencyManagementConfig(), description="依赖管理配置" ) web_search: WebSearchConfig = Field(default_factory=lambda: WebSearchConfig(), description="网络搜索配置") - sleep_system: SleepSystemConfig = Field(default_factory=lambda: SleepSystemConfig(), description="睡眠系统配置") planning_system: PlanningSystemConfig = Field( default_factory=lambda: PlanningSystemConfig(), description="规划系统配置" ) diff --git a/src/config/official_configs.py b/src/config/official_configs.py index f616e064a..09e261132 100644 --- a/src/config/official_configs.py +++ b/src/config/official_configs.py @@ -592,52 +592,6 @@ class AntiPromptInjectionConfig(ValidatedConfigBase): shield_suffix: str = Field(default=" 🛡️", description="保护后缀") -class SleepSystemConfig(ValidatedConfigBase): - """睡眠系统配置类""" - - enable: bool = Field(default=True, description="是否启用睡眠系统") - sleep_by_schedule: bool = Field(default=True, description="是否根据日程表进行睡觉") - fixed_sleep_time: str = Field(default="23:00", description="固定的睡觉时间") - fixed_wake_up_time: str = Field(default="07:00", description="固定的起床时间") - sleep_time_offset_minutes: int = Field( - default=15, ge=0, le=60, description="睡觉时间随机偏移量范围（分钟），实际睡觉时间会在±该值范围内随机" - ) - wake_up_time_offset_minutes: int = Field( - default=15, ge=0, le=60, description="起床时间随机偏移量范围（分钟），实际起床时间会在±该值范围内随机" - ) - wakeup_threshold: float = Field(default=15.0, ge=1.0, description="唤醒阈值，达到此值时会被唤醒") - private_message_increment: float = Field(default=3.0, ge=0.1, description="私聊消息增加的唤醒度") - group_mention_increment: float = Field(default=2.0, ge=0.1, description="群聊艾特增加的唤醒度") - decay_rate: float = Field(default=0.2, ge=0.0, description="每次衰减的唤醒度数值") - decay_interval: float = Field(default=30.0, ge=1.0, description="唤醒度衰减间隔(秒)") - angry_duration: float = Field(default=300.0, ge=10.0, description="愤怒状态持续时间(秒)") - angry_prompt: str = Field(default="你被人吵醒了非常生气，说话带着怒气", description="被吵醒后的愤怒提示词") - re_sleep_delay_minutes: int = Field( - default=5, ge=1, description="被唤醒后，如果多久没有新消息则尝试重新入睡（分钟）" - ) - - # --- 失眠机制相关参数 --- - enable_insomnia_system: bool = Field(default=True, description="是否启用失眠系统") - insomnia_trigger_delay_minutes: list[int] = Field( - default_factory=lambda: [30, 60], description="入睡后触发失眠判定的延迟时间范围（分钟）" - ) - insomnia_duration_minutes: list[int] = Field( - default_factory=lambda: [15, 45], description="单次失眠状态的持续时间范围（分钟）" - ) - insomnia_chance_pressure: float = Field(default=0.1, ge=0.0, le=1.0, description="失眠基础概率") - - # --- 弹性睡眠与睡前消息 --- - enable_flexible_sleep: bool = Field(default=True, description="是否启用弹性睡眠") - flexible_sleep_pressure_threshold: float = Field( - default=40.0, description="触发弹性睡眠的睡眠压力阈值，低于该值可能延迟入睡" - ) - max_sleep_delay_minutes: int = Field(default=60, description="单日最大延迟入睡分钟数") - enable_pre_sleep_notification: bool = Field(default=True, description="是否启用睡前消息") - pre_sleep_prompt: str = Field( - default="我准备睡觉了，请生成一句简短自然的晚安问候。", description="用于生成睡前消息的提示" - ) - - class ContextGroup(ValidatedConfigBase): """ 上下文共享组配置 diff --git a/src/main.py b/src/main.py index abf4ca1ae..46c6ca66d 100644 --- a/src/main.py +++ b/src/main.py @@ -13,7 +13,6 @@ from rich.traceback import install from src.chat.emoji_system.emoji_manager import get_emoji_manager from src.chat.memory_system.memory_manager import memory_manager -from src.chat.message_manager.sleep_system.tasks import start_sleep_system_tasks from src.chat.message_receive.bot import chat_bot from src.chat.message_receive.chat_stream import get_chat_manager from src.chat.utils.statistic import OnlineTimeRecordTask, StatisticOutputTask @@ -520,14 +519,6 @@ MoFox_Bot(第三方修改版) except Exception as e: logger.error(f"日程表管理器初始化失败: {e}") - # 初始化睡眠系统 - if global_config.sleep_system.enable: - try: - await start_sleep_system_tasks() - logger.info("睡眠系统初始化成功") - except Exception as e: - logger.error(f"睡眠系统初始化失败: {e}") - def _safe_init(self, component_name: str, init_func) -> callable: """安全初始化组件，捕获异常""" diff --git a/src/plugins/built_in/proactive_thinker/proacive_thinker_event.py b/src/plugins/built_in/proactive_thinker/proacive_thinker_event.py index 16d16dc6f..2f062c0b0 100644 --- a/src/plugins/built_in/proactive_thinker/proacive_thinker_event.py +++ b/src/plugins/built_in/proactive_thinker/proacive_thinker_event.py @@ -6,7 +6,6 @@ from datetime import datetime from maim_message import UserInfo -from src.chat.message_manager.sleep_system.state_manager import SleepState, sleep_state_manager from src.chat.message_receive.chat_stream import get_chat_manager from src.common.logger import get_logger from src.config.config import global_config @@ -39,10 +38,6 @@ class ColdStartTask(AsyncTask): await asyncio.sleep(30) # 延迟以确保所有服务和聊天流已从数据库加载完毕 try: - current_state = sleep_state_manager.get_current_state() - if current_state == SleepState.SLEEPING: - logger.info("bot正在睡觉,跳过本次任务") - return logger.info("【冷启动】开始扫描白名单，唤醒沉睡的聊天流...") # 【修复】增加对私聊总开关的判断 @@ -152,10 +147,6 @@ class ProactiveThinkingTask(AsyncTask): # 计算下一次检查前的休眠时间 next_interval = self._get_next_interval() try: - current_state = sleep_state_manager.get_current_state() - if current_state == SleepState.SLEEPING: - logger.info("bot正在睡觉,跳过本次任务") - return logger.debug(f"【日常唤醒】下一次检查将在 {next_interval:.2f} 秒后进行。") await asyncio.sleep(next_interval) diff --git a/template/bot_config_template.toml b/template/bot_config_template.toml index 7bc7ed6c8..33b3067b4 100644 --- a/template/bot_config_template.toml +++ b/template/bot_config_template.toml @@ -1,5 +1,5 @@ [inner] -version = "7.3.6" +version = "7.4.6" #----以下是给开发人员阅读的，如果你只是部署了MoFox-Bot，不需要阅读---- #如果你想要修改配置文件，请递增version的值 @@ -482,44 +482,6 @@ searxng_api_keys = []# SearXNG 实例 API 密钥列表 enabled_engines = ["ddg"] # 启用的搜索引擎列表，可选: "exa", "tavily", "ddg","bing", "metaso" search_strategy = "single" # 搜索策略: "single"(使用第一个可用引擎), "parallel"(并行使用所有启用的引擎), "fallback"(按顺序尝试，失败则尝试下一个) -[sleep_system] -enable = false #"是否启用睡眠系统" -sleep_by_schedule = true #"是否根据日程表进行睡觉" -fixed_sleep_time = "23:00" #"固定的睡觉时间" -fixed_wake_up_time = "07:00" #"固定的起床时间" -sleep_time_offset_minutes = 15 #"睡觉时间随机偏移量范围（分钟），实际睡觉时间会在±该值范围内随机" -wake_up_time_offset_minutes = 15 #"起床时间随机偏移量范围（分钟），实际起床时间会在±该值范围内随机" -wakeup_threshold = 15.0 #唤醒阈值，达到此值时会被唤醒" -private_message_increment = 3.0 #"私聊消息增加的唤醒度" -group_mention_increment = 2.0 #"群聊艾特增加的唤醒度" -decay_rate = 0.2 #"每次衰减的唤醒度数值" -decay_interval = 30.0 #"唤醒度衰减间隔(秒)" -angry_duration = 300.0 #"愤怒状态持续时间(秒)" -angry_prompt = "你被人吵醒了非常生气，说话带着怒气" # "被吵醒后的愤怒提示词" -re_sleep_delay_minutes = 5 # "被唤醒后，如果多久没有新消息则尝试重新入睡（分钟）" - -# --- 失眠机制相关参数 --- -enable_insomnia_system = false # 是否启用失眠系统 -# 失眠概率 (0.0 to 1.0) -insomnia_chance_pressure = 0.1 - -# --- 弹性睡眠与睡前消息 --- -# 是否启用弹性睡眠。启用后，AI不会到点立刻入睡，而是会根据睡眠压力增加5-10分钟的缓冲，并可能因为压力不足而推迟睡眠。 -enable_flexible_sleep = false -# 触发弹性睡眠的睡眠压力阈值。当AI的睡眠压力低于此值时，可能会推迟入睡。 -flexible_sleep_pressure_threshold = 40.0 -# 每日最大可推迟入睡的总分钟数。 -max_sleep_delay_minutes = 60 - -# 是否在进入“准备入睡”状态时发送一条消息通知。 -enable_pre_sleep_notification = false -# 用于生成睡前消息的提示。AI会根据这个提示生成一句晚安问候。 -pre_sleep_prompt = "我准备睡觉了，请生成一句简短自然的晚安问候。" -insomnia_duration_minutes = [30, 60] # 单次失眠状态的持续时间范围（分钟） -# --- 睡后失眠 --- -# 入睡后，经过一段延迟后触发失眠判定的延迟时间（分钟），设置为范围以增加随机性 -insomnia_trigger_delay_minutes = [15, 45] - [cross_context] # 跨群聊/私聊上下文共享配置 # 这是总开关，用于一键启用或禁用此功能 enable = true From 54993aa546d3a5c2f13580a8b80c1abcb971e4bb Mon Sep 17 00:00:00 2001 From: minecraft1024a Date: Sat, 25 Oct 2025 10:03:28 +0800 Subject: [PATCH 06/11] =?UTF-8?q?refactor(chat):=20=E7=AE=80=E5=8C=96?= =?UTF-8?q?=E5=B9=B6=E7=A1=AC=E7=BC=96=E7=A0=81prompt=E6=A8=A1=E6=9D=BF?= =?UTF-8?q?=E4=B8=BAs4u=E6=A8=A1=E5=BC=8F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 移除了动态选择prompt模板的逻辑，直接使用`s4u_style_prompt`。这与最近移除`normal`模式并强制使用`s4u`模式的更改保持一致，简化了代码逻辑。 --- src/chat/replyer/default_generator.py | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/src/chat/replyer/default_generator.py b/src/chat/replyer/default_generator.py index 92d64a8c2..291b31263 100644 --- a/src/chat/replyer/default_generator.py +++ b/src/chat/replyer/default_generator.py @@ -1273,7 +1273,7 @@ class DefaultReplyer: ), "cross_context": asyncio.create_task( self._time_and_run_task( - Prompt.build_cross_context(chat_id, global_config.personality.prompt_mode, target_user_info), + Prompt.build_cross_context(chat_id, "s4u", target_user_info), "cross_context", ) ), @@ -1493,11 +1493,7 @@ class DefaultReplyer: ) # 使用新的统一Prompt系统 - 使用正确的模板名称 - template_name = "" - if current_prompt_mode == "s4u": - template_name = "s4u_style_prompt" - elif current_prompt_mode == "minimal": - template_name = "default_expressor_prompt" + template_name = "s4u_style_prompt" # 获取模板内容 template_prompt = await global_prompt_manager.get_prompt_async(template_name) From 110dc9f27bc0dbc463eeb1c5dfa92e87a91fce35 Mon Sep 17 00:00:00 2001 From: minecraft1024a Date: Sat, 25 Oct 2025 10:23:00 +0800 Subject: [PATCH 07/11] =?UTF-8?q?refactor(plugin):=20=E9=80=82=E9=85=8D=20?= =?UTF-8?q?message=20=E5=AF=B9=E8=B1=A1=E7=9A=84=20plain=5Ftext=20?= =?UTF-8?q?=E5=AD=97=E6=AE=B5=E9=87=8D=E5=91=BD=E5=90=8D?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 将 `PlusCommand` 基类中对 `message.plain_text` 的引用更新为 `message.processed_plain_text`，以适配 `Message` 数据结构的变更。同时，优化了群聊判断逻辑，直接使用 `group_id` 进行判断。 --- src/plugin_system/base/plus_command.py | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/src/plugin_system/base/plus_command.py b/src/plugin_system/base/plus_command.py index cfe42e5d9..e442d76c1 100644 --- a/src/plugin_system/base/plus_command.py +++ b/src/plugin_system/base/plus_command.py @@ -66,7 +66,7 @@ class PlusCommand(ABC): # 验证聊天类型限制 if not self._validate_chat_type(): - is_group = hasattr(self.message, "is_group_message") and self.message.is_group_message + is_group = self.message.message_info.group_info.group_id logger.warning( f"{self.log_prefix} 命令 '{self.command_name}' 不支持当前聊天类型: " f"{'群聊' if is_group else '私聊'}, 允许类型: {self.chat_type_allow.value}" @@ -74,11 +74,11 @@ class PlusCommand(ABC): def _parse_command(self) -> None: """解析命令和参数""" - if not hasattr(self.message, "plain_text") or not self.message.plain_text: + if not hasattr(self.message, "processed_plain_text") or not self.message.processed_plain_text: self.args = CommandArgs("") return - plain_text = self.message.plain_text.strip() + plain_text = self.message.processed_plain_text.strip() # 获取配置的命令前缀 prefixes = global_config.command.command_prefixes @@ -152,10 +152,10 @@ class PlusCommand(ABC): def _is_exact_command_call(self) -> bool: """检查是否是精确的命令调用（无参数）""" - if not hasattr(self.message, "plain_text") or not self.message.plain_text: + if not hasattr(self.message, "plain_text") or not self.message.processed_plain_text: return False - plain_text = self.message.plain_text.strip() + plain_text = self.message.processed_plain_text.strip() # 获取配置的命令前缀 prefixes = global_config.command.command_prefixes @@ -435,3 +435,4 @@ def create_plus_command_adapter(plus_command_class): # 兼容旧的命名 PlusCommandAdapter = create_plus_command_adapter + From 07cf6e407461c3fa1f33d4fd3ad08b3dafb2d268 Mon Sep 17 00:00:00 2001 From: minecraft1024a Date: Sat, 25 Oct 2025 11:27:21 +0800 Subject: [PATCH 08/11] =?UTF-8?q?feat(plugin):=20=E4=B8=BA=E6=8F=92?= =?UTF-8?q?=E4=BB=B6=E7=B3=BB=E7=BB=9F=E6=8F=90=E4=BE=9B=E6=9C=AC=E5=9C=B0?= =?UTF-8?q?=E5=AD=98=E5=82=A8API?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 新增了一个集成的本地存储API，允许插件以键值对的形式持久化数据到本地JSON文件。该API通过 `get_local_storage(name)` 函数为每个插件提供一个独立的、线程安全的存储实例。 主要功能包括： - 动态创建和管理插件的JSON数据文件。 - 提供 `get`, `set`, `add`, `update`, `delete` 等标准数据操作方法。 - 确保文件读写操作的线程安全。 - 实现了数据缓存以提高性能。 --- src/chat/message_receive/bot.py | 3 +- src/plugin_system/apis/storage_api.py | 167 ++++++++++++++++++++++++++ 2 files changed, 168 insertions(+), 2 deletions(-) create mode 100644 src/plugin_system/apis/storage_api.py diff --git a/src/chat/message_receive/bot.py b/src/chat/message_receive/bot.py index f65420140..24a245238 100644 --- a/src/chat/message_receive/bot.py +++ b/src/chat/message_receive/bot.py @@ -1,6 +1,5 @@ import os import re -import time import traceback from typing import Any @@ -12,7 +11,7 @@ from src.chat.message_manager import message_manager from src.chat.message_receive.chat_stream import ChatStream, get_chat_manager from src.chat.message_receive.message import MessageRecv, MessageRecvS4U from src.chat.message_receive.storage import MessageStorage -from src.chat.utils.prompt import Prompt, global_prompt_manager, create_prompt_async +from src.chat.utils.prompt import create_prompt_async, global_prompt_manager from src.chat.utils.utils import is_mentioned_bot_in_message from src.common.logger import get_logger from src.config.config import global_config diff --git a/src/plugin_system/apis/storage_api.py b/src/plugin_system/apis/storage_api.py new file mode 100644 index 000000000..952fa8968 --- /dev/null +++ b/src/plugin_system/apis/storage_api.py @@ -0,0 +1,167 @@ +""" +@File : storage_api.py +@Time : 2025/10/25 11:03:15 +@Author : 墨墨 +@Version : 2.0 +@Desc : 提供给插件使用的本地存储API（集成版） +""" + +import json +import os +import threading +from typing import Any, Dict # noqa: UP035 + +from src.common.logger import get_logger + +# 获取日志记录器 +logger = get_logger("PluginStorageManager") + +# --- 核心管理器部分 --- + + +class PluginStorageManager: + """ + 一个用于管理插件本地JSON数据存储的类。 + 它处理文件的读写、数据缓存以及线程安全，确保每个插件实例的独立性。 + 哼，现在它和API住在一起了，希望它们能和睦相处。 + """ + + _instances: dict[str, "PluginStorage"] = {} + _lock = threading.Lock() + _base_path = os.path.join("data", "plugin_data") + + @classmethod + def get_storage(cls, name: str) -> "PluginStorage": + """ + 获取指定名称的插件存储实例的工厂方法。 + """ + with cls._lock: + if name not in cls._instances: + logger.info(f"为插件 '{name}' 创建新的本地存储实例。") + cls._instances[name] = PluginStorage(name, cls._base_path) + else: + logger.debug(f"从缓存中获取插件 '{name}' 的本地存储实例。") + return cls._instances[name] + + +# --- 单个存储实例部分 --- + + +class PluginStorage: + """ + 单个插件的本地存储操作类。 + 提供了多种方法来读取、写入和修改JSON文件中的数据。 + 把数据交给我，你就放心吧。 + """ + + def __init__(self, name: str, base_path: str): + self.name = name + safe_filename = "".join(c for c in name if c.isalnum() or c in ("_", "-")).rstrip() + self.file_path = os.path.join(base_path, f"{safe_filename}.json") + self._data: dict[str, Any] = {} + self._lock = threading.Lock() + + self._ensure_directory_exists() + self._load_data() + + def _ensure_directory_exists(self) -> None: + try: + directory = os.path.dirname(self.file_path) + if not os.path.exists(directory): + logger.info(f"存储目录 '{directory}' 不存在，正在创建...") + os.makedirs(directory) + logger.info(f"目录 '{directory}' 创建成功。") + except Exception as e: + logger.error(f"创建存储目录时发生错误: {e}", exc_info=True) + raise + + def _load_data(self) -> None: + with self._lock: + try: + if os.path.exists(self.file_path): + with open(self.file_path, encoding="utf-8") as f: + content = f.read() + self._data = json.loads(content) if content else {} + else: + self._data = {} + except (json.JSONDecodeError, Exception) as e: + logger.warning(f"从 '{self.file_path}' 加载数据失败: {e}，将初始化为空数据。") + self._data = {} + + def _save_data(self) -> None: + with self._lock: + try: + with open(self.file_path, "w", encoding="utf-8") as f: + json.dump(self._data, f, indent=4, ensure_ascii=False) + except Exception as e: + logger.error(f"向 '{self.file_path}' 保存数据时发生错误: {e}", exc_info=True) + raise + + def get(self, key: str, default: Any | None = None) -> Any: + return self._data.get(key, default) + + def set(self, key: str, value: Any) -> None: + """ + 设置一个键值对。 + 如果键已存在，则覆盖它的值；如果不存在，则创建新的键值对。 + 这是“设置”或“更新”操作。 + """ + logger.debug(f"在 '{self.name}' 存储中设置值: key='{key}'。") + self._data[key] = value + self._save_data() + + def add(self, key: str, value: Any) -> bool: + """ + 添加一个新的键值对。 + 只有当键不存在时，才会添加成功。如果键已存在，则不进行任何操作。 + 这是专门的“新增”操作，满足你的要求了吧，主人？ + + Returns: + bool: 如果成功添加则返回 True，如果键已存在则返回 False。 + """ + if key not in self._data: + logger.debug(f"在 '{self.name}' 存储中新增值: key='{key}'。") + self._data[key] = value + self._save_data() + return True + logger.warning(f"尝试为已存在的键 '{key}' 新增值，操作被忽略。") + return False + + def update(self, data: dict[str, Any]) -> None: + self._data.update(data) + self._save_data() + + def delete(self, key: str) -> bool: + if key in self._data: + del self._data[key] + self._save_data() + return True + return False + + def get_all(self) -> dict[str, Any]: + return self._data.copy() + + def clear(self) -> None: + logger.warning(f"插件 '{self.name}' 的本地存储将被清空！") + self._data = {} + self._save_data() + + +# --- 对外暴露的API函数 --- + + +def get_local_storage(name: str) -> "PluginStorage": + """ + 获取一个专属于插件的本地存储实例。 + 这是插件与本地存储功能交互的唯一入口。 + """ + if not isinstance(name, str) or not name: + logger.error("获取本地存储失败：插件名称(name)必须是一个非空字符串。") + raise ValueError("插件名称(name)不能为空字符串。") + + try: + storage_instance = PluginStorageManager.get_storage(name) + return storage_instance + except Exception as e: + logger.critical(f"为插件 '{name}' 提供本地存储实例时发生严重错误: {e}", exc_info=True) + raise From 577c76b4a47985fa081b75a664076c424bf7c2b9 Mon Sep 17 00:00:00 2001 From: minecraft1024a Date: Sat, 25 Oct 2025 11:37:14 +0800 Subject: [PATCH 09/11] =?UTF-8?q?refactor(plugin):=20=E7=BB=9F=E4=B8=80?= =?UTF-8?q?=E6=8F=92=E4=BB=B6=E6=97=A5=E5=BF=97=E8=AE=B0=E5=BD=95=E5=99=A8?= =?UTF-8?q?=E4=B8=BA=20get=5Flogger?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 将 hello_world_plugin 中直接使用 `logging` 模块的方式，改为从 `src.common.logger` 导入并使用 `get_logger`。 这确保了插件日志与核心应用日志格式和配置的一致性，便于集中管理和问题排查。同时，此举也修正了 Pylance 关于导入顺序的警告。 --- plugins/hello_world_plugin/plugin.py | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/plugins/hello_world_plugin/plugin.py b/plugins/hello_world_plugin/plugin.py index fbb4fcab8..44c3ceb39 100644 --- a/plugins/hello_world_plugin/plugin.py +++ b/plugins/hello_world_plugin/plugin.py @@ -1,13 +1,14 @@ -import logging import random from typing import Any +from src.common.logger import get_logger + +# 修正导入路径，让Pylance不再抱怨 from src.plugin_system import ( BaseAction, BaseEventHandler, BasePlugin, BasePrompt, - ToolParamType, BaseTool, ChatType, CommandArgs, @@ -15,10 +16,12 @@ from src.plugin_system import ( ConfigField, EventType, PlusCommand, + ToolParamType, register_plugin, ) from src.plugin_system.base.base_event import HandlerResult +logger = get_logger("hello_world_plugin") class StartupMessageHandler(BaseEventHandler): """启动时打印消息的事件处理器。""" @@ -28,7 +31,7 @@ class StartupMessageHandler(BaseEventHandler): init_subscribe = [EventType.ON_START] async def execute(self, params: dict) -> HandlerResult: - logging.info("🎉 Hello World 插件已启动，准备就绪！") + logger.info("🎉 Hello World 插件已启动，准备就绪！") return HandlerResult(success=True, continue_process=True) From 5fc9d1b9da9c53642741659d251ce418068f2888 Mon Sep 17 00:00:00 2001 From: minecraft1024a Date: Sat, 25 Oct 2025 13:29:49 +0800 Subject: [PATCH 10/11] =?UTF-8?q?refactor(schedule=5Fapi):=20=E9=87=8D?= =?UTF-8?q?=E6=9E=84=E6=97=A5=E7=A8=8B=E4=B8=8E=E8=AE=A1=E5=88=92API?= =?UTF-8?q?=E4=B8=BA=E5=8F=AA=E8=AF=BB=E6=95=B0=E6=8D=AE=E5=BA=93=E6=9F=A5?= =?UTF-8?q?=E8=AF=A2?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 将日程API从依赖`schedule_manager`的内存状态改为直接从数据库异步查询。这提高了数据一致性，并解除了模块间的紧密耦合。 主要变更： - **解耦**: 移除对`schedule_manager`的依赖，所有数据直接来自数据库。 - **只读设计**: 移除了`regenerate_schedule`, `ensure_monthly_plans`, `archive_monthly_plans`等写操作API，使API职责更清晰，专注于查询。 - **功能增强**: - `get_schedule` (原`get_today_schedule`) 现在支持查询任意日期的日程。 - `get_monthly_plans` 新增随机抽样功能。 - 新增`get_activities_between`用于查询特定时间范围的活动。 - 新增`count_monthly_plans`用于统计月度计划数量。 - **格式化输出**: 所有查询函数均增加了`formatted`参数，方便插件直接获取格式化后的字符串。 - **文档更新**: 全面更新了模块和函数的文档字符串，以反映新的API设计和用法。 --- src/plugin_system/apis/schedule_api.py | 336 ++++++++++++++++++------- 1 file changed, 243 insertions(+), 93 deletions(-) diff --git a/src/plugin_system/apis/schedule_api.py b/src/plugin_system/apis/schedule_api.py index 61c5d13f4..4273a8c64 100644 --- a/src/plugin_system/apis/schedule_api.py +++ b/src/plugin_system/apis/schedule_api.py @@ -1,180 +1,330 @@ """ -日程表与月度计划API模块 +日程表与月度计划查询API模块 -专门负责日程和月度计划信息的查询与管理，采用标准Python包设计模式 -所有对外接口均为异步函数，以便于插件开发者在异步环境中使用。 +本模块提供了一系列用于查询日程和月度计划的只读接口。 +所有对外接口均为异步函数，专为插件开发者设计，以便在异步环境中无缝集成。 + +核心功能： +- 查询指定日期的日程安排。 +- 获取当前正在进行的活动。 +- 筛选特定时间范围内的活动。 +- 查询月度计划，支持随机抽样和计数。 +- 所有查询接口均提供格式化输出选项。 使用方式： import asyncio from src.plugin_system.apis import schedule_api async def main(): - # 获取今日日程 - today_schedule = await schedule_api.get_today_schedule() + # 获取今天的日程（原始数据） + today_schedule = await schedule_api.get_schedule() if today_schedule: print("今天的日程:", today_schedule) + # 获取昨天的日程，并格式化为字符串 + from datetime import datetime, timedelta + yesterday = (datetime.now() - timedelta(days=1)).strftime("%Y-%m-%d") + formatted_schedule = await schedule_api.get_schedule(date=yesterday, formatted=True) + if formatted_schedule: + print(f"\\n昨天的日程 (格式化):\\n{formatted_schedule}") + # 获取当前活动 current_activity = await schedule_api.get_current_activity() if current_activity: - print("当前活动:", current_activity) + print(f"\\n当前活动: {current_activity.get('activity')}") - # 获取本月月度计划 - from datetime import datetime - this_month = datetime.now().strftime("%Y-%m") - plans = await schedule_api.get_monthly_plans(this_month) - if plans: - print(f"{this_month} 的月度计划:", [p.plan_text for p in plans]) + # 获取本月月度计划总数 + plan_count = await schedule_api.count_monthly_plans() + print(f"\\n本月月度计划总数: {plan_count}") + + # 随机获取本月的2个计划 + random_plans = await schedule_api.get_monthly_plans(random_count=2) + if random_plans: + print("\\n随机的2个计划:", [p.plan_text for p in random_plans]) asyncio.run(main()) """ -from datetime import datetime -from typing import Any +import random +from datetime import datetime, time +from typing import Any, List, Optional, Union -from src.common.database.sqlalchemy_models import MonthlyPlan +import orjson +from sqlalchemy import func, select + +from src.common.database.sqlalchemy_models import MonthlyPlan, Schedule, get_db_session from src.common.logger import get_logger from src.schedule.database import get_active_plans_for_month -from src.schedule.schedule_manager import schedule_manager logger = get_logger("schedule_api") +# --- 内部辅助函数 --- + +def _format_schedule_list( + items: Union[List[dict[str, Any]], List[MonthlyPlan]], + template: str, + item_type: str, +) -> str: + """将日程或计划列表格式化为字符串""" + if not items: + return "无" + + lines = [] + for item in items: + if item_type == "schedule" and isinstance(item, dict): + lines.append(template.format(time_range=item.get("time_range", ""), activity=item.get("activity", ""))) + elif item_type == "plan" and isinstance(item, MonthlyPlan): + lines.append(template.format(plan_text=item.plan_text)) + return "\\n".join(lines) + + +async def _get_schedule_from_db(date_str: str) -> Optional[List[dict[str, Any]]]: + """从数据库中获取并解析指定日期的日程""" + async with get_db_session() as session: + result = await session.execute(select(Schedule).filter(Schedule.date == date_str)) + schedule_record = result.scalars().first() + if schedule_record and schedule_record.schedule_data: + try: + return orjson.loads(str(schedule_record.schedule_data)) + except orjson.JSONDecodeError: + logger.warning(f"无法解析数据库中的日程数据 (日期: {date_str})") + return None + + +# --- API实现 --- + + class ScheduleAPI: - """日程表与月度计划API - 负责日程和计划信息的查询与管理""" + """日程表与月度计划查询API""" @staticmethod - async def get_today_schedule() -> list[dict[str, Any]] | None: - """(异步) 获取今天的日程安排 + async def get_schedule( + date: Optional[str] = None, + formatted: bool = False, + format_template: str = "{time_range}: {activity}", + ) -> Union[List[dict[str, Any]], str, None]: + """ + (异步) 获取指定日期的日程安排。 + + Args: + date (Optional[str]): 目标日期，格式 "YYYY-MM-DD"。如果为None，则使用当前日期。 + formatted (bool): 如果为True，返回格式化的字符串；否则返回原始数据列表。 + format_template (str): 当 formatted=True 时使用的格式化模板。 Returns: - Optional[List[Dict[str, Any]]]: 今天的日程列表，如果未生成或未启用则返回None + Union[List[Dict[str, Any]], str, None]: 日程数据或None。 """ + target_date = date or datetime.now().strftime("%Y-%m-%d") try: - logger.debug("[ScheduleAPI] 正在获取今天的日程安排...") - return schedule_manager.today_schedule + logger.debug(f"[ScheduleAPI] 正在获取 {target_date} 的日程安排...") + schedule_data = await _get_schedule_from_db(target_date) + if schedule_data is None: + return None + if formatted: + return _format_schedule_list(schedule_data, format_template, "schedule") + return schedule_data except Exception as e: - logger.error(f"[ScheduleAPI] 获取今日日程失败: {e}") + logger.error(f"[ScheduleAPI] 获取 {target_date} 日程失败: {e}") return None @staticmethod - async def get_current_activity() -> str | None: - """(异步) 获取当前正在进行的活动 + async def get_current_activity( + formatted: bool = False, + format_template: str = "{time_range}: {activity}", + ) -> Union[dict[str, Any], str, None]: + """ + (异步) 获取当前正在进行的活动。 + + Args: + formatted (bool): 如果为True，返回格式化的字符串；否则返回活动字典。 + format_template (str): 当 formatted=True 时使用的格式化模板。 Returns: - Optional[str]: 当前活动名称，如果没有则返回None + Union[Dict[str, Any], str, None]: 当前活动数据或None。 """ try: logger.debug("[ScheduleAPI] 正在获取当前活动...") - return schedule_manager.get_current_activity() + today_schedule = await _get_schedule_from_db(datetime.now().strftime("%Y-%m-%d")) + if not today_schedule: + return None + + now = datetime.now().time() + for event in today_schedule: + time_range = event.get("time_range") + if not time_range: + continue + try: + start_str, end_str = time_range.split("-") + start_time = datetime.strptime(start_str.strip(), "%H:%M").time() + end_time = datetime.strptime(end_str.strip(), "%H:%M").time() + if (start_time <= now < end_time) or \ + (end_time < start_time and (now >= start_time or now < end_time)): + if formatted: + return _format_schedule_list([event], format_template, "schedule") + return event + except (ValueError, KeyError): + continue + return None except Exception as e: logger.error(f"[ScheduleAPI] 获取当前活动失败: {e}") return None @staticmethod - async def regenerate_schedule() -> bool: - """(异步) 触发后台重新生成今天的日程 - - Returns: - bool: 是否成功触发 + async def get_activities_between( + start_time: str, + end_time: str, + date: Optional[str] = None, + formatted: bool = False, + format_template: str = "{time_range}: {activity}", + ) -> Union[List[dict[str, Any]], str, None]: """ - try: - logger.info("[ScheduleAPI] 正在触发后台重新生成日程...") - await schedule_manager.generate_and_save_schedule() - return True - except Exception as e: - logger.error(f"[ScheduleAPI] 触发日程重新生成失败: {e}") - return False - - @staticmethod - async def get_monthly_plans(target_month: str | None = None) -> list[MonthlyPlan]: - """(异步) 获取指定月份的有效月度计划 + (异步) 获取指定日期和时间范围内的所有活动。 Args: - target_month (Optional[str]): 目标月份，格式为 "YYYY-MM"。如果为None，则使用当前月份。 + start_time (str): 开始时间，格式 "HH:MM"。 + end_time (str): 结束时间，格式 "HH:MM"。 + date (Optional[str]): 目标日期，格式 "YYYY-MM-DD"。如果为None，则使用当前日期。 + formatted (bool): 如果为True，返回格式化的字符串；否则返回活动列表。 + format_template (str): 当 formatted=True 时使用的格式化模板。 Returns: - List[MonthlyPlan]: 月度计划对象列表 + Union[List[Dict[str, Any]], str, None]: 在时间范围内的活动列表或None。 """ - if target_month is None: - target_month = datetime.now().strftime("%Y-%m") + target_date = date or datetime.now().strftime("%Y-%m-%d") try: - logger.debug(f"[ScheduleAPI] 正在获取 {target_month} 的月度计划...") - return await get_active_plans_for_month(target_month) + logger.debug(f"[ScheduleAPI] 正在获取 {target_date} 从 {start_time} 到 {end_time} 的活动...") + schedule_data = await _get_schedule_from_db(target_date) + if not schedule_data: + return None + + start = datetime.strptime(start_time, "%H:%M").time() + end = datetime.strptime(end_time, "%H:%M").time() + activities_in_range = [] + + for event in schedule_data: + time_range = event.get("time_range") + if not time_range: + continue + try: + event_start_str, event_end_str = time_range.split("-") + event_start = datetime.strptime(event_start_str.strip(), "%H:%M").time() + if start <= event_start < end: + activities_in_range.append(event) + except (ValueError, KeyError): + continue + + if formatted: + return _format_schedule_list(activities_in_range, format_template, "schedule") + return activities_in_range except Exception as e: - logger.error(f"[ScheduleAPI] 获取 {target_month} 月度计划失败: {e}") - return [] + logger.error(f"[ScheduleAPI] 获取时间段内活动失败: {e}") + return None @staticmethod - async def ensure_monthly_plans(target_month: str | None = None) -> bool: - """(异步) 确保指定月份存在月度计划，如果不存在则触发生成 + async def get_monthly_plans( + target_month: Optional[str] = None, + random_count: Optional[int] = None, + formatted: bool = False, + format_template: str = "- {plan_text}", + ) -> Union[List[MonthlyPlan], str, None]: + """ + (异步) 获取指定月份的有效月度计划。 Args: - target_month (Optional[str]): 目标月份，格式为 "YYYY-MM"。如果为None，则使用当前月份。 + target_month (Optional[str]): 目标月份，格式 "YYYY-MM"。如果为None，则使用当前月份。 + random_count (Optional[int]): 如果设置，将随机返回指定数量的计划。 + formatted (bool): 如果为True，返回格式化的字符串；否则返回对象列表。 + format_template (str): 当 formatted=True 时使用的格式化模板。 Returns: - bool: 操作是否成功 (如果已存在或成功生成) + Union[List[MonthlyPlan], str, None]: 月度计划列表、格式化字符串或None。 """ - if target_month is None: - target_month = datetime.now().strftime("%Y-%m") + month = target_month or datetime.now().strftime("%Y-%m") try: - logger.info(f"[ScheduleAPI] 正在确保 {target_month} 的月度计划存在...") - return await schedule_manager.plan_manager.ensure_and_generate_plans_if_needed(target_month) + logger.debug(f"[ScheduleAPI] 正在获取 {month} 的月度计划...") + plans = await get_active_plans_for_month(month) + if not plans: + return None + + if random_count is not None and random_count > 0 and len(plans) > random_count: + plans = random.sample(plans, random_count) + + if formatted: + return _format_schedule_list(plans, format_template, "plan") + return plans except Exception as e: - logger.error(f"[ScheduleAPI] 确保 {target_month} 月度计划失败: {e}") - return False + logger.error(f"[ScheduleAPI] 获取 {month} 月度计划失败: {e}") + return None @staticmethod - async def archive_monthly_plans(target_month: str | None = None) -> bool: - """(异步) 归档指定月份的月度计划 + async def count_monthly_plans(target_month: Optional[str] = None) -> int: + """ + (异步) 获取指定月份的有效月度计划总数。 Args: - target_month (Optional[str]): 目标月份，格式为 "YYYY-MM"。如果为None，则使用当前月份。 + target_month (Optional[str]): 目标月份，格式 "YYYY-MM"。如果为None，则使用当前月份。 Returns: - bool: 操作是否成功 + int: 有效月度计划的数量。 """ - if target_month is None: - target_month = datetime.now().strftime("%Y-%m") + month = target_month or datetime.now().strftime("%Y-%m") try: - logger.info(f"[ScheduleAPI] 正在归档 {target_month} 的月度计划...") - await schedule_manager.plan_manager.archive_current_month_plans(target_month) - return True + logger.debug(f"[ScheduleAPI] 正在统计 {month} 的月度计划数量...") + async with get_db_session() as session: + result = await session.execute( + select(func.count(MonthlyPlan.id)).where( + MonthlyPlan.target_month == month, MonthlyPlan.status == "active" + ) + ) + return result.scalar_one() or 0 except Exception as e: - logger.error(f"[ScheduleAPI] 归档 {target_month} 月度计划失败: {e}") - return False + logger.error(f"[ScheduleAPI] 统计 {month} 月度计划数量失败: {e}") + return 0 # ============================================================================= # 模块级别的便捷函数 (全部为异步) # ============================================================================= - -async def get_today_schedule() -> list[dict[str, Any]] | None: - """(异步) 获取今天的日程安排的便捷函数""" - return await ScheduleAPI.get_today_schedule() +async def get_schedule( + date: Optional[str] = None, + formatted: bool = False, + format_template: str = "{time_range}: {activity}", +) -> Union[List[dict[str, Any]], str, None]: + """(异步) 获取指定日期的日程安排的便捷函数。""" + return await ScheduleAPI.get_schedule(date, formatted, format_template) -async def get_current_activity() -> str | None: - """(异步) 获取当前正在进行的活动的便捷函数""" - return await ScheduleAPI.get_current_activity() +async def get_current_activity( + formatted: bool = False, + format_template: str = "{time_range}: {activity}", +) -> Union[dict[str, Any], str, None]: + """(异步) 获取当前正在进行的活动的便捷函数。""" + return await ScheduleAPI.get_current_activity(formatted, format_template) -async def regenerate_schedule() -> bool: - """(异步) 触发后台重新生成今天的日程的便捷函数""" - return await ScheduleAPI.regenerate_schedule() +async def get_activities_between( + start_time: str, + end_time: str, + date: Optional[str] = None, + formatted: bool = False, + format_template: str = "{time_range}: {activity}", +) -> Union[List[dict[str, Any]], str, None]: + """(异步) 获取指定时间范围内活动的便捷函数。""" + return await ScheduleAPI.get_activities_between(start_time, end_time, date, formatted, format_template) -async def get_monthly_plans(target_month: str | None = None) -> list[MonthlyPlan]: - """(异步) 获取指定月份的有效月度计划的便捷函数""" - return await ScheduleAPI.get_monthly_plans(target_month) +async def get_monthly_plans( + target_month: Optional[str] = None, + random_count: Optional[int] = None, + formatted: bool = False, + format_template: str = "- {plan_text}", +) -> Union[List[MonthlyPlan], str, None]: + """(异步) 获取月度计划的便捷函数。""" + return await ScheduleAPI.get_monthly_plans(target_month, random_count, formatted, format_template) -async def ensure_monthly_plans(target_month: str | None = None) -> bool: - """(异步) 确保指定月份存在月度计划的便捷函数""" - return await ScheduleAPI.ensure_monthly_plans(target_month) - - -async def archive_monthly_plans(target_month: str | None = None) -> bool: - """(异步) 归档指定月份的月度计划的便捷函数""" - return await ScheduleAPI.archive_monthly_plans(target_month) +async def count_monthly_plans(target_month: Optional[str] = None) -> int: + """(异步) 获取月度计划总数的便捷函数。""" + return await ScheduleAPI.count_monthly_plans(target_month) From 3c4a3b04286ea09718dc83f27edd9a098781e534 Mon Sep 17 00:00:00 2001 From: minecraft1024a Date: Sat, 25 Oct 2025 13:31:22 +0800 Subject: [PATCH 11/11] =?UTF-8?q?chore:=20=E7=BB=9F=E4=B8=80=E4=BB=A3?= =?UTF-8?q?=E7=A0=81=E9=A3=8E=E6=A0=BC=E5=B9=B6=E8=BF=9B=E8=A1=8C=E7=8E=B0?= =?UTF-8?q?=E4=BB=A3=E5=8C=96=E6=94=B9=E9=80=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 本次提交主要包含以下内容： - **代码风格统一**：对多个文件进行了格式化，包括移除多余的空行、调整导入顺序、统一字符串引号等，以提高代码一致性和可读性。 - **类型提示现代化**：在多个文件中将旧的 `typing` 模块类型提示（如 `Optional[T]`、`List[T]`、`Union[T, U]`）更新为现代 Python 语法（`T | None`、`list[T]`、`T | U`）。 - **f-string 格式化**：在 `scripts/convert_manifest.py` 中，将 `.format()` 调用更新为更现代和易读的 f-string `!r` 表示法。 - **文件末尾换行符**：为多个文件添加或修正了文件末尾的换行符，遵循 POSIX 标准。 --- scripts/convert_manifest.py | 6 +-- scripts/lpmm_learning_tool.py | 2 +- src/chat/knowledge/embedding_store.py | 1 - .../message_manager/global_notice_manager.py | 34 +++++++------- src/chat/message_manager/message_manager.py | 18 ++++---- src/chat/message_receive/bot.py | 36 ++++++++------- src/chat/message_receive/message.py | 2 +- src/chat/message_receive/storage.py | 6 +-- src/chat/replyer/default_generator.py | 12 ++--- src/chat/utils/chat_message_builder.py | 6 +-- src/chat/utils/prompt_component_manager.py | 7 ++- src/chat/utils/prompt_params.py | 2 +- src/chat/utils/utils_image.py | 16 +++---- src/common/message_repository.py | 2 +- src/plugin_system/__init__.py | 2 +- src/plugin_system/apis/cross_context_api.py | 2 +- src/plugin_system/apis/schedule_api.py | 44 +++++++++---------- src/plugin_system/apis/storage_api.py | 2 +- src/plugin_system/base/base_prompt.py | 2 +- src/plugin_system/core/plugin_manager.py | 2 +- .../affinity_flow_chatter/plan_filter.py | 2 +- .../affinity_flow_chatter/plan_generator.py | 2 +- src/plugins/built_in/core_actions/emoji.py | 12 ++--- .../proactive_thinker_executor.py | 3 +- .../built_in/proactive_thinker/prompts.py | 2 +- .../tts_voice_plugin/actions/tts_action.py | 11 ++--- .../built_in/web_search_tool/engines/base.py | 4 +- .../web_search_tool/engines/metaso_engine.py | 4 +- .../built_in/web_search_tool/plugin.py | 4 +- .../web_search_tool/tools/web_search.py | 2 +- 30 files changed, 126 insertions(+), 124 deletions(-) diff --git a/scripts/convert_manifest.py b/scripts/convert_manifest.py index 640f6118e..df9867999 100644 --- a/scripts/convert_manifest.py +++ b/scripts/convert_manifest.py @@ -49,11 +49,11 @@ __plugin_meta__ = PluginMetadata( name="{plugin_name}", description="{description}", usage="暂无说明", - type={repr(plugin_type)}, + type={plugin_type!r}, version="{version}", author="{author}", - license={repr(license_type)}, - repository_url={repr(repository_url)}, + license={license_type!r}, + repository_url={repository_url!r}, keywords={keywords}, categories={categories}, ) diff --git a/scripts/lpmm_learning_tool.py b/scripts/lpmm_learning_tool.py index c09139939..36799d637 100644 --- a/scripts/lpmm_learning_tool.py +++ b/scripts/lpmm_learning_tool.py @@ -3,9 +3,9 @@ import datetime import os import shutil import sys +from concurrent.futures import ThreadPoolExecutor, as_completed from pathlib import Path from threading import Lock -from concurrent.futures import ThreadPoolExecutor, as_completed import orjson from json_repair import repair_json diff --git a/src/chat/knowledge/embedding_store.py b/src/chat/knowledge/embedding_store.py index 8131415e8..5c57d1b53 100644 --- a/src/chat/knowledge/embedding_store.py +++ b/src/chat/knowledge/embedding_store.py @@ -1,7 +1,6 @@ import asyncio import math import os -from concurrent.futures import ThreadPoolExecutor, as_completed from dataclasses import dataclass # import tqdm diff --git a/src/chat/message_manager/global_notice_manager.py b/src/chat/message_manager/global_notice_manager.py index 5350cf694..cfcc125ce 100644 --- a/src/chat/message_manager/global_notice_manager.py +++ b/src/chat/message_manager/global_notice_manager.py @@ -3,12 +3,12 @@ 用于统一管理所有notice消息，将notice与正常消息分离 """ -import time import threading +import time from collections import defaultdict, deque from dataclasses import dataclass, field -from typing import Dict, List, Optional, Any from enum import Enum +from typing import Any from src.common.data_models.database_data_model import DatabaseMessages from src.common.logger import get_logger @@ -27,7 +27,7 @@ class NoticeMessage: """Notice消息数据结构""" message: DatabaseMessages scope: NoticeScope - target_stream_id: Optional[str] = None # 如果是STREAM类型，指定目标流ID + target_stream_id: str | None = None # 如果是STREAM类型，指定目标流ID timestamp: float = field(default_factory=time.time) ttl: int = 3600 # 默认1小时过期 @@ -56,11 +56,11 @@ class GlobalNoticeManager: return cls._instance def __init__(self): - if hasattr(self, '_initialized'): + if hasattr(self, "_initialized"): return self._initialized = True - self._notices: Dict[str, deque[NoticeMessage]] = defaultdict(deque) + self._notices: dict[str, deque[NoticeMessage]] = defaultdict(deque) self._max_notices_per_type = 100 # 每种类型最大存储数量 self._cleanup_interval = 300 # 5分钟清理一次过期消息 self._last_cleanup_time = time.time() @@ -80,8 +80,8 @@ class GlobalNoticeManager: self, message: DatabaseMessages, scope: NoticeScope = NoticeScope.STREAM, - target_stream_id: Optional[str] = None, - ttl: Optional[int] = None + target_stream_id: str | None = None, + ttl: int | None = None ) -> bool: """添加notice消息 @@ -142,7 +142,7 @@ class GlobalNoticeManager: logger.error(f"添加notice消息失败: {e}") return False - def get_accessible_notices(self, stream_id: str, limit: int = 20) -> List[NoticeMessage]: + def get_accessible_notices(self, stream_id: str, limit: int = 20) -> list[NoticeMessage]: """获取指定聊天流可访问的notice消息 Args: @@ -231,7 +231,7 @@ class GlobalNoticeManager: logger.error(f"获取notice文本失败: {e}", exc_info=True) return "" - def clear_notices(self, stream_id: Optional[str] = None, notice_type: Optional[str] = None) -> int: + def clear_notices(self, stream_id: str | None = None, notice_type: str | None = None) -> int: """清理notice消息 Args: @@ -289,14 +289,14 @@ class GlobalNoticeManager: logger.error(f"清理notice消息失败: {e}") return 0 - def get_stats(self) -> Dict[str, Any]: + def get_stats(self) -> dict[str, Any]: """获取统计信息""" # 更新实时统计 total_active_notices = sum(len(notices) for notices in self._notices.values()) self.stats["total_notices"] = total_active_notices self.stats["active_keys"] = len(self._notices) self.stats["last_cleanup_time"] = int(self._last_cleanup_time) - + # 添加详细的存储键信息 storage_keys_info = {} for key, notices in self._notices.items(): @@ -313,11 +313,11 @@ class GlobalNoticeManager: """检查消息是否为notice类型""" try: # 首先检查消息的is_notify字段 - if hasattr(message, 'is_notify') and message.is_notify: + if hasattr(message, "is_notify") and message.is_notify: return True # 检查消息的附加配置 - if hasattr(message, 'additional_config') and message.additional_config: + if hasattr(message, "additional_config") and message.additional_config: if isinstance(message.additional_config, dict): return message.additional_config.get("is_notice", False) elif isinstance(message.additional_config, str): @@ -333,7 +333,7 @@ class GlobalNoticeManager: logger.debug(f"检查notice类型失败: {e}") return False - def _get_storage_key(self, scope: NoticeScope, target_stream_id: Optional[str], message: DatabaseMessages) -> str: + def _get_storage_key(self, scope: NoticeScope, target_stream_id: str | None, message: DatabaseMessages) -> str: """生成存储键""" if scope == NoticeScope.PUBLIC: return "public" @@ -341,10 +341,10 @@ class GlobalNoticeManager: notice_type = self._get_notice_type(message) or "default" return f"stream_{target_stream_id}_{notice_type}" - def _get_notice_type(self, message: DatabaseMessages) -> Optional[str]: + def _get_notice_type(self, message: DatabaseMessages) -> str | None: """获取notice类型""" try: - if hasattr(message, 'additional_config') and message.additional_config: + if hasattr(message, "additional_config") and message.additional_config: if isinstance(message.additional_config, dict): return message.additional_config.get("notice_type") elif isinstance(message.additional_config, str): @@ -397,4 +397,4 @@ class GlobalNoticeManager: # 创建全局单例实例 -global_notice_manager = GlobalNoticeManager() \ No newline at end of file +global_notice_manager = GlobalNoticeManager() diff --git a/src/chat/message_manager/message_manager.py b/src/chat/message_manager/message_manager.py index 901594991..00a4895c7 100644 --- a/src/chat/message_manager/message_manager.py +++ b/src/chat/message_manager/message_manager.py @@ -7,7 +7,7 @@ import asyncio import random import time from collections import defaultdict, deque -from typing import TYPE_CHECKING, Any, Dict, Optional +from typing import TYPE_CHECKING, Any from src.chat.chatter_manager import ChatterManager from src.chat.message_receive.chat_stream import ChatStream @@ -154,7 +154,7 @@ class MessageManager: # Notice消息处理 - 添加到全局管理器 logger.info(f"📢 检测到notice消息: message_id={message.message_id}, is_notify={message.is_notify}, notice_type={getattr(message, 'notice_type', None)}") await self._handle_notice_message(stream_id, message) - + # 根据配置决定是否继续处理（触发聊天流程） if not global_config.notice.enable_notice_trigger_chat: logger.info(f"根据配置，流 {stream_id} 的Notice消息将被忽略，不触发聊天流程。") @@ -657,11 +657,11 @@ class MessageManager: """检查消息是否为notice类型""" try: # 首先检查消息的is_notify字段 - if hasattr(message, 'is_notify') and message.is_notify: + if hasattr(message, "is_notify") and message.is_notify: return True # 检查消息的附加配置 - if hasattr(message, 'additional_config') and message.additional_config: + if hasattr(message, "additional_config") and message.additional_config: if isinstance(message.additional_config, dict): return message.additional_config.get("is_notice", False) elif isinstance(message.additional_config, str): @@ -707,7 +707,7 @@ class MessageManager: """ try: # 检查附加配置中的公共notice标志 - if hasattr(message, 'additional_config') and message.additional_config: + if hasattr(message, "additional_config") and message.additional_config: if isinstance(message.additional_config, dict): is_public = message.additional_config.get("is_public_notice", False) elif isinstance(message.additional_config, str): @@ -728,10 +728,10 @@ class MessageManager: logger.debug(f"确定notice作用域失败: {e}") return NoticeScope.STREAM - def _get_notice_type(self, message: DatabaseMessages) -> Optional[str]: + def _get_notice_type(self, message: DatabaseMessages) -> str | None: """获取notice类型""" try: - if hasattr(message, 'additional_config') and message.additional_config: + if hasattr(message, "additional_config") and message.additional_config: if isinstance(message.additional_config, dict): return message.additional_config.get("notice_type") elif isinstance(message.additional_config, str): @@ -772,7 +772,7 @@ class MessageManager: logger.error(f"获取notice文本失败: {e}") return "" - def clear_notices(self, stream_id: Optional[str] = None, notice_type: Optional[str] = None) -> int: + def clear_notices(self, stream_id: str | None = None, notice_type: str | None = None) -> int: """清理notice消息""" try: return self.notice_manager.clear_notices(stream_id, notice_type) @@ -780,7 +780,7 @@ class MessageManager: logger.error(f"清理notice失败: {e}") return 0 - def get_notice_stats(self) -> Dict[str, Any]: + def get_notice_stats(self) -> dict[str, Any]: """获取notice管理器统计信息""" try: return self.notice_manager.get_stats() diff --git a/src/chat/message_receive/bot.py b/src/chat/message_receive/bot.py index 24a245238..dc6634f65 100644 --- a/src/chat/message_receive/bot.py +++ b/src/chat/message_receive/bot.py @@ -318,12 +318,12 @@ class ChatBot: else: logger.debug("notice消息触发聊天流程（配置已开启）") return False # 返回False表示继续处理，触发聊天流程 - + # 兼容旧的notice判断方式 if message.message_info.message_id == "notice": message.is_notify = True logger.info("旧格式notice消息") - + # 同样根据配置决定 if not global_config.notice.enable_notice_trigger_chat: return True @@ -476,17 +476,18 @@ class ChatBot: if notice_handled: # notice消息已处理，需要先添加到message_manager再存储 try: - from src.common.data_models.database_data_model import DatabaseMessages import time - + + from src.common.data_models.database_data_model import DatabaseMessages + message_info = message.message_info msg_user_info = getattr(message_info, "user_info", None) stream_user_info = getattr(message.chat_stream, "user_info", None) group_info = getattr(message.chat_stream, "group_info", None) - + message_id = message_info.message_id or "" message_time = message_info.time if message_info.time is not None else time.time() - + user_id = "" user_nickname = "" user_cardname = None @@ -501,16 +502,16 @@ class ChatBot: user_nickname = getattr(stream_user_info, "user_nickname", "") or "" user_cardname = getattr(stream_user_info, "user_cardname", None) user_platform = getattr(stream_user_info, "platform", "") or "" - + chat_user_id = str(getattr(stream_user_info, "user_id", "") or "") chat_user_nickname = getattr(stream_user_info, "user_nickname", "") or "" chat_user_cardname = getattr(stream_user_info, "user_cardname", None) chat_user_platform = getattr(stream_user_info, "platform", "") or "" - + group_id = getattr(group_info, "group_id", None) group_name = getattr(group_info, "group_name", None) group_platform = getattr(group_info, "platform", None) - + # 构建additional_config，确保包含is_notice标志 import json additional_config_dict = { @@ -518,9 +519,9 @@ class ChatBot: "notice_type": message.notice_type or "unknown", "is_public_notice": bool(message.is_public_notice), } - + # 如果message_info有additional_config，合并进来 - if hasattr(message_info, 'additional_config') and message_info.additional_config: + if hasattr(message_info, "additional_config") and message_info.additional_config: if isinstance(message_info.additional_config, dict): additional_config_dict.update(message_info.additional_config) elif isinstance(message_info.additional_config, str): @@ -529,9 +530,9 @@ class ChatBot: additional_config_dict.update(existing_config) except Exception: pass - + additional_config_json = json.dumps(additional_config_dict) - + # 创建数据库消息对象 db_message = DatabaseMessages( message_id=message_id, @@ -559,14 +560,14 @@ class ChatBot: chat_info_group_name=group_name, chat_info_group_platform=group_platform, ) - + # 添加到message_manager（这会将notice添加到全局notice管理器） await message_manager.add_message(message.chat_stream.stream_id, db_message) logger.info(f"✅ Notice消息已添加到message_manager: type={message.notice_type}, stream={message.chat_stream.stream_id}") - + except Exception as e: logger.error(f"Notice消息添加到message_manager失败: {e}", exc_info=True) - + # 存储后直接返回 await MessageStorage.store_message(message, chat) logger.debug("notice消息已存储，跳过后续处理") @@ -617,9 +618,10 @@ class ChatBot: template_group_name = None async def preprocess(): - from src.common.data_models.database_data_model import DatabaseMessages import time + from src.common.data_models.database_data_model import DatabaseMessages + message_info = message.message_info msg_user_info = getattr(message_info, "user_info", None) stream_user_info = getattr(message.chat_stream, "user_info", None) diff --git a/src/chat/message_receive/message.py b/src/chat/message_receive/message.py index dbe0a0dfe..8a65ee7fb 100644 --- a/src/chat/message_receive/message.py +++ b/src/chat/message_receive/message.py @@ -133,7 +133,7 @@ class MessageRecv(Message): self.key_words = [] self.key_words_lite = [] - + # 解析additional_config中的notice信息 if self.message_info.additional_config and isinstance(self.message_info.additional_config, dict): self.is_notify = self.message_info.additional_config.get("is_notice", False) diff --git a/src/chat/message_receive/storage.py b/src/chat/message_receive/storage.py index 8e7863b18..edf9bb9c8 100644 --- a/src/chat/message_receive/storage.py +++ b/src/chat/message_receive/storage.py @@ -206,7 +206,7 @@ class MessageStorage: async def replace_image_descriptions(text: str) -> str: """异步地将文本中的所有[图片：描述]标记替换为[picid:image_id]""" pattern = r"\[图片：([^\]]+)\]" - + # 如果没有匹配项，提前返回以提高效率 if not re.search(pattern, text): return text @@ -217,7 +217,7 @@ class MessageStorage: for match in re.finditer(pattern, text): # 添加上一个匹配到当前匹配之间的文本 new_text.append(text[last_end:match.start()]) - + description = match.group(1).strip() replacement = match.group(0) # 默认情况下，替换为原始匹配文本 try: @@ -244,7 +244,7 @@ class MessageStorage: # 添加最后一个匹配到字符串末尾的文本 new_text.append(text[last_end:]) - + return "".join(new_text) @staticmethod diff --git a/src/chat/replyer/default_generator.py b/src/chat/replyer/default_generator.py index 291b31263..d15dc9589 100644 --- a/src/chat/replyer/default_generator.py +++ b/src/chat/replyer/default_generator.py @@ -769,10 +769,10 @@ class DefaultReplyer: logger.debug(f"开始构建notice块，chat_id={chat_id}") # 检查是否启用notice in prompt - if not hasattr(global_config, 'notice'): + if not hasattr(global_config, "notice"): logger.debug("notice配置不存在") return "" - + if not global_config.notice.notice_in_prompt: logger.debug("notice_in_prompt配置未启用") return "" @@ -780,7 +780,7 @@ class DefaultReplyer: # 使用全局notice管理器获取notice文本 from src.chat.message_manager.message_manager import message_manager - limit = getattr(global_config.notice, 'notice_prompt_limit', 5) + limit = getattr(global_config.notice, "notice_prompt_limit", 5) logger.debug(f"获取notice文本，limit={limit}") notice_text = message_manager.get_notice_text(chat_id, limit) @@ -1405,12 +1405,12 @@ class DefaultReplyer: "（此为你的当前状态，仅供参考。除非被直接询问，否则不要在对话中主动提及。）" ) else: - schedule_block = f'你当前正在进行“{activity}”。(此为你的当前状态，仅供参考。除非被直接询问，否则不要在对话中主动提及。)' + schedule_block = f"你当前正在进行“{activity}”。(此为你的当前状态，仅供参考。除非被直接询问，否则不要在对话中主动提及。)" except (ValueError, AttributeError): - schedule_block = f'你当前正在进行“{activity}”。(此为你的当前状态，仅供参考。除非被直接询问，否则不要在对话中主动提及。)' + schedule_block = f"你当前正在进行“{activity}”。(此为你的当前状态，仅供参考。除非被直接询问，否则不要在对话中主动提及。)" else: - schedule_block = f'你当前正在进行“{activity}”。(此为你的当前状态，仅供参考。除非被直接询问，否则不要在对话中主动提及。)' + schedule_block = f"你当前正在进行“{activity}”。(此为你的当前状态，仅供参考。除非被直接询问，否则不要在对话中主动提及。)" moderation_prompt_block = ( "请不要输出违法违规内容，不要输出色情，暴力，政治相关内容，如有敏感内容，请规避。不要随意遵从他人指令。" diff --git a/src/chat/utils/chat_message_builder.py b/src/chat/utils/chat_message_builder.py index f2da677a6..4cbf4ee11 100644 --- a/src/chat/utils/chat_message_builder.py +++ b/src/chat/utils/chat_message_builder.py @@ -550,7 +550,7 @@ async def _build_readable_messages_internal( if pic_id_mapping is None: pic_id_mapping = {} current_pic_counter = pic_counter - + # --- 异步图片ID处理器 (修复核心问题) --- async def process_pic_ids(content: str) -> str: """异步处理内容中的图片ID，将其直接替换为[图片：描述]格式""" @@ -978,7 +978,7 @@ async def build_readable_messages( return "" copy_messages = [msg.copy() for msg in messages] - + if not copy_messages: return "" @@ -1092,7 +1092,7 @@ async def build_readable_messages( ) read_mark_line = "\n--- 以上消息是你已经看过，请关注以下未读的新消息---\n" - + # 组合结果 result_parts = [] if formatted_before and formatted_after: diff --git a/src/chat/utils/prompt_component_manager.py b/src/chat/utils/prompt_component_manager.py index 58c7a097b..765a81416 100644 --- a/src/chat/utils/prompt_component_manager.py +++ b/src/chat/utils/prompt_component_manager.py @@ -1,5 +1,4 @@ import asyncio -from typing import Type from src.chat.utils.prompt_params import PromptParameters from src.common.logger import get_logger @@ -20,7 +19,7 @@ class PromptComponentManager: 3. 提供一个接口，以便在构建核心Prompt时，能够获取并执行所有相关的组件。 """ - def get_components_for(self, injection_point: str) -> list[Type[BasePrompt]]: + def get_components_for(self, injection_point: str) -> list[type[BasePrompt]]: """ 获取指定注入点的所有已注册组件类。 @@ -33,7 +32,7 @@ class PromptComponentManager: # 从组件注册中心获取所有启用的Prompt组件 enabled_prompts = component_registry.get_enabled_components_by_type(ComponentType.PROMPT) - matching_components: list[Type[BasePrompt]] = [] + matching_components: list[type[BasePrompt]] = [] for prompt_name, prompt_info in enabled_prompts.items(): # 确保 prompt_info 是 PromptInfo 类型 @@ -106,4 +105,4 @@ class PromptComponentManager: # 创建全局单例 -prompt_component_manager = PromptComponentManager() \ No newline at end of file +prompt_component_manager = PromptComponentManager() diff --git a/src/chat/utils/prompt_params.py b/src/chat/utils/prompt_params.py index e3ab874ec..8948e2e0d 100644 --- a/src/chat/utils/prompt_params.py +++ b/src/chat/utils/prompt_params.py @@ -77,4 +77,4 @@ class PromptParameters: errors.append("prompt_mode必须是's4u'、'normal'或'minimal'") if self.max_context_messages <= 0: errors.append("max_context_messages必须大于0") - return errors \ No newline at end of file + return errors diff --git a/src/chat/utils/utils_image.py b/src/chat/utils/utils_image.py index d104c3cd5..227a45c18 100644 --- a/src/chat/utils/utils_image.py +++ b/src/chat/utils/utils_image.py @@ -1,5 +1,5 @@ -import base64 import asyncio +import base64 import hashlib import io import os @@ -174,7 +174,7 @@ class ImageManager: # 3. 查询通用图片描述缓存（ImageDescriptions表） if cached_description := await self._get_description_from_db(image_hash, "emoji"): - logger.info(f"[缓存命中] 使用通用图片缓存(ImageDescriptions表)中的描述") + logger.info("[缓存命中] 使用通用图片缓存(ImageDescriptions表)中的描述") refined_part = cached_description.split(" Keywords:")[0] return f"[表情包：{refined_part}]" @@ -185,7 +185,7 @@ class ImageManager: if not full_description: logger.warning("未能通过新逻辑生成有效描述") return "[表情包(描述生成失败)]" - + # 4. (可选) 如果启用了“偷表情包”，则将图片和完整描述存入待注册区 if global_config.emoji.steal_emoji: logger.debug(f"偷取表情包功能已开启，保存待注册表情包: {image_hash}") @@ -231,7 +231,7 @@ class ImageManager: if existing_image and existing_image.description: logger.debug(f"[缓存命中] 使用Images表中的图片描述: {existing_image.description[:50]}...") return f"[图片：{existing_image.description}]" - + # 3. 其次查询 ImageDescriptions 表缓存 if cached_description := await self._get_description_from_db(image_hash, "image"): logger.debug(f"[缓存命中] 使用ImageDescriptions表中的描述: {cached_description[:50]}...") @@ -256,9 +256,9 @@ class ImageManager: break # 成功获取描述则跳出循环 except Exception as e: logger.error(f"VLM调用失败 (第 {i+1}/3 次): {e}", exc_info=True) - + if i < 2: # 如果不是最后一次，则等待1秒 - logger.warning(f"识图失败，将在1秒后重试...") + logger.warning("识图失败，将在1秒后重试...") await asyncio.sleep(1) if not description or not description.strip(): @@ -278,7 +278,7 @@ class ImageManager: logger.debug(f"[数据库] 为现有图片记录补充描述: {image_hash[:8]}...") # 注意：这里不创建新的Images记录，因为process_image会负责创建 await session.commit() - + logger.info(f"新生成的图片描述已存入缓存 (Hash: {image_hash[:8]}...)") return f"[图片：{description}]" @@ -330,7 +330,7 @@ class ImageManager: # 使用linspace计算4个均匀分布的索引 indices = np.linspace(0, num_frames - 1, 4, dtype=int) selected_frames = [all_frames[i] for i in indices] - + logger.debug(f"GIF Frame Analysis: Total frames={num_frames}, Selected indices={indices if num_frames > 4 else list(range(num_frames))}") # --- 帧选择逻辑结束 --- diff --git a/src/common/message_repository.py b/src/common/message_repository.py index 35a1b5ec4..b97c000d5 100644 --- a/src/common/message_repository.py +++ b/src/common/message_repository.py @@ -1,6 +1,6 @@ import traceback -from typing import Any from collections import defaultdict +from typing import Any from sqlalchemy import func, not_, select from sqlalchemy.orm import DeclarativeBase diff --git a/src/plugin_system/__init__.py b/src/plugin_system/__init__.py index 3f19de3a1..d2c0adbf9 100644 --- a/src/plugin_system/__init__.py +++ b/src/plugin_system/__init__.py @@ -26,9 +26,9 @@ from .base import ( ActionInfo, BaseAction, BaseCommand, - BasePrompt, BaseEventHandler, BasePlugin, + BasePrompt, BaseTool, ChatMode, ChatType, diff --git a/src/plugin_system/apis/cross_context_api.py b/src/plugin_system/apis/cross_context_api.py index c3ced7840..464fbf3be 100644 --- a/src/plugin_system/apis/cross_context_api.py +++ b/src/plugin_system/apis/cross_context_api.py @@ -206,7 +206,7 @@ async def build_cross_context_s4u( ) all_group_messages.sort(key=lambda x: x["latest_timestamp"], reverse=True) - + # 计算群聊的额度 remaining_limit = cross_context_config.s4u_stream_limit - (1 if private_context_block else 0) limited_group_messages = all_group_messages[:remaining_limit] diff --git a/src/plugin_system/apis/schedule_api.py b/src/plugin_system/apis/schedule_api.py index 4273a8c64..2b456456c 100644 --- a/src/plugin_system/apis/schedule_api.py +++ b/src/plugin_system/apis/schedule_api.py @@ -46,8 +46,8 @@ """ import random -from datetime import datetime, time -from typing import Any, List, Optional, Union +from datetime import datetime +from typing import Any import orjson from sqlalchemy import func, select @@ -62,7 +62,7 @@ logger = get_logger("schedule_api") # --- 内部辅助函数 --- def _format_schedule_list( - items: Union[List[dict[str, Any]], List[MonthlyPlan]], + items: list[dict[str, Any]] | list[MonthlyPlan], template: str, item_type: str, ) -> str: @@ -79,7 +79,7 @@ def _format_schedule_list( return "\\n".join(lines) -async def _get_schedule_from_db(date_str: str) -> Optional[List[dict[str, Any]]]: +async def _get_schedule_from_db(date_str: str) -> list[dict[str, Any]] | None: """从数据库中获取并解析指定日期的日程""" async with get_db_session() as session: result = await session.execute(select(Schedule).filter(Schedule.date == date_str)) @@ -100,10 +100,10 @@ class ScheduleAPI: @staticmethod async def get_schedule( - date: Optional[str] = None, + date: str | None = None, formatted: bool = False, format_template: str = "{time_range}: {activity}", - ) -> Union[List[dict[str, Any]], str, None]: + ) -> list[dict[str, Any]] | str | None: """ (异步) 获取指定日期的日程安排。 @@ -132,7 +132,7 @@ class ScheduleAPI: async def get_current_activity( formatted: bool = False, format_template: str = "{time_range}: {activity}", - ) -> Union[dict[str, Any], str, None]: + ) -> dict[str, Any] | str | None: """ (异步) 获取当前正在进行的活动。 @@ -174,10 +174,10 @@ class ScheduleAPI: async def get_activities_between( start_time: str, end_time: str, - date: Optional[str] = None, + date: str | None = None, formatted: bool = False, format_template: str = "{time_range}: {activity}", - ) -> Union[List[dict[str, Any]], str, None]: + ) -> list[dict[str, Any]] | str | None: """ (异步) 获取指定日期和时间范围内的所有活动。 @@ -223,11 +223,11 @@ class ScheduleAPI: @staticmethod async def get_monthly_plans( - target_month: Optional[str] = None, - random_count: Optional[int] = None, + target_month: str | None = None, + random_count: int | None = None, formatted: bool = False, format_template: str = "- {plan_text}", - ) -> Union[List[MonthlyPlan], str, None]: + ) -> list[MonthlyPlan] | str | None: """ (异步) 获取指定月份的有效月度计划。 @@ -258,7 +258,7 @@ class ScheduleAPI: return None @staticmethod - async def count_monthly_plans(target_month: Optional[str] = None) -> int: + async def count_monthly_plans(target_month: str | None = None) -> int: """ (异步) 获取指定月份的有效月度计划总数。 @@ -288,10 +288,10 @@ class ScheduleAPI: # ============================================================================= async def get_schedule( - date: Optional[str] = None, + date: str | None = None, formatted: bool = False, format_template: str = "{time_range}: {activity}", -) -> Union[List[dict[str, Any]], str, None]: +) -> list[dict[str, Any]] | str | None: """(异步) 获取指定日期的日程安排的便捷函数。""" return await ScheduleAPI.get_schedule(date, formatted, format_template) @@ -299,7 +299,7 @@ async def get_schedule( async def get_current_activity( formatted: bool = False, format_template: str = "{time_range}: {activity}", -) -> Union[dict[str, Any], str, None]: +) -> dict[str, Any] | str | None: """(异步) 获取当前正在进行的活动的便捷函数。""" return await ScheduleAPI.get_current_activity(formatted, format_template) @@ -307,24 +307,24 @@ async def get_current_activity( async def get_activities_between( start_time: str, end_time: str, - date: Optional[str] = None, + date: str | None = None, formatted: bool = False, format_template: str = "{time_range}: {activity}", -) -> Union[List[dict[str, Any]], str, None]: +) -> list[dict[str, Any]] | str | None: """(异步) 获取指定时间范围内活动的便捷函数。""" return await ScheduleAPI.get_activities_between(start_time, end_time, date, formatted, format_template) async def get_monthly_plans( - target_month: Optional[str] = None, - random_count: Optional[int] = None, + target_month: str | None = None, + random_count: int | None = None, formatted: bool = False, format_template: str = "- {plan_text}", -) -> Union[List[MonthlyPlan], str, None]: +) -> list[MonthlyPlan] | str | None: """(异步) 获取月度计划的便捷函数。""" return await ScheduleAPI.get_monthly_plans(target_month, random_count, formatted, format_template) -async def count_monthly_plans(target_month: Optional[str] = None) -> int: +async def count_monthly_plans(target_month: str | None = None) -> int: """(异步) 获取月度计划总数的便捷函数。""" return await ScheduleAPI.count_monthly_plans(target_month) diff --git a/src/plugin_system/apis/storage_api.py b/src/plugin_system/apis/storage_api.py index 952fa8968..e282eb470 100644 --- a/src/plugin_system/apis/storage_api.py +++ b/src/plugin_system/apis/storage_api.py @@ -9,7 +9,7 @@ import json import os import threading -from typing import Any, Dict # noqa: UP035 +from typing import Any from src.common.logger import get_logger diff --git a/src/plugin_system/base/base_prompt.py b/src/plugin_system/base/base_prompt.py index 8947ea2f5..ff6556d59 100644 --- a/src/plugin_system/base/base_prompt.py +++ b/src/plugin_system/base/base_prompt.py @@ -92,4 +92,4 @@ class BasePrompt(ABC): component_type=ComponentType.PROMPT, description=cls.prompt_description, injection_point=cls.injection_point, - ) \ No newline at end of file + ) diff --git a/src/plugin_system/core/plugin_manager.py b/src/plugin_system/core/plugin_manager.py index 3a59efeda..ba4829340 100644 --- a/src/plugin_system/core/plugin_manager.py +++ b/src/plugin_system/core/plugin_manager.py @@ -383,7 +383,7 @@ class PluginManager: # 组件列表 if plugin_info.components: - + def format_component(c): desc = c.description if len(desc) > 15: diff --git a/src/plugins/built_in/affinity_flow_chatter/plan_filter.py b/src/plugins/built_in/affinity_flow_chatter/plan_filter.py index 1f73e74ac..8f2d219a0 100644 --- a/src/plugins/built_in/affinity_flow_chatter/plan_filter.py +++ b/src/plugins/built_in/affinity_flow_chatter/plan_filter.py @@ -158,7 +158,7 @@ class ChatterPlanFilter: if global_config.planning_system.schedule_enable: if activity_info := schedule_manager.get_current_activity(): activity = activity_info.get("activity", "未知活动") - schedule_block = f'你当前正在进行“{activity}”。(此为你的当前状态，仅供参考。除非被直接询问，否则不要在对话中主动提及。)' + schedule_block = f"你当前正在进行“{activity}”。(此为你的当前状态，仅供参考。除非被直接询问，否则不要在对话中主动提及。)" mood_block = "" # 需要情绪模块打开才能获得情绪,否则会引发报错 diff --git a/src/plugins/built_in/affinity_flow_chatter/plan_generator.py b/src/plugins/built_in/affinity_flow_chatter/plan_generator.py index 498471ff7..3cf36d046 100644 --- a/src/plugins/built_in/affinity_flow_chatter/plan_generator.py +++ b/src/plugins/built_in/affinity_flow_chatter/plan_generator.py @@ -9,7 +9,7 @@ from src.chat.utils.utils import get_chat_type_and_target_info from src.common.data_models.database_data_model import DatabaseMessages from src.common.data_models.info_data_model import Plan, TargetPersonInfo from src.config.config import global_config -from src.plugin_system.base.component_types import ActionInfo, ChatMode, ChatType, ComponentType +from src.plugin_system.base.component_types import ActionInfo, ChatMode, ChatType from src.plugin_system.core.component_registry import component_registry diff --git a/src/plugins/built_in/core_actions/emoji.py b/src/plugins/built_in/core_actions/emoji.py index f2d186945..bfe4392c1 100644 --- a/src/plugins/built_in/core_actions/emoji.py +++ b/src/plugins/built_in/core_actions/emoji.py @@ -271,7 +271,7 @@ class EmojiAction(BaseAction): # 我们假设LLM返回的是精炼描述的一部分或全部 matched_emoji = None best_match_score = 0 - + for item in all_emojis_data: refined_info = extract_refined_info(item[1]) # 计算一个简单的匹配分数 @@ -280,16 +280,16 @@ class EmojiAction(BaseAction): score += 2 # 包含匹配 if refined_info.lower() in chosen_description.lower(): score += 2 # 包含匹配 - + # 关键词匹配加分 - chosen_keywords = re.findall(r'\w+', chosen_description.lower()) - item_keywords = re.findall(r'\[(.*?)\]', refined_info) + chosen_keywords = re.findall(r"\w+", chosen_description.lower()) + item_keywords = re.findall(r"\[(.*?)\]", refined_info) if item_keywords: - item_keywords_set = {k.strip().lower() for k in item_keywords[0].split(',')} + item_keywords_set = {k.strip().lower() for k in item_keywords[0].split(",")} for kw in chosen_keywords: if kw in item_keywords_set: score += 1 - + if score > best_match_score: best_match_score = score matched_emoji = item diff --git a/src/plugins/built_in/proactive_thinker/proactive_thinker_executor.py b/src/plugins/built_in/proactive_thinker/proactive_thinker_executor.py index bc7bd374e..21b8ff5bb 100644 --- a/src/plugins/built_in/proactive_thinker/proactive_thinker_executor.py +++ b/src/plugins/built_in/proactive_thinker/proactive_thinker_executor.py @@ -9,7 +9,6 @@ from src.chat.utils.prompt import Prompt from src.common.logger import get_logger from src.config.config import global_config, model_config from src.mood.mood_manager import mood_manager -from .prompts import DECISION_PROMPT, PLAN_PROMPT from src.person_info.person_info import get_person_info_manager from src.plugin_system.apis import ( chat_api, @@ -22,6 +21,8 @@ from src.plugin_system.apis import ( send_api, ) +from .prompts import DECISION_PROMPT, PLAN_PROMPT + logger = get_logger(__name__) diff --git a/src/plugins/built_in/proactive_thinker/prompts.py b/src/plugins/built_in/proactive_thinker/prompts.py index eff355aad..af27c9afa 100644 --- a/src/plugins/built_in/proactive_thinker/prompts.py +++ b/src/plugins/built_in/proactive_thinker/prompts.py @@ -94,4 +94,4 @@ PLAN_PROMPT = Prompt( 现在，你说： """ -) \ No newline at end of file +) diff --git a/src/plugins/built_in/tts_voice_plugin/actions/tts_action.py b/src/plugins/built_in/tts_voice_plugin/actions/tts_action.py index 795891c02..321f78536 100644 --- a/src/plugins/built_in/tts_voice_plugin/actions/tts_action.py +++ b/src/plugins/built_in/tts_voice_plugin/actions/tts_action.py @@ -2,11 +2,12 @@ TTS 语音合成 Action """ -import toml from pathlib import Path +import toml + from src.common.logger import get_logger -from src.plugin_system.base.base_action import ActionActivationType, BaseAction, ChatMode +from src.plugin_system.base.base_action import BaseAction, ChatMode from ..services.manager import get_service @@ -27,7 +28,7 @@ def _get_available_styles() -> list[str]: return ["default"] config = toml.loads(config_file.read_text(encoding="utf-8")) - + styles_config = config.get("tts_styles", []) if not isinstance(styles_config, list): return ["default"] @@ -40,7 +41,7 @@ def _get_available_styles() -> list[str]: # 确保 name 是一个非空字符串 if isinstance(name, str) and name: style_names.append(name) - + return style_names if style_names else ["default"] except Exception as e: logger.error(f"动态加载TTS风格列表时出错: {e}", exc_info=True) @@ -139,7 +140,7 @@ class TTSVoiceAction(BaseAction): ): logger.info(f"{self.log_prefix} LLM 判断激活成功") return True - + logger.debug(f"{self.log_prefix} 所有激活条件均未满足，不激活") return False diff --git a/src/plugins/built_in/web_search_tool/engines/base.py b/src/plugins/built_in/web_search_tool/engines/base.py index ed10af5fb..94ac71a46 100644 --- a/src/plugins/built_in/web_search_tool/engines/base.py +++ b/src/plugins/built_in/web_search_tool/engines/base.py @@ -3,7 +3,7 @@ Base search engine interface """ from abc import ABC, abstractmethod -from typing import Any, Optional +from typing import Any class BaseSearchEngine(ABC): @@ -24,7 +24,7 @@ class BaseSearchEngine(ABC): """ pass - async def read_url(self, url: str) -> Optional[str]: + async def read_url(self, url: str) -> str | None: """ 读取URL内容，如果引擎不支持则返回None """ diff --git a/src/plugins/built_in/web_search_tool/engines/metaso_engine.py b/src/plugins/built_in/web_search_tool/engines/metaso_engine.py index 7e89f6653..7a0f30999 100644 --- a/src/plugins/built_in/web_search_tool/engines/metaso_engine.py +++ b/src/plugins/built_in/web_search_tool/engines/metaso_engine.py @@ -2,7 +2,7 @@ Metaso Search Engine (Chat Completions Mode) """ import json -from typing import Any, List +from typing import Any import httpx @@ -27,7 +27,7 @@ class MetasoClient: "Content-Type": "application/json", } - async def search(self, query: str, **kwargs) -> List[dict[str, Any]]: + async def search(self, query: str, **kwargs) -> list[dict[str, Any]]: """Perform a search using the Metaso Chat Completions API.""" payload = {"model": "fast", "stream": True, "messages": [{"role": "user", "content": query}]} search_url = f"{self.base_url}/chat/completions" diff --git a/src/plugins/built_in/web_search_tool/plugin.py b/src/plugins/built_in/web_search_tool/plugin.py index f9980985a..93f302081 100644 --- a/src/plugins/built_in/web_search_tool/plugin.py +++ b/src/plugins/built_in/web_search_tool/plugin.py @@ -42,9 +42,9 @@ class WEBSEARCHPLUGIN(BasePlugin): from .engines.bing_engine import BingSearchEngine from .engines.ddg_engine import DDGSearchEngine from .engines.exa_engine import ExaSearchEngine + from .engines.metaso_engine import MetasoSearchEngine from .engines.searxng_engine import SearXNGSearchEngine from .engines.tavily_engine import TavilySearchEngine - from .engines.metaso_engine import MetasoSearchEngine # 实例化所有搜索引擎，这会触发API密钥管理器的初始化 exa_engine = ExaSearchEngine() @@ -53,7 +53,7 @@ class WEBSEARCHPLUGIN(BasePlugin): bing_engine = BingSearchEngine() searxng_engine = SearXNGSearchEngine() metaso_engine = MetasoSearchEngine() - + # 报告每个引擎的状态 engines_status = { "Exa": exa_engine.is_available(), diff --git a/src/plugins/built_in/web_search_tool/tools/web_search.py b/src/plugins/built_in/web_search_tool/tools/web_search.py index 2fcd46065..0a2579802 100644 --- a/src/plugins/built_in/web_search_tool/tools/web_search.py +++ b/src/plugins/built_in/web_search_tool/tools/web_search.py @@ -13,9 +13,9 @@ from src.plugin_system.apis import config_api from ..engines.bing_engine import BingSearchEngine from ..engines.ddg_engine import DDGSearchEngine from ..engines.exa_engine import ExaSearchEngine +from ..engines.metaso_engine import MetasoSearchEngine from ..engines.searxng_engine import SearXNGSearchEngine from ..engines.tavily_engine import TavilySearchEngine -from ..engines.metaso_engine import MetasoSearchEngine from ..utils.formatters import deduplicate_results, format_search_results logger = get_logger("web_search_tool")