From e4ee5ac4c70adc85921ff2f8bd006b6af396b4d1 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Tue, 10 Jun 2025 11:19:48 +0000 Subject: [PATCH] =?UTF-8?q?=F0=9F=A4=96=20=E8=87=AA=E5=8A=A8=E6=A0=BC?= =?UTF-8?q?=E5=BC=8F=E5=8C=96=E4=BB=A3=E7=A0=81=20[skip=20ci]?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../focus_chat/planners/action_manager.py | 137 ++++++------ src/plugin_system/apis/database_api.py | 10 +- src/plugin_system/apis/plugin_api.py | 6 +- src/plugin_system/apis/stream_api.py | 20 +- src/plugin_system/base/base_action.py | 123 ++++++----- src/plugin_system/core/component_registry.py | 2 +- src/plugin_system/core/plugin_manager.py | 78 +++---- src/plugins/built_in/core_actions/plugin.py | 195 ++++++++---------- src/plugins/examples/simple_plugin/plugin.py | 8 +- 9 files changed, 283 insertions(+), 296 deletions(-) diff --git a/src/chat/focus_chat/planners/action_manager.py b/src/chat/focus_chat/planners/action_manager.py index 86a8990fa..988b3112b 100644 --- a/src/chat/focus_chat/planners/action_manager.py +++ b/src/chat/focus_chat/planners/action_manager.py @@ -18,69 +18,72 @@ ActionInfo = Dict[str, Any] class PluginActionWrapper(BaseAction): """ 新插件系统Action组件的兼容性包装器 - + 将新插件系统的Action组件包装为旧系统兼容的BaseAction接口 """ - - def __init__(self, plugin_action, action_name: str, action_data: dict, reasoning: str, cycle_timers: dict, thinking_id: str): + + def __init__( + self, plugin_action, action_name: str, action_data: dict, reasoning: str, cycle_timers: dict, thinking_id: str + ): """初始化包装器""" # 调用旧系统BaseAction初始化，只传递它能接受的参数 super().__init__( - action_data=action_data, - reasoning=reasoning, - cycle_timers=cycle_timers, - thinking_id=thinking_id + action_data=action_data, reasoning=reasoning, cycle_timers=cycle_timers, thinking_id=thinking_id ) - + # 存储插件Action实例（它已经包含了所有必要的服务对象） self.plugin_action = plugin_action self.action_name = action_name - + # 从插件Action实例复制属性到包装器 self._sync_attributes_from_plugin_action() - + def _sync_attributes_from_plugin_action(self): """从插件Action实例同步属性到包装器""" # 基本属性 - self.action_name = getattr(self.plugin_action, 'action_name', self.action_name) - + self.action_name = getattr(self.plugin_action, "action_name", self.action_name) + # 设置兼容的默认值 self.action_description = f"插件Action: {self.action_name}" self.action_parameters = {} self.action_require = [] - + # 激活类型属性（从新插件系统转换） - plugin_focus_type = getattr(self.plugin_action, 'focus_activation_type', None) - plugin_normal_type = getattr(self.plugin_action, 'normal_activation_type', None) - + plugin_focus_type = getattr(self.plugin_action, "focus_activation_type", None) + plugin_normal_type = getattr(self.plugin_action, "normal_activation_type", None) + if plugin_focus_type: - self.focus_activation_type = plugin_focus_type.value if hasattr(plugin_focus_type, 'value') else str(plugin_focus_type) + self.focus_activation_type = ( + plugin_focus_type.value if hasattr(plugin_focus_type, "value") else str(plugin_focus_type) + ) if plugin_normal_type: - self.normal_activation_type = plugin_normal_type.value if hasattr(plugin_normal_type, 'value') else str(plugin_normal_type) - + self.normal_activation_type = ( + plugin_normal_type.value if hasattr(plugin_normal_type, "value") else str(plugin_normal_type) + ) + # 其他属性 - self.random_activation_probability = getattr(self.plugin_action, 'random_activation_probability', 0.0) - self.llm_judge_prompt = getattr(self.plugin_action, 'llm_judge_prompt', "") - self.activation_keywords = getattr(self.plugin_action, 'activation_keywords', []) - self.keyword_case_sensitive = getattr(self.plugin_action, 'keyword_case_sensitive', False) - + self.random_activation_probability = getattr(self.plugin_action, "random_activation_probability", 0.0) + self.llm_judge_prompt = getattr(self.plugin_action, "llm_judge_prompt", "") + self.activation_keywords = getattr(self.plugin_action, "activation_keywords", []) + self.keyword_case_sensitive = getattr(self.plugin_action, "keyword_case_sensitive", False) + # 模式和并行设置 - plugin_mode = getattr(self.plugin_action, 'mode_enable', None) + plugin_mode = getattr(self.plugin_action, "mode_enable", None) if plugin_mode: - self.mode_enable = plugin_mode.value if hasattr(plugin_mode, 'value') else str(plugin_mode) - - self.parallel_action = getattr(self.plugin_action, 'parallel_action', True) + self.mode_enable = plugin_mode.value if hasattr(plugin_mode, "value") else str(plugin_mode) + + self.parallel_action = getattr(self.plugin_action, "parallel_action", True) self.enable_plugin = True - + async def handle_action(self) -> tuple[bool, str]: """兼容旧系统的动作处理接口，委托给插件Action的execute方法""" try: # 调用插件Action的execute方法 success, response = await self.plugin_action.execute() - + logger.debug(f"插件Action {self.action_name} 执行{'成功' if success else '失败'}: {response}") return success, response - + except Exception as e: logger.error(f"插件Action {self.action_name} 执行异常: {e}") return False, f"插件Action执行失败: {str(e)}" @@ -190,36 +193,35 @@ class ActionManager: # 从旧的_ACTION_REGISTRY获取插件动作 self._load_registered_actions() logger.debug("从旧注册表加载插件动作成功") - + # 从新插件系统获取Action组件 self._load_plugin_system_actions() logger.debug("从新插件系统加载Action组件成功") - + except Exception as e: logger.error(f"加载插件动作失败: {e}") - + 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) - + for action_name, action_info in action_components.items(): if action_name in self._registered_actions: logger.debug(f"Action组件 {action_name} 已存在，跳过") continue - + # 将新插件系统的ActionInfo转换为旧系统格式 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', []), + "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, @@ -227,29 +229,30 @@ class ActionManager: "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_system_component": True, - "_plugin_name": getattr(action_info, 'plugin_name', ''), + "_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 - - logger.debug(f"从插件系统加载Action组件: {action_name} (插件: {getattr(action_info, 'plugin_name', 'unknown')})") - + + logger.debug( + f"从插件系统加载Action组件: {action_name} (插件: {getattr(action_info, 'plugin_name', 'unknown')})" + ) + logger.info(f"从新插件系统加载了 {len(action_components)} 个Action组件") - + except Exception as e: logger.error(f"从插件系统加载Action组件失败: {e}") import traceback + logger.error(traceback.format_exc()) def create_action( @@ -289,13 +292,22 @@ class ActionManager: # if action_name not in self._using_actions: # logger.warning(f"当前不可用的动作类型: {action_name}") # return None - + # 检查是否是新插件系统的Action组件 action_info = self._registered_actions.get(action_name) if action_info and action_info.get("_plugin_system_component", False): return self._create_plugin_system_action( - action_name, action_data, reasoning, cycle_timers, thinking_id, - observations, chat_stream, log_prefix, shutting_down, expressor, replyer + action_name, + action_data, + reasoning, + cycle_timers, + thinking_id, + observations, + chat_stream, + log_prefix, + shutting_down, + expressor, + replyer, ) # 旧系统的动作创建逻辑 @@ -324,7 +336,7 @@ class ActionManager: except Exception as e: logger.error(f"创建动作处理器实例失败: {e}") return None - + def _create_plugin_system_action( self, action_name: str, @@ -338,7 +350,7 @@ class ActionManager: shutting_down: bool = False, expressor: DefaultExpressor = None, replyer: DefaultReplyer = None, - ) -> Optional['PluginActionWrapper']: + ) -> Optional["PluginActionWrapper"]: """ 创建新插件系统的Action组件实例，并包装为兼容旧系统的接口 @@ -347,13 +359,13 @@ class ActionManager: """ try: from src.plugin_system.core.component_registry import component_registry - + # 获取组件类 component_class = component_registry.get_component_class(action_name) if not component_class: logger.error(f"未找到插件Action组件类: {action_name}") return None - + # 创建插件Action实例 plugin_action_instance = component_class( action_data=action_data, @@ -364,9 +376,9 @@ class ActionManager: expressor=expressor, replyer=replyer, observations=observations, - log_prefix=log_prefix + log_prefix=log_prefix, ) - + # 创建兼容性包装器 wrapper = PluginActionWrapper( plugin_action=plugin_action_instance, @@ -374,15 +386,16 @@ class ActionManager: action_data=action_data, reasoning=reasoning, cycle_timers=cycle_timers, - thinking_id=thinking_id + thinking_id=thinking_id, ) - + logger.debug(f"创建插件Action实例成功: {action_name}") return wrapper - + except Exception as e: logger.error(f"创建插件Action实例失败 {action_name}: {e}") import traceback + logger.error(traceback.format_exc()) return None diff --git a/src/plugin_system/apis/database_api.py b/src/plugin_system/apis/database_api.py index 7d847a381..7b99e895b 100644 --- a/src/plugin_system/apis/database_api.py +++ b/src/plugin_system/apis/database_api.py @@ -16,15 +16,15 @@ class DatabaseAPI: """ async def store_action_info( - self, - action_build_into_prompt: bool = False, - action_prompt_display: str = "", + self, + action_build_into_prompt: bool = False, + action_prompt_display: str = "", action_done: bool = True, thinking_id: str = "", - action_data: dict = None + action_data: dict = None, ) -> None: """存储action信息到数据库 - + Args: action_build_into_prompt: 是否构建到提示中 action_prompt_display: 显示的action提示信息 diff --git a/src/plugin_system/apis/plugin_api.py b/src/plugin_system/apis/plugin_api.py index f488ff54a..0931a0055 100644 --- a/src/plugin_system/apis/plugin_api.py +++ b/src/plugin_system/apis/plugin_api.py @@ -54,10 +54,10 @@ class PluginAPI(MessageAPI, LLMAPI, DatabaseAPI, ConfigAPI, UtilsAPI, StreamAPI, } self.log_prefix = log_prefix - + # 存储action上下文信息 self._action_context = {} - + # 调用所有父类的初始化 super().__init__() @@ -97,7 +97,7 @@ class PluginAPI(MessageAPI, LLMAPI, DatabaseAPI, ConfigAPI, UtilsAPI, StreamAPI, self._action_context["thinking_id"] = thinking_id self._action_context["shutting_down"] = shutting_down self._action_context.update(kwargs) - + def get_action_context(self, key: str, default=None): """获取action上下文信息""" return self._action_context.get(key, default) diff --git a/src/plugin_system/apis/stream_api.py b/src/plugin_system/apis/stream_api.py index 9dfb03fcc..0ed20401d 100644 --- a/src/plugin_system/apis/stream_api.py +++ b/src/plugin_system/apis/stream_api.py @@ -162,10 +162,10 @@ class StreamAPI: async def wait_for_new_message(self, timeout: int = 1200) -> Tuple[bool, str]: """等待新消息或超时 - + Args: timeout: 超时时间（秒），默认1200秒 - + Returns: Tuple[bool, str]: (是否收到新消息, 空字符串) """ @@ -175,21 +175,21 @@ class StreamAPI: if not observations: logger.warning(f"{self.log_prefix} 无法获取observations服务，无法等待新消息") return False, "" - + # 获取第一个观察对象（通常是ChattingObservation） observation = observations[0] if observations else None if not observation: logger.warning(f"{self.log_prefix} 无观察对象，无法等待新消息") return False, "" - + # 从action上下文获取thinking_id thinking_id = self.get_action_context("thinking_id") if not thinking_id: logger.warning(f"{self.log_prefix} 无thinking_id，无法等待新消息") return False, "" - + logger.info(f"{self.log_prefix} 开始等待新消息... (超时: {timeout}秒)") - + wait_start_time = asyncio.get_event_loop().time() while True: # 检查关闭标志 @@ -197,21 +197,21 @@ class StreamAPI: if shutting_down: logger.info(f"{self.log_prefix} 等待新消息时检测到关闭信号，中断等待") return False, "" - + # 检查新消息 thinking_id_timestamp = parse_thinking_id_to_timestamp(thinking_id) if await observation.has_new_messages_since(thinking_id_timestamp): logger.info(f"{self.log_prefix} 检测到新消息") return True, "" - + # 检查超时 if asyncio.get_event_loop().time() - wait_start_time > timeout: logger.warning(f"{self.log_prefix} 等待新消息超时({timeout}秒)") return False, "" - + # 短暂休眠 await asyncio.sleep(0.5) - + except asyncio.CancelledError: logger.info(f"{self.log_prefix} 等待新消息被中断 (CancelledError)") return False, "" diff --git a/src/plugin_system/base/base_action.py b/src/plugin_system/base/base_action.py index 556863633..c8ce005eb 100644 --- a/src/plugin_system/base/base_action.py +++ b/src/plugin_system/base/base_action.py @@ -11,7 +11,7 @@ class BaseAction(ABC): """Action组件基类 Action是插件的一种组件类型，用于处理聊天中的动作逻辑 - + 子类可以通过类属性定义激活条件，这些会在实例化时转换为实例属性： - focus_activation_type: 专注模式激活类型 - normal_activation_type: 普通模式激活类型 @@ -22,19 +22,21 @@ class BaseAction(ABC): - random_activation_probability: 随机激活概率 - llm_judge_prompt: LLM判断提示词 """ - - def __init__(self, - action_data: dict, - reasoning: str, - cycle_timers: dict, - thinking_id: str, - observations: list = None, - expressor = None, - replyer = None, - chat_stream = None, - log_prefix: str = "", - shutting_down: bool = False, - **kwargs): + + def __init__( + self, + action_data: dict, + reasoning: str, + cycle_timers: dict, + thinking_id: str, + observations: list = None, + expressor=None, + replyer=None, + chat_stream=None, + log_prefix: str = "", + shutting_down: bool = False, + **kwargs, + ): """初始化Action组件 Args: @@ -56,60 +58,57 @@ class BaseAction(ABC): self.thinking_id = thinking_id self.log_prefix = log_prefix self.shutting_down = shutting_down - + # 设置动作基本信息实例属性（兼容旧系统） - self.action_name: str = getattr(self, 'action_name', self.__class__.__name__.lower().replace('action', '')) - self.action_description: str = getattr(self, 'action_description', self.__doc__ or "Action组件") - self.action_parameters: dict = getattr(self.__class__, 'action_parameters', {}).copy() - self.action_require: list[str] = getattr(self.__class__, 'action_require', []).copy() - + self.action_name: str = getattr(self, "action_name", self.__class__.__name__.lower().replace("action", "")) + self.action_description: str = getattr(self, "action_description", self.__doc__ or "Action组件") + self.action_parameters: dict = getattr(self.__class__, "action_parameters", {}).copy() + self.action_require: list[str] = getattr(self.__class__, "action_require", []).copy() + # 设置激活类型实例属性（从类属性复制，提供默认值） - self.focus_activation_type: str = self._get_activation_type_value('focus_activation_type', 'never') - self.normal_activation_type: str = self._get_activation_type_value('normal_activation_type', 'never') - self.random_activation_probability: float = getattr(self.__class__, 'random_activation_probability', 0.0) - self.llm_judge_prompt: str = getattr(self.__class__, 'llm_judge_prompt', "") - self.activation_keywords: list[str] = getattr(self.__class__, 'activation_keywords', []).copy() - self.keyword_case_sensitive: bool = getattr(self.__class__, 'keyword_case_sensitive', False) - self.mode_enable: str = self._get_mode_value('mode_enable', 'all') - self.parallel_action: bool = getattr(self.__class__, 'parallel_action', True) - self.associated_types: list[str] = getattr(self.__class__, 'associated_types', []).copy() + self.focus_activation_type: str = self._get_activation_type_value("focus_activation_type", "never") + self.normal_activation_type: str = self._get_activation_type_value("normal_activation_type", "never") + self.random_activation_probability: float = getattr(self.__class__, "random_activation_probability", 0.0) + self.llm_judge_prompt: str = getattr(self.__class__, "llm_judge_prompt", "") + self.activation_keywords: list[str] = getattr(self.__class__, "activation_keywords", []).copy() + self.keyword_case_sensitive: bool = getattr(self.__class__, "keyword_case_sensitive", False) + self.mode_enable: str = self._get_mode_value("mode_enable", "all") + self.parallel_action: bool = getattr(self.__class__, "parallel_action", True) + self.associated_types: list[str] = getattr(self.__class__, "associated_types", []).copy() self.enable_plugin: bool = True # 默认启用 - + # 创建API实例，传递所有服务对象 self.api = PluginAPI( chat_stream=chat_stream or kwargs.get("chat_stream"), - expressor=expressor or kwargs.get("expressor"), + expressor=expressor or kwargs.get("expressor"), replyer=replyer or kwargs.get("replyer"), observations=observations or kwargs.get("observations", []), - log_prefix=log_prefix + log_prefix=log_prefix, ) - + # 设置API的action上下文 - self.api.set_action_context( - thinking_id=thinking_id, - shutting_down=shutting_down - ) - + self.api.set_action_context(thinking_id=thinking_id, shutting_down=shutting_down) + logger.debug(f"{self.log_prefix} Action组件初始化完成") - + def _get_activation_type_value(self, attr_name: str, default: str) -> str: """获取激活类型的字符串值""" attr = getattr(self.__class__, attr_name, None) if attr is None: return default - if hasattr(attr, 'value'): + if hasattr(attr, "value"): return attr.value return str(attr) - + def _get_mode_value(self, attr_name: str, default: str) -> str: """获取模式的字符串值""" attr = getattr(self.__class__, attr_name, None) if attr is None: return default - if hasattr(attr, 'value'): + if hasattr(attr, "value"): return attr.value return str(attr) - + async def send_reply(self, content: str) -> bool: """发送回复消息 @@ -138,8 +137,8 @@ class BaseAction(ABC): name = cls.__name__.lower().replace("action", "") if description is None: description = cls.__doc__ or f"{cls.__name__} Action组件" - description = description.strip().split('\n')[0] # 取第一行作为描述 - + description = description.strip().split("\n")[0] # 取第一行作为描述 + # 安全获取激活类型值 def get_enum_value(attr_name, default): attr = getattr(cls, attr_name, None) @@ -147,29 +146,29 @@ class BaseAction(ABC): # 如果没有定义，返回默认的枚举值 return getattr(ActionActivationType, default.upper(), ActionActivationType.NEVER) return attr - + def get_mode_value(attr_name, default): attr = getattr(cls, attr_name, None) if attr is None: return getattr(ChatMode, default.upper(), ChatMode.ALL) return attr - + return ActionInfo( name=name, component_type=ComponentType.ACTION, description=description, - focus_activation_type=get_enum_value('focus_activation_type', 'never'), - normal_activation_type=get_enum_value('normal_activation_type', 'never'), - activation_keywords=getattr(cls, 'activation_keywords', []).copy(), - keyword_case_sensitive=getattr(cls, 'keyword_case_sensitive', False), - mode_enable=get_mode_value('mode_enable', 'all'), - parallel_action=getattr(cls, 'parallel_action', True), - random_activation_probability=getattr(cls, 'random_activation_probability', 0.0), - llm_judge_prompt=getattr(cls, 'llm_judge_prompt', ""), + focus_activation_type=get_enum_value("focus_activation_type", "never"), + normal_activation_type=get_enum_value("normal_activation_type", "never"), + activation_keywords=getattr(cls, "activation_keywords", []).copy(), + keyword_case_sensitive=getattr(cls, "keyword_case_sensitive", False), + mode_enable=get_mode_value("mode_enable", "all"), + parallel_action=getattr(cls, "parallel_action", True), + random_activation_probability=getattr(cls, "random_activation_probability", 0.0), + llm_judge_prompt=getattr(cls, "llm_judge_prompt", ""), # 使用正确的字段名 - action_parameters=getattr(cls, 'action_parameters', {}).copy(), - action_require=getattr(cls, 'action_require', []).copy(), - associated_types=getattr(cls, 'associated_types', []).copy() + action_parameters=getattr(cls, "action_parameters", {}).copy(), + action_require=getattr(cls, "action_require", []).copy(), + associated_types=getattr(cls, "associated_types", []).copy(), ) @abstractmethod @@ -180,14 +179,14 @@ class BaseAction(ABC): Tuple[bool, str]: (是否执行成功, 回复文本) """ pass - + async def handle_action(self) -> Tuple[bool, str]: """兼容旧系统的handle_action接口，委托给execute方法 - + 为了保持向后兼容性，旧系统的代码可能会调用handle_action方法。 此方法将调用委托给新的execute方法。 - + Returns: Tuple[bool, str]: (是否执行成功, 回复文本) """ - return await self.execute() \ No newline at end of file + return await self.execute() diff --git a/src/plugin_system/core/component_registry.py b/src/plugin_system/core/component_registry.py index baf8af798..b0d2446ae 100644 --- a/src/plugin_system/core/component_registry.py +++ b/src/plugin_system/core/component_registry.py @@ -69,7 +69,7 @@ class ComponentRegistry: self._register_action_component(component_info, component_class) elif component_type == ComponentType.COMMAND: self._register_command_component(component_info, component_class) - + logger.debug(f"已注册{component_type.value}组件: {component_name} ({component_class.__name__})") return True diff --git a/src/plugin_system/core/plugin_manager.py b/src/plugin_system/core/plugin_manager.py index 586b3b014..ea6c4977c 100644 --- a/src/plugin_system/core/plugin_manager.py +++ b/src/plugin_system/core/plugin_manager.py @@ -22,10 +22,10 @@ class PluginManager: def __init__(self): self.plugin_directories: List[str] = [] - self.loaded_plugins: Dict[str, 'BasePlugin'] = {} + self.loaded_plugins: Dict[str, "BasePlugin"] = {} self.failed_plugins: Dict[str, str] = {} self.plugin_paths: Dict[str, str] = {} # 记录插件名到目录路径的映射 - + logger.info("插件管理器初始化完成") def add_plugin_directory(self, directory: str): @@ -43,7 +43,7 @@ class PluginManager: tuple[int, int]: (插件数量, 组件数量) """ logger.debug("开始加载所有插件...") - + # 第一阶段：加载所有插件模块（注册插件类） total_loaded_modules = 0 total_failed_modules = 0 @@ -52,9 +52,9 @@ class PluginManager: loaded, failed = self._load_plugin_modules_from_directory(directory) total_loaded_modules += loaded total_failed_modules += failed - + logger.debug(f"插件模块加载完成 - 成功: {total_loaded_modules}, 失败: {total_failed_modules}") - + # 第二阶段：实例化所有已注册的插件类 from src.plugin_system.base.base_plugin import get_registered_plugin_classes, instantiate_and_register_plugin @@ -65,17 +65,17 @@ class PluginManager: for plugin_name, plugin_class in plugin_classes.items(): # 使用记录的插件目录路径 plugin_dir = self.plugin_paths.get(plugin_name) - + # 如果没有记录，则尝试查找（fallback） if not plugin_dir: plugin_dir = self._find_plugin_directory(plugin_class) if plugin_dir: self.plugin_paths[plugin_name] = plugin_dir - + if instantiate_and_register_plugin(plugin_class, plugin_dir): total_registered += 1 self.loaded_plugins[plugin_name] = plugin_class - + # 📊 显示插件详细信息 plugin_info = component_registry.get_plugin_info(plugin_name) if plugin_info: @@ -83,28 +83,32 @@ class PluginManager: for comp in plugin_info.components: comp_type = comp.component_type.name component_types[comp_type] = component_types.get(comp_type, 0) + 1 - + components_str = ", ".join([f"{count}个{ctype}" for ctype, count in component_types.items()]) - logger.info(f"✅ 插件加载成功: {plugin_name} v{plugin_info.version} ({components_str}) - {plugin_info.description}") + logger.info( + f"✅ 插件加载成功: {plugin_name} v{plugin_info.version} ({components_str}) - {plugin_info.description}" + ) else: logger.info(f"✅ 插件加载成功: {plugin_name}") else: total_failed_registration += 1 self.failed_plugins[plugin_name] = "插件注册失败" logger.error(f"❌ 插件加载失败: {plugin_name}") - + # 获取组件统计信息 stats = component_registry.get_registry_stats() - + # 📋 显示插件加载总览 if total_registered > 0: - action_count = stats.get('action_components', 0) - command_count = stats.get('command_components', 0) - total_components = stats.get('total_components', 0) - + action_count = stats.get("action_components", 0) + command_count = stats.get("command_components", 0) + total_components = stats.get("total_components", 0) + logger.info("🎉 插件系统加载完成!") - logger.info(f"📊 总览: {total_registered}个插件, {total_components}个组件 (Action: {action_count}, Command: {command_count})") - + logger.info( + f"📊 总览: {total_registered}个插件, {total_components}个组件 (Action: {action_count}, Command: {command_count})" + ) + # 显示详细的插件列表 logger.info("📋 已加载插件详情:") for plugin_name, _plugin_class in self.loaded_plugins.items(): @@ -115,31 +119,31 @@ class PluginManager: author_info = f"by {plugin_info.author}" if plugin_info.author else "" info_parts = [part for part in [version_info, author_info] if part] extra_info = f" ({', '.join(info_parts)})" if info_parts else "" - + logger.info(f" 📦 {plugin_name}{extra_info}") - + # 组件列表 if plugin_info.components: - action_components = [c for c in plugin_info.components if c.component_type.name == 'ACTION'] - command_components = [c for c in plugin_info.components if c.component_type.name == 'COMMAND'] - + action_components = [c for c in plugin_info.components if c.component_type.name == "ACTION"] + command_components = [c for c in plugin_info.components if c.component_type.name == "COMMAND"] + if action_components: action_names = [c.name for c in action_components] logger.info(f" 🎯 Action组件: {', '.join(action_names)}") - + if command_components: command_names = [c.name for c in command_components] logger.info(f" ⚡ Command组件: {', '.join(command_names)}") - + # 依赖信息 if plugin_info.dependencies: logger.info(f" 🔗 依赖: {', '.join(plugin_info.dependencies)}") - + # 配置文件信息 if plugin_info.config_file: config_status = "✅" if self.plugin_paths.get(plugin_name) else "❌" logger.info(f" ⚙️ 配置: {plugin_info.config_file} {config_status}") - + # 显示目录统计 logger.info("📂 加载目录统计:") for directory in self.plugin_directories: @@ -149,12 +153,12 @@ class PluginManager: plugin_path = self.plugin_paths.get(plugin_name, "") if plugin_path.startswith(directory): plugins_in_dir.append(plugin_name) - + if plugins_in_dir: logger.info(f" 📁 {directory}: {len(plugins_in_dir)}个插件 ({', '.join(plugins_in_dir)})") else: logger.info(f" 📁 {directory}: 0个插件") - + # 失败信息 if total_failed_registration > 0: logger.info(f"⚠️ 失败统计: {total_failed_registration}个插件加载失败") @@ -162,10 +166,10 @@ class PluginManager: logger.info(f" ❌ {failed_plugin}: {error}") else: logger.warning("😕 没有成功加载任何插件") - + # 返回插件数量和组件数量 return total_registered, total_components - + def _find_plugin_directory(self, plugin_class) -> Optional[str]: """查找插件类对应的目录路径""" try: @@ -186,9 +190,9 @@ class PluginManager: if not os.path.exists(directory): logger.warning(f"插件目录不存在: {directory}") return loaded_count, failed_count - + logger.debug(f"正在扫描插件目录: {directory}") - + # 遍历目录中的所有Python文件和包 for item in os.listdir(directory): item_path = os.path.join(directory, item) @@ -212,10 +216,10 @@ class PluginManager: failed_count += 1 return loaded_count, failed_count - + def _load_plugin_module_file(self, plugin_file: str, plugin_name: str, plugin_dir: str) -> bool: """加载单个插件模块文件 - + Args: plugin_file: 插件文件路径 plugin_name: 插件名称 @@ -239,10 +243,10 @@ class PluginManager: module = importlib.util.module_from_spec(spec) spec.loader.exec_module(module) - + # 记录插件名和目录路径的映射 self.plugin_paths[plugin_name] = plugin_dir - + logger.debug(f"插件模块加载成功: {plugin_file}") return True diff --git a/src/plugins/built_in/core_actions/plugin.py b/src/plugins/built_in/core_actions/plugin.py index 4b60f6579..9e7110e9b 100644 --- a/src/plugins/built_in/core_actions/plugin.py +++ b/src/plugins/built_in/core_actions/plugin.py @@ -9,10 +9,7 @@ import re from typing import List, Tuple, Type, Optional # 导入新插件系统 -from src.plugin_system import ( - BasePlugin, register_plugin, BaseAction, - ComponentInfo, ActionActivationType, ChatMode -) +from src.plugin_system import BasePlugin, register_plugin, BaseAction, ComponentInfo, ActionActivationType, ChatMode # 导入依赖的系统组件 from src.common.logger_manager import get_logger @@ -27,47 +24,43 @@ WAITING_TIME_THRESHOLD = 1200 # 等待新消息时间阈值，单位秒 class ReplyAction(BaseAction): """回复动作 - 参与聊天回复""" - + # 激活设置 focus_activation_type = ActionActivationType.ALWAYS normal_activation_type = ActionActivationType.NEVER mode_enable = ChatMode.FOCUS parallel_action = False - + # 动作参数定义（旧系统格式） action_parameters = { "reply_to": "如果是明确回复某个人的发言，请在reply_to参数中指定，格式：（用户名:发言内容），如果不是，reply_to的值设为none" } - + # 动作使用场景（旧系统字段名） - action_require = [ - "你想要闲聊或者随便附和", - "有人提到你", - "如果你刚刚进行了回复，不要对同一个话题重复回应" - ] - + action_require = ["你想要闲聊或者随便附和", "有人提到你", "如果你刚刚进行了回复，不要对同一个话题重复回应"] + # 关联类型 associated_types = ["text"] - + async def execute(self) -> Tuple[bool, str]: """执行回复动作""" logger.info(f"{self.log_prefix} 决定回复: {self.reasoning}") - + try: # 获取聊天观察 chatting_observation = self._get_chatting_observation() if not chatting_observation: return False, "未找到聊天观察" - + # 处理回复目标 anchor_message = await self._resolve_reply_target(chatting_observation) - + # 获取回复器服务 replyer = self.api.get_service("replyer") if not replyer: logger.error(f"{self.log_prefix} 未找到回复器服务") return False, "回复器服务不可用" - + # 执行回复 success, reply_set = await replyer.deal_reply( cycle_timers=self.cycle_timers, @@ -76,25 +69,25 @@ class ReplyAction(BaseAction): reasoning=self.reasoning, thinking_id=self.thinking_id, ) - + # 构建回复文本 reply_text = self._build_reply_text(reply_set) - + # 存储动作记录 await self.api.store_action_info( action_build_into_prompt=False, action_prompt_display=reply_text, action_done=True, thinking_id=self.thinking_id, - action_data=self.action_data + action_data=self.action_data, ) - + return success, reply_text - + except Exception as e: logger.error(f"{self.log_prefix} 回复动作执行失败: {e}") return False, f"回复失败: {str(e)}" - + def _get_chatting_observation(self) -> Optional[ChattingObservation]: """获取聊天观察对象""" observations = self.api.get_service("observations") or [] @@ -102,11 +95,11 @@ class ReplyAction(BaseAction): if isinstance(obs, ChattingObservation): return obs return None - + async def _resolve_reply_target(self, chatting_observation: ChattingObservation): """解析回复目标消息""" reply_to = self.action_data.get("reply_to", "none") - + if ":" in reply_to or "：" in reply_to: # 解析回复目标格式：用户名:消息内容 parts = re.split(pattern=r"[:：]", string=reply_to, maxsplit=1) @@ -118,18 +111,14 @@ class ReplyAction(BaseAction): if chat_stream: anchor_message.update_chat_stream(chat_stream) return anchor_message - + # 创建空锚点消息 logger.info(f"{self.log_prefix} 未找到锚点消息，创建占位符") chat_stream = self.api.get_service("chat_stream") if chat_stream: - return await create_empty_anchor_message( - chat_stream.platform, - chat_stream.group_info, - chat_stream - ) + return await create_empty_anchor_message(chat_stream.platform, chat_stream.group_info, chat_stream) return None - + def _build_reply_text(self, reply_set) -> str: """构建回复文本""" reply_text = "" @@ -144,37 +133,35 @@ class ReplyAction(BaseAction): class NoReplyAction(BaseAction): """不回复动作，继承时会等待新消息或超时""" + focus_activation_type = ActionActivationType.ALWAYS normal_activation_type = ActionActivationType.NEVER mode_enable = ChatMode.FOCUS parallel_action = False - + # 默认超时时间，将由插件在注册时设置 waiting_timeout = 1200 - + # 动作参数定义 action_parameters = {} - + # 动作使用场景 - action_require = [ - "你连续发送了太多消息，且无人回复", - "想要暂时不回复" - ] - + action_require = ["你连续发送了太多消息，且无人回复", "想要暂时不回复"] + # 关联类型 associated_types = [] - + async def execute(self) -> Tuple[bool, str]: """执行不回复动作，等待新消息或超时""" try: # 使用类属性中的超时时间 timeout = self.waiting_timeout - + logger.info(f"{self.log_prefix} 选择不回复，等待新消息中... (超时: {timeout}秒)") - + # 等待新消息或达到时间上限 return await self.api.wait_for_new_message(timeout) - + except Exception as e: logger.error(f"{self.log_prefix} 不回复动作执行失败: {e}") return False, f"不回复动作执行失败: {e}" @@ -182,14 +169,14 @@ class NoReplyAction(BaseAction): class EmojiAction(BaseAction): """表情动作 - 发送表情包""" - + # 激活设置 focus_activation_type = ActionActivationType.LLM_JUDGE normal_activation_type = ActionActivationType.RANDOM mode_enable = ChatMode.ALL parallel_action = True random_activation_probability = 0.1 # 默认值，可通过配置覆盖 - + # LLM判断提示词 llm_judge_prompt = """ 判定是否需要使用表情动作的条件： @@ -199,37 +186,32 @@ class EmojiAction(BaseAction): 请回答"是"或"否"。 """ - + # 动作参数定义 - action_parameters = { - "description": "文字描述你想要发送的表情包内容" - } - + action_parameters = {"description": "文字描述你想要发送的表情包内容"} + # 动作使用场景 - action_require = [ - "表达情绪时可以选择使用", - "重点：不要连续发，如果你已经发过[表情包]，就不要选择此动作" - ] - + action_require = ["表达情绪时可以选择使用", "重点：不要连续发，如果你已经发过[表情包]，就不要选择此动作"] + # 关联类型 associated_types = ["emoji"] - + async def execute(self) -> Tuple[bool, str]: """执行表情动作""" logger.info(f"{self.log_prefix} 决定发送表情") - + try: # 创建空锚点消息 anchor_message = await self._create_anchor_message() if not anchor_message: return False, "无法创建锚点消息" - + # 获取回复器服务 replyer = self.api.get_service("replyer") if not replyer: logger.error(f"{self.log_prefix} 未找到回复器服务") return False, "回复器服务不可用" - + # 执行表情处理 success, reply_set = await replyer.deal_emoji( cycle_timers=self.cycle_timers, @@ -237,28 +219,24 @@ class EmojiAction(BaseAction): anchor_message=anchor_message, thinking_id=self.thinking_id, ) - + # 构建回复文本 reply_text = self._build_reply_text(reply_set) - + return success, reply_text - + except Exception as e: logger.error(f"{self.log_prefix} 表情动作执行失败: {e}") return False, f"表情发送失败: {str(e)}" - + async def _create_anchor_message(self): """创建锚点消息""" chat_stream = self.api.get_service("chat_stream") if chat_stream: logger.info(f"{self.log_prefix} 为表情包创建占位符") - return await create_empty_anchor_message( - chat_stream.platform, - chat_stream.group_info, - chat_stream - ) + return await create_empty_anchor_message(chat_stream.platform, chat_stream.group_info, chat_stream) return None - + def _build_reply_text(self, reply_set) -> str: """构建回复文本""" reply_text = "" @@ -273,13 +251,13 @@ class EmojiAction(BaseAction): class ExitFocusChatAction(BaseAction): """退出专注聊天动作 - 从专注模式切换到普通模式""" - + # 激活设置 focus_activation_type = ActionActivationType.LLM_JUDGE normal_activation_type = ActionActivationType.NEVER mode_enable = ChatMode.FOCUS parallel_action = False - + # LLM判断提示词 llm_judge_prompt = """ 判定是否需要退出专注聊天的条件： @@ -289,38 +267,38 @@ class ExitFocusChatAction(BaseAction): 请回答"是"或"否"。 """ - + # 动作参数定义 action_parameters = {} - + # 动作使用场景 action_require = [ "很长时间没有回复，你决定退出专注聊天", "当前内容不需要持续专注关注，你决定退出专注聊天", - "聊天内容已经完成，你决定退出专注聊天" + "聊天内容已经完成，你决定退出专注聊天", ] - + # 关联类型 associated_types = [] - + async def execute(self) -> Tuple[bool, str]: """执行退出专注聊天动作""" logger.info(f"{self.log_prefix} 决定退出专注聊天: {self.reasoning}") - + try: # 转换状态 - 这里返回特殊的命令标识 status_message = "" - + # 通过返回值中的特殊标识来通知系统执行状态切换 # 系统会识别这个返回值并执行相应的状态切换逻辑 self._mark_state_change() - + return True, status_message - + except Exception as e: logger.error(f"{self.log_prefix} 退出专注聊天动作执行失败: {e}") return False, f"退出专注聊天失败: {str(e)}" - + def _mark_state_change(self): """标记状态切换请求""" # 通过action_data传递状态切换命令 @@ -331,13 +309,13 @@ class ExitFocusChatAction(BaseAction): @register_plugin class CoreActionsPlugin(BasePlugin): """核心动作插件 - + 系统内置插件，提供基础的聊天交互功能： - Reply: 回复动作 - - NoReply: 不回复动作 + - NoReply: 不回复动作 - Emoji: 表情动作 """ - + # 插件基本信息 plugin_name = "core_actions" plugin_description = "系统核心动作插件，提供基础聊天交互功能" @@ -345,44 +323,37 @@ class CoreActionsPlugin(BasePlugin): plugin_author = "MaiBot团队" enable_plugin = True config_file_name = "config.toml" - + def get_plugin_components(self) -> List[Tuple[ComponentInfo, Type]]: """返回插件包含的组件列表""" - + # 从配置获取表情动作的随机概率 emoji_chance = self.get_config("emoji.random_probability", 0.1) - + # 动态设置EmojiAction的随机概率 EmojiAction.random_activation_probability = emoji_chance - + # 从配置获取不回复动作的超时时间 no_reply_timeout = self.get_config("no_reply.waiting_timeout", 1200) - + # 动态设置NoReplyAction的超时时间 NoReplyAction.waiting_timeout = no_reply_timeout - + return [ # 回复动作 - (ReplyAction.get_action_info( - name="reply", - description="参与聊天回复，处理文本和表情的发送" - ), ReplyAction), - + (ReplyAction.get_action_info(name="reply", description="参与聊天回复，处理文本和表情的发送"), ReplyAction), # 不回复动作 - (NoReplyAction.get_action_info( - name="no_reply", - description="暂时不回复消息，等待新消息或超时" - ), NoReplyAction), - + ( + NoReplyAction.get_action_info(name="no_reply", description="暂时不回复消息，等待新消息或超时"), + NoReplyAction, + ), # 表情动作 - (EmojiAction.get_action_info( - name="emoji", - description="发送表情包辅助表达情绪" - ), EmojiAction), - + (EmojiAction.get_action_info(name="emoji", description="发送表情包辅助表达情绪"), EmojiAction), # 退出专注聊天动作 - (ExitFocusChatAction.get_action_info( - name="exit_focus_chat", - description="退出专注聊天，从专注模式切换到普通模式" - ), ExitFocusChatAction) - ] \ No newline at end of file + ( + ExitFocusChatAction.get_action_info( + name="exit_focus_chat", description="退出专注聊天，从专注模式切换到普通模式" + ), + ExitFocusChatAction, + ), + ] diff --git a/src/plugins/examples/simple_plugin/plugin.py b/src/plugins/examples/simple_plugin/plugin.py index 6667b1f89..71b2fb7c8 100644 --- a/src/plugins/examples/simple_plugin/plugin.py +++ b/src/plugins/examples/simple_plugin/plugin.py @@ -40,12 +40,12 @@ class HelloAction(BaseAction): async def execute(self) -> Tuple[bool, str]: """执行问候动作""" username = self.action_data.get("username", "朋友") - + # 使用默认配置值（避免创建新插件实例） greeting_template = "你好，{username}！" enable_emoji = True enable_llm = False - + # 如果启用LLM生成个性化问候 if enable_llm: try: @@ -116,11 +116,11 @@ class StatusCommand(BaseCommand): """执行状态查询命令""" # 获取匹配的参数 query_type = self.matched_groups.get("type", "系统") - + # 使用默认配置值（避免创建新插件实例） show_detailed = True allowed_types = ["系统", "插件"] - + if query_type not in allowed_types: response = f"不支持的查询类型: {query_type}\n支持的类型: {', '.join(allowed_types)}" elif show_detailed: