Merge branch 'dev' of https://github.com/MaiM-with-u/MaiBot into dev

src/chat/planner_actions/action_manager.py

@@ -1,15 +1,12 @@
-from typing import Dict, List, Optional, Type, Any
+from typing import Dict, List, Optional, Type
 from src.plugin_system.base.base_action import BaseAction
 from src.chat.message_receive.chat_stream import ChatStream
 from src.common.logger import get_logger
 from src.plugin_system.core.component_registry import component_registry
-from src.plugin_system.base.component_types import ComponentType
+from src.plugin_system.base.component_types import ComponentType, ActionActivationType, ChatMode, ActionInfo
 
 logger = get_logger("action_manager")
 
-# 定义动作信息类型
-ActionInfo = Dict[str, Any]
-
 
 class ActionManager:
     """
@@ -20,8 +17,8 @@ class ActionManager:
 
     # 类常量
     DEFAULT_RANDOM_PROBABILITY = 0.3
-    DEFAULT_MODE = "all"
-    DEFAULT_ACTIVATION_TYPE = "always"
+    DEFAULT_MODE = ChatMode.ALL
+    DEFAULT_ACTIVATION_TYPE = ActionActivationType.ALWAYS
 
     def __init__(self):
         """初始化动作管理器"""
@@ -30,14 +27,11 @@ class ActionManager:
         # 当前正在使用的动作集合，默认加载默认动作
         self._using_actions: Dict[str, ActionInfo] = {}
 
-        # 默认动作集，仅作为快照，用于恢复默认
-        self._default_actions: Dict[str, ActionInfo] = {}
-
         # 加载插件动作
         self._load_plugin_actions()
 
         # 初始化时将默认动作加载到使用中的动作
-        self._using_actions = self._default_actions.copy()
+        self._using_actions = component_registry.get_default_actions()
 
     def _load_plugin_actions(self) -> None:
         """
@@ -54,43 +48,15 @@ class ActionManager:
     def _load_plugin_system_actions(self) -> None:
         """从插件系统的component_registry加载Action组件"""
         try:
-            from src.plugin_system.core.component_registry import component_registry
-            from src.plugin_system.base.component_types import ComponentType
-
             # 获取所有Action组件
-            action_components = component_registry.get_components_by_type(ComponentType.ACTION)
+            action_components: Dict[str, ActionInfo] = component_registry.get_components_by_type(ComponentType.ACTION)  # type: ignore
 
             for action_name, action_info in action_components.items():
                 if action_name in self._registered_actions:
                     logger.debug(f"Action组件 {action_name} 已存在，跳过")
                     continue
 
