<Thinking>

我需要分析这个git diff，并生成一个与之前完全不同的commit message。

让我先分析变更内容：

1. **主要变更**：
   - 在 `anti_injector.py` 中添加了新的 `auto` 处理模式
   - 添加了命令跳过列表功能 (`command_skip_list`)
   - 重构了反注入管理命令，从独立插件移动到核心动作插件
   - 更新了配置文件以支持新功能
   - 在插件管理器中添加了跳过列表刷新逻辑

2. **之前的commit message重点**：
   - 强调了"advanced anti-injection capabilities"
   - 重点描述了"intelligent 'auto' mode"
   - 提到了"command skip list"
   - 强调了"dynamically assesses threats"
   - 提到了"refactored and integrated into core actions plugin"

3. **我需要完全不同的角度**：
   - 可以从架构重构的角度
   - 可以从用户体验改进的角度
   - 可以从系统集成的角度
   - 可以从性能优化的角度

让我从**系统架构优化和插件整合**的角度来写这个commit message，重点强调：
- 插件系统的重构和整合
- 管理命令的迁移和统一
- 跳过机制的实现
- 自动化决策系统的引入

这样就能避免使用之前message中的关键词和结构。
</Thinking>

refactor(plugins): 重构反注入插件架构并优化命令管理体系

将反注入管理功能从独立插件迁移至核心动作模块，实现更好的系统集成。新增智能跳过机制，允许已注册的插件命令绕过检测流程，有效减少误判。同时引入自适应处理策略，系统可根据威胁评估结果自主选择最适当的响应方式。

插件管理器现已集成自动刷新功能，确保跳过列表与插件状态保持同步。配置系统扩展支持多种跳过模式和自定义规则，提升了整体可维护性和用户体验。
ps：谢谢雅诺狐姐姐投喂的提交喵^ω^

src/chat/antipromptinjector/__init__.py

@@ -18,6 +18,12 @@ from .anti_injector import AntiPromptInjector, get_anti_injector, initialize_ant
 from .config import DetectionResult
 from .detector import PromptInjectionDetector
 from .shield import MessageShield