-                # 将插件系统的ActionInfo转换为ActionManager格式
-                converted_action_info = {
-                    "description": action_info.description,
-                    "parameters": getattr(action_info, "action_parameters", {}),
-                    "require": getattr(action_info, "action_require", []),
-                    "associated_types": getattr(action_info, "associated_types", []),
-                    "enable_plugin": action_info.enabled,
-                    # 激活类型相关
-                    "focus_activation_type": action_info.focus_activation_type.value,
-                    "normal_activation_type": action_info.normal_activation_type.value,
-                    "random_activation_probability": action_info.random_activation_probability,
-                    "llm_judge_prompt": action_info.llm_judge_prompt,
-                    "activation_keywords": action_info.activation_keywords,
-                    "keyword_case_sensitive": action_info.keyword_case_sensitive,
-                    # 模式和并行设置
-                    "mode_enable": action_info.mode_enable.value,
-                    "parallel_action": action_info.parallel_action,
-                    # 插件信息
-                    "_plugin_name": getattr(action_info, "plugin_name", ""),
-                }
-
-                self._registered_actions[action_name] = converted_action_info
-
-                # 如果启用，也添加到默认动作集
-                if action_info.enabled:
-                    self._default_actions[action_name] = converted_action_info
+                self._registered_actions[action_name] = action_info
 
                 logger.debug(
                     f"从插件系统加载Action组件: {action_name} (插件: {getattr(action_info, 'plugin_name', 'unknown')})"
@@ -133,7 +99,9 @@ class ActionManager:
         """
         try:
             # 获取组件类 - 明确指定查询Action类型
-            component_class = component_registry.get_component_class(action_name, ComponentType.ACTION)
+            component_class: Type[BaseAction] = component_registry.get_component_class(
+                action_name, ComponentType.ACTION
+            )  # type: ignore
             if not component_class:
                 logger.warning(f"{log_prefix} 未找到Action组件: {action_name}")
                 return None
@@ -173,10 +141,6 @@ class ActionManager:
         """获取所有已注册的动作集"""
         return self._registered_actions.copy()
 
-    def get_default_actions(self) -> Dict[str, ActionInfo]:
-        """获取默认动作集"""
-        return self._default_actions.copy()
-
     def get_using_actions(self) -> Dict[str, ActionInfo]:
         """获取当前正在使用的动作集合"""
         return self._using_actions.copy()
@@ -221,31 +185,31 @@ class ActionManager:
         logger.debug(f"已从使用集中移除动作 {action_name}")
         return True
 
-    def add_action(self, action_name: str, description: str, parameters: Dict = None, require: List = None) -> bool:
-        """
-        添加新的动作到注册集
+    # def add_action(self, action_name: str, description: str, parameters: Dict = None, require: List = None) -> bool:
+    #     """
+    #     添加新的动作到注册集
 
-        Args:
-            action_name: 动作名称
-            description: 动作描述
-            parameters: 动作参数定义，默认为空字典
-            require: 动作依赖项，默认为空列表
+    #     Args:
+    #         action_name: 动作名称
+    #         description: 动作描述
+    #         parameters: 动作参数定义，默认为空字典
+    #         require: 动作依赖项，默认为空列表
 
-        Returns:
-            bool: 添加是否成功
-        """
-        if action_name in self._registered_actions:
-            return False
+    #     Returns:
+    #         bool: 添加是否成功
+    #     """
+    #     if action_name in self._registered_actions:
+    #         return False
 
-        if parameters is None:
-            parameters = {}
-        if require is None:
-            require = []
+    #     if parameters is None:
+    #         parameters = {}
+    #     if require is None:
+    #         require = []
 
-        action_info = {"description": description, "parameters": parameters, "require": require}
+    #     action_info = {"description": description, "parameters": parameters, "require": require}
 
-        self._registered_actions[action_name] = action_info
-        return True
+    #     self._registered_actions[action_name] = action_info
+    #     return True
 
     def remove_action(self, action_name: str) -> bool:
         """从注册集移除指定动作"""
@@ -264,10 +228,9 @@ class ActionManager:
 
     def restore_actions(self) -> None:
         """恢复到默认动作集"""
-        logger.debug(
-            f"恢复动作集: 从 {list(self._using_actions.keys())} 恢复到默认动作集 {list(self._default_actions.keys())}"
-        )
-        self._using_actions = self._default_actions.copy()
+        actions_to_restore = list(self._using_actions.keys())
+        self._using_actions = component_registry.get_default_actions()
+        logger.debug(f"恢复动作集: 从 {actions_to_restore} 恢复到默认动作集 {list(self._using_actions.keys())}")
 
     def add_system_action_if_needed(self, action_name: str) -> bool:
         """
@@ -297,4 +260,4 @@ class ActionManager:
         """
         from src.plugin_system.core.component_registry import component_registry
 
-        return component_registry.get_component_class(action_name)
+        return component_registry.get_component_class(action_name)  # type: ignore

src/chat/planner_actions/action_modifier.py

@@ -1,15 +1,20 @@
-from typing import List, Any, Dict
-from src.common.logger import get_logger
-from src.chat.focus_chat.hfc_utils import CycleDetail
-from src.chat.message_receive.chat_stream import get_chat_manager
-from src.config.config import global_config
-from src.llm_models.utils_model import LLMRequest
 import random
 import asyncio
 import hashlib
 import time
+from typing import List, Any, Dict, TYPE_CHECKING
+
+from src.common.logger import get_logger
+from src.config.config import global_config
+from src.llm_models.utils_model import LLMRequest
+from src.chat.focus_chat.hfc_utils import CycleDetail
+from src.chat.message_receive.chat_stream import get_chat_manager, ChatMessageContext
 from src.chat.planner_actions.action_manager import ActionManager
 from src.chat.utils.chat_message_builder import get_raw_msg_before_timestamp_with_chat, build_readable_messages
+from src.plugin_system.base.component_types import ChatMode, ActionInfo, ActionActivationType
+
+if TYPE_CHECKING:
+    from src.chat.message_receive.chat_stream import ChatStream
 
 logger = get_logger("action_manager")
 
@@ -25,7 +30,7 @@ class ActionModifier:
     def __init__(self, action_manager: ActionManager, chat_id: str):
         """初始化动作处理器"""
         self.chat_id = chat_id
-        self.chat_stream = get_chat_manager().get_stream(self.chat_id)
+        self.chat_stream: ChatStream = get_chat_manager().get_stream(self.chat_id)  # type: ignore
         self.log_prefix = f"[{get_chat_manager().get_stream_name(self.chat_id) or self.chat_id}]"
 
         self.action_manager = action_manager
@@ -45,7 +50,7 @@ class ActionModifier:
         self,
         history_loop=None,
         message_content: str = "",
-    ):
+    ):  # sourcery skip: use-named-expression
         """
         动作修改流程，整合传统观察处理和新的激活类型判定
 
@@ -82,9 +87,9 @@ class ActionModifier:
 
         # === 第一阶段：传统观察处理 ===
         # if history_loop:
-            # removals_from_loop = await self.analyze_loop_actions(history_loop)
-            # if removals_from_loop:
-                # removals_s1.extend(removals_from_loop)
+        # removals_from_loop = await self.analyze_loop_actions(history_loop)
+        # if removals_from_loop:
+        # removals_s1.extend(removals_from_loop)
 
         # 检查动作的关联类型
         chat_context = self.chat_stream.context
@@ -125,15 +130,14 @@ class ActionModifier:
             f"{self.log_prefix} 动作修改流程结束，最终可用动作: {list(self.action_manager.get_using_actions().keys())}||移除记录: {removals_summary}"
         )
 
-    def _check_action_associated_types(self, all_actions, chat_context):
+    def _check_action_associated_types(self, all_actions: Dict[str, ActionInfo], chat_context: ChatMessageContext):
         type_mismatched_actions = []
-        for action_name, data in all_actions.items():
-            if data.get("associated_types"):
-                if not chat_context.check_types(data["associated_types"]):
-                    associated_types_str = ", ".join(data["associated_types"])
-                    reason = f"适配器不支持（需要: {associated_types_str}）"
-                    type_mismatched_actions.append((action_name, reason))
-                    logger.debug(f"{self.log_prefix}决定移除动作: {action_name}，原因: {reason}")
+        for action_name, action_info in all_actions.items():
+            if action_info.associated_types and not chat_context.check_types(action_info.associated_types):
+                associated_types_str = ", ".join(action_info.associated_types)
+                reason = f"适配器不支持（需要: {associated_types_str}）"
+                type_mismatched_actions.append((action_name, reason))
+                logger.debug(f"{self.log_prefix}决定移除动作: {action_name}，原因: {reason}")
         return type_mismatched_actions
 
     async def _get_deactivated_actions_by_type(
@@ -167,28 +171,28 @@ class ActionModifier:
             if activation_type == "always":
                 continue  # 总是激活，无需处理
 
-            elif activation_type == "random":
-                probability = action_info.get("random_activation_probability", ActionManager.DEFAULT_RANDOM_PROBABILITY)
-                if not (random.random() < probability):
+            elif activation_type == ActionActivationType.RANDOM:
+                probability = action_info.random_activation_probability or ActionManager.DEFAULT_RANDOM_PROBABILITY
+                if random.random() >= probability:
                     reason = f"RANDOM类型未触发（概率{probability}）"
                     deactivated_actions.append((action_name, reason))
                     logger.debug(f"{self.log_prefix}未激活动作: {action_name}，原因: {reason}")
 
-            elif activation_type == "keyword":
+            elif activation_type == ActionActivationType.KEYWORD:
                 if not self._check_keyword_activation(action_name, action_info, chat_content):
-                    keywords = action_info.get("activation_keywords", [])
+                    keywords = action_info.activation_keywords
                     reason = f"关键词未匹配（关键词: {keywords}）"
                     deactivated_actions.append((action_name, reason))
                     logger.debug(f"{self.log_prefix}未激活动作: {action_name}，原因: {reason}")
 
-            elif activation_type == "llm_judge":
+            elif activation_type == ActionActivationType.LLM_JUDGE:
                 llm_judge_actions[action_name] = action_info
 
             elif activation_type == "never":
                 reason = "激活类型为never"
                 deactivated_actions.append((action_name, reason))
                 logger.debug(f"{self.log_prefix}未激活动作: {action_name}，原因: 激活类型为never")
-            
+
             else:
                 logger.warning(f"{self.log_prefix}未知的激活类型: {activation_type}，跳过处理")
 
@@ -273,7 +277,7 @@ class ActionModifier:
                 task_results = await asyncio.gather(*tasks, return_exceptions=True)
 
                 # 处理结果并更新缓存
-                for _, (action_name, result) in enumerate(zip(task_names, task_results, strict=False)):
+                for action_name, result in zip(task_names, task_results, strict=False):
                     if isinstance(result, Exception):
                         logger.error(f"{self.log_prefix}LLM判定action {action_name} 时出错: {result}")
                         results[action_name] = False
@@ -289,7 +293,7 @@ class ActionModifier:
             except Exception as e:
                 logger.error(f"{self.log_prefix}并行LLM判定失败: {e}")
                 # 如果并行执行失败，为所有任务返回False
-                for action_name in tasks_to_run.keys():
+                for action_name in tasks_to_run:
                     results[action_name] = False
 
         # 清理过期缓存
@@ -300,10 +304,11 @@ class ActionModifier:
     def _cleanup_expired_cache(self, current_time: float):
         """清理过期的缓存条目"""
         expired_keys = []
-        for cache_key, cache_data in self._llm_judge_cache.items():
-            if current_time - cache_data["timestamp"] > self._cache_expiry_time:
-                expired_keys.append(cache_key)
-
+        expired_keys.extend(
+            cache_key
+            for cache_key, cache_data in self._llm_judge_cache.items()
+            if current_time - cache_data["timestamp"] > self._cache_expiry_time
+        )
         for key in expired_keys:
             del self._llm_judge_cache[key]
 
@@ -382,7 +387,7 @@ class ActionModifier:
     def _check_keyword_activation(
         self,
         action_name: str,
-        action_info: Dict[str, Any],
+        action_info: ActionInfo,
         chat_content: str = "",
     ) -> bool:
         """
@@ -399,8 +404,8 @@ class ActionModifier:
             bool: 是否应该激活此action
         """
 
-        activation_keywords = action_info.get("activation_keywords", [])
-        case_sensitive = action_info.get("keyword_case_sensitive", False)
+        activation_keywords = action_info.activation_keywords
+        case_sensitive = action_info.keyword_case_sensitive
 
         if not activation_keywords:
             logger.warning(f"{self.log_prefix}动作 {action_name} 设置为关键词触发但未配置关键词")
@@ -500,13 +505,13 @@ class ActionModifier:
 
         return removals
 
-    def get_available_actions_count(self,mode:str = "focus") -> int:
+    def get_available_actions_count(self, mode: str = "focus") -> int:
         """获取当前可用动作数量（排除默认的no_action）"""
         current_actions = self.action_manager.get_using_actions_for_mode(mode)
         # 排除no_action（如果存在）
         filtered_actions = {k: v for k, v in current_actions.items() if k != "no_action"}
         return len(filtered_actions)
-    
+
     def should_skip_planning_for_no_reply(self) -> bool:
         """判断是否应该跳过规划过程"""
         current_actions = self.action_manager.get_using_actions_for_mode("focus")

src/chat/planner_actions/planner.py

@@ -1,23 +1,26 @@
-import json  # <--- 确保导入 json
+import json
+import time
 import traceback
 from typing import Dict, Any, Optional
 from rich.traceback import install
+from datetime import datetime
+from json_repair import repair_json
+
 from src.llm_models.utils_model import LLMRequest
 from src.config.config import global_config
 from src.common.logger import get_logger
 from src.chat.utils.prompt_builder import Prompt, global_prompt_manager
-from src.chat.planner_actions.action_manager import ActionManager
-from json_repair import repair_json
-from src.chat.utils.utils import get_chat_type_and_target_info
-from datetime import datetime
-from src.chat.message_receive.chat_stream import get_chat_manager
 from src.chat.utils.chat_message_builder import (
     build_readable_actions,
-    build_readable_messages,
     get_actions_by_timestamp_with_chat,
+    build_readable_messages,
     get_raw_msg_before_timestamp_with_chat,
 )
-import time
+from src.chat.utils.utils import get_chat_type_and_target_info
+from src.chat.planner_actions.action_manager import ActionManager
+from src.chat.message_receive.chat_stream import get_chat_manager
+from src.plugin_system.base.component_types import ChatMode, ActionInfo
+
 
 logger = get_logger("planner")
 
@@ -28,7 +31,7 @@ def init_prompt():
     Prompt(
         """
 {time_block}