+from .command_skip_list import (
+    initialize_skip_list, 
+    should_skip_injection_detection, 
+    refresh_plugin_commands,
+    get_skip_patterns_info
+)
     
 __all__ = [
         "AntiPromptInjector",
@@ -25,7 +31,11 @@ __all__ = [
         "initialize_anti_injector",
         "DetectionResult",
         "PromptInjectionDetector",
-        "MessageShield"
+        "MessageShield",
+        "initialize_skip_list",
+        "should_skip_injection_detection",
+        "refresh_plugin_commands",
+        "get_skip_patterns_info"
     ]
 
 

src/chat/antipromptinjector/anti_injector.py

@@ -22,6 +22,7 @@ from src.chat.message_receive.message import MessageRecv
 from .config import DetectionResult, ProcessResult
 from .detector import PromptInjectionDetector
 from .shield import MessageShield
+from .command_skip_list import should_skip_injection_detection, initialize_skip_list
 
 # 数据库相关导入
 from src.common.database.sqlalchemy_models import BanUser, AntiInjectionStats, get_db_session
@@ -38,6 +39,9 @@ class AntiPromptInjector:
         self.detector = PromptInjectionDetector()
         self.shield = MessageShield()
         
+        # 初始化跳过列表
+        initialize_skip_list()
+        
     async def _get_or_create_stats(self):
         """获取或创建统计记录"""
         try:
@@ -73,7 +77,7 @@ class AntiPromptInjector:
                         continue
                     elif key == 'last_processing_time':
                         # 直接设置最后处理时间
-                        stats.last_processing_time = value
+                        stats.last_process_time = value
                         continue
                     elif hasattr(stats, key):
                         if key in ['total_messages', 'detected_injections', 
@@ -127,10 +131,17 @@ class AntiPromptInjector:
             if whitelist_result is not None:
                 return ProcessResult.ALLOWED, None, whitelist_result[2]
             
-            # 4. 内容检测
+            # 4. 命令跳过列表检测
+            message_text = self._extract_text_content(message)
+            should_skip, skip_reason = should_skip_injection_detection(message_text)
+            if should_skip:
+                logger.debug(f"消息匹配跳过列表，跳过反注入检测: {skip_reason}")
+                return ProcessResult.ALLOWED, None, f"命令跳过检测 - {skip_reason}"
+            
+            # 5. 内容检测
             detection_result = await self.detector.detect(message.processed_plain_text)
             
-            # 5. 处理检测结果
+            # 6. 处理检测结果
             if detection_result.is_injection:
                 await self._update_stats(detected_injections=1)
                 
@@ -163,8 +174,34 @@ class AntiPromptInjector:
                     else:
                         # 置信度不高，允许通过
                         return ProcessResult.ALLOWED, None, "检测到轻微可疑内容，已允许通过"
+                
+                elif self.config.process_mode == "auto":
+                    # 自动模式：根据威胁等级自动选择处理方式
+                    auto_action = self._determine_auto_action(detection_result)
+                    
+                    if auto_action == "block":
+                        # 高威胁：直接丢弃
+                        await self._update_stats(blocked_messages=1)
+                        return ProcessResult.BLOCKED_INJECTION, None, f"自动模式：检测到高威胁内容，消息已拒绝 (置信度: {detection_result.confidence:.2f})"
+                    
+                    elif auto_action == "shield":
+                        # 中等威胁：加盾处理
+                        await self._update_stats(shielded_messages=1)
+                        
+                        shielded_content = self.shield.create_shielded_message(
+                            message.processed_plain_text, 
+                            detection_result.confidence
+                        )
+                        
+                        summary = self.shield.create_safety_summary(detection_result.confidence, detection_result.matched_patterns)
+                        
+                        return ProcessResult.SHIELDED, shielded_content, f"自动模式：检测到中等威胁已加盾处理: {summary}"
+                    
+                    else:  # auto_action == "allow"
+                        # 低威胁：允许通过
+                        return ProcessResult.ALLOWED, None, "自动模式：检测到轻微可疑内容，已允许通过"
             
-            # 6. 正常消息
+            # 7. 正常消息
             return ProcessResult.ALLOWED, None, "消息检查通过"
             
         except Exception as e:
@@ -267,6 +304,87 @@ class AntiPromptInjector:
                 return True, None, "用户白名单"
         
         return None
+    
+    def _determine_auto_action(self, detection_result: DetectionResult) -> str:
+        """自动模式：根据检测结果确定处理动作
+        
+        Args:
+            detection_result: 检测结果
+            
+        Returns:
+            处理动作: "block"(丢弃), "shield"(加盾), "allow"(允许)
+        """
+        confidence = detection_result.confidence
+        matched_patterns = detection_result.matched_patterns
+        
+        # 高威胁阈值：直接丢弃
+        HIGH_THREAT_THRESHOLD = 0.85
+        # 中威胁阈值：加盾处理
+        MEDIUM_THREAT_THRESHOLD = 0.5
+        
+        # 基于置信度的基础判断
+        if confidence >= HIGH_THREAT_THRESHOLD:
+            base_action = "block"
+        elif confidence >= MEDIUM_THREAT_THRESHOLD:
+            base_action = "shield"
+        else:
+            base_action = "allow"
+        
+        # 基于匹配模式的威胁等级调整
+        high_risk_patterns = [
+            'system', '系统', 'admin', '管理', 'root', 'sudo',
+            'exec', '执行', 'command', '命令', 'shell', '终端',
+            'forget', '忘记', 'ignore', '忽略', 'override', '覆盖',
+            'roleplay', '扮演', 'pretend', '伪装', 'assume', '假设',
+            'reveal', '揭示', 'dump', '转储', 'extract', '提取',
+            'secret', '秘密', 'confidential', '机密', 'private', '私有'
+        ]
+        
+        medium_risk_patterns = [
+            '角色', '身份', '模式', 'mode', '权限', 'privilege',
+            '规则', 'rule', '限制', 'restriction', '安全', 'safety'
+        ]
+        
+        # 检查匹配的模式是否包含高风险关键词
+        high_risk_count = 0
+        medium_risk_count = 0
+        
+        for pattern in matched_patterns:
+            pattern_lower = pattern.lower()
+            for risk_keyword in high_risk_patterns:
+                if risk_keyword in pattern_lower:
+                    high_risk_count += 1
+                    break
+            else:
+                for risk_keyword in medium_risk_patterns:
+                    if risk_keyword in pattern_lower:
+                        medium_risk_count += 1
+                        break
+        
+        # 根据风险模式调整决策
+        if high_risk_count >= 2:
+            # 多个高风险模式匹配，提升威胁等级
+            if base_action == "allow":
+                base_action = "shield"
+            elif base_action == "shield":
+                base_action = "block"
+        elif high_risk_count >= 1:
+            # 单个高风险模式匹配，适度提升
+            if base_action == "allow" and confidence > 0.3:
+                base_action = "shield"
+        elif medium_risk_count >= 3:
+            # 多个中风险模式匹配
+            if base_action == "allow" and confidence > 0.2:
+                base_action = "shield"
+        
+        # 特殊情况：如果检测方法是LLM且置信度很高，倾向于更严格处理
+        if detection_result.detection_method == "llm" and confidence > 0.9:
+            base_action = "block"
+        
+        logger.debug(f"自动模式决策: 置信度={confidence:.3f}, 高风险模式={high_risk_count}, "
+                    f"中风险模式={medium_risk_count}, 决策={base_action}")
+        
+        return base_action
 
     async def _detect_injection(self, message: MessageRecv) -> DetectionResult:
         """检测提示词注入"""
@@ -318,9 +436,9 @@ class AntiPromptInjector:
             # 宽松模式：消息加盾
             if self.shield.is_shield_needed(detection_result.confidence, detection_result.matched_patterns):
                 original_text = message.processed_plain_text
-                shielded_text = self.shield.shield_message(
+                shielded_text = self.shield.create_shielded_message(
                     original_text, 
-                    detection_result.matched_patterns
+                    detection_result.confidence
                 )
                 
                 logger.info(f"宽松模式：消息已加盾 (置信度: {detection_result.confidence:.2f})")
@@ -328,8 +446,6 @@ class AntiPromptInjector:
                 
                 # 创建处理摘要
                 summary = self.shield.create_safety_summary(
-                    len(original_text),
-                    len(shielded_text), 
                     detection_result.confidence,
                     detection_result.matched_patterns
                 )
@@ -339,6 +455,39 @@ class AntiPromptInjector:
                 # 置信度不够，允许通过
                 return True, None, f"置信度不足，允许通过 - {detection_result.reason}"
         
+        elif self.config.process_mode == "auto":
+            # 自动模式：根据威胁等级自动选择处理方式
+            auto_action = self._determine_auto_action(detection_result)
+            
+            if auto_action == "block":
+                # 高威胁：直接丢弃
+                logger.warning(f"自动模式：丢弃高威胁消息 (置信度: {detection_result.confidence:.2f})")
+                await self._update_stats(blocked_messages=1)
+                return False, None, f"自动模式阻止 - {detection_result.reason}"
+            
+            elif auto_action == "shield":
+                # 中等威胁：加盾处理
+                original_text = message.processed_plain_text
+                shielded_text = self.shield.create_shielded_message(
+                    original_text, 
+                    detection_result.confidence
+                )
+                
+                logger.info(f"自动模式：消息已加盾 (置信度: {detection_result.confidence:.2f})")
+                await self._update_stats(shielded_messages=1)
+                
+                # 创建处理摘要
+                summary = self.shield.create_safety_summary(
+                    detection_result.confidence,
+                    detection_result.matched_patterns
+                )
+                
+                return True, shielded_text, f"自动模式加盾 - {summary}"
+            
+            else:  # auto_action == "allow"
+                # 低威胁：允许通过
+                return True, None, f"自动模式允许通过 - {detection_result.reason}"
+        
         # 默认允许通过
         return True, None, "默认允许通过"
     
@@ -394,7 +543,7 @@ class AntiPromptInjector:
                 "shielded_messages": stats.shielded_messages or 0,
                 "detection_rate": f"{detection_rate:.2f}%",
                 "average_processing_time": f"{avg_processing_time:.3f}s",
-                "last_processing_time": f"{stats.last_processing_time:.3f}s" if stats.last_processing_time else "0.000s",
+                "last_processing_time": f"{stats.last_process_time:.3f}s" if stats.last_process_time else "0.000s",
                 "error_count": stats.error_count or 0
             }
         except Exception as e:

src/chat/antipromptinjector/command_skip_list.py

@@ -0,0 +1,289 @@
+# -*- coding: utf-8 -*-
+"""
+命令跳过列表模块
+
+本模块负责管理反注入系统的命令跳过列表，自动收集插件注册的命令
+并提供检查机制来跳过对合法命令的反注入检测。
+"""
+
+import re
+from typing import Set, List, Pattern, Optional, Dict
+from dataclasses import dataclass
+
+from src.common.logger import get_logger
+from src.config.config import global_config
+
+logger = get_logger("anti_injector.skip_list")
+
+
+@dataclass
+class SkipPattern:
+    """跳过模式信息"""
+    pattern: str
+    """原始模式字符串"""
+    
+    compiled_pattern: Pattern[str]
+    """编译后的正则表达式"""
+    
+    source: str
+    """模式来源：plugin, manual, system"""
+    
+    description: str = ""
+    """模式描述"""
+
+
+class CommandSkipListManager:
+    """命令跳过列表管理器"""
+    
+    def __init__(self):
+        """初始化跳过列表管理器"""
+        self.config = global_config.anti_prompt_injection
+        self._skip_patterns: Dict[str, SkipPattern] = {}
+        self._plugin_command_patterns: Set[str] = set()
+        self._is_initialized = False
+        
+    def initialize(self):
+        """初始化跳过列表"""
+        if self._is_initialized:
+            return
+            
+        logger.info("初始化反注入命令跳过列表...")
+        
+        # 清空现有模式
+        self._skip_patterns.clear()
+        self._plugin_command_patterns.clear()
+        
+        if not self.config.enable_command_skip_list:
+            logger.info("命令跳过列表已禁用")
+            return
+        
+        # 添加系统命令模式
+        if self.config.skip_system_commands:
+            self._add_system_command_patterns()
+        
+        # 自动收集插件命令
+        if self.config.auto_collect_plugin_commands:
+            self._collect_plugin_commands()
+        
+        # 添加手动指定的模式
+        self._add_manual_patterns()
+        
+        self._is_initialized = True
+        logger.info(f"跳过列表初始化完成，共收集 {len(self._skip_patterns)} 个模式")
+        
+    def _add_system_command_patterns(self):
+        """添加系统内置命令模式"""
+        system_patterns = [
+            (r"^/pm\b", "/pm 插件管理命令"),
+            (r"^/反注入统计\b", "反注入统计查询命令"),
+            (r"^^/反注入跳过列表(?:\s+(.+))?$", "反注入列表管理命令"),
+        ]
+        
+        for pattern_str, description in system_patterns:
+            self._add_skip_pattern(pattern_str, "system", description)
+    
+    def _collect_plugin_commands(self):
+        """自动收集插件注册的命令"""
+        try:
+            from src.plugin_system.apis import component_manage_api
+            from src.plugin_system.base.component_types import ComponentType
+            
+            # 获取所有注册的命令组件
+            command_components = component_manage_api.get_components_info_by_type(ComponentType.COMMAND)
+            
+            if not command_components:
+                logger.debug("没有找到注册的命令组件（插件可能还未加载）")
+                return
+            
+            collected_count = 0
+            for command_name, command_info in command_components.items():
+                # 获取命令的匹配模式
+                if hasattr(command_info, 'command_pattern') and command_info.command_pattern:
+                    pattern = command_info.command_pattern
+                    description = f"插件命令: {command_name}"
+                    
+                    # 添加到跳过列表
+                    if self._add_skip_pattern(pattern, "plugin", description):
+                        self._plugin_command_patterns.add(pattern)
+                        collected_count += 1
+                        logger.debug(f"收集插件命令模式: {pattern} ({command_name})")
+                
+                # 如果没有明确的模式，尝试从命令名生成基础模式
+                elif command_name:
+                    # 生成基础命令模式
+                    basic_patterns = [
+                        f"^/{re.escape(command_name)}\\b",  # /command_name
+                        f"^{re.escape(command_name)}\\b",   # command_name
+                    ]
+                    
+                    for pattern in basic_patterns:
+                        description = f"插件命令: {command_name} (自动生成)"
+                        if self._add_skip_pattern(pattern, "plugin", description):
+                            self._plugin_command_patterns.add(pattern)
+                            collected_count += 1
+            
+            if collected_count > 0:
+                logger.info(f"自动收集了 {collected_count} 个插件命令模式")
+            else:
+                logger.debug("当前没有收集到插件命令模式（插件可能还未加载）")
+            
+        except Exception as e:
+            logger.warning(f"自动收集插件命令时出错: {e}")
+    
+    def _add_manual_patterns(self):
+        """添加手动指定的模式"""
+        manual_patterns = self.config.manual_skip_patterns or []
+        
+        for pattern_str in manual_patterns:
+            if pattern_str.strip():
+                self._add_skip_pattern(pattern_str.strip(), "manual", "手动配置的跳过模式")
+    
+    def _add_skip_pattern(self, pattern_str: str, source: str, description: str = "") -> bool:
+        """添加跳过模式
+        
+        Args:
+            pattern_str: 模式字符串
+            source: 模式来源
+            description: 模式描述
+            
+        Returns:
+            是否成功添加
+        """
+        try:
+            # 编译正则表达式
+            compiled_pattern = re.compile(pattern_str, re.IGNORECASE | re.DOTALL)
+            
+            # 创建跳过模式对象
+            skip_pattern = SkipPattern(
+                pattern=pattern_str,
+                compiled_pattern=compiled_pattern,
+                source=source,
+                description=description
+            )
+            
+            # 使用模式字符串作为键，避免重复
+            pattern_key = f"{source}:{pattern_str}"
+            self._skip_patterns[pattern_key] = skip_pattern
+            
+            return True
+            
+        except re.error as e:
+            logger.error(f"无效的正则表达式模式 '{pattern_str}': {e}")
+            return False
+    
+    def should_skip_detection(self, message_text: str) -> tuple[bool, Optional[str]]:
+        """检查消息是否应该跳过反注入检测
+        
+        Args:
+            message_text: 待检查的消息文本
+            
+        Returns:
+            (是否跳过, 匹配的模式描述)
+        """
+        if not self.config.enable_command_skip_list or not self._is_initialized:
+            return False, None
+        
+        message_text = message_text.strip()
+        if not message_text:
+            return False, None
+        
+        # 检查所有跳过模式
+        for pattern_key, skip_pattern in self._skip_patterns.items():
+            try:
+                if skip_pattern.compiled_pattern.search(message_text):
+                    logger.debug(f"消息匹配跳过模式: {skip_pattern.pattern} ({skip_pattern.description})")
+                    return True, skip_pattern.description
+            except Exception as e:
+                logger.warning(f"检查跳过模式时出错 '{skip_pattern.pattern}': {e}")
+        
+        return False, None
+    
+    def refresh_plugin_commands(self):
+        """刷新插件命令列表"""
+        if not self.config.auto_collect_plugin_commands:
+            return
+        
+        logger.info("刷新插件命令跳过列表...")
+        
+        # 移除旧的插件模式
+        old_plugin_patterns = [
+            key for key, pattern in self._skip_patterns.items() 
+            if pattern.source == "plugin"
+        ]
+        
+        for key in old_plugin_patterns:
+            del self._skip_patterns[key]
+        
+        self._plugin_command_patterns.clear()
+        
+        # 重新收集插件命令
+        self._collect_plugin_commands()
+        
+        logger.info(f"插件命令跳过列表已刷新，当前共有 {len(self._skip_patterns)} 个模式")
+    
+    def get_skip_patterns_info(self) -> Dict[str, List[Dict[str, str]]]:
+        """获取跳过模式信息
+        
+        Returns:
+            按来源分组的模式信息
+        """
+        result = {"system": [], "plugin": [], "manual": []}
+        
+        for skip_pattern in self._skip_patterns.values():
+            pattern_info = {
+                "pattern": skip_pattern.pattern,
+                "description": skip_pattern.description
+            }
+            
+            if skip_pattern.source in result:
+                result[skip_pattern.source].append(pattern_info)
+        
+        return result
+    
+    def add_temporary_skip_pattern(self, pattern: str, description: str = "") -> bool:
+        """添加临时跳过模式（运行时添加，不保存到配置）
+        
+        Args:
+            pattern: 模式字符串
+            description: 模式描述
+            
+        Returns:
+            是否成功添加
+        """
+        return self._add_skip_pattern(pattern, "temporary", description or "临时跳过模式")
+    
+    def remove_temporary_patterns(self):
+        """移除所有临时跳过模式"""
+        temp_patterns = [
+            key for key, pattern in self._skip_patterns.items() 
+            if pattern.source == "temporary"
+        ]
+        
+        for key in temp_patterns:
+            del self._skip_patterns[key]
+        
+        logger.info(f"已移除 {len(temp_patterns)} 个临时跳过模式")
+
+
+# 全局跳过列表管理器实例
+skip_list_manager = CommandSkipListManager()
+
+
+def initialize_skip_list():
+    """初始化跳过列表"""
+    skip_list_manager.initialize()
+
+
+def should_skip_injection_detection(message_text: str) -> tuple[bool, Optional[str]]:
+    """检查消息是否应该跳过反注入检测"""
+    return skip_list_manager.should_skip_detection(message_text)
+
+
+def refresh_plugin_commands():
+    """刷新插件命令列表"""
+    skip_list_manager.refresh_plugin_commands()
+
+
+def get_skip_patterns_info():
+    """获取跳过模式信息"""
+    return skip_list_manager.get_skip_patterns_info()

src/config/official_configs.py

@@ -982,7 +982,7 @@ class AntiPromptInjectionConfig(ConfigBase):
     """是否启用规则检测"""
     
     process_mode: str = "lenient"
-    """处理模式：strict(严格模式，直接丢弃), lenient(宽松模式，消息加盾)"""
+    """处理模式：strict(严格模式，直接丢弃), lenient(宽松模式，消息加盾), auto(自动模式，根据威胁等级自动选择加盾或丢弃)"""
     
     # 白名单配置
     whitelist: list[list[str]] = field(default_factory=list)
@@ -1028,6 +1028,19 @@ class AntiPromptInjectionConfig(ConfigBase):
     
     shield_suffix: str = " 🛡️"
     """加盾消息后缀"""
+    
+    # 跳过列表配置
+    enable_command_skip_list: bool = True
+    """是否启用命令跳过列表，启用后插件注册的命令将自动跳过反注入检测"""
+    
+    auto_collect_plugin_commands: bool = True
+    """是否自动收集插件注册的命令加入跳过列表"""
+    
+    manual_skip_patterns: list[str] = field(default_factory=list)
+    """手动指定的跳过模式列表，支持正则表达式"""
+    
+    skip_system_commands: bool = True
+    """是否跳过系统内置命令（如 /pm, /help 等）"""
 
 
 @dataclass

src/plugin_system/core/plugin_manager.py

@@ -84,6 +84,9 @@ class PluginManager:
 
         self._show_stats(total_registered, total_failed_registration)
 
+        # 插件加载完成后，刷新反注入跳过列表
+        self._refresh_anti_injection_skip_list()
+
         return total_registered, total_failed_registration
 
     def load_registered_plugin_classes(self, plugin_name: str) -> Tuple[bool, int]:
@@ -589,6 +592,25 @@ class PluginManager:
             logger.debug("详细错误信息: ", exc_info=True)
             return False
 
+    def _refresh_anti_injection_skip_list(self):
+        """插件加载完成后刷新反注入跳过列表"""
+        try:
+            # 异步刷新反注入跳过列表
+            import asyncio
+            from src.chat.antipromptinjector.command_skip_list import skip_list_manager
+            
+            # 如果当前在事件循环中，直接调用
+            try:
+                loop = asyncio.get_running_loop()
+                # 在后台任务中执行刷新
+                loop.create_task(skip_list_manager.refresh_plugin_commands())
+                logger.debug("已触发反注入跳过列表刷新")
+            except RuntimeError:
+                # 没有运行的事件循环，稍后刷新
+                logger.debug("当前无事件循环，反注入跳过列表将在首次使用时刷新")
+        except Exception as e:
+            logger.warning(f"刷新反注入跳过列表失败: {e}")
+
 
 # 全局插件管理器实例
 plugin_manager = PluginManager()

src/plugins/built_in/WEB_SEARCH_TOOL/_manifest.json

@@ -0,0 +1,27 @@
+{
+  "manifest_version": 1,
+  "name": "web_search_tool",
+  "version": "1.0.0",
+  "description": "一个用于在互联网上搜索信息的工具",
+  "author": {
+    "name": "MaiBot-Plus开发团队",
+    "url": "https://github.com/MaiBot-Plus"
+  },
+  "license": "GPL-v3.0-or-later",
+  
+  "host_application": {
+    "min_version": "0.10.0"
+  },
+  "homepage_url": "https://github.com/MaiBot-Plus/MaiMbot-Pro-Max",
+  "repository_url": "https://github.com/MaiBot-Plus/MaiMbot-Pro-Max",
+  "keywords": ["web_search", "url_parser"],
+  "categories": ["web_search", "url_parser"],
+  
+  "default_locale": "zh-CN",
+  "locales_path": "_locales",
+  
+  "plugin_info": {
+    "is_built_in": false,
+    "plugin_type": "web_search"
+  }
+}

src/plugins/built_in/WEB_SEARCH_TOOL/plugin.py

@@ -0,0 +1,676 @@
+import asyncio
+import functools
+import itertools
+from typing import Any, Dict, List
+from datetime import datetime, timedelta
+from exa_py import Exa
+from asyncddgs import aDDGS
+from tavily import TavilyClient
+
+from src.common.logger import get_logger
+from typing import Tuple,Type
+from src.plugin_system import (
+    BasePlugin,
+    register_plugin,
+    BaseTool,
+    ComponentInfo,
+    ConfigField,
+    llm_api,
+    ToolParamType,
+    PythonDependency
+)
+from src.plugin_system.apis import config_api  # 添加config_api导入
+from src.common.cache_manager import tool_cache
+import httpx
+from bs4 import BeautifulSoup
+
+logger = get_logger("web_surfing_tool")
+
+
+class WebSurfingTool(BaseTool):
+    name: str = "web_search"
+    description: str = "用于执行网络搜索。当用户明确要求搜索，或者需要获取关于公司、产品、事件的最新信息、新闻或动态时，必须使用此工具"
+    available_for_llm: bool = True
+    parameters = [
+        ("query", ToolParamType.STRING, "要搜索的关键词或问题。", True, None),
+        ("num_results", ToolParamType.INTEGER, "期望每个搜索引擎返回的搜索结果数量，默认为5。", False, None),
+        ("time_range", ToolParamType.STRING, "指定搜索的时间范围，可以是 'any', 'week', 'month'。默认为 'any'。", False, ["any", "week", "month"])
+    ] # type: ignore
+
+    def __init__(self, plugin_config=None):
+        super().__init__(plugin_config)
+        
+        # 初始化EXA API密钥轮询器
+        self.exa_clients = []
+        self.exa_key_cycle = None
+        
+        # 优先从主配置文件读取，如果没有则从插件配置文件读取
+        EXA_API_KEYS = config_api.get_global_config("exa.api_keys", None)
+        if EXA_API_KEYS is None:
+            # 从插件配置文件读取
+            EXA_API_KEYS = self.get_config("exa.api_keys", [])
+        
+        if isinstance(EXA_API_KEYS, list) and EXA_API_KEYS:
+            valid_keys = [key.strip() for key in EXA_API_KEYS if isinstance(key, str) and key.strip() not in ("None", "")]
+            if valid_keys:
+                self.exa_clients = [Exa(api_key=key) for key in valid_keys]
+                self.exa_key_cycle = itertools.cycle(self.exa_clients)
+                logger.info(f"已配置 {len(valid_keys)} 个 Exa API 密钥")
+            else:
+                logger.warning("Exa API Keys 配置无效，Exa 搜索功能将不可用。")
+        else:
+            logger.warning("Exa API Keys 未配置，Exa 搜索功能将不可用。")
+
+        # 初始化Tavily API密钥轮询器
+        self.tavily_clients = []
+        self.tavily_key_cycle = None
+        
+        # 优先从主配置文件读取，如果没有则从插件配置文件读取
+        TAVILY_API_KEYS = config_api.get_global_config("tavily.api_keys", None)
+        if TAVILY_API_KEYS is None:
+            # 从插件配置文件读取
+            TAVILY_API_KEYS = self.get_config("tavily.api_keys", [])
+        
+        if isinstance(TAVILY_API_KEYS, list) and TAVILY_API_KEYS:
+            valid_keys = [key.strip() for key in TAVILY_API_KEYS if isinstance(key, str) and key.strip() not in ("None", "")]
+            if valid_keys:
+                self.tavily_clients = [TavilyClient(api_key=key) for key in valid_keys]
+                self.tavily_key_cycle = itertools.cycle(self.tavily_clients)
+                logger.info(f"已配置 {len(valid_keys)} 个 Tavily API 密钥")
+            else:
+                logger.warning("Tavily API Keys 配置无效，Tavily 搜索功能将不可用。")
+        else:
+            logger.warning("Tavily API Keys 未配置，Tavily 搜索功能将不可用。")
+
+    async def execute(self, function_args: Dict[str, Any]) -> Dict[str, Any]:
+        query = function_args.get("query")
+        if not query:
+            return {"error": "搜索查询不能为空。"}
+
+        # 获取当前文件路径用于缓存键
+        import os
+        current_file_path = os.path.abspath(__file__)
+
+        # 检查缓存
+        query = function_args.get("query")
+        cached_result = await tool_cache.get(self.name, function_args, current_file_path, semantic_query=query)
+        if cached_result:
+            logger.info(f"缓存命中: {self.name} -> {function_args}")
+            return cached_result
+
+        # 读取搜索配置
+        enabled_engines = config_api.get_global_config("web_search.enabled_engines", ["ddg"])
+        search_strategy = config_api.get_global_config("web_search.search_strategy", "single")
+        
+        logger.info(f"开始搜索，策略: {search_strategy}, 启用引擎: {enabled_engines}, 参数: '{function_args}'")
+
+        # 根据策略执行搜索
+        if search_strategy == "parallel":
+            result = await self._execute_parallel_search(function_args, enabled_engines)
+        elif search_strategy == "fallback":
+            result = await self._execute_fallback_search(function_args, enabled_engines)
+        else:  # single
+            result = await self._execute_single_search(function_args, enabled_engines)
+        
+        # 保存到缓存
+        if "error" not in result:
+            query = function_args.get("query")
+            await tool_cache.set(self.name, function_args, current_file_path, result, semantic_query=query)
+            
+        return result
+
+    async def _execute_parallel_search(self, function_args: Dict[str, Any], enabled_engines: List[str]) -> Dict[str, Any]:
+        """并行搜索策略：同时使用所有启用的搜索引擎"""
+        search_tasks = []
+        
+        for engine in enabled_engines:
+            if engine == "exa" and self.exa_clients:
+                # 使用参数中的数量，如果没有则默认5个
+                custom_args = function_args.copy()
+                custom_args["num_results"] = custom_args.get("num_results", 5)
+                search_tasks.append(self._search_exa(custom_args))
+            elif engine == "tavily" and self.tavily_clients:
+                custom_args = function_args.copy()
+                custom_args["num_results"] = custom_args.get("num_results", 5)
+                search_tasks.append(self._search_tavily(custom_args))
+            elif engine == "ddg":
+                custom_args = function_args.copy()
+                custom_args["num_results"] = custom_args.get("num_results", 5)
+                search_tasks.append(self._search_ddg(custom_args))
+
+        if not search_tasks:
+            return {"error": "没有可用的搜索引擎。"}
+
+        try:
+            search_results_lists = await asyncio.gather(*search_tasks, return_exceptions=True)
+            
+            all_results = []
+            for result in search_results_lists:
+                if isinstance(result, list):
+                    all_results.extend(result)
+                elif isinstance(result, Exception):
+                    logger.error(f"搜索时发生错误: {result}")
+
+            # 去重并格式化
+            unique_results = self._deduplicate_results(all_results)
+            formatted_content = self._format_results(unique_results)
+            
+            return {
+                "type": "web_search_result",
+                "content": formatted_content,
+            }
+
+        except Exception as e:
+            logger.error(f"执行并行网络搜索时发生异常: {e}", exc_info=True)
+            return {"error": f"执行网络搜索时发生严重错误: {str(e)}"}
+
+    async def _execute_fallback_search(self, function_args: Dict[str, Any], enabled_engines: List[str]) -> Dict[str, Any]:
+        """回退搜索策略：按顺序尝试搜索引擎，失败则尝试下一个"""
+        for engine in enabled_engines:
+            try:
+                custom_args = function_args.copy()
+                custom_args["num_results"] = custom_args.get("num_results", 5)
+                
+                if engine == "exa" and self.exa_clients:
+                    results = await self._search_exa(custom_args)
+                elif engine == "tavily" and self.tavily_clients:
+                    results = await self._search_tavily(custom_args)
+                elif engine == "ddg":
+                    results = await self._search_ddg(custom_args)
+                else:
+                    continue
+                
+                if results:  # 如果有结果，直接返回
+                    formatted_content = self._format_results(results)
+                    return {
+                        "type": "web_search_result",
+                        "content": formatted_content,
+                    }
+                    
+            except Exception as e:
+                logger.warning(f"{engine} 搜索失败，尝试下一个引擎: {e}")
+                continue
+        
+        return {"error": "所有搜索引擎都失败了。"}
+
+    async def _execute_single_search(self, function_args: Dict[str, Any], enabled_engines: List[str]) -> Dict[str, Any]:
+        """单一搜索策略：只使用第一个可用的搜索引擎"""
+        for engine in enabled_engines:
+            custom_args = function_args.copy()
+            custom_args["num_results"] = custom_args.get("num_results", 5)
+            
+            try:
+                if engine == "exa" and self.exa_clients:
+                    results = await self._search_exa(custom_args)
+                elif engine == "tavily" and self.tavily_clients:
+                    results = await self._search_tavily(custom_args)
+                elif engine == "ddg":
+                    results = await self._search_ddg(custom_args)
+                else:
+                    continue
+                
+                formatted_content = self._format_results(results)
+                return {
+                    "type": "web_search_result",
+                    "content": formatted_content,
+                }
+                
+            except Exception as e:
+                logger.error(f"{engine} 搜索失败: {e}")
+                return {"error": f"{engine} 搜索失败: {str(e)}"}
+        
+        return {"error": "没有可用的搜索引擎。"}
+
+    def _deduplicate_results(self, results: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        unique_urls = set()
+        unique_results = []
+        for res in results:
+            if isinstance(res, dict) and res.get("url") and res["url"] not in unique_urls:
+                unique_urls.add(res["url"])
+                unique_results.append(res)
+        return unique_results
+
+    async def _search_exa(self, args: Dict[str, Any]) -> List[Dict[str, Any]]:
+        query = args["query"]
+        num_results = args.get("num_results", 3)
+        time_range = args.get("time_range", "any")
+
+        exa_args = {"num_results": num_results, "text": True, "highlights": True}
+        if time_range != "any":
+            today = datetime.now()
+            start_date = today - timedelta(days=7 if time_range == "week" else 30)
+            exa_args["start_published_date"] = start_date.strftime('%Y-%m-%d')
+
+        try:
+            if not self.exa_key_cycle:
+                return []
+            
+            # 使用轮询机制获取下一个客户端
+            exa_client = next(self.exa_key_cycle)
+            loop = asyncio.get_running_loop()
+            func = functools.partial(exa_client.search_and_contents, query, **exa_args)
+            search_response = await loop.run_in_executor(None, func)
+            
+            return [
+                {
+                    "title": res.title,
+                    "url": res.url,
+                    "snippet": " ".join(getattr(res, 'highlights', [])) or (getattr(res, 'text', '')[:250] + '...'),
+                    "provider": "Exa"
+                }
+                for res in search_response.results
+            ]
+        except Exception as e:
+            logger.error(f"Exa 搜索失败: {e}")
+            return []
+
+    async def _search_tavily(self, args: Dict[str, Any]) -> List[Dict[str, Any]]:
+        query = args["query"]
+        num_results = args.get("num_results", 3)
+        time_range = args.get("time_range", "any")
+
+        try:
+            if not self.tavily_key_cycle:
+                return []
+            
+            # 使用轮询机制获取下一个客户端
+            tavily_client = next(self.tavily_key_cycle)
+            
+            # 构建Tavily搜索参数
+            search_params = {
+                "query": query,
+                "max_results": num_results,
+                "search_depth": "basic",
+                "include_answer": False,
+                "include_raw_content": False
+            }
+            
+            # 根据时间范围调整搜索参数
+            if time_range == "week":
+                search_params["days"] = 7
+            elif time_range == "month":
+                search_params["days"] = 30
+            
+            loop = asyncio.get_running_loop()
+            func = functools.partial(tavily_client.search, **search_params)
+            search_response = await loop.run_in_executor(None, func)
+            
+            results = []
+            if search_response and "results" in search_response:
+                for res in search_response["results"]:
+                    results.append({
+                        "title": res.get("title", "无标题"),
+                        "url": res.get("url", ""),
+                        "snippet": res.get("content", "")[:300] + "..." if res.get("content") else "无摘要",
+                        "provider": "Tavily"
+                    })
+            
+            return results
+            
+        except Exception as e:
+            logger.error(f"Tavily 搜索失败: {e}")
+            return []
+
+    async def _search_ddg(self, args: Dict[str, Any]) -> List[Dict[str, Any]]:
+        query = args["query"]
+        num_results = args.get("num_results", 3)
+        
+        try:
+            async with aDDGS() as ddgs:
+                search_response = await ddgs.text(query, max_results=num_results)
+            
+            return [
+                {
+                    "title": r.get("title"),
+                    "url": r.get("href"),
+                    "snippet": r.get("body"),
+                    "provider": "DuckDuckGo"
+                }
+                for r in search_response
+            ]
+        except Exception as e:
+            logger.error(f"DuckDuckGo 搜索失败: {e}")
+            return []
+
+    def _format_results(self, results: List[Dict[str, Any]]) -> str:
+        if not results:
+            return "没有找到相关的网络信息。"
+
+        formatted_string = "根据网络搜索结果：\n\n"
+        for i, res in enumerate(results, 1):
+            title = res.get("title", '无标题')
+            url = res.get("url", '#')
+            snippet = res.get("snippet", '无摘要')
+            provider = res.get("provider", "未知来源")
+            
+            formatted_string += f"{i}. **{title}** (来自: {provider})\n"
+            formatted_string += f"   - 摘要: {snippet}\n"
+            formatted_string += f"   - 来源: {url}\n\n"
+            
+        return formatted_string
+    
+class URLParserTool(BaseTool):
+    """
+    一个用于解析和总结一个或多个网页URL内容的工具。
+    """
+    name: str = "parse_url"
+    description: str = "当需要理解一个或多个特定网页链接的内容时，使用此工具。例如：'这些网页讲了什么？[https://example.com, https://example2.com]' 或 '帮我总结一下这些文章'"
+    available_for_llm: bool = True
+    parameters = [
+        ("urls", ToolParamType.STRING, "要理解的网站", True, None),
+    ]
+    def __init__(self, plugin_config=None):
+        super().__init__(plugin_config)
+        
+        # 初始化EXA API密钥轮询器
+        self.exa_clients = []
+        self.exa_key_cycle = None
+        
+        # 优先从主配置文件读取，如果没有则从插件配置文件读取
+        EXA_API_KEYS = config_api.get_global_config("exa.api_keys", None)
+        if EXA_API_KEYS is None:
+            # 从插件配置文件读取
+            EXA_API_KEYS = self.get_config("exa.api_keys", [])
+        
+        if isinstance(EXA_API_KEYS, list) and EXA_API_KEYS:
+            valid_keys = [key.strip() for key in EXA_API_KEYS if isinstance(key, str) and key.strip() not in ("None", "")]
+            if valid_keys:
+                self.exa_clients = [Exa(api_key=key) for key in valid_keys]
+                self.exa_key_cycle = itertools.cycle(self.exa_clients)
+                logger.info(f"URL解析工具已配置 {len(valid_keys)} 个 Exa API 密钥")
+            else:
+                logger.warning("Exa API Keys 配置无效，URL解析功能将受限。")
+        else:
+            logger.warning("Exa API Keys 未配置，URL解析功能将受限。")
+    async def _local_parse_and_summarize(self, url: str) -> Dict[str, Any]:
+        """
+        使用本地库(httpx, BeautifulSoup)解析URL，并调用LLM进行总结。
+        """
+        try:
+            # 读取代理配置
+            enable_proxy = self.get_config("proxy.enable_proxy", False)
+            proxies = None
+            
+            if enable_proxy:
+                socks5_proxy = self.get_config("proxy.socks5_proxy", None)
+                http_proxy = self.get_config("proxy.http_proxy", None)
+                https_proxy = self.get_config("proxy.https_proxy", None)
+                
+                # 优先使用SOCKS5代理（全协议代理）
+                if socks5_proxy:
+                    proxies = socks5_proxy
+                    logger.info(f"使用SOCKS5代理: {socks5_proxy}")
+                elif http_proxy or https_proxy:
+                    proxies = {}
+                    if http_proxy:
+                        proxies["http://"] = http_proxy
+                    if https_proxy:
+                        proxies["https://"] = https_proxy
+                    logger.info(f"使用HTTP/HTTPS代理配置: {proxies}")
+            
+            client_kwargs = {"timeout": 15.0, "follow_redirects": True}
+            if proxies:
+                client_kwargs["proxies"] = proxies
+            
+            async with httpx.AsyncClient(**client_kwargs) as client:
+                response = await client.get(url)
+                response.raise_for_status()
+
+            soup = BeautifulSoup(response.text, "html.parser")
+            
+            title = soup.title.string if soup.title else "无标题"
+            for script in soup(["script", "style"]):
+                script.extract()
+            text = soup.get_text(separator="\n", strip=True)
+
+            if not text:
+                return {"error": "无法从页面提取有效文本内容。"}
+
+            summary_prompt = f"请根据以下网页内容，生成一段不超过300字的中文摘要，保留核心信息和关键点:\n\n---\n\n标题: {title}\n\n内容:\n{text[:4000]}\n\n---\n\n摘要:"
+
+
+            text_model = str(self.get_config("models.text_model", "replyer_1"))
+            models = llm_api.get_available_models()
+            model_config = models.get(text_model)
+            if not model_config:
+                logger.error("未配置LLM模型")
+                return {"error": "未配置LLM模型"}
+
+            success, summary, reasoning, model_name = await llm_api.generate_with_model(
+                    prompt=summary_prompt,
+                    model_config=model_config,
+                    request_type="story.generate",
+                    temperature=0.3,
+                    max_tokens=1000
+                )
+
+            if not success:
+                logger.info(f"生成摘要失败: {summary}")
+                return {"error": "发生ai错误"}
+
+            logger.info(f"成功生成摘要内容：'{summary}'")
+
+            return {
+                "title": title,
+                "url": url,
+                "snippet": summary,
+                "source": "local"
+            }
+
+        except httpx.HTTPStatusError as e:
+            logger.warning(f"本地解析URL '{url}' 失败 (HTTP {e.response.status_code})")
+            return {"error": f"请求失败，状态码: {e.response.status_code}"}
+        except Exception as e:
+            logger.error(f"本地解析或总结URL '{url}' 时发生未知异常: {e}", exc_info=True)
+            return {"error": f"发生未知错误: {str(e)}"}
+
+    async def execute(self, function_args: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        执行URL内容提取和总结。优先使用Exa，失败后尝试本地解析。
+        """
+        # 获取当前文件路径用于缓存键
+        import os
+        current_file_path = os.path.abspath(__file__)
+
+        # 检查缓存
+        cached_result = await tool_cache.get(self.name, function_args, current_file_path)
+        if cached_result:
+            logger.info(f"缓存命中: {self.name} -> {function_args}")
+            return cached_result
+            
+        urls_input = function_args.get("urls")
+        if not urls_input:
+            return {"error": "URL列表不能为空。"}
+
+        # 处理URL输入，确保是列表格式
+        if isinstance(urls_input, str):
+            # 如果是字符串，尝试解析为URL列表
+            import re
+            # 提取所有HTTP/HTTPS URL
+            url_pattern = r'https?://[^\s\],]+'
+            urls = re.findall(url_pattern, urls_input)
+            if not urls:
+                # 如果没有找到标准URL，将整个字符串作为单个URL
+                if urls_input.strip().startswith(('http://', 'https://')):
+                    urls = [urls_input.strip()]
+                else:
+                    return {"error": "提供的字符串中未找到有效的URL。"}
+        elif isinstance(urls_input, list):
+            urls = [url.strip() for url in urls_input if isinstance(url, str) and url.strip()]
+        else:
+            return {"error": "URL格式不正确，应为字符串或列表。"}
+
+        # 验证URL格式
+        valid_urls = []
+        for url in urls:
+            if url.startswith(('http://', 'https://')):
+                valid_urls.append(url)
+            else:
+                logger.warning(f"跳过无效URL: {url}")
+        
+        if not valid_urls:
+            return {"error": "未找到有效的URL。"}
+        
+        urls = valid_urls
+        logger.info(f"准备解析 {len(urls)} 个URL: {urls}")
+
+        successful_results = []
+        error_messages = []
+        urls_to_retry_locally = []
+        
+        # 步骤 1: 尝试使用 Exa API 进行解析
+        contents_response = None
+        if self.exa_key_cycle:
+            logger.info(f"开始使用 Exa API 解析URL: {urls}")
+            try:
+                # 使用轮询机制获取下一个客户端
+                exa_client = next(self.exa_key_cycle)
+                loop = asyncio.get_running_loop()
+                exa_params = {"text": True, "summary": True, "highlights": True}
+                func = functools.partial(exa_client.get_contents, urls, **exa_params)
+                contents_response = await loop.run_in_executor(None, func)
+            except Exception as e:
+                logger.error(f"执行 Exa URL解析时发生严重异常: {e}", exc_info=True)
+                contents_response = None # 确保异常后为None
+
+        # 步骤 2: 处理Exa的响应
+        if contents_response and hasattr(contents_response, 'statuses'):
+            results_map = {res.url: res for res in contents_response.results} if hasattr(contents_response, 'results') else {}
+            if contents_response.statuses:
+                for status in contents_response.statuses:
+                    if status.status == 'success':
+                        res = results_map.get(status.id)
+                        if res:
+                            summary = getattr(res, 'summary', '')
+                            highlights = " ".join(getattr(res, 'highlights', []))
+                            text_snippet = (getattr(res, 'text', '')[:300] + '...') if getattr(res, 'text', '') else ''
+                            snippet = summary or highlights or text_snippet or '无摘要'
+                            
+                            successful_results.append({
+                                "title": getattr(res, 'title', '无标题'),
+                                "url": getattr(res, 'url', status.id),
+                                "snippet": snippet,
+                                "source": "exa"
+                            })
+                    else:
+                        error_tag = getattr(status, 'error', '未知错误')
+                        logger.warning(f"Exa解析URL '{status.id}' 失败: {error_tag}。准备本地重试。")
+                        urls_to_retry_locally.append(status.id)
+        else:
+            # 如果Exa未配置、API调用失败或返回无效响应，则所有URL都进入本地重试
+            urls_to_retry_locally.extend(url for url in urls if url not in [res['url'] for res in successful_results])
+
+
+        # 步骤 3: 对失败的URL进行本地解析
+        if urls_to_retry_locally:
+            logger.info(f"开始本地解析以下URL: {urls_to_retry_locally}")
+            local_tasks = [self._local_parse_and_summarize(url) for url in urls_to_retry_locally]
+            local_results = await asyncio.gather(*local_tasks)
+            
+            for i, res in enumerate(local_results):
+                url = urls_to_retry_locally[i]
+                if "error" in res:
+                    error_messages.append(f"URL: {url} - 解析失败: {res['error']}")
+                else:
+                    successful_results.append(res)
+
+        if not successful_results:
+            return {"error": "无法从所有给定的URL获取内容。", "details": error_messages}
+
+        formatted_content = self._format_results(successful_results)
+        
+        result = {
+            "type": "url_parse_result",
+            "content": formatted_content,
+            "errors": error_messages
+        }
+        
+        # 保存到缓存
+        if "error" not in result:
+            await tool_cache.set(self.name, function_args, self.__class__, result)
+
+        return result
+
+    def _format_results(self, results: List[Dict[str, Any]]) -> str:
+        """
+        将成功解析的结果列表格式化为一段简洁的文本。
+        """
+        formatted_parts = []
+        for res in results:
+            title = res.get('title', '无标题')
+            url = res.get('url', '#')
+            snippet = res.get('snippet', '无摘要')
+            source = res.get('source', '未知')
+
+            formatted_string = f"**{title}**\n"
+            formatted_string += f"**内容摘要**:\n{snippet}\n"
+            formatted_string += f"**来源**: {url} (由 {source} 解析)\n"
+            formatted_parts.append(formatted_string)
+
+        return "\n---\n".join(formatted_parts)
+
+@register_plugin
+class WEBSEARCHPLUGIN(BasePlugin):
+
+    # 插件基本信息
+    plugin_name: str = "web_search_tool"  # 内部标识符
+    enable_plugin: bool = True
+    dependencies: List[str] = []  # 插件依赖列表
+    # Python包依赖列表 - 支持两种格式：
+    # 方式1: 简单字符串列表（向后兼容）
+    # python_dependencies: List[str] = ["asyncddgs", "exa_py", "httpx[socks]"]
+    
+    # 方式2: 详细的PythonDependency对象（推荐）
+    python_dependencies: List[PythonDependency] = [
+        PythonDependency(
+            package_name="asyncddgs",
+            description="异步DuckDuckGo搜索库",
+            optional=False
+        ),
+        PythonDependency(
+            package_name="exa_py",
+            description="Exa搜索API客户端库",
+            optional=True  # 如果没有API密钥，这个是可选的
+        ),
+        PythonDependency(
+            package_name="tavily",
+            install_name="tavily-python",  # 安装时使用这个名称
+            description="Tavily搜索API客户端库",
+            optional=True  # 如果没有API密钥，这个是可选的
+        ),
+        PythonDependency(
+            package_name="httpx",
+            version=">=0.20.0",
+            install_name="httpx[socks]",  # 安装时使用这个名称（包含可选依赖）
+            description="支持SOCKS代理的HTTP客户端库",
+            optional=False
+        )
+    ]
+    config_file_name: str = "config.toml"  # 配置文件名
+
+    # 配置节描述
+    config_section_descriptions = {"plugin": "插件基本信息", "proxy": "链接本地解析代理配置"}
+
+    # 配置Schema定义
+    # 注意：EXA配置和组件设置已迁移到主配置文件(bot_config.toml)的[exa]和[web_search]部分
+    config_schema: dict = {
+        "plugin": {
+            "name": ConfigField(type=str, default="WEB_SEARCH_PLUGIN", description="插件名称"),
+            "version": ConfigField(type=str, default="1.0.0", description="插件版本"),
+            "enabled": ConfigField(type=bool, default=False, description="是否启用插件"),
+        },
+        "proxy": {
+            "http_proxy": ConfigField(type=str, default=None, description="HTTP代理地址，格式如: http://proxy.example.com:8080"),
+            "https_proxy": ConfigField(type=str, default=None, description="HTTPS代理地址，格式如: http://proxy.example.com:8080"),
+            "socks5_proxy": ConfigField(type=str, default=None, description="SOCKS5代理地址，格式如: socks5://proxy.example.com:1080"),
+            "enable_proxy": ConfigField(type=bool, default=False, description="是否启用代理")
+        },
+    }
+    def get_plugin_components(self) -> List[Tuple[ComponentInfo, Type]]:
+        enable_tool =[]
+        # 从主配置文件读取组件启用配置
+        if config_api.get_global_config("web_search.enable_web_search_tool", True):
+            enable_tool.append((WebSurfingTool.get_tool_info(), WebSurfingTool))
+        if config_api.get_global_config("web_search.enable_url_tool", True):
+            enable_tool.append((URLParserTool.get_tool_info(), URLParserTool))
+        return enable_tool

src/plugins/built_in/anti_injector_manager.py

@@ -1,133 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-反注入系统管理命令插件
-
-提供管理和监控反注入系统的命令接口，包括：
-- 系统状态查看
-- 配置修改
-- 统计信息查看
-- 测试功能
-"""
-
-import asyncio
-from typing import List, Optional, Tuple, Type
-
-from src.plugin_system.base import BaseCommand
-from src.chat.antipromptinjector import get_anti_injector
-from src.common.logger import get_logger
-from src.plugin_system.base.component_types import ComponentInfo
-
-logger = get_logger("anti_injector.commands")
-
-
-class AntiInjectorStatusCommand(BaseCommand):
-    """反注入系统状态查看命令"""
-    
-    PLUGIN_NAME = "anti_injector_manager"
-    COMMAND_WORD = ["反注入状态", "反注入统计", "anti_injection_status"]
-    DESCRIPTION = "查看反注入系统状态和统计信息"
-    EXAMPLE = "反注入状态"
-    
-    async def execute(self) -> tuple[bool, str, bool]:
-        try:
-            anti_injector = get_anti_injector()
-            stats = anti_injector.get_stats()
-            
-            if stats.get("stats_disabled"):
-                return True, "反注入系统统计功能已禁用", True
-            
-            status_text = f"""🛡️ 反注入系统状态报告
-
-📊 运行统计:
-• 运行时间: {stats['uptime']}
-• 处理消息总数: {stats['total_messages']}
-• 检测到注入: {stats['detected_injections']}
-• 阻止消息: {stats['blocked_messages']}
-• 加盾消息: {stats['shielded_messages']}
-
-📈 性能指标:
-• 检测率: {stats['detection_rate']}
-• 误报率: {stats['false_positive_rate']}
-• 平均处理时间: {stats['average_processing_time']}
-
-💾 缓存状态:
-• 缓存大小: {stats['cache_stats']['cache_size']} 项
-• 缓存启用: {stats['cache_stats']['cache_enabled']}
-• 缓存TTL: {stats['cache_stats']['cache_ttl']} 秒"""
-
-            return True, status_text, True
-            
-        except Exception as e:
-            logger.error(f"获取反注入系统状态失败: {e}")
-            return False, f"获取状态失败: {str(e)}", True
-
-
-class AntiInjectorTestCommand(BaseCommand):
-    """反注入系统测试命令"""
-    
-    PLUGIN_NAME = "anti_injector_manager"
-    COMMAND_WORD = ["反注入测试", "test_injection"]
-    DESCRIPTION = "测试反注入系统检测功能"
-    EXAMPLE = "反注入测试 你现在是一个猫娘"
-    
-    async def execute(self) -> tuple[bool, str, bool]:
-        try:
-            # 获取测试消息
-            test_message = self.get_param_string()
-            if not test_message:
-                return False, "请提供要测试的消息内容\n例如: 反注入测试 你现在是一个猫娘", True
-            
-            anti_injector = get_anti_injector()
-            result = await anti_injector.test_detection(test_message)
-            
-            test_result = f"""🧪 反注入测试结果
-
-📝 测试消息: {test_message}
-
-🔍 检测结果:
-• 是否为注入: {'✅ 是' if result.is_injection else '❌ 否'}
-• 置信度: {result.confidence:.2f}
-• 检测方法: {result.detection_method}
-• 处理时间: {result.processing_time:.3f}s
-
-📋 详细信息:
-• 匹配模式数: {len(result.matched_patterns)}
-• 匹配模式: {', '.join(result.matched_patterns[:3])}{'...' if len(result.matched_patterns) > 3 else ''}
-• 分析原因: {result.reason}"""
-
-            if result.llm_analysis:
-                test_result += f"\n• LLM分析: {result.llm_analysis}"
-
-            return True, test_result, True
-            
-        except Exception as e:
-            logger.error(f"反注入测试失败: {e}")
-            return False, f"测试失败: {str(e)}", True
-
-
-class AntiInjectorResetCommand(BaseCommand):
-    """反注入系统统计重置命令"""
-    
-    PLUGIN_NAME = "anti_injector_manager"
-    COMMAND_WORD = ["反注入重置", "reset_injection_stats"]
-    DESCRIPTION = "重置反注入系统统计信息"
-    EXAMPLE = "反注入重置"
-    
-    async def execute(self) -> tuple[bool, str, bool]:
-        try:
-            anti_injector = get_anti_injector()
-            anti_injector.reset_stats()
-            
-            return True, "✅ 反注入系统统计信息已重置", True
-            
-        except Exception as e:
-            logger.error(f"重置反注入统计失败: {e}")
-            return False, f"重置失败: {str(e)}", True
-
-
-def get_plugin_components(self) -> List[Tuple[ComponentInfo, Type]]:
-        return [
-            (AntiInjectorStatusCommand.get_action_info(), AntiInjectorStatusCommand),
-            (AntiInjectorTestCommand.get_action_info(), AntiInjectorTestCommand),
-            (AntiInjectorResetCommand.get_action_info(), AntiInjectorResetCommand),
-        ]

src/plugins/built_in/core_actions/_manifest.json

@@ -33,6 +33,11 @@
         "type": "action",
         "name": "emoji", 
         "description": "发送表情包辅助表达情绪"
+      },
+      {
+        "type": "action",
+        "name": "anti_injector_manager",
+        "description": "管理和监控反注入系统"
       }
     ]
   }

src/plugins/built_in/core_actions/anti_injector_manager.py

@@ -0,0 +1,253 @@
+"""
+反注入系统管理命令插件
+
+提供管理和监控反注入系统的命令接口，包括：
+- 系统状态查看
+- 配置修改
+- 统计信息查看
+- 测试功能
+"""
+
+
+from src.plugin_system.base import BaseCommand
+from src.chat.antipromptinjector import get_anti_injector
+from src.chat.antipromptinjector.command_skip_list import (
+    get_skip_patterns_info, 
+    skip_list_manager
+)
+from src.common.logger import get_logger
+
+logger = get_logger("anti_injector.commands")
+
+
+class AntiInjectorStatusCommand(BaseCommand):
+    """反注入系统状态查看命令"""
+    
+    command_name = "反注入状态"  # 命令名称，作为唯一标识符
+    command_description = "查看反注入系统状态和统计信息"  # 命令描述
+    command_pattern = r"^/反注入状态$"  # 命令匹配的正则表达式
+
+    async def execute(self) -> tuple[bool, str, bool]:
+        try:
+            anti_injector = get_anti_injector()
+            stats = await anti_injector.get_stats()
+            
+            if stats.get("stats_disabled"):
+                return True, "反注入系统统计功能已禁用", True
+            
+            status_text = f"""🛡️ 反注入系统状态报告
+
+📊 运行统计:
+• 运行时间: {stats['uptime']}
+• 处理消息总数: {stats['total_messages']}
+• 检测到注入: {stats['detected_injections']}
+• 阻止消息: {stats['blocked_messages']}
+• 加盾消息: {stats['shielded_messages']}
+
+📈 性能指标:
+• 检测率: {stats['detection_rate']}
+• 平均处理时间: {stats['average_processing_time']}
+• 最后处理时间: {stats['last_processing_time']}
+
+⚠️ 错误计数: {stats['error_count']}"""
+            await self.send_text(status_text)
+            return True, status_text, True
+            
+        except Exception as e:
+            logger.error(f"获取反注入系统状态失败: {e}")
+            await self.send_text(f"获取状态失败: {str(e)}")
+            return False, f"获取状态失败: {str(e)}", True
+
+
+class AntiInjectorSkipListCommand(BaseCommand):
+    """反注入跳过列表管理命令"""
+    
+    command_name = "反注入跳过列表"
+    command_description = "管理反注入系统的命令跳过列表"
+    command_pattern = r"^/反注入跳过列表(?:\s+(?P<subcommand>.+))?$"
+
+    async def execute(self) -> tuple[bool, str, bool]:
+        try:
+            # 从正则匹配中获取参数
+            subcommand_raw = None
+            if self.matched_groups and "subcommand" in self.matched_groups:
+                subcommand_raw = self.matched_groups.get("subcommand")
+            
+            subcommand = subcommand_raw.strip() if subcommand_raw and subcommand_raw.strip() else ""
+            
+            if not subcommand:
+                return await self._show_status()
+            
+            # 处理子命令
+            subcommand_parts = subcommand.split()
+            main_cmd = subcommand_parts[0].lower()
+            
+            if main_cmd == "状态" or main_cmd == "status":
+                return await self._show_status()
+            elif main_cmd == "刷新" or main_cmd == "refresh":
+                return await self._refresh_commands()
+            elif main_cmd == "列表" or main_cmd == "list":
+                list_type = subcommand_parts[1] if len(subcommand_parts) > 1 else "all"
+                return await self._show_patterns(list_type)
+            elif main_cmd == "添加" or main_cmd == "add":
+                await self.send_text("暂不支持权限管理系统，该命令不可用")
+                return False, "功能受限", True
+            elif main_cmd == "帮助" or main_cmd == "help":
+                return await self._show_help()
+            else:
+                await self.send_text(f"未知的子命令: {main_cmd}")
+                return await self._show_help()
+                
+        except Exception as e:
+            logger.error(f"执行反注入跳过列表命令失败: {e}")
+            await self.send_text(f"命令执行失败: {str(e)}")
+            return False, f"命令执行失败: {str(e)}", True
+    
+    async def _show_help(self) -> tuple[bool, str, bool]:
+        """显示帮助信息"""
+        help_text = """🛡️ 反注入跳过列表管理
+
+📋 可用命令:
+• /反注入跳过列表 状态 - 查看跳过列表状态
+• /反注入跳过列表 列表 [类型] - 查看跳过模式列表
+  - 类型: all(所有), system(系统), plugin(插件), manual(手动)
+• /反注入跳过列表 刷新 - 刷新插件命令列表
+• /反注入跳过列表 添加 <模式> - 临时添加跳过模式
+• /反注入跳过列表 帮助 - 显示此帮助信息
+
+💡 示例:
+• /反注入跳过列表 列表 plugin
+• /反注入跳过列表 添加 ^/test\\b"""
+        
+        await self.send_text(help_text)
+        return True, "帮助信息已发送", True
+    
+    async def _show_status(self) -> tuple[bool, str, bool]:
+        """显示跳过列表状态"""
+        # 强制刷新插件命令，确保获取最新的插件列表
+        patterns_info = get_skip_patterns_info()
+        
+        system_count = len(patterns_info.get("system", []))
+        plugin_count = len(patterns_info.get("plugin", []))
+        manual_count = len(patterns_info.get("manual", []))
+        temp_count = len([p for p in skip_list_manager._skip_patterns.values() if p.source == "temporary"])
+        total_count = system_count + plugin_count + manual_count + temp_count
+        
+        from src.config.config import global_config
+        config = global_config.anti_prompt_injection
+        
+        status_text = f"""🛡️ 反注入跳过列表状态
+
+📊 模式统计:
+• 系统命令模式: {system_count} 个
+• 插件命令模式: {plugin_count} 个  
+• 手动配置模式: {manual_count} 个
+• 临时添加模式: {temp_count} 个
+• 总计: {total_count} 个
+
+⚙️ 配置状态:
+• 跳过列表启用: {'✅' if config.enable_command_skip_list else '❌'}
+• 自动收集插件命令: {'✅' if config.auto_collect_plugin_commands else '❌'}
+• 跳过系统命令: {'✅' if config.skip_system_commands else '❌'}
+
+💡 使用 "/反注入跳过列表 列表" 查看详细模式"""
+        
+        await self.send_text(status_text)
+        return True, status_text, True
+    
+    async def _show_patterns(self, pattern_type: str = "all") -> tuple[bool, str, bool]:
+        """显示跳过模式列表"""
+        # 强制刷新插件命令，确保获取最新的插件列表
+        patterns_info = get_skip_patterns_info()
+        
+        if pattern_type == "all":
+            # 显示所有模式
+            result_text = "🛡️ 所有跳过模式列表\n\n"
+            
+            for source_type, patterns in patterns_info.items():
+                if patterns:
+                    type_name = {
+                        "system": "📱 系统命令",
+                        "plugin": "🔌 插件命令", 
+                        "manual": "✋ 手动配置"
+                    }.get(source_type, source_type)
+                    
+                    result_text += f"{type_name} ({len(patterns)} 个):\n"
+                    for i, pattern in enumerate(patterns[:10], 1):  # 限制显示前10个
+                        result_text += f"  {i}. {pattern['pattern']}\n"
+                        if pattern['description']:
+                            result_text += f"     说明: {pattern['description']}\n"
+                    
+                    if len(patterns) > 10:
+                        result_text += f"  ... 还有 {len(patterns) - 10} 个模式\n"
+                    result_text += "\n"
+            
+            # 添加临时模式
+            temp_patterns = [p for p in skip_list_manager._skip_patterns.values() if p.source == "temporary"]
+            if temp_patterns:
+                result_text += f"⏱️ 临时模式 ({len(temp_patterns)} 个):\n"
+                for i, pattern in enumerate(temp_patterns[:5], 1):
+                    result_text += f"  {i}. {pattern.pattern}\n"
+                if len(temp_patterns) > 5:
+                    result_text += f"  ... 还有 {len(temp_patterns) - 5} 个临时模式\n"
+        
+        else:
+            # 显示特定类型的模式
+            if pattern_type not in patterns_info:
+                await self.send_text(f"未知的模式类型: {pattern_type}")
+                return False, "未知模式类型", True
+            
+            patterns = patterns_info[pattern_type]
+            type_name = {
+                "system": "📱 系统命令模式",
+                "plugin": "🔌 插件命令模式", 
+                "manual": "✋ 手动配置模式"
+            }.get(pattern_type, pattern_type)
+            
+            result_text = f"🛡️ {type_name} ({len(patterns)} 个)\n\n"
+            
+            if not patterns:
+                result_text += "暂无此类型的跳过模式"
+            else:
+                for i, pattern in enumerate(patterns, 1):
+                    result_text += f"{i}. {pattern['pattern']}\n"
+                    if pattern['description']:
+                        result_text += f"   说明: {pattern['description']}\n"
+                    result_text += "\n"
+        
+        await self.send_text(result_text)
+        return True, result_text, True
+    
+    async def _refresh_commands(self) -> tuple[bool, str, bool]:
+        """刷新插件命令列表"""
+        try:
+            patterns_info = get_skip_patterns_info()
+            plugin_count = len(patterns_info.get("plugin", []))
+            
+            result_text = f"✅ 插件命令列表已刷新\n\n当前收集到 {plugin_count} 个插件命令模式"
+            await self.send_text(result_text)
+            return True, result_text, True
+            
+        except Exception as e:
+            logger.error(f"刷新插件命令列表失败: {e}")
+            await self.send_text(f"刷新失败: {str(e)}")
+            return False, f"刷新失败: {str(e)}", True
+    
+    async def _add_temporary_pattern(self, pattern: str) -> tuple[bool, str, bool]:
+        """添加临时跳过模式"""
+        try:
+            success = skip_list_manager.add_temporary_skip_pattern(pattern, "用户临时添加")
+            
+            if success:
+                result_text = f"✅ 临时跳过模式已添加: {pattern}\n\n⚠️ 此模式仅在当前运行期间有效，重启后会失效"
+                await self.send_text(result_text)
+                return True, result_text, True
+            else:
+                result_text = f"❌ 添加临时跳过模式失败: {pattern}\n\n可能是无效的正则表达式"
+                await self.send_text(result_text)
+                return False, result_text, True
+                
+        except Exception as e:
+            logger.error(f"添加临时跳过模式失败: {e}")
+            await self.send_text(f"添加失败: {str(e)}")
+            return False, f"添加失败: {str(e)}", True

src/plugins/built_in/core_actions/plugin.py

@@ -11,12 +11,14 @@ from typing import List, Tuple, Type
 from src.plugin_system import BasePlugin, register_plugin, ComponentInfo
 from src.plugin_system.base.config_types import ConfigField
 
+
 # 导入依赖的系统组件
 from src.common.logger import get_logger
 
 # 导入API模块 - 标准Python包方式
 from src.plugins.built_in.core_actions.no_reply import NoReplyAction
 from src.plugins.built_in.core_actions.emoji import EmojiAction
+from src.plugins.built_in.core_actions.anti_injector_manager import AntiInjectorStatusCommand, AntiInjectorSkipListCommand
 
 logger = get_logger("core_actions")
 
@@ -55,6 +57,7 @@ class CoreActionsPlugin(BasePlugin):
         "components": {
             "enable_no_reply": ConfigField(type=bool, default=True, description="是否启用不回复动作"),
             "enable_emoji": ConfigField(type=bool, default=True, description="是否启用发送表情/图片动作"),
+            "enable_anti_injector_manager": ConfigField(type=bool, default=True, description="是否启用反注入系统管理命令"),
         },
     }
 
@@ -67,6 +70,9 @@ class CoreActionsPlugin(BasePlugin):
             components.append((NoReplyAction.get_action_info(), NoReplyAction))
         if self.get_config("components.enable_emoji", True):
             components.append((EmojiAction.get_action_info(), EmojiAction))
+        if self.get_config("components.enable_anti_injector_manager", True):
+            components.append((AntiInjectorStatusCommand.get_command_info(), AntiInjectorStatusCommand))
+            components.append((AntiInjectorSkipListCommand.get_command_info(), AntiInjectorSkipListCommand))
 
 
         return components