-{indentify_block}
+{identity_block}
 你现在需要根据聊天内容，选择的合适的action来参与聊天。
 {chat_context_description}，以下是具体的聊天内容：
 {chat_content_block}
@@ -76,7 +79,7 @@ class ActionPlanner:
 
         self.last_obs_time_mark = 0.0
 
-    async def plan(self,mode:str = "focus") -> Dict[str, Any]:
+    async def plan(self, mode: str = "focus") -> Dict[str, Dict[str, Any]]:  # sourcery skip: dict-comprehension
         """
         规划器 (Planner): 使用LLM根据上下文决定做出什么动作。
         """
@@ -84,6 +87,7 @@ class ActionPlanner:
         action = "no_reply"  # 默认动作
         reasoning = "规划器初始化默认"
         action_data = {}
+        current_available_actions: Dict[str, ActionInfo] = {}
 
         try:
             is_group_chat = True
@@ -95,7 +99,7 @@ class ActionPlanner:
 
             # 获取完整的动作信息
             all_registered_actions = self.action_manager.get_registered_actions()
-            current_available_actions = {}
+
             for action_name in current_available_actions_dict.keys():
                 if action_name in all_registered_actions:
                     current_available_actions[action_name] = all_registered_actions[action_name]
@@ -111,7 +115,11 @@ class ActionPlanner:
                 reasoning = "没有可用的动作"
                 logger.info(f"{self.log_prefix}{reasoning}")
                 return {
-                    "action_result": {"action_type": action, "action_data": action_data, "reasoning": reasoning},
+                    "action_result": {
+                        "action_type": action,
+                        "action_data": action_data,
+                        "reasoning": reasoning,
+                    },
                 }
 
             # --- 构建提示词 (调用修改后的 PromptBuilder 方法) ---
@@ -140,7 +148,7 @@ class ActionPlanner:
 
             except Exception as req_e:
                 logger.error(f"{self.log_prefix}LLM 请求执行失败: {req_e}")
-                reasoning = f"LLM 请求失败，你的模型出现问题: {req_e}"
+                reasoning = f"LLM 请求失败，模型出现问题: {req_e}"
                 action = "no_reply"
 
             if llm_content:
@@ -162,7 +170,6 @@ class ActionPlanner:
                     reasoning = parsed_json.get("reasoning", "未提供原因")
 
                     # 将所有其他属性添加到action_data
-                    action_data = {}
                     for key, value in parsed_json.items():
                         if key not in ["action", "reasoning"]:
                             action_data[key] = value
@@ -173,8 +180,8 @@ class ActionPlanner:
                         logger.warning(
                             f"{self.log_prefix}LLM 返回了当前不可用或无效的动作: '{action}' (可用: {list(current_available_actions.keys())})，将强制使用 'no_reply'"
                         )
-                        action = "no_reply"
                         reasoning = f"LLM 返回了当前不可用的动作 '{action}' (可用: {list(current_available_actions.keys())})。原始理由: {reasoning}"
+                        action = "no_reply"
 
                 except Exception as json_e:
                     logger.warning(f"{self.log_prefix}解析LLM响应JSON失败 {json_e}. LLM原始输出: '{llm_content}'")
@@ -190,8 +197,7 @@ class ActionPlanner:
 
         is_parallel = False
         if action in current_available_actions:
-            action_info = current_available_actions[action]
-            is_parallel = action_info.get("parallel_action", False)
+            is_parallel = current_available_actions[action].parallel_action
 
         action_result = {
             "action_type": action,
@@ -201,20 +207,18 @@ class ActionPlanner:
             "is_parallel": is_parallel,
         }
 
-        plan_result = {
+        return {
             "action_result": action_result,
             "action_prompt": prompt,
         }
 
-        return plan_result
-
     async def build_planner_prompt(
         self,
         is_group_chat: bool,  # Now passed as argument
         chat_target_info: Optional[dict],  # Now passed as argument
-        current_available_actions,
+        current_available_actions: Dict[str, ActionInfo],
         mode: str = "focus",
-    ) -> str:
+    ) -> str:  # sourcery skip: use-join
         """构建 Planner LLM 的提示词 (获取模板并填充数据)"""
         try:
             message_list_before_now = get_raw_msg_before_timestamp_with_chat(
@@ -279,23 +283,23 @@ class ActionPlanner:
             action_options_block = ""
 
             for using_actions_name, using_actions_info in current_available_actions.items():
-                if using_actions_info["parameters"]:
+                if using_actions_info.action_parameters:
                     param_text = "\n"
-                    for param_name, param_description in using_actions_info["parameters"].items():
+                    for param_name, param_description in using_actions_info.action_parameters.items():
                         param_text += f'    "{param_name}":"{param_description}"\n'
                     param_text = param_text.rstrip("\n")
                 else:
                     param_text = ""
 
                 require_text = ""
-                for require_item in using_actions_info["require"]:
+                for require_item in using_actions_info.action_require:
                     require_text += f"- {require_item}\n"
                 require_text = require_text.rstrip("\n")
 
                 using_action_prompt = await global_prompt_manager.get_prompt_async("action_prompt")
                 using_action_prompt = using_action_prompt.format(
                     action_name=using_actions_name,
-                    action_description=using_actions_info["description"],
+                    action_description=using_actions_info.description,
                     action_parameters=param_text,
                     action_require=require_text,
                 )
@@ -312,10 +316,10 @@ class ActionPlanner:
             else:
                 bot_nickname = ""
             bot_core_personality = global_config.personality.personality_core
-            indentify_block = f"你的名字是{bot_name}{bot_nickname}，你{bot_core_personality}："
+            identity_block = f"你的名字是{bot_name}{bot_nickname}，你{bot_core_personality}："
 
             planner_prompt_template = await global_prompt_manager.get_prompt_async("planner_prompt")
-            prompt = planner_prompt_template.format(
+            return planner_prompt_template.format(
                 time_block=time_block,
                 by_what=by_what,
                 chat_context_description=chat_context_description,
@@ -324,10 +328,8 @@ class ActionPlanner:
                 no_action_block=no_action_block,
                 action_options_text=action_options_block,
                 moderation_prompt=moderation_prompt_block,
-                indentify_block=indentify_block,
+                identity_block=identity_block,
             )
-            return prompt
-
         except Exception as e:
             logger.error(f"构建 Planner 提示词时出错: {e}")
             logger.error(traceback.format_exc())