"""
MCP 桥接插件 v2.0.0
将 MCP (Model Context Protocol) 服务器的工具桥接到 MaiBot

v2.0.0 配置与架构精简（功能保持不变）:
- MCP 服务器配置统一为 Claude Desktop 的 mcpServers JSON（WebUI / config.toml 同一入口）
- 兼容迁移：检测到旧版 servers.list 时自动迁移为 mcpServers（仅迁移，避免多入口混淆）
- 移除 WebUI 导入导出/快速添加服务器的旧实现（避免 tomlkit 依赖与格式混乱）

v1.9.0 双轨制架构:
- 软流程 (ReAct): LLM 自主决策，动态多轮调用 MCP 工具，灵活应对复杂场景
- 硬流程 (Workflow): 用户预定义的工作流，固定执行顺序，可靠可控
- 工具链重命名为 Workflow，更清晰地表达其"预定义流程"的本质
- 命令更新：/mcp workflow 替代 /mcp chain

v1.8.1 工具链易用性优化:
- 快速添加工具链：WebUI 表单式配置，无需手写 JSON
- 工具链模板：提供常用工具链配置模板参考
- 使用指南：内置变量语法和命令说明
- 状态显示优化：详细展示工具链步骤和参数信息

v1.8.0 工具链支持:
- 工具链：将多个工具按顺序执行，后续工具可使用前序工具的输出
- 自定义工具链：在 WebUI 配置工具链，自动注册为组合工具供 LLM 调用
- 变量替换：支持 ${input.参数}、${step.输出键}、${prev} 变量
- 工具链命令：/mcp chain 查看、测试、管理工具链

v1.7.0 稳定性与易用性优化:
- 断路器模式：故障服务器快速失败，避免拖慢整体响应
- 状态实时刷新：WebUI 每 10 秒自动更新连接状态
- 断路器状态显示：在状态面板显示熔断/试探状态

v1.6.0 配置导入导出:
- 新增 /mcp import 命令，支持从 Claude Desktop 格式导入配置
- 新增 /mcp export 命令，导出为 Claude Desktop (mcpServers) 格式
- 支持 stdio、sse、http、streamable_http 全部传输类型
- 自动跳过同名服务器，防止重复导入

v1.5.4 易用性优化:
- 新增 MCP 服务器获取快捷入口（魔搭、Smithery、Glama 等）
- 优化快速入门指南，提供配置示例
- 帮助新用户快速上手 MCP

v1.5.3 配置优化:
- 新增智能心跳 WebUI 配置项：启用开关、最大间隔倍数
- 支持在 WebUI 中开启/关闭智能心跳功能

v1.5.2 性能优化:
- 智能心跳间隔：根据服务器稳定性动态调整心跳频率
- 稳定服务器逐渐增加间隔，减少不必要的网络请求
- 断开的服务器使用较短间隔快速重连

v1.5.1 易用性优化（v2.0.0 起已移除）:
- 「快速添加服务器」表单式配置（已统一为 Claude mcpServers JSON，避免多入口混淆）

v1.5.0 性能优化:
- 服务器并行连接：多个服务器同时连接，大幅减少启动时间
- 连接耗时统计：日志显示并行连接总耗时

v1.4.4 修复:
- 修复首次生成默认配置文件时多行字符串导致 TOML 解析失败的问题
- 简化 config_schema 默认值，避免主程序 json.dumps 产生无效 TOML

v1.4.3 修复:
- 修复 WebUI 保存配置后多行字符串格式错误导致配置文件无法读取的问题
- 清理未使用的导入

v1.4.0 新增功能:
- 工具禁用管理
- 调用链路追踪
- 工具调用缓存
- 工具权限控制
"""

import asyncio
import fnmatch
import hashlib
import json
import re
import time
import uuid
from collections import OrderedDict, deque
from dataclasses import asdict, dataclass, field
from pathlib import Path
from typing import Any, Dict, List, Optional, Tuple, Type

from src.common.logger import get_logger
from src.plugin_system import (
    BasePlugin,
    register_plugin,
    BaseTool,
    BaseCommand,
    ComponentInfo,
    ConfigField,
    ToolParamType,
)
from src.plugin_system.base.config_types import section_meta
from src.plugin_system.base.component_types import ToolInfo, ComponentType, EventType
from src.plugin_system.base.base_events_handler import BaseEventHandler

from .mcp_client import (
    MCPServerConfig,
    MCPToolInfo,
    MCPResourceInfo,
    MCPPromptInfo,
    TransportType,
    mcp_manager,
)
from .core.claude_config import (
    ClaudeConfigError,
    legacy_servers_list_to_claude_config,
    parse_claude_mcp_config,
)
from .tool_chain import (
    ToolChainDefinition,
    tool_chain_manager,
)

logger = get_logger("mcp_bridge_plugin")


# ============================================================================
# v1.4.0: 调用链路追踪
# ============================================================================

@dataclass
class ToolCallRecord:
    """工具调用记录"""
    call_id: str
    timestamp: float
    tool_name: str
    server_name: str
    chat_id: str = ""
    user_id: str = ""
    user_query: str = ""
    arguments: Dict = field(default_factory=dict)
    raw_result: str = ""
    processed_result: str = ""
    duration_ms: float = 0.0
    success: bool = True
    error: str = ""
    post_processed: bool = False
    cache_hit: bool = False


class ToolCallTracer:
    """工具调用追踪器"""
    
    def __init__(self, max_records: int = 100):
        self._records: deque[ToolCallRecord] = deque(maxlen=max_records)
        self._enabled: bool = True
        self._log_enabled: bool = False
        self._log_path: Optional[Path] = None
    
    def configure(self, enabled: bool, max_records: int, log_enabled: bool, log_path: Optional[Path] = None) -> None:
        """配置追踪器"""
        self._enabled = enabled
        self._records = deque(self._records, maxlen=max_records)
        self._log_enabled = log_enabled
        self._log_path = log_path
    
    def record(self, record: ToolCallRecord) -> None:
        """添加调用记录"""
        if not self._enabled:
            return
        
        self._records.append(record)
        
        if self._log_enabled and self._log_path:
            self._write_to_log(record)
    
    def get_recent(self, n: int = 10) -> List[ToolCallRecord]:
        """获取最近 N 条记录"""
        return list(self._records)[-n:]
    
    def get_by_tool(self, tool_name: str) -> List[ToolCallRecord]:
        """按工具名筛选记录"""
        return [r for r in self._records if r.tool_name == tool_name]
    
    def get_by_server(self, server_name: str) -> List[ToolCallRecord]:
        """按服务器名筛选记录"""
        return [r for r in self._records if r.server_name == server_name]
    
    def clear(self) -> None:
        """清空记录"""
        self._records.clear()
    
    def _write_to_log(self, record: ToolCallRecord) -> None:
        """写入 JSONL 日志文件"""
        try:
            if self._log_path:
                self._log_path.parent.mkdir(parents=True, exist_ok=True)
                with open(self._log_path, "a", encoding="utf-8") as f:
                    f.write(json.dumps(asdict(record), ensure_ascii=False) + "\n")
        except Exception as e:
            logger.warning(f"写入追踪日志失败: {e}")
    
    @property
    def total_records(self) -> int:
        return len(self._records)


# 全局追踪器实例
tool_call_tracer = ToolCallTracer()


# ============================================================================
# v1.4.0: 工具调用缓存
# ============================================================================

@dataclass
class CacheEntry:
    """缓存条目"""
    tool_name: str
    args_hash: str
    result: str
    created_at: float
    expires_at: float
    hit_count: int = 0


class ToolCallCache:
    """工具调用缓存（LRU）"""
    
    def __init__(self, max_entries: int = 200, ttl: int = 300):
        self._cache: OrderedDict[str, CacheEntry] = OrderedDict()
        self._max_entries = max_entries
        self._ttl = ttl
        self._enabled = False
        self._exclude_patterns: List[str] = []
        self._stats = {"hits": 0, "misses": 0}
    
    def configure(self, enabled: bool, ttl: int, max_entries: int, exclude_tools: str) -> None:
        """配置缓存"""
        self._enabled = enabled
        self._ttl = ttl
        self._max_entries = max_entries
        self._exclude_patterns = [p.strip() for p in exclude_tools.strip().split("\n") if p.strip()]
    
    def get(self, tool_name: str, args: Dict) -> Optional[str]:
        """获取缓存"""
        if not self._enabled:
            return None
        
        if self._is_excluded(tool_name):
            return None
        
        key = self._generate_key(tool_name, args)
        
        if key not in self._cache:
            self._stats["misses"] += 1
            return None
        
        entry = self._cache[key]
        
        # 检查是否过期
        if time.time() > entry.expires_at:
            del self._cache[key]
            self._stats["misses"] += 1
            return None
        
        # LRU: 移到末尾
        self._cache.move_to_end(key)
        entry.hit_count += 1
        self._stats["hits"] += 1
        
        return entry.result
    
    def set(self, tool_name: str, args: Dict, result: str) -> None:
        """设置缓存"""
        if not self._enabled:
            return
        
        if self._is_excluded(tool_name):
            return
        
        key = self._generate_key(tool_name, args)
        now = time.time()
        
        entry = CacheEntry(
            tool_name=tool_name,
            args_hash=key,
            result=result,
            created_at=now,
            expires_at=now + self._ttl,
        )
        
        # 如果已存在，更新
        if key in self._cache:
            self._cache[key] = entry
            self._cache.move_to_end(key)
        else:
            # 检查容量
            self._evict_if_needed()
            self._cache[key] = entry
    
    def clear(self) -> None:
        """清空缓存"""
        self._cache.clear()
        self._stats = {"hits": 0, "misses": 0}
    
    def _generate_key(self, tool_name: str, args: Dict) -> str:
        """生成缓存键"""
        args_str = json.dumps(args, sort_keys=True, ensure_ascii=False)
        content = f"{tool_name}:{args_str}"
        return hashlib.md5(content.encode()).hexdigest()
    
    def _is_excluded(self, tool_name: str) -> bool:
        """检查是否在排除列表中"""
        for pattern in self._exclude_patterns:
            if fnmatch.fnmatch(tool_name, pattern):
                return True
        return False
    
    def _evict_if_needed(self) -> None:
        """必要时淘汰条目"""
        # 先清理过期的
        now = time.time()
        expired_keys = [k for k, v in self._cache.items() if now > v.expires_at]
        for k in expired_keys:
            del self._cache[k]
        
        # LRU 淘汰
        while len(self._cache) >= self._max_entries:
            self._cache.popitem(last=False)
    
    def get_stats(self) -> Dict[str, Any]:
        """获取缓存统计"""
        total = self._stats["hits"] + self._stats["misses"]
        hit_rate = (self._stats["hits"] / total * 100) if total > 0 else 0
        return {
            "enabled": self._enabled,
            "entries": len(self._cache),
            "max_entries": self._max_entries,
            "ttl": self._ttl,
            "hits": self._stats["hits"],
            "misses": self._stats["misses"],
            "hit_rate": f"{hit_rate:.1f}%",
        }


# 全局缓存实例
tool_call_cache = ToolCallCache()


# ============================================================================
# v1.4.0: 工具权限控制
# ============================================================================

class PermissionChecker:
    """工具权限检查器"""
    
    def __init__(self):
        self._enabled = False
        self._default_mode = "allow_all"  # allow_all 或 deny_all
        self._rules: List[Dict] = []
        self._quick_deny_groups: set = set()
        self._quick_allow_users: set = set()
    
    def configure(
        self,
        enabled: bool,
        default_mode: str,
        rules_json: str,
        quick_deny_groups: str = "",
        quick_allow_users: str = "",
    ) -> None:
        """配置权限检查器"""
        self._enabled = enabled
        self._default_mode = default_mode if default_mode in ("allow_all", "deny_all") else "allow_all"
        
        # 解析快捷配置
        self._quick_deny_groups = {g.strip() for g in quick_deny_groups.strip().split("\n") if g.strip()}
        self._quick_allow_users = {u.strip() for u in quick_allow_users.strip().split("\n") if u.strip()}
        
        try:
            self._rules = json.loads(rules_json) if rules_json.strip() else []
        except json.JSONDecodeError as e:
            logger.warning(f"权限规则 JSON 解析失败: {e}")
            self._rules = []
    
    def check(self, tool_name: str, chat_id: str, user_id: str, is_group: bool) -> bool:
        """检查权限
        
        Args:
            tool_name: 工具名称
            chat_id: 聊天 ID（群号或私聊 ID）
            user_id: 用户 ID
            is_group: 是否为群聊
            
        Returns:
            True 表示允许，False 表示拒绝
        """
        if not self._enabled:
            return True
        
        # 快捷配置优先级最高
        # 1. 管理员白名单（始终允许）
        if user_id and user_id in self._quick_allow_users:
            return True
        
        # 2. 禁用群列表（始终拒绝）
        if is_group and chat_id and chat_id in self._quick_deny_groups:
            return False
        
        # 查找匹配的规则
        for rule in self._rules:
            tool_pattern = rule.get("tool", "")
            if not self._match_tool(tool_pattern, tool_name):
                continue
            
            # 找到匹配的规则
            mode = rule.get("mode", "")
            allowed = rule.get("allowed", [])
            denied = rule.get("denied", [])
            
            # 构建当前上下文的 ID 列表
            context_ids = self._build_context_ids(chat_id, user_id, is_group)
            
            # 检查 denied 列表（优先级最高）
            if denied:
                for ctx_id in context_ids:
                    if self._match_id_list(denied, ctx_id):
                        return False
            
            # 检查 allowed 列表
            if allowed:
                for ctx_id in context_ids:
                    if self._match_id_list(allowed, ctx_id):
                        return True
                # 如果是 whitelist 模式且不在 allowed 中，拒绝
                if mode == "whitelist":
                    return False
            
            # 规则匹配但没有明确允许/拒绝，继续检查下一条规则
        
        # 没有匹配的规则，使用默认模式
        return self._default_mode == "allow_all"
    
    def _match_tool(self, pattern: str, tool_name: str) -> bool:
        """工具名通配符匹配"""
        if not pattern:
            return False
        return fnmatch.fnmatch(tool_name, pattern)
    
    def _build_context_ids(self, chat_id: str, user_id: str, is_group: bool) -> List[str]:
        """构建上下文 ID 列表"""
        ids = []
        
        # 用户级别（任何场景生效）
        if user_id:
            ids.append(f"qq:{user_id}:user")
        
        # 场景级别
        if is_group and chat_id:
            ids.append(f"qq:{chat_id}:group")
        elif chat_id:
            ids.append(f"qq:{chat_id}:private")
        
        return ids
    
    def _match_id_list(self, id_list: List[str], context_id: str) -> bool:
        """检查 ID 是否在列表中"""
        for rule_id in id_list:
            if fnmatch.fnmatch(context_id, rule_id):
                return True
        return False
    
    def get_rules_for_tool(self, tool_name: str) -> List[Dict]:
        """获取特定工具的权限规则"""
        return [r for r in self._rules if self._match_tool(r.get("tool", ""), tool_name)]


# 全局权限检查器实例
permission_checker = PermissionChecker()


# ============================================================================
# 工具类型转换
# ============================================================================

def convert_json_type_to_tool_param_type(json_type: str) -> ToolParamType:
    """将 JSON Schema 类型转换为 MaiBot 的 ToolParamType"""
    type_mapping = {
        "string": ToolParamType.STRING,
        "integer": ToolParamType.INTEGER,
        "number": ToolParamType.FLOAT,
        "boolean": ToolParamType.BOOLEAN,
        "array": ToolParamType.STRING,
        "object": ToolParamType.STRING,
    }
    return type_mapping.get(json_type, ToolParamType.STRING)


def parse_mcp_parameters(input_schema: Dict[str, Any]) -> List[Tuple[str, ToolParamType, str, bool, Optional[List[str]]]]:
    """解析 MCP 工具的参数 schema，转换为 MaiBot 的参数格式"""
    parameters = []
    
    if not input_schema:
        # 为无参数的工具添加占位参数，避免某些模型报错
        parameters.append(("_placeholder", ToolParamType.STRING, "占位参数，无需填写", False, None))
        return parameters
    
    properties = input_schema.get("properties", {})
    required = input_schema.get("required", [])
    
    # 如果没有任何参数，添加占位参数
    if not properties:
        parameters.append(("_placeholder", ToolParamType.STRING, "占位参数，无需填写", False, None))
        return parameters
    
    for param_name, param_info in properties.items():
        json_type = param_info.get("type", "string")
        param_type = convert_json_type_to_tool_param_type(json_type)
        description = param_info.get("description", f"参数 {param_name}")
        
        if json_type == "array":
            description = f"{description} (JSON 数组格式)"
        elif json_type == "object":
            description = f"{description} (JSON 对象格式)"
        
        is_required = param_name in required
        enum_values = param_info.get("enum")
        
        if enum_values is not None:
            enum_values = [str(v) for v in enum_values]
        
        parameters.append((param_name, param_type, description, is_required, enum_values))
    
    return parameters


# ============================================================================
# MCP 工具代理
# ============================================================================

class MCPToolProxy(BaseTool):
    """MCP 工具代理基类"""
    
    name: str = ""
    description: str = ""
    parameters: List[Tuple[str, ToolParamType, str, bool, Optional[List[str]]]] = []
    available_for_llm: bool = True
    
    _mcp_tool_key: str = ""
    _mcp_original_name: str = ""
    _mcp_server_name: str = ""
    
    async def execute(self, function_args: Dict[str, Any]) -> Dict[str, Any]:
        """执行 MCP 工具调用"""
        global _plugin_instance
        
        call_id = str(uuid.uuid4())[:8]
        start_time = time.time()
        
        # 移除 MaiBot 内部标记
        args = {k: v for k, v in function_args.items() if k != "llm_called"}
        
        # 解析 JSON 字符串参数
        parsed_args = {}
        for key, value in args.items():
            if isinstance(value, str):
                try:
                    if value.startswith(("[", "{")):
                        parsed_args[key] = json.loads(value)
                    else:
                        parsed_args[key] = value
                except json.JSONDecodeError:
                    parsed_args[key] = value
            else:
                parsed_args[key] = value
        
        # 获取上下文信息
        chat_id, user_id, is_group, user_query = self._get_context_info()
        
        # v1.4.0: 权限检查
        if not permission_checker.check(self.name, chat_id, user_id, is_group):
            logger.warning(f"权限拒绝: 工具 {self.name}, chat={chat_id}, user={user_id}")
            return {
                "name": self.name,
                "content": f"⛔ 权限不足：工具 {self.name} 在当前场景下不可用"
            }
        
        logger.debug(f"调用 MCP 工具: {self._mcp_tool_key}, 参数: {parsed_args}")
        
        # v1.4.0: 检查缓存
        cache_hit = False
        cached_result = tool_call_cache.get(self.name, parsed_args)
        
        if cached_result is not None:
            cache_hit = True
            content = cached_result
            raw_result = cached_result
            success = True
            error = ""
            logger.debug(f"MCP 工具 {self.name} 命中缓存")
        else:
            # 调用 MCP
            result = await mcp_manager.call_tool(self._mcp_tool_key, parsed_args)
            
            if result.success:
                content = result.content
                raw_result = content
                success = True
                error = ""
                
                # 存入缓存
                tool_call_cache.set(self.name, parsed_args, content)
            else:
                content = self._format_error_message(result.error, result.duration_ms)
                raw_result = result.error
                success = False
                error = result.error
                logger.warning(f"MCP 工具 {self.name} 调用失败: {result.error}")
        
        # v1.3.0: 后处理
        post_processed = False
        processed_result = content
        if success:
            processed_content = await self._post_process_result(content)
            if processed_content != content:
                post_processed = True
                processed_result = processed_content
                content = processed_content
        
        duration_ms = (time.time() - start_time) * 1000
        
        # v1.4.0: 记录调用追踪
        record = ToolCallRecord(
            call_id=call_id,
            timestamp=start_time,
            tool_name=self.name,
            server_name=self._mcp_server_name,
            chat_id=chat_id,
            user_id=user_id,
            user_query=user_query,
            arguments=parsed_args,
            raw_result=raw_result[:1000] if raw_result else "",
            processed_result=processed_result[:1000] if processed_result else "",
            duration_ms=duration_ms,
            success=success,
            error=error,
            post_processed=post_processed,
            cache_hit=cache_hit,
        )
        tool_call_tracer.record(record)
        
        return {"name": self.name, "content": content}
    
    def _get_context_info(self) -> Tuple[str, str, bool, str]:
        """获取上下文信息"""
        chat_id = ""
        user_id = ""
        is_group = False
        user_query = ""
        
        if self.chat_stream and hasattr(self.chat_stream, "context") and self.chat_stream.context:
            try:
                ctx = self.chat_stream.context
                if hasattr(ctx, "chat_id"):
                    chat_id = str(ctx.chat_id) if ctx.chat_id else ""
                if hasattr(ctx, "user_id"):
                    user_id = str(ctx.user_id) if ctx.user_id else ""
                if hasattr(ctx, "is_group"):
                    is_group = bool(ctx.is_group)
                
                last_message = ctx.get_last_message()
                if last_message and hasattr(last_message, "processed_plain_text"):
                    user_query = last_message.processed_plain_text or ""
            except Exception as e:
                logger.debug(f"获取上下文信息失败: {e}")
        
        return chat_id, user_id, is_group, user_query

    async def _post_process_result(self, content: str) -> str:
        """v1.3.0: 对工具返回结果进行后处理（摘要提炼）"""
        global _plugin_instance
        
        if _plugin_instance is None:
            return content
        
        settings = _plugin_instance.config.get("settings", {})
        
        if not settings.get("post_process_enabled", False):
            return content
        
        server_post_config = self._get_server_post_process_config()
        
        if server_post_config is not None:
            if not server_post_config.get("enabled", True):
                return content
        
        threshold = settings.get("post_process_threshold", 500)
        if server_post_config and "threshold" in server_post_config:
            threshold = server_post_config["threshold"]
        
        content_length = len(content) if content else 0
        if content_length <= threshold:
            return content
        
        user_query = self._get_context_info()[3]
        if not user_query:
            return content
        
        max_tokens = settings.get("post_process_max_tokens", 500)
        if server_post_config and "max_tokens" in server_post_config:
            max_tokens = server_post_config["max_tokens"]
        
        prompt_template = settings.get("post_process_prompt", "")
        if server_post_config and "prompt" in server_post_config:
            prompt_template = server_post_config["prompt"]
        
        if not prompt_template:
            prompt_template = """用户问题：{query}

工具返回内容：
{result}

请从上述内容中提取与用户问题最相关的关键信息，简洁准确地输出："""
        
        try:
            prompt = prompt_template.format(query=user_query, result=content)
        except KeyError as e:
            logger.warning(f"后处理 prompt 模板格式错误: {e}")
            return content
        
        try:
            processed_content = await self._call_post_process_llm(prompt, max_tokens, settings, server_post_config)
            if processed_content:
                logger.info(f"MCP 工具 {self.name} 后处理完成: {content_length} -> {len(processed_content)} 字符")
                return processed_content
            return content
        except Exception as e:
            logger.error(f"MCP 工具 {self.name} 后处理失败: {e}")
            return content
    
    def _get_server_post_process_config(self) -> Optional[Dict[str, Any]]:
        """获取当前服务器的后处理配置"""
        global _plugin_instance
        
        if _plugin_instance is None:
            return None

        servers = _plugin_instance._load_mcp_servers_config()
        for server_conf in servers:
            if server_conf.get("name") == self._mcp_server_name:
                return server_conf.get("post_process")
        
        return None
    
    async def _call_post_process_llm(
        self,
        prompt: str,
        max_tokens: int,
        settings: Dict[str, Any],
        server_config: Optional[Dict[str, Any]]
    ) -> Optional[str]:
        """调用 LLM 进行后处理"""
        from src.config.config import model_config
        from src.config.api_ada_configs import TaskConfig
        from src.llm_models.utils_model import LLMRequest
        
        model_name = settings.get("post_process_model", "")
        if server_config and "model" in server_config:
            model_name = server_config["model"]
        
        if model_name:
            task_config = TaskConfig(
                model_list=[model_name],
                max_tokens=max_tokens,
                temperature=0.3,
                slow_threshold=30.0,
            )
        else:
            task_config = model_config.model_task_config.utils
        
        llm_request = LLMRequest(model_set=task_config, request_type="mcp_post_process")
        
        response, (reasoning, model_used, _) = await llm_request.generate_response_async(
            prompt=prompt,
            max_tokens=max_tokens,
            temperature=0.3,
        )
        
        return response.strip() if response else None
    
    def _format_error_message(self, error: str, duration_ms: float) -> str:
        """格式化友好的错误消息"""
        if not error:
            return "工具调用失败（未知错误）"
        
        error_lower = error.lower()
        
        if "未连接" in error or "not connected" in error_lower:
            return f"⚠️ MCP 服务器 [{self._mcp_server_name}] 未连接，请检查服务器状态或等待自动重连"
        
        if "超时" in error or "timeout" in error_lower:
            return f"⏱️ 工具调用超时（耗时 {duration_ms:.0f}ms），服务器响应过慢，请稍后重试"
        
        if "connection" in error_lower and ("closed" in error_lower or "reset" in error_lower):
            return f"🔌 与 MCP 服务器 [{self._mcp_server_name}] 的连接已断开，正在尝试重连..."
        
        if "invalid" in error_lower and "argument" in error_lower:
            return f"❌ 参数错误: {error}"
        
        return f"❌ 工具调用失败: {error}"
    
    async def direct_execute(self, **function_args) -> Dict[str, Any]:
        """直接执行（供其他插件调用）"""
        return await self.execute(function_args)


def create_mcp_tool_class(
    tool_key: str,
    tool_info: MCPToolInfo,
    tool_prefix: str,
    disabled: bool = False
) -> Type[MCPToolProxy]:
    """根据 MCP 工具信息动态创建 BaseTool 子类"""
    parameters = parse_mcp_parameters(tool_info.input_schema)
    
    class_name = f"MCPTool_{tool_info.server_name}_{tool_info.name}".replace("-", "_").replace(".", "_")
    tool_name = tool_key.replace("-", "_").replace(".", "_")
    
    description = tool_info.description
    if not description.endswith(f"[来自 MCP 服务器: {tool_info.server_name}]"):
        description = f"{description} [来自 MCP 服务器: {tool_info.server_name}]"
    
    tool_class = type(
        class_name,
        (MCPToolProxy,),
        {
            "name": tool_name,
            "description": description,
            "parameters": parameters,
            "available_for_llm": not disabled,  # v1.4.0: 禁用的工具不可被 LLM 调用
            "_mcp_tool_key": tool_key,
            "_mcp_original_name": tool_info.name,
            "_mcp_server_name": tool_info.server_name,
        }
    )
    
    return tool_class


class MCPToolRegistry:
    """MCP 工具注册表"""
    
    def __init__(self):
        self._tool_classes: Dict[str, Type[MCPToolProxy]] = {}
        self._tool_infos: Dict[str, ToolInfo] = {}
    
    def register_tool(
        self,
        tool_key: str,
        tool_info: MCPToolInfo,
        tool_prefix: str,
        disabled: bool = False
    ) -> Tuple[ToolInfo, Type[MCPToolProxy]]:
        """注册 MCP 工具"""
        tool_class = create_mcp_tool_class(tool_key, tool_info, tool_prefix, disabled)
        
        self._tool_classes[tool_key] = tool_class
        
        info = ToolInfo(
            name=tool_class.name,
            tool_description=tool_class.description,
            enabled=True,
            tool_parameters=tool_class.parameters,
            component_type=ComponentType.TOOL,
        )
        self._tool_infos[tool_key] = info
        
        return info, tool_class
    
    def unregister_tool(self, tool_key: str) -> bool:
        """注销工具"""
        if tool_key in self._tool_classes:
            del self._tool_classes[tool_key]
            del self._tool_infos[tool_key]
            return True
        return False
    
    def get_all_components(self) -> List[Tuple[ComponentInfo, Type]]:
        """获取所有工具组件"""
        return [(self._tool_infos[key], self._tool_classes[key]) for key in self._tool_classes.keys()]
    
    def clear(self) -> None:
        """清空所有注册"""
        self._tool_classes.clear()
        self._tool_infos.clear()


# 全局工具注册表
mcp_tool_registry = MCPToolRegistry()

# 全局插件实例引用
_plugin_instance: Optional["MCPBridgePlugin"] = None


# ============================================================================
# 内置工具
# ============================================================================

class MCPReadResourceTool(BaseTool):
    """v1.2.0: MCP 资源读取工具"""
    
    name = "mcp_read_resource"
    description = "读取 MCP 服务器提供的资源内容（如文件、数据库记录等）。使用前请先用 mcp_status 查看可用资源。"
    parameters = [
        ("uri", ToolParamType.STRING, "资源 URI（如 file:///path/to/file 或自定义 URI）", True, None),
        ("server_name", ToolParamType.STRING, "指定服务器名称（可选，不指定则自动查找）", False, None),
    ]
    available_for_llm = True
    
    async def execute(self, function_args: Dict[str, Any]) -> Dict[str, Any]:
        uri = function_args.get("uri", "")
        server_name = function_args.get("server_name")
        
        if not uri:
            return {"name": self.name, "content": "❌ 请提供资源 URI"}
        
        result = await mcp_manager.read_resource(uri, server_name)
        
        if result.success:
            return {"name": self.name, "content": result.content}
        else:
            return {"name": self.name, "content": f"❌ 读取资源失败: {result.error}"}
    
    async def direct_execute(self, **function_args) -> Dict[str, Any]:
        return await self.execute(function_args)


class MCPGetPromptTool(BaseTool):
    """v1.2.0: MCP 提示模板工具"""
    
    name = "mcp_get_prompt"
    description = "获取 MCP 服务器提供的提示模板内容。使用前请先用 mcp_status 查看可用模板。"
    parameters = [
        ("name", ToolParamType.STRING, "提示模板名称", True, None),
        ("arguments", ToolParamType.STRING, "模板参数（JSON 对象格式）", False, None),
        ("server_name", ToolParamType.STRING, "指定服务器名称（可选）", False, None),
    ]
    available_for_llm = True
    
    async def execute(self, function_args: Dict[str, Any]) -> Dict[str, Any]:
        prompt_name = function_args.get("name", "")
        arguments_str = function_args.get("arguments", "")
        server_name = function_args.get("server_name")
        
        if not prompt_name:
            return {"name": self.name, "content": "❌ 请提供提示模板名称"}
        
        arguments = None
        if arguments_str:
            try:
                arguments = json.loads(arguments_str)
            except json.JSONDecodeError:
                return {"name": self.name, "content": "❌ 参数格式错误，请使用 JSON 对象格式"}
        
        result = await mcp_manager.get_prompt(prompt_name, arguments, server_name)
        
        if result.success:
            return {"name": self.name, "content": result.content}
        else:
            return {"name": self.name, "content": f"❌ 获取提示模板失败: {result.error}"}
    
    async def direct_execute(self, **function_args) -> Dict[str, Any]:
        return await self.execute(function_args)


# ============================================================================
# v1.8.0: 工具链代理工具
# ============================================================================

class ToolChainProxyBase(BaseTool):
    """工具链代理基类"""
    
    name: str = ""
    description: str = ""
    parameters: List[Tuple[str, ToolParamType, str, bool, Optional[List[str]]]] = []
    available_for_llm: bool = True
    
    _chain_name: str = ""
    
    async def execute(self, function_args: Dict[str, Any]) -> Dict[str, Any]:
        """执行工具链"""
        # 移除内部标记
        args = {k: v for k, v in function_args.items() if k != "llm_called"}
        
        logger.debug(f"执行工具链 {self._chain_name}，参数: {args}")
        
        result = await tool_chain_manager.execute_chain(self._chain_name, args)
        
        if result.success:
            # 构建输出
            output_parts = []
            output_parts.append(result.final_output)
            
            # 可选：添加执行摘要
            # output_parts.append(f"\n\n---\n执行摘要:\n{result.to_summary()}")
            
            return {"name": self.name, "content": "\n".join(output_parts)}
        else:
            error_msg = f"⚠️ 工具链执行失败: {result.error}"
            if result.step_results:
                error_msg += f"\n\n执行详情:\n{result.to_summary()}"
            return {"name": self.name, "content": error_msg}
    
    async def direct_execute(self, **function_args) -> Dict[str, Any]:
        return await self.execute(function_args)


def create_chain_tool_class(chain: ToolChainDefinition) -> Type[ToolChainProxyBase]:
    """根据工具链定义动态创建工具类"""
    # 构建参数列表
    parameters = []
    for param_name, param_desc in chain.input_params.items():
        parameters.append((param_name, ToolParamType.STRING, param_desc, True, None))
    
    # 生成类名和工具名
    class_name = f"ToolChain_{chain.name}".replace("-", "_").replace(".", "_")
    tool_name = f"chain_{chain.name}".replace("-", "_").replace(".", "_")
    
    # 构建描述
    description = chain.description
    if chain.steps:
        step_names = [s.tool_name.split("_")[-1] for s in chain.steps[:3]]
        description += f" (执行流程: {' → '.join(step_names)}{'...' if len(chain.steps) > 3 else ''})"
    
    tool_class = type(
        class_name,
        (ToolChainProxyBase,),
        {
            "name": tool_name,
            "description": description,
            "parameters": parameters,
            "available_for_llm": True,
            "_chain_name": chain.name,
        }
    )
    
    return tool_class


class ToolChainRegistry:
    """工具链注册表"""
    
    def __init__(self):
        self._tool_classes: Dict[str, Type[ToolChainProxyBase]] = {}
        self._tool_infos: Dict[str, ToolInfo] = {}
    
    def register_chain(self, chain: ToolChainDefinition) -> Tuple[ToolInfo, Type[ToolChainProxyBase]]:
        """注册工具链为组合工具"""
        tool_class = create_chain_tool_class(chain)
        
        self._tool_classes[chain.name] = tool_class
        
        info = ToolInfo(
            name=tool_class.name,
            tool_description=tool_class.description,
            enabled=True,
            tool_parameters=tool_class.parameters,
            component_type=ComponentType.TOOL,
        )
        self._tool_infos[chain.name] = info
        
        return info, tool_class
    
    def unregister_chain(self, chain_name: str) -> bool:
        """注销工具链"""
        if chain_name in self._tool_classes:
            del self._tool_classes[chain_name]
            del self._tool_infos[chain_name]
            return True
        return False
    
    def get_all_components(self) -> List[Tuple[ComponentInfo, Type]]:
        """获取所有工具链组件"""
        return [(self._tool_infos[key], self._tool_classes[key]) for key in self._tool_classes.keys()]
    
    def clear(self) -> None:
        """清空所有注册"""
        self._tool_classes.clear()
        self._tool_infos.clear()


# 全局工具链注册表
tool_chain_registry = ToolChainRegistry()


class MCPStatusTool(BaseTool):
    """MCP 状态查询工具"""
    
    name = "mcp_status"
    description = "查询 MCP 桥接插件的状态，包括服务器连接状态、可用工具列表、工具链列表、资源列表、提示模板列表、调用统计、追踪记录等信息"
    parameters = [
        ("query_type", ToolParamType.STRING, "查询类型", False, ["status", "tools", "chains", "resources", "prompts", "stats", "trace", "cache", "all"]),
        ("server_name", ToolParamType.STRING, "指定服务器名称（可选）", False, None),
    ]
    available_for_llm = True
    
    async def execute(self, function_args: Dict[str, Any]) -> Dict[str, Any]:
        query_type = function_args.get("query_type", "status")
        server_name = function_args.get("server_name")
        
        result_parts = []
        
        if query_type in ("status", "all"):
            result_parts.append(self._format_status(server_name))
        
        if query_type in ("tools", "all"):
            result_parts.append(self._format_tools(server_name))
        
        if query_type in ("chains", "all"):
            result_parts.append(self._format_chains())
        
        if query_type in ("resources", "all"):
            result_parts.append(self._format_resources(server_name))
        
        if query_type in ("prompts", "all"):
            result_parts.append(self._format_prompts(server_name))
        
        if query_type in ("stats", "all"):
            result_parts.append(self._format_stats(server_name))
        
        # v1.4.0: 追踪记录
        if query_type in ("trace",):
            result_parts.append(self._format_trace())
        
        # v1.4.0: 缓存状态
        if query_type in ("cache",):
            result_parts.append(self._format_cache())
        
        return {
            "name": self.name,
            "content": "\n\n".join(result_parts) if result_parts else "未知的查询类型"
        }
    
    def _format_status(self, server_name: Optional[str] = None) -> str:
        status = mcp_manager.get_status()
        lines = ["📊 MCP 桥接插件状态"]
        lines.append(f"  总服务器数: {status['total_servers']}")
        lines.append(f"  已连接: {status['connected_servers']}")
        lines.append(f"  已断开: {status['disconnected_servers']}")
        lines.append(f"  可用工具数: {status['total_tools']}")
        lines.append(f"  心跳检测: {'运行中' if status['heartbeat_running'] else '已停止'}")
        
        lines.append("\n🔌 服务器详情:")
        for name, info in status['servers'].items():
            if server_name and name != server_name:
                continue
            status_icon = "✅" if info['connected'] else "❌"
            enabled_text = "" if info['enabled'] else " (已禁用)"
            lines.append(f"  {status_icon} {name}{enabled_text}")
            lines.append(f"     传输: {info['transport']}, 工具数: {info['tools_count']}")
            if info['consecutive_failures'] > 0:
                lines.append(f"     ⚠️ 连续失败: {info['consecutive_failures']} 次")
        
        return "\n".join(lines)
    
    def _format_tools(self, server_name: Optional[str] = None) -> str:
        tools = mcp_manager.all_tools
        lines = ["🔧 可用 MCP 工具"]
        
        by_server: Dict[str, List[str]] = {}
        for tool_key, (tool_info, _) in tools.items():
            if server_name and tool_info.server_name != server_name:
                continue
            if tool_info.server_name not in by_server:
                by_server[tool_info.server_name] = []
            by_server[tool_info.server_name].append(f"  • {tool_key}: {tool_info.description[:50]}...")
        
        for srv_name, tool_list in by_server.items():
            lines.append(f"\n📦 {srv_name} ({len(tool_list)} 个工具):")
            lines.extend(tool_list)
        
        if not by_server:
            lines.append("  (无可用工具)")
        
        return "\n".join(lines)
    
    def _format_stats(self, server_name: Optional[str] = None) -> str:
        stats = mcp_manager.get_all_stats()
        lines = ["📈 调用统计"]
        
        g = stats['global']
        lines.append(f"  总调用次数: {g['total_tool_calls']}")
        lines.append(f"  成功: {g['successful_calls']}, 失败: {g['failed_calls']}")
        if g['total_tool_calls'] > 0:
            success_rate = (g['successful_calls'] / g['total_tool_calls']) * 100
            lines.append(f"  成功率: {success_rate:.1f}%")
        lines.append(f"  运行时间: {g['uptime_seconds']:.0f} 秒")
        
        return "\n".join(lines)
    
    def _format_resources(self, server_name: Optional[str] = None) -> str:
        resources = mcp_manager.all_resources
        if not resources:
            return "📦 当前没有可用的 MCP 资源"
        
        lines = ["📦 可用 MCP 资源"]
        by_server: Dict[str, List[MCPResourceInfo]] = {}
        for key, (resource_info, _) in resources.items():
            if server_name and resource_info.server_name != server_name:
                continue
            if resource_info.server_name not in by_server:
                by_server[resource_info.server_name] = []
            by_server[resource_info.server_name].append(resource_info)
        
        for srv_name, resource_list in by_server.items():
            lines.append(f"\n🔌 {srv_name} ({len(resource_list)} 个资源):")
            for res in resource_list:
                lines.append(f"  • {res.name}: {res.uri}")
        
        return "\n".join(lines)
    
    def _format_prompts(self, server_name: Optional[str] = None) -> str:
        prompts = mcp_manager.all_prompts
        if not prompts:
            return "📝 当前没有可用的 MCP 提示模板"
        
        lines = ["📝 可用 MCP 提示模板"]
        by_server: Dict[str, List[MCPPromptInfo]] = {}
        for key, (prompt_info, _) in prompts.items():
            if server_name and prompt_info.server_name != server_name:
                continue
            if prompt_info.server_name not in by_server:
                by_server[prompt_info.server_name] = []
            by_server[prompt_info.server_name].append(prompt_info)
        
        for srv_name, prompt_list in by_server.items():
            lines.append(f"\n🔌 {srv_name} ({len(prompt_list)} 个模板):")
            for prompt in prompt_list:
                lines.append(f"  • {prompt.name}")
        
        return "\n".join(lines)
    
    def _format_trace(self) -> str:
        """v1.4.0: 格式化追踪记录"""
        records = tool_call_tracer.get_recent(10)
        if not records:
            return "🔍 暂无调用追踪记录"
        
        lines = ["🔍 最近调用追踪记录"]
        for r in reversed(records):
            status = "✅" if r.success else "❌"
            cache = "📦" if r.cache_hit else ""
            post = "🔄" if r.post_processed else ""
            lines.append(f"  {status}{cache}{post} {r.tool_name} ({r.duration_ms:.0f}ms)")
            if r.error:
                lines.append(f"     错误: {r.error[:50]}")
        
        return "\n".join(lines)
    
    def _format_cache(self) -> str:
        """v1.4.0: 格式化缓存状态"""
        stats = tool_call_cache.get_stats()
        lines = ["🗄️ 缓存状态"]
        lines.append(f"  启用: {'是' if stats['enabled'] else '否'}")
        lines.append(f"  条目数: {stats['entries']}/{stats['max_entries']}")
        lines.append(f"  TTL: {stats['ttl']}秒")
        lines.append(f"  命中: {stats['hits']}, 未命中: {stats['misses']}")
        lines.append(f"  命中率: {stats['hit_rate']}")
        return "\n".join(lines)
    
    def _format_chains(self) -> str:
        """v1.8.0: 格式化工具链列表"""
        chains = tool_chain_manager.get_all_chains()
        if not chains:
            return "🔗 当前没有配置工具链"
        
        lines = ["🔗 工具链列表"]
        for name, chain in chains.items():
            status = "✅" if chain.enabled else "❌"
            lines.append(f"\n{status} {name}")
            lines.append(f"   描述: {chain.description[:50]}...")
            lines.append(f"   步骤: {len(chain.steps)} 个")
            for i, step in enumerate(chain.steps[:3]):
                lines.append(f"     {i+1}. {step.tool_name}")
            if len(chain.steps) > 3:
                lines.append(f"     ... 还有 {len(chain.steps) - 3} 个步骤")
            if chain.input_params:
                params = ", ".join(chain.input_params.keys())
                lines.append(f"   参数: {params}")
        
        return "\n".join(lines)
    
    async def direct_execute(self, **function_args) -> Dict[str, Any]:
        return await self.execute(function_args)


# ============================================================================
# 命令处理
# ============================================================================

class MCPStatusCommand(BaseCommand):
    """MCP 状态查询命令 - 通过 /mcp 命令查看服务器状态"""

    command_name = "mcp_status_command"
    command_description = "查看 MCP 服务器连接状态和统计信息"
    command_pattern = r"^[/／]mcp(?:\s+(?P<subcommand>status|tools|stats|reconnect|trace|cache|perm|export|search|chain))?(?:\s+(?P<arg>.+))?$"

    async def execute(self) -> Tuple[bool, Optional[str], bool]:
        """执行命令"""
        subcommand = self.matched_groups.get("subcommand", "status") or "status"
        arg = self.matched_groups.get("arg")

        if subcommand == "reconnect":
            return await self._handle_reconnect(arg)
        
        # v1.4.0: 追踪命令
        if subcommand == "trace":
            return await self._handle_trace(arg)
        
        # v1.4.0: 缓存命令
        if subcommand == "cache":
            return await self._handle_cache(arg)
        
        # v1.4.0: 权限命令
        if subcommand == "perm":
            return await self._handle_perm(arg)
        
        # v1.6.0: 导出命令
        if subcommand == "export":
            return await self._handle_export(arg)
        
        # v1.7.0: 工具搜索命令
        if subcommand == "search":
            return await self._handle_search(arg)
        
        # v1.8.0: 工具链命令
        if subcommand == "chain":
            return await self._handle_chain(arg)

        result = self._format_output(subcommand, arg)
        await self.send_text(result)
        return (True, None, True)

    def _find_similar_servers(self, name: str, max_results: int = 3) -> List[str]:
        """查找相似的服务器名称"""
        name_lower = name.lower()
        all_servers = list(mcp_manager._clients.keys())
        
        # 简单的相似度匹配：包含关系或前缀匹配
        similar = []
        for srv in all_servers:
            srv_lower = srv.lower()
            if name_lower in srv_lower or srv_lower in name_lower:
                similar.append(srv)
            elif srv_lower.startswith(name_lower[:3]) if len(name_lower) >= 3 else False:
                similar.append(srv)
        
        return similar[:max_results]

    async def _handle_reconnect(self, server_name: Optional[str] = None) -> Tuple[bool, Optional[str], bool]:
        """处理重连请求"""
        if server_name:
            if server_name not in mcp_manager._clients:
                # 提示相似的服务器名
                similar = self._find_similar_servers(server_name)
                msg = f"❌ 服务器 '{server_name}' 不存在"
                if similar:
                    msg += f"\n💡 你是不是想找: {', '.join(similar)}"
                await self.send_text(msg)
                return (True, None, True)

            await self.send_text(f"🔄 正在重连服务器 {server_name}...")
            success = await mcp_manager.reconnect_server(server_name)
            if success:
                await self.send_text(f"✅ 服务器 {server_name} 重连成功")
            else:
                await self.send_text(f"❌ 服务器 {server_name} 重连失败")
        else:
            disconnected = mcp_manager.disconnected_servers
            if not disconnected:
                await self.send_text("✅ 所有服务器都已连接")
                return (True, None, True)

            await self.send_text(f"🔄 正在重连 {len(disconnected)} 个断开的服务器...")
            for srv in disconnected:
                success = await mcp_manager.reconnect_server(srv)
                status = "✅" if success else "❌"
                await self.send_text(f"{status} {srv}")

        return (True, None, True)
    
    async def _handle_trace(self, arg: Optional[str] = None) -> Tuple[bool, Optional[str], bool]:
        """v1.4.0: 处理追踪命令"""
        if arg and arg.isdigit():
            # /mcp trace 20 - 最近 N 条
            n = int(arg)
            records = tool_call_tracer.get_recent(n)
        elif arg:
            # /mcp trace <tool_name> - 特定工具
            records = tool_call_tracer.get_by_tool(arg)
        else:
            # /mcp trace - 最近 10 条
            records = tool_call_tracer.get_recent(10)
        
        if not records:
            await self.send_text("🔍 暂无调用追踪记录\n\n用法: /mcp trace [数量|工具名]")
            return (True, None, True)
        
        lines = [f"🔍 调用追踪记录 ({len(records)} 条)"]
        lines.append("-" * 30)
        for i, r in enumerate(reversed(records)):
            status_icon = "✅" if r.success else "❌"
            cache_tag = " [缓存]" if r.cache_hit else ""
            post_tag = " [后处理]" if r.post_processed else ""
            ts = time.strftime("%H:%M:%S", time.localtime(r.timestamp))
            lines.append(f"{status_icon} [{ts}] {r.tool_name}")
            lines.append(f"   {r.duration_ms:.0f}ms | {r.server_name}{cache_tag}{post_tag}")
            if r.error:
                lines.append(f"   错误: {r.error[:50]}")
            if i < len(records) - 1:
                lines.append("")
        
        await self.send_text("\n".join(lines))
        return (True, None, True)
    
    async def _handle_cache(self, arg: Optional[str] = None) -> Tuple[bool, Optional[str], bool]:
        """v1.4.0: 处理缓存命令"""
        if arg == "clear":
            tool_call_cache.clear()
            await self.send_text("✅ 缓存已清空")
            return (True, None, True)
        
        stats = tool_call_cache.get_stats()
        lines = ["🗄️ 缓存状态"]
        lines.append(f"├ 启用: {'是' if stats['enabled'] else '否'}")
        lines.append(f"├ 条目: {stats['entries']}/{stats['max_entries']}")
        lines.append(f"├ TTL: {stats['ttl']}秒")
        lines.append(f"├ 命中: {stats['hits']}")
        lines.append(f"├ 未命中: {stats['misses']}")
        lines.append(f"└ 命中率: {stats['hit_rate']}")
        
        await self.send_text("\n".join(lines))
        return (True, None, True)
    
    async def _handle_perm(self, arg: Optional[str] = None) -> Tuple[bool, Optional[str], bool]:
        """v1.4.0: 处理权限命令"""
        global _plugin_instance
        
        if _plugin_instance is None:
            await self.send_text("❌ 插件未初始化")
            return (True, None, True)
        
        perm_config = _plugin_instance.config.get("permissions", {})
        enabled = perm_config.get("perm_enabled", False)
        default_mode = perm_config.get("perm_default_mode", "allow_all")
        
        if arg:
            # 查看特定工具的权限
            rules = permission_checker.get_rules_for_tool(arg)
            if not rules:
                await self.send_text(f"🔐 工具 {arg} 无特定权限规则\n默认模式: {default_mode}")
            else:
                lines = [f"🔐 工具 {arg} 的权限规则:"]
                for r in rules:
                    lines.append(f"  • 模式: {r.get('mode', 'default')}")
                    if r.get("allowed"):
                        lines.append(f"    允许: {', '.join(r['allowed'][:3])}...")
                    if r.get("denied"):
                        lines.append(f"    拒绝: {', '.join(r['denied'][:3])}...")
                await self.send_text("\n".join(lines))
        else:
            # 查看权限配置概览
            lines = ["🔐 权限控制配置"]
            lines.append(f"├ 启用: {'是' if enabled else '否'}")
            lines.append(f"├ 默认模式: {default_mode}")
            # 快捷配置
            deny_count = len(permission_checker._quick_deny_groups)
            allow_count = len(permission_checker._quick_allow_users)
            if deny_count > 0:
                lines.append(f"├ 禁用群: {deny_count} 个")
            if allow_count > 0:
                lines.append(f"├ 管理员白名单: {allow_count} 人")
            lines.append(f"└ 高级规则: {len(permission_checker._rules)} 条")
            await self.send_text("\n".join(lines))
        
        return (True, None, True)
    
    async def _handle_export(self, format_type: Optional[str] = None) -> Tuple[bool, Optional[str], bool]:
        """v1.6.0: 处理导出命令"""
        global _plugin_instance
        
        if _plugin_instance is None:
            await self.send_text("❌ 插件未初始化")
            return (True, None, True)
        
        servers_section = _plugin_instance.config.get("servers", {})
        if not isinstance(servers_section, dict):
            servers_section = {}

        claude_json = str(servers_section.get("claude_config_json", "") or "")
        if not claude_json.strip():
            legacy_list = str(servers_section.get("list", "") or "")
            claude_json = legacy_servers_list_to_claude_config(legacy_list) or ""

        if not claude_json.strip():
            await self.send_text("📤 当前没有配置任何服务器")
            return (True, None, True)

        try:
            pretty = json.dumps(json.loads(claude_json), ensure_ascii=False, indent=2)
        except Exception:
            pretty = claude_json

        lines = ["📤 导出为 Claude Desktop 格式（mcpServers）:"]
        if format_type and format_type.strip() and format_type.strip().lower() != "claude":
            lines.append("（v2.0 已精简为仅 Claude 格式，忽略其他格式参数）")
        lines.append("")
        lines.append(pretty)
        await self.send_text("\n".join(lines))
        
        return (True, None, True)

    async def _handle_search(self, query: Optional[str] = None) -> Tuple[bool, Optional[str], bool]:
        """v1.7.0: 处理工具搜索命令"""
        if not query or not query.strip():
            # 显示使用帮助
            help_text = """🔍 工具搜索

用法: /mcp search <关键词>

示例:
  /mcp search time     搜索包含 time 的工具
  /mcp search fetch    搜索包含 fetch 的工具
  /mcp search *        列出所有工具

支持模糊匹配工具名称和描述"""
            await self.send_text(help_text)
            return (True, None, True)

        query = query.strip().lower()
        tools = mcp_manager.all_tools

        if not tools:
            await self.send_text("🔍 当前没有可用的 MCP 工具")
            return (True, None, True)

        # 搜索匹配的工具
        matched = []
        for tool_key, (tool_info, client) in tools.items():
            tool_name = tool_key.lower()
            tool_desc = (tool_info.description or "").lower()

            # * 表示列出所有
            if query == "*":
                matched.append((tool_key, tool_info, client))
            elif query in tool_name or query in tool_desc:
                matched.append((tool_key, tool_info, client))

        if not matched:
            await self.send_text(f"🔍 未找到匹配 '{query}' 的工具")
            return (True, None, True)

        # 按服务器分组显示
        by_server: Dict[str, List[Tuple[str, Any]]] = {}
        for tool_key, tool_info, client in matched:
            server_name = tool_info.server_name
            if server_name not in by_server:
                by_server[server_name] = []
            by_server[server_name].append((tool_key, tool_info))

        # 如果只有一个服务器或结果较少，显示全部；否则折叠
        single_server = len(by_server) == 1
        lines = [f"🔍 搜索结果: {len(matched)} 个工具匹配 '{query}'"]

        for srv_name, tool_list in by_server.items():
            lines.append(f"\n📦 {srv_name} ({len(tool_list)} 个):")
            
            # 单服务器或结果少于 15 个时显示全部
            show_all = single_server or len(matched) <= 15
            display_limit = len(tool_list) if show_all else 5
            
            for tool_key, tool_info in tool_list[:display_limit]:
                desc = tool_info.description[:40] + "..." if len(tool_info.description) > 40 else tool_info.description
                lines.append(f"  • {tool_key}")
                lines.append(f"    {desc}")
            if len(tool_list) > display_limit:
                lines.append(f"  ... 还有 {len(tool_list) - display_limit} 个，用 /mcp search {query} {srv_name} 筛选")

        await self.send_text("\n".join(lines))
        return (True, None, True)

    async def _handle_chain(self, arg: Optional[str] = None) -> Tuple[bool, Optional[str], bool]:
        """v1.8.0: 处理工具链命令"""
        if not arg or not arg.strip():
            # 显示工具链列表和帮助
            chains = tool_chain_manager.get_all_chains()
            
            lines = ["🔗 工具链管理"]
            lines.append("")
            
            if chains:
                lines.append(f"已配置 {len(chains)} 个工具链:")
                for name, chain in chains.items():
                    status = "✅" if chain.enabled else "❌"
                    steps_count = len(chain.steps)
                    lines.append(f"  {status} {name} ({steps_count} 步)")
            else:
                lines.append("当前没有配置工具链")
            
            lines.append("")
            lines.append("命令:")
            lines.append("  /mcp chain list       查看所有工具链")
            lines.append("  /mcp chain <名称>     查看工具链详情")
            lines.append("  /mcp chain test <名称> <参数JSON>  测试执行")
            lines.append("  /mcp chain reload     重新加载配置")
            lines.append("")
            lines.append("💡 在 WebUI「工具链」配置区编辑工具链")
            
            await self.send_text("\n".join(lines))
            return (True, None, True)
        
        parts = arg.strip().split(maxsplit=2)
        sub_action = parts[0].lower()
        
        if sub_action == "list":
            # 列出所有工具链
            chains = tool_chain_manager.get_all_chains()
            if not chains:
                await self.send_text("🔗 当前没有配置工具链")
                return (True, None, True)
            
            lines = [f"🔗 工具链列表 ({len(chains)} 个)"]
            for name, chain in chains.items():
                status = "✅" if chain.enabled else "❌"
                lines.append(f"\n{status} {name}")
                lines.append(f"   {chain.description[:60]}...")
                lines.append(f"   步骤: {' → '.join([s.tool_name.split('_')[-1] for s in chain.steps[:4]])}")
                if chain.input_params:
                    lines.append(f"   参数: {', '.join(chain.input_params.keys())}")
            
            await self.send_text("\n".join(lines))
            return (True, None, True)
        
        elif sub_action == "reload":
            # 重新加载工具链配置
            global _plugin_instance
            if _plugin_instance:
                _plugin_instance._load_tool_chains()
                chains = tool_chain_manager.get_all_chains()
                from src.plugin_system.core.component_registry import component_registry
                registered = 0
                for name, chain in tool_chain_manager.get_enabled_chains().items():
                    tool_name = f"chain_{name}".replace("-", "_").replace(".", "_")
                    if component_registry.get_component_info(tool_name, ComponentType.TOOL):
                        registered += 1
                lines = ["✅ 已重新加载工具链配置"]
                lines.append(f"📋 配置数: {len(chains)} 个")
                lines.append(f"🔧 已注册: {registered} 个（可被 LLM 调用）")
                if chains:
                    lines.append("")
                    lines.append("工具链列表:")
                    for name, chain in chains.items():
                        status = "✅" if chain.enabled else "❌"
                        lines.append(f"  {status} chain_{name}")
                await self.send_text("\n".join(lines))
            else:
                await self.send_text("❌ 插件未初始化")
            return (True, None, True)
        
        elif sub_action == "test" and len(parts) >= 2:
            # 测试执行工具链
            chain_name = parts[1]
            args_json = parts[2] if len(parts) > 2 else "{}"
            
            chain = tool_chain_manager.get_chain(chain_name)
            if not chain:
                await self.send_text(f"❌ 工具链 '{chain_name}' 不存在")
                return (True, None, True)
            
            try:
                input_args = json.loads(args_json)
            except json.JSONDecodeError:
                await self.send_text("❌ 参数 JSON 格式错误")
                return (True, None, True)
            
            await self.send_text(f"🔄 正在执行工具链 {chain_name}...")
            
            result = await tool_chain_manager.execute_chain(chain_name, input_args)
            
            lines = []
            if result.success:
                lines.append(f"✅ 工具链执行成功 ({result.total_duration_ms:.0f}ms)")
                lines.append("")
                lines.append("执行详情:")
                lines.append(result.to_summary())
                lines.append("")
                lines.append("最终输出:")
                output_preview = result.final_output[:500]
                if len(result.final_output) > 500:
                    output_preview += "..."
                lines.append(output_preview)
            else:
                lines.append("❌ 工具链执行失败")
                lines.append(f"错误: {result.error}")
                if result.step_results:
                    lines.append("")
                    lines.append("执行详情:")
                    lines.append(result.to_summary())
            
            await self.send_text("\n".join(lines))
            return (True, None, True)
        
        else:
            # 查看特定工具链详情
            chain_name = sub_action
            chain = tool_chain_manager.get_chain(chain_name)
            
            if not chain:
                # 尝试模糊匹配
                all_chains = tool_chain_manager.get_all_chains()
                similar = [n for n in all_chains.keys() if chain_name.lower() in n.lower()]
                msg = f"❌ 工具链 '{chain_name}' 不存在"
                if similar:
                    msg += f"\n💡 你是不是想找: {', '.join(similar[:3])}"
                await self.send_text(msg)
                return (True, None, True)
            
            lines = [f"🔗 工具链: {chain.name}"]
            lines.append(f"状态: {'✅ 启用' if chain.enabled else '❌ 禁用'}")
            lines.append(f"描述: {chain.description}")
            lines.append("")
            
            if chain.input_params:
                lines.append("📥 输入参数:")
                for param, desc in chain.input_params.items():
                    lines.append(f"  • {param}: {desc}")
                lines.append("")
            
            lines.append(f"📋 执行步骤 ({len(chain.steps)} 个):")
            for i, step in enumerate(chain.steps):
                optional_tag = " (可选)" if step.optional else ""
                lines.append(f"  {i+1}. {step.tool_name}{optional_tag}")
                if step.description:
                    lines.append(f"     {step.description}")
                if step.output_key:
                    lines.append(f"     输出键: {step.output_key}")
                if step.args_template:
                    args_preview = json.dumps(step.args_template, ensure_ascii=False)[:60]
                    lines.append(f"     参数: {args_preview}...")
            
            lines.append("")
            lines.append(f"💡 测试: /mcp chain test {chain.name} " + '{"参数": "值"}')
            
            await self.send_text("\n".join(lines))
            return (True, None, True)

    def _format_output(self, subcommand: str, server_name: str = None) -> str:
        """格式化输出"""
        status = mcp_manager.get_status()
        stats = mcp_manager.get_all_stats()
        lines = []

        if subcommand in ("status", "all"):
            lines.append("📊 MCP 桥接插件状态")
            lines.append(f"├ 服务器: {status['connected_servers']}/{status['total_servers']} 已连接")
            lines.append(f"├ 工具数: {status['total_tools']}")
            lines.append(f"└ 心跳: {'运行中' if status['heartbeat_running'] else '已停止'}")

            if status["servers"]:
                lines.append("\n🔌 服务器列表:")
                for name, info in status["servers"].items():
                    if server_name and name != server_name:
                        continue
                    icon = "✅" if info["connected"] else "❌"
                    enabled = "" if info["enabled"] else " (禁用)"
                    lines.append(f"  {icon} {name}{enabled}")
                    lines.append(f"     {info['transport']} | {info['tools_count']} 工具")
                    # 显示断路器状态
                    cb = info.get("circuit_breaker", {})
                    cb_state = cb.get("state", "closed")
                    if cb_state == "open":
                        lines.append("     ⚡ 断路器熔断中")
                    elif cb_state == "half_open":
                        lines.append("     ⚡ 断路器试探中")
                    if info["consecutive_failures"] > 0:
                        lines.append(f"     ⚠️ 连续失败 {info['consecutive_failures']} 次")

        if subcommand in ("tools", "all"):
            tools = mcp_manager.all_tools
            if tools:
                lines.append("\n🔧 可用工具:")
                by_server = {}
                for key, (info, _) in tools.items():
                    if server_name and info.server_name != server_name:
                        continue
                    by_server.setdefault(info.server_name, []).append(info.name)

                # 如果指定了服务器名，显示全部工具；否则折叠显示
                show_all = server_name is not None
                
                for srv, tool_list in by_server.items():
                    lines.append(f"  📦 {srv} ({len(tool_list)})")
                    if show_all:
                        # 指定服务器时显示全部
                        for t in tool_list:
                            lines.append(f"     • {t}")
                    else:
                        # 未指定时折叠显示
                        for t in tool_list[:5]:
                            lines.append(f"     • {t}")
                        if len(tool_list) > 5:
                            lines.append(f"     ... 还有 {len(tool_list) - 5} 个，用 /mcp tools {srv} 查看全部")

        if subcommand in ("stats", "all"):
            g = stats["global"]
            lines.append("\n📈 调用统计:")
            lines.append(f"  总调用: {g['total_tool_calls']}")
            if g["total_tool_calls"] > 0:
                rate = (g["successful_calls"] / g["total_tool_calls"]) * 100
                lines.append(f"  成功率: {rate:.1f}%")
            lines.append(f"  运行: {g['uptime_seconds']:.0f}秒")

        if not lines:
            lines.append("📖 MCP 桥接插件命令帮助")
            lines.append("")
            lines.append("状态查询:")
            lines.append("  /mcp              查看连接状态")
            lines.append("  /mcp tools        查看所有工具")
            lines.append("  /mcp tools <服务器> 查看指定服务器工具")
            lines.append("  /mcp stats        查看调用统计")
            lines.append("")
            lines.append("工具搜索:")
            lines.append("  /mcp search <关键词>  搜索工具")
            lines.append("  /mcp search *         列出所有工具")
            lines.append("")
            lines.append("服务器管理:")
            lines.append("  /mcp reconnect        重连断开的服务器")
            lines.append("  /mcp reconnect <名称> 重连指定服务器")
            lines.append("")
            lines.append("服务器配置（Claude）:")
            lines.append("  /mcp import <json>    合并 Claude mcpServers 配置")
            lines.append("  /mcp export           导出当前 mcpServers 配置")
            lines.append("")
            lines.append("工具链:")
            lines.append("  /mcp chain            查看工具链列表")
            lines.append("  /mcp chain <名称>     查看工具链详情")
            lines.append("  /mcp chain test <名称> <参数>  测试执行")
            lines.append("")
            lines.append("其他:")
            lines.append("  /mcp trace   查看调用追踪")
            lines.append("  /mcp cache   查看缓存状态")
            lines.append("  /mcp perm    查看权限配置")

        return "\n".join(lines)


class MCPImportCommand(BaseCommand):
    """v1.6.0: MCP 配置导入命令 - 支持从 Claude Desktop 格式导入"""

    command_name = "mcp_import_command"
    command_description = "从 Claude Desktop 或其他格式导入 MCP 服务器配置"
    # 匹配 /mcp import 后面的所有内容（包括多行 JSON）
    command_pattern = r"^[/／]mcp\s+import(?:\s+(?P<content>.+))?$"

    async def execute(self) -> Tuple[bool, Optional[str], bool]:
        """执行导入命令"""
        global _plugin_instance
        
        if _plugin_instance is None:
            await self.send_text("❌ 插件未初始化")
            return (True, None, True)
        
        content = self.matched_groups.get("content", "")
        
        if not content or not content.strip():
            # 显示使用帮助
            help_text = """📥 MCP 配置导入

用法: /mcp import <JSON配置>

支持的格式:
• Claude Desktop 格式 (mcpServers 对象)
• 兼容旧版：MaiBot servers 列表数组（将自动迁移为 mcpServers）

示例:
/mcp import {"mcpServers":{"time":{"command":"uvx","args":["mcp-server-time"]}}}

/mcp import {"mcpServers":{"api":{"url":"https://example.com/mcp","transport":"sse"}}}"""
            await self.send_text(help_text)
            return (True, None, True)

        raw_text = content.strip()

        # 解析输入：支持 Claude mcpServers 或旧版 servers 列表数组
        try:
            data = json.loads(raw_text)
        except json.JSONDecodeError as e:
            await self.send_text(f"❌ JSON 解析失败: {e}")
            return (True, None, True)

        if isinstance(data, list):
            migrated = legacy_servers_list_to_claude_config(raw_text)
            if not migrated:
                await self.send_text("❌ 旧版 servers 列表解析失败，无法迁移")
                return (True, None, True)
            data = json.loads(migrated)

        if not isinstance(data, dict):
            await self.send_text("❌ 配置必须是 JSON 对象（包含 mcpServers）")
            return (True, None, True)

        incoming_mapping = data.get("mcpServers", data)
        if not isinstance(incoming_mapping, dict):
            await self.send_text("❌ mcpServers 必须是 JSON 对象")
            return (True, None, True)

        # 校验输入配置
        try:
            parse_claude_mcp_config(json.dumps({"mcpServers": incoming_mapping}, ensure_ascii=False))
        except ClaudeConfigError as e:
            await self.send_text(f"❌ 配置校验失败: {e}")
            return (True, None, True)

        servers_section = _plugin_instance.config.get("servers", {})
        if not isinstance(servers_section, dict):
            servers_section = {}

        existing_json = str(servers_section.get("claude_config_json", "") or "")
        if not existing_json.strip():
            legacy_list = str(servers_section.get("list", "") or "")
            existing_json = legacy_servers_list_to_claude_config(legacy_list) or ""

        existing_mapping: Dict[str, Any] = {}
        if existing_json.strip():
            try:
                parsed = json.loads(existing_json)
                mapping = parsed.get("mcpServers", parsed)
                if isinstance(mapping, dict):
                    existing_mapping = mapping
            except Exception:
                existing_mapping = {}

        added: List[str] = []
        skipped: List[str] = []

        for name, conf in incoming_mapping.items():
            if name in existing_mapping:
                skipped.append(str(name))
                continue
            existing_mapping[str(name)] = conf
            added.append(str(name))

        if "servers" not in _plugin_instance.config:
            _plugin_instance.config["servers"] = {}

        _plugin_instance.config["servers"]["claude_config_json"] = json.dumps(
            {"mcpServers": existing_mapping}, ensure_ascii=False, indent=2
        )

        # 持久化到配置文件（使用插件基类的写入逻辑）
        try:
            config_path = Path(_plugin_instance.plugin_dir) / _plugin_instance.config_file_name
            _plugin_instance._save_config_to_file(_plugin_instance.config, str(config_path))
        except Exception as e:
            logger.warning(f"保存配置文件失败: {e}")

        lines = []
        if added:
            lines.append(f"✅ 成功导入 {len(added)} 个服务器:")
            for n in added[:20]:
                lines.append(f"  • {n}")
            if len(added) > 20:
                lines.append(f"  ... 还有 {len(added) - 20} 个")
        else:
            lines.append("⚠️ 没有新服务器可导入")

        if skipped:
            lines.append(f"\n⏭️ 跳过 {len(skipped)} 个已存在的服务器")

        lines.append("\n💡 发送 /mcp reconnect 使配置生效")

        await self.send_text("\n".join(lines))
        return (True, None, True)


# ============================================================================
# 事件处理器
# ============================================================================

class MCPStartupHandler(BaseEventHandler):
    """MCP 启动事件处理器"""
    
    event_type = EventType.ON_START
    handler_name = "mcp_startup_handler"
    handler_description = "MCP 桥接插件启动处理器"
    weight = 0
    intercept_message = False
    
    async def execute(self, message: Optional[Any]) -> Tuple[bool, bool, Optional[str], None, None]:
        """处理启动事件"""
        global _plugin_instance
        
        if _plugin_instance is None:
            logger.warning("MCP 桥接插件实例未初始化")
            return (False, True, None, None, None)
        
        logger.info("MCP 桥接插件收到 ON_START 事件，开始连接 MCP 服务器...")
        await _plugin_instance._async_connect_servers()
        
        await mcp_manager.start_heartbeat()
        
        return (True, True, None, None, None)


class MCPStopHandler(BaseEventHandler):
    """MCP 停止事件处理器"""
    
    event_type = EventType.ON_STOP
    handler_name = "mcp_stop_handler"
    handler_description = "MCP 桥接插件停止处理器"
    weight = 0
    intercept_message = False
    
    async def execute(self, message: Optional[Any]) -> Tuple[bool, bool, Optional[str], None, None]:
        """处理停止事件"""
        global _plugin_instance
        
        logger.info("MCP 桥接插件收到 ON_STOP 事件，正在关闭...")

        if _plugin_instance is not None:
            await _plugin_instance._stop_status_refresher()
        
        await mcp_manager.shutdown()
        mcp_tool_registry.clear()
        
        logger.info("MCP 桥接插件已关闭所有连接")
        return (True, True, None, None, None)


# ============================================================================
# 主插件类
# ============================================================================

@register_plugin
class MCPBridgePlugin(BasePlugin):
    """MCP 桥接插件 v2.0.0 - 将 MCP 服务器的工具桥接到 MaiBot"""
    
    plugin_name: str = "mcp_bridge_plugin"
    enable_plugin: bool = False  # 默认禁用，用户需在 WebUI 手动启用
    dependencies: List[str] = []
    python_dependencies: List[str] = ["mcp"]
    config_file_name: str = "config.toml"
    
    config_section_descriptions = {
        "guide": section_meta("📖 快速入门", order=1),
        "plugin": section_meta("🔘 插件开关", order=2),
        "servers": section_meta("🔌 MCP Servers（Claude）", order=3),
        "tool_chains": section_meta("🔗 Workflow（硬流程/工具链）", order=4),
        "react": section_meta("🔄 ReAct（软流程）", collapsed=True, order=5),
        "status": section_meta("📊 运行状态", order=10),
        "tools": section_meta("🔧 工具管理", collapsed=True, order=20),
        "permissions": section_meta("🔐 权限控制", collapsed=True, order=21),
        "settings": section_meta("⚙️ 高级设置", collapsed=True, order=30),
    }
    
    config_schema: dict = {
        # 新手引导区（只读）
        "guide": {
            "quick_start": ConfigField(
                type=str,
                default="1. 获取 MCP 服务器  2. 在「MCP Servers（Claude）」粘贴 mcpServers 配置  3. 保存后发送 /mcp reconnect  4. （可选）在「Workflow/ ReAct」配置流程",
                description="三步开始使用",
                label="🚀 快速入门",
                disabled=True,
                order=1,
            ),
            "mcp_sources": ConfigField(
                type=str,
                default="https://modelscope.cn/mcp (魔搭·推荐) | https://smithery.ai | https://glama.ai | https://mcp.so",
                description="复制链接到浏览器打开，获取免费 MCP 服务器",
                label="🌐 获取 MCP 服务器",
                disabled=True,
                hint="魔搭 ModelScope 国内免费推荐，将 mcpServers 配置粘贴到「MCP Servers（Claude）」即可",
                order=2,
            ),
            "example_config": ConfigField(
                type=str,
                default='{"mcpServers":{"time":{"url":"https://mcp.api-inference.modelscope.cn/server/mcp-server-time"}}}',
                description="复制到 MCP Servers（Claude）可直接使用（免费时间服务器）",
                label="📝 配置示例",
                disabled=True,
                order=3,
            ),
        },
        "plugin": {
            "enabled": ConfigField(
                type=bool,
                default=False,
                description="是否启用插件（默认关闭）",
                label="启用插件",
            ),
        },
        "settings": {
            "tool_prefix": ConfigField(
                type=str,
                default="mcp",
                description="🏷️ 工具前缀 - 生成的工具名格式: {前缀}_{服务器名}_{工具名}",
                label="🏷️ 工具前缀",
                placeholder="mcp",
                order=1,
            ),
            "connect_timeout": ConfigField(
                type=float,
                default=30.0,
                description="⏱️ 连接超时（秒）",
                label="⏱️ 连接超时（秒）",
                min=5.0,
                max=120.0,
                step=5.0,
                order=2,
            ),
            "call_timeout": ConfigField(
                type=float,
                default=60.0,
                description="⏱️ 调用超时（秒）",
                label="⏱️ 调用超时（秒）",
                min=10.0,
                max=300.0,
                step=10.0,
                order=3,
            ),
            "auto_connect": ConfigField(
                type=bool,
                default=True,
                description="🔄 启动时自动连接所有已启用的服务器",
                label="🔄 自动连接",
                order=4,
            ),
            "retry_attempts": ConfigField(
                type=int,
                default=3,
                description="🔁 连接失败时的重试次数",
                label="🔁 重试次数",
                min=0,
                max=10,
                order=5,
            ),
            "retry_interval": ConfigField(
                type=float,
                default=5.0,
                description="⏳ 重试间隔（秒）",
                label="⏳ 重试间隔（秒）",
                min=1.0,
                max=60.0,
                step=1.0,
                order=6,
            ),
            "heartbeat_enabled": ConfigField(
                type=bool,
                default=True,
                description="💓 定期检测服务器连接状态",
                label="💓 启用心跳检测",
                order=7,
            ),
            "heartbeat_interval": ConfigField(
                type=float,
                default=60.0,
                description="💓 基准心跳间隔（秒）",
                label="💓 心跳间隔（秒）",
                min=10.0,
                max=300.0,
                step=10.0,
                hint="智能心跳会根据服务器稳定性自动调整",
                order=8,
            ),
            "heartbeat_adaptive": ConfigField(
                type=bool,
                default=True,
                description="🧠 根据服务器稳定性自动调整心跳间隔",
                label="🧠 智能心跳",
                hint="稳定服务器逐渐增加间隔，断开的服务器缩短间隔",
                order=9,
            ),
            "heartbeat_max_multiplier": ConfigField(
                type=float,
                default=3.0,
                description="稳定服务器的最大间隔倍数",
                label="📈 最大间隔倍数",
                min=1.5,
                max=5.0,
                step=0.5,
                hint="稳定服务器心跳间隔最高可达 基准间隔 × 此值",
                order=10,
            ),
            "auto_reconnect": ConfigField(
                type=bool,
                default=True,
                description="🔄 检测到断开时自动尝试重连",
                label="🔄 自动重连",
                order=11,
            ),
            "max_reconnect_attempts": ConfigField(
                type=int,
                default=3,
                description="🔄 连续重连失败后暂停重连",
                label="🔄 最大重连次数",
                min=1,
                max=10,
                order=12,
            ),
            # v1.7.0: 状态刷新配置
            "status_refresh_enabled": ConfigField(
                type=bool,
                default=True,
                description="📊 定期更新 WebUI 状态显示",
                label="📊 启用状态实时刷新",
                hint="关闭后 WebUI 状态仅在启动时更新",
                order=13,
            ),
            "status_refresh_interval": ConfigField(
                type=float,
                default=10.0,
                description="📊 状态刷新间隔（秒）",
                label="📊 状态刷新间隔（秒）",
                min=5.0,
                max=60.0,
                step=5.0,
                hint="值越小刷新越频繁，但会增加少量 CPU 消耗",
                order=14,
            ),
            "enable_resources": ConfigField(
                type=bool,
                default=False,
                description="📦 允许读取 MCP 服务器提供的资源",
                label="📦 启用 Resources（实验性）",
                order=11,
            ),
            "enable_prompts": ConfigField(
                type=bool,
                default=False,
                description="📝 允许使用 MCP 服务器提供的提示模板",
                label="📝 启用 Prompts（实验性）",
                order=12,
            ),
            # v1.3.0 后处理配置
            "post_process_enabled": ConfigField(
                type=bool,
                default=False,
                description="🔄 使用 LLM 对长结果进行摘要提炼",
                label="🔄 启用结果后处理",
                order=20,
            ),
            "post_process_threshold": ConfigField(
                type=int,
                default=500,
                description="📏 结果长度超过此值才触发后处理",
                label="📏 后处理阈值（字符）",
                min=100,
                max=5000,
                step=100,
                order=21,
            ),
            "post_process_max_tokens": ConfigField(
                type=int,
                default=500,
                description="📝 LLM 摘要输出的最大 token 数",
                label="📝 后处理最大输出 token",
                min=100,
                max=2000,
                step=50,
                order=22,
            ),
            "post_process_model": ConfigField(
                type=str,
                default="",
                description="🤖 指定用于后处理的模型名称",
                label="🤖 后处理模型（可选）",
                placeholder="留空则使用 Utils 模型组",
                order=23,
            ),
            "post_process_prompt": ConfigField(
                type=str,
                default="用户问题：{query}\\n\\n工具返回内容：\\n{result}\\n\\n请从上述内容中提取与用户问题最相关的关键信息，简洁准确地输出：",
                description="📋 后处理提示词模板",
                label="📋 后处理提示词模板",
                input_type="textarea",
                rows=8,
                order=24,
            ),
            # v1.4.0 追踪配置
            "trace_enabled": ConfigField(
                type=bool,
                default=True,
                description="🔍 记录工具调用详情",
                label="🔍 启用调用追踪",
                order=30,
            ),
            "trace_max_records": ConfigField(
                type=int,
                default=100,
                description="内存中保留的最大记录数",
                label="📊 追踪记录上限",
                min=10,
                max=1000,
                order=31,
            ),
            "trace_log_enabled": ConfigField(
                type=bool,
                default=False,
                description="是否将追踪记录写入日志文件",
                label="📝 追踪日志文件",
                hint="启用后记录写入 plugins/MaiBot_MCPBridgePlugin/logs/trace.jsonl",
                order=32,
            ),
            # v1.4.0 缓存配置
            "cache_enabled": ConfigField(
                type=bool,
                default=False,
                description="🗄️ 缓存相同参数的调用结果",
                label="🗄️ 启用调用缓存",
                hint="相同参数的调用会返回缓存结果，减少重复请求",
                order=40,
            ),
            "cache_ttl": ConfigField(
                type=int,
                default=300,
                description="缓存有效期（秒）",
                label="⏱️ 缓存有效期（秒）",
                min=60,
                max=3600,
                order=41,
            ),
            "cache_max_entries": ConfigField(
                type=int,
                default=200,
                description="最大缓存条目数（超出后 LRU 淘汰）",
                label="📦 最大缓存条目",
                min=50,
                max=1000,
                order=42,
            ),
            "cache_exclude_tools": ConfigField(
                type=str,
                default="",
                description="不缓存的工具（每行一个，支持通配符 *）",
                label="🚫 缓存排除列表",
                input_type="textarea",
                rows=4,
                hint="时间类、随机类工具建议排除，如 mcp_time_*",
                order=43,
            ),
        },
        # v1.4.0 工具管理
        "tools": {
            "tool_list": ConfigField(
                type=str,
                default="(启动后自动生成)",
                description="当前已注册的 MCP 工具列表（只读）",
                label="📋 工具清单",
                input_type="textarea",
                disabled=True,
                rows=12,
                hint="从此处复制工具名到下方禁用列表或工具链配置",
                order=1,
            ),
            "disabled_tools": ConfigField(
                type=str,
                default="",
                description="要禁用的工具名（每行一个）",
                label="🚫 禁用工具列表",
                input_type="textarea",
                rows=6,
                hint="从上方工具清单复制工具名，每行一个。禁用后该工具不会被 LLM 调用",
                order=2,
            ),
        },
        # v1.8.0 工具链配置
        "tool_chains": {
            "chains_enabled": ConfigField(
                type=bool,
                default=True,
                description="🔗 启用工具链功能",
                label="🔗 启用工具链",
                hint="工具链可将多个工具按顺序执行，后续工具可使用前序工具的输出",
                order=1,
            ),
            # 工具链使用指南
            "chains_guide": ConfigField(
                type=str,
                default="""工具链将多个 MCP 工具串联执行，后续步骤可使用前序步骤的输出

📌 变量语法:
  ${input.参数名}  - 用户输入的参数
  ${step.输出键}   - 某步骤的输出（需设置 output_key）
  ${prev}         - 上一步的输出
  ${prev.字段}    - 上一步输出(JSON)的某字段
  ${step.输出键.0.字段} / ${step.输出键[0].字段} - 访问数组下标
  ${step.输出键['return'][0]['location']}       - 支持 bracket 写法

📌 测试命令:
  /mcp chain list          - 查看所有工具链
  /mcp chain 链名 {"参数":"值"}  - 测试执行""",
                description="工具链使用说明",
                label="📖 使用指南",
                input_type="textarea",
                disabled=True,
                rows=10,
                order=2,
            ),
            # 快速添加工具链（表单式）
            "quick_chain_name": ConfigField(
                type=str,
                default="",
                description="工具链名称（英文，如 search_and_summarize）",
                label="➕ 快速添加 - 名称",
                placeholder="my_tool_chain",
                hint="必填，将作为 LLM 可调用的工具名",
                order=10,
            ),
            "quick_chain_desc": ConfigField(
                type=str,
                default="",
                description="工具链描述（供 LLM 理解何时使用）",
                label="➕ 快速添加 - 描述",
                placeholder="先搜索内容，再获取详情并总结",
                hint="必填，清晰描述工具链的用途",
                order=11,
            ),
            "quick_chain_params": ConfigField(
                type=str,
                default="",
                description="输入参数（每行一个，格式: 参数名=描述）",
                label="➕ 快速添加 - 输入参数",
                input_type="textarea",
                rows=3,
                placeholder="query=搜索关键词\nmax_results=最大结果数",
                hint="定义用户需要提供的参数",
                order=12,
            ),
            "quick_chain_steps": ConfigField(
                type=str,
                default="",
                description="执行步骤（每行一个，格式: 工具名|参数JSON|输出键）",
                label="➕ 快速添加 - 执行步骤",
                input_type="textarea",
                rows=5,
                placeholder='mcp_server_search|{"keyword":"${input.query}"}|search_result\nmcp_server_detail|{"id":"${prev}"}|\n# 访问数组示例:\n# mcp_geo|{"q":"${input.query}"}|geo\n# mcp_next|{"location":"${step.geo.return.0.location}"}|',
                hint="格式: 工具名|参数模板|输出键（输出键可选，用于后续步骤引用 ${step.xxx}）",
                order=13,
            ),
            "quick_chain_add": ConfigField(
                type=str,
                default="",
                description="填写上方信息后，在此输入 ADD 并保存即可添加",
                label="➕ 确认添加",
                placeholder="输入 ADD 并保存",
                hint="添加后会自动合并到下方工具链列表",
                order=14,
            ),
            # 工具链模板
            "chains_templates": ConfigField(
                type=str,
                default="""📋 常用工具链模板（复制到下方列表使用）:

1️⃣ 搜索+详情模板:
{
  "name": "search_and_detail",
  "description": "搜索内容并获取详情",
  "input_params": {"query": "搜索关键词"},
  "steps": [
    {"tool_name": "搜索工具名", "args_template": {"keyword": "${input.query}"}, "output_key": "results"},
    {"tool_name": "详情工具名", "args_template": {"id": "${prev}"}}
  ]
}

2️⃣ 获取+处理模板:
{
  "name": "fetch_and_process",
  "description": "获取数据并处理",
  "input_params": {"url": "目标URL"},
  "steps": [
    {"tool_name": "获取工具名", "args_template": {"url": "${input.url}"}, "output_key": "data"},
    {"tool_name": "处理工具名", "args_template": {"content": "${step.data}"}}
  ]
}

3️⃣ 多步骤可选模板:
{
  "name": "multi_step_chain",
  "description": "多步骤处理，部分可选",
  "input_params": {"input": "输入内容"},
  "steps": [
    {"tool_name": "步骤1工具", "args_template": {"data": "${input.input}"}, "output_key": "step1"},
    {"tool_name": "步骤2工具", "args_template": {"data": "${prev}"}, "output_key": "step2", "optional": true},
    {"tool_name": "步骤3工具", "args_template": {"data": "${step.step1}"}}
  ]
}""",
                description="工具链配置模板参考",
                label="📝 配置模板",
                input_type="textarea",
                disabled=True,
                rows=15,
                order=20,
            ),
            "chains_list": ConfigField(
                type=str,
                default="[]",
                description="工具链配置（JSON 数组格式）",
                label="📋 工具链列表",
                input_type="textarea",
                rows=20,
                placeholder='''[
  {
    "name": "search_and_detail",
    "description": "先搜索再获取详情",
    "input_params": {"query": "搜索关键词"},
    "steps": [
      {"tool_name": "mcp_server_search", "args_template": {"keyword": "${input.query}"}, "output_key": "search_result"},
      {"tool_name": "mcp_server_get_detail", "args_template": {"id": "${step.search_result}"}}
    ]
  }
]''',
                hint="每个工具链包含 name、description、input_params、steps",
                order=30,
            ),
            "chains_status": ConfigField(
                type=str,
                default="(启动后自动生成)",
                description="当前已注册的工具链状态（只读）",
                label="📊 工具链状态",
                input_type="textarea",
                disabled=True,
                rows=8,
                order=40,
            ),
        },
        # v1.9.0 ReAct 软流程配置
        "react": {
            "react_enabled": ConfigField(
                type=bool,
                default=False,
                description="🔄 将 MCP 工具注册到记忆检索 ReAct 系统",
                label="🔄 启用 ReAct 集成",
                hint="启用后，MaiBot 的 ReAct Agent 可在记忆检索时调用 MCP 工具",
                order=1,
            ),
            "react_guide": ConfigField(
                type=str,
                default="""ReAct 软流程说明:

📌 什么是 ReAct?
ReAct (Reasoning + Acting) 是 LLM 自主决策的多轮工具调用模式。
与 Workflow 硬流程不同，ReAct 由 LLM 动态决定调用哪些工具。

📌 工作原理:
1. 用户提问 → LLM 分析需要什么信息
2. LLM 选择调用工具 → 获取结果
3. LLM 观察结果 → 决定是否需要更多信息
4. 重复 2-3 直到信息足够 → 生成最终回答

📌 与 Workflow 的区别:
- ReAct (软流程): LLM 自主决策，灵活但不可预测
- Workflow (硬流程): 用户预定义，固定流程，可靠可控

📌 使用场景:
- 复杂问题需要多步推理
- 不确定需要调用哪些工具
- 需要根据中间结果动态调整""",
                description="ReAct 软流程使用说明",
                label="📖 使用指南",
                input_type="textarea",
                disabled=True,
                rows=15,
                order=2,
            ),
            "filter_mode": ConfigField(
                type=str,
                default="whitelist",
                description="过滤模式",
                label="📋 过滤模式",
                choices=["whitelist", "blacklist"],
                hint="whitelist: 只注册列出的工具；blacklist: 排除列出的工具",
                order=3,
            ),
            "tool_filter": ConfigField(
                type=str,
                default="",
                description="工具过滤列表（每行一个，支持通配符 * 和精确匹配）",
                label="🔍 工具过滤列表",
                input_type="textarea",
                rows=6,
                placeholder="""# 精确匹配示例:
mcp_bing_web_search_bing_search
mcp_mcmod_search_mod

# 通配符示例:
mcp_*_search_*
mcp_bing_*""",
                hint="白名单模式: 只注册列出的工具；黑名单模式: 排除列出的工具。支持 # 注释",
                order=4,
            ),
            "react_status": ConfigField(
                type=str,
                default="(启动后自动生成)",
                description="当前已注册到 ReAct 的工具状态（只读）",
                label="📊 ReAct 工具状态",
                input_type="textarea",
                disabled=True,
                rows=6,
                order=10,
            ),
        },
        # v1.4.0 权限控制
        "permissions": {
            "perm_enabled": ConfigField(
                type=bool,
                default=False,
                description="🔐 按群/用户限制工具使用",
                label="🔐 启用权限控制",
                order=1,
            ),
            "perm_default_mode": ConfigField(
                type=str,
                default="allow_all",
                description="默认模式：allow_all（默认允许）或 deny_all（默认禁止）",
                label="📋 默认模式",
                placeholder="allow_all",
                hint="allow_all: 未配置的默认允许；deny_all: 未配置的默认禁止",
                order=2,
            ),
            # 快捷配置（简化版）
            "quick_deny_groups": ConfigField(
                type=str,
                default="",
                description="禁止使用所有 MCP 工具的群号（每行一个）",
                label="🚫 禁用群列表（快捷）",
                input_type="textarea",
                rows=4,
                hint="填入群号，该群将无法使用任何 MCP 工具",
                order=3,
            ),
            "quick_allow_users": ConfigField(
                type=str,
                default="",
                description="始终允许使用所有工具的用户 QQ 号（管理员白名单，每行一个）",
                label="✅ 管理员白名单（快捷）",
                input_type="textarea",
                rows=3,
                hint="填入 QQ 号，该用户在任何场景都可使用 MCP 工具",
                order=4,
            ),
            # 高级配置
            "perm_rules": ConfigField(
                type=str,
                default="[]",
                description="高级权限规则（JSON 格式，可针对特定工具配置）",
                label="📜 高级权限规则（可选）",
                input_type="textarea",
                rows=10,
                placeholder='''[
  {"tool": "mcp_*_delete_*", "denied": ["qq:123456:group"]}
]''',
                hint="格式: qq:ID:group/private/user，工具名支持通配符 *",
                order=10,
            ),
        },
        # v2.0: 服务器配置统一为 Claude Desktop mcpServers 规范（JSON）
        "servers": {
            "claude_config_json": ConfigField(
                type=str,
                default='{"mcpServers":{}}',
                description="Claude Desktop 规范的 MCP 配置（JSON）",
                label="🔌 MCP Servers（Claude 规范）",
                input_type="textarea",
                rows=18,
                hint="仅支持 Claude Desktop 的 mcpServers JSON。每个服务器需包含 command(stdio) 或 url(remote)。",
                order=1,
            ),
            "claude_config_guide": ConfigField(
                type=str,
                default="""示例：
{
  "mcpServers": {
    "fetch": { "command": "uvx", "args": ["mcp-server-fetch"] },
    "time": { "url": "https://mcp.api-inference.modelscope.cn/server/mcp-server-time" }
  }
}

可选字段：
- enabled: true/false
- headers: {"Authorization":"Bearer ..."}
- env: {"KEY":"VALUE"}
- transport/type: "streamable_http" | "http" | "sse"（remote 可选，默认 streamable_http）
""",
                description="配置说明（只读）",
                label="📖 配置说明",
                input_type="textarea",
                disabled=True,
                rows=12,
                order=2,
            ),
        },
        "status": {
            "connection_status": ConfigField(
                type=str,
                default="未初始化",
                description="当前 MCP 服务器连接状态和工具列表",
                label="📊 连接状态",
                input_type="textarea",
                disabled=True,
                rows=15,
                hint="此状态仅在插件启动时更新。查询实时状态请发送 /mcp 命令",
                order=1,
            ),
        },
    }
    
    @staticmethod
    def _fix_config_multiline_strings(config_path: Path) -> bool:
        """修复配置文件中的多行字符串格式问题
        
        处理两种情况：
        1. 带转义 \\n 的单行字符串（json.dumps 生成）
        2. 跨越多行但使用普通双引号的字符串（控制字符错误）
        
        Returns:
            bool: 是否进行了修复
        """
        if not config_path.exists():
            return False
        
        try:
            content = config_path.read_text(encoding="utf-8")
            
            # 情况1: 修复带转义 \n 的单行字符串
            # 匹配: key = "内容包含\n的字符串"
            pattern1 = r'^(\s*\w+\s*=\s*)"((?:[^"\\]|\\.)*\\n(?:[^"\\]|\\.)*)"(\s*)$'
            
            # 情况2: 修复跨越多行的普通双引号字符串
            # 匹配: key = "第一行
            #       第二行
            #       第三行"
            pattern2_start = r'^(\s*\w+\s*=\s*)"([^"]*?)$'  # 开始行
            pattern2_end = r'^([^"]*)"(\s*)$'  # 结束行
            
            lines = content.split("\n")
            fixed_lines = []
            modified = False
            
            i = 0
            while i < len(lines):
                line = lines[i]
                
                # 情况1: 单行带转义换行符
                match1 = re.match(pattern1, line)
                if match1:
                    prefix = match1.group(1)
                    value = match1.group(2)
                    suffix = match1.group(3)
                    # 将转义的换行符还原为实际换行符
                    unescaped = value.replace("\\n", "\n").replace("\\t", "\t").replace('\\"', '"').replace("\\\\", "\\")
                    fixed_line = f'{prefix}"""{unescaped}"""{suffix}'
                    fixed_lines.append(fixed_line)
                    modified = True
                    i += 1
                    continue
                
                # 情况2: 跨越多行的字符串
                match2_start = re.match(pattern2_start, line)
                if match2_start:
                    prefix = match2_start.group(1)
                    first_part = match2_start.group(2)
                    
                    # 收集后续行直到找到结束引号
                    multiline_parts = [first_part]
                    j = i + 1
                    found_end = False
                    
                    while j < len(lines):
                        next_line = lines[j]
                        match2_end = re.match(pattern2_end, next_line)
                        if match2_end:
                            multiline_parts.append(match2_end.group(1))
                            suffix = match2_end.group(2)
                            found_end = True
                            j += 1
                            break
                        else:
                            multiline_parts.append(next_line)
                            j += 1
                    
                    if found_end and len(multiline_parts) > 1:
                        # 合并为三引号字符串
                        full_value = "\n".join(multiline_parts)
                        fixed_line = f'{prefix}"""{full_value}"""{suffix}'
                        fixed_lines.append(fixed_line)
                        modified = True
                        i = j
                        continue
                
                fixed_lines.append(line)
                i += 1
            
            if modified:
                config_path.write_text("\n".join(fixed_lines), encoding="utf-8")
                logger.info("已自动修复配置文件中的多行字符串格式")
                return True
            
            return False
        except Exception as e:
            logger.warning(f"修复配置文件格式失败: {e}")
            return False
    
    def __init__(self, *args, **kwargs):
        global _plugin_instance
        
        # 在父类初始化前尝试修复配置文件格式
        config_path = Path(__file__).parent / "config.toml"
        self._fix_config_multiline_strings(config_path)
        
        super().__init__(*args, **kwargs)
        self._initialized = False
        self._status_refresh_running = False
        self._status_refresh_task: Optional[asyncio.Task] = None
        self._last_persisted_display_hash: str = ""
        self._last_servers_config_error: str = ""
        _plugin_instance = self
        
        # 配置 MCP 管理器
        settings = self.config.get("settings", {})
        mcp_manager.configure(settings)
        
        # v1.4.0: 配置追踪器
        trace_log_path = Path(__file__).parent / "logs" / "trace.jsonl"
        tool_call_tracer.configure(
            enabled=settings.get("trace_enabled", True),
            max_records=settings.get("trace_max_records", 100),
            log_enabled=settings.get("trace_log_enabled", False),
            log_path=trace_log_path,
        )
        
        # v1.4.0: 配置缓存
        tool_call_cache.configure(
            enabled=settings.get("cache_enabled", False),
            ttl=settings.get("cache_ttl", 300),
            max_entries=settings.get("cache_max_entries", 200),
            exclude_tools=settings.get("cache_exclude_tools", ""),
        )
        
        # v1.4.0: 配置权限检查器
        perm_config = self.config.get("permissions", {})
        permission_checker.configure(
            enabled=perm_config.get("perm_enabled", False),
            default_mode=perm_config.get("perm_default_mode", "allow_all"),
            rules_json=perm_config.get("perm_rules", "[]"),
            quick_deny_groups=perm_config.get("quick_deny_groups", ""),
            quick_allow_users=perm_config.get("quick_allow_users", ""),
        )
        
        # 注册状态变化回调
        mcp_manager.set_status_change_callback(self._update_status_display)
        
        # v2.0: 服务器配置统一由 servers.claude_config_json 提供（不再通过 WebUI 导入/快速添加写入旧 servers.list）
        
        # v1.8.0: 初始化工具链管理器
        tool_chain_manager.set_executor(mcp_manager)
        self._load_tool_chains()

    def _persist_runtime_displays(self) -> None:
        """将 WebUI 只读展示字段写回配置文件，使 WebUI 能正确显示运行状态。"""
        try:
            config_path = Path(self.plugin_dir) / self.config_file_name

            payload = {
                "status.connection_status": str(self.config.get("status", {}).get("connection_status", "") or ""),
                "tools.tool_list": str(self.config.get("tools", {}).get("tool_list", "") or ""),
                "tool_chains.chains_status": str(self.config.get("tool_chains", {}).get("chains_status", "") or ""),
                "react.react_status": str(self.config.get("react", {}).get("react_status", "") or ""),
            }
            digest = hashlib.sha256(json.dumps(payload, ensure_ascii=False).encode("utf-8")).hexdigest()
            if digest == self._last_persisted_display_hash:
                return

            self._save_config_to_file(self.config, str(config_path))
            self._last_persisted_display_hash = digest
        except Exception as e:
            logger.debug(f"写回运行状态到配置文件失败: {e}")
    
    def _process_quick_add_chain(self) -> None:
        """v1.8.0: 处理快速添加工具链表单"""
        chains_config = self.config.get("tool_chains", {})
        
        # 检查是否触发添加
        add_trigger = chains_config.get("quick_chain_add", "").strip().upper()
        if add_trigger != "ADD":
            return
        
        # 获取表单数据
        chain_name = chains_config.get("quick_chain_name", "").strip()
        chain_desc = chains_config.get("quick_chain_desc", "").strip()
        params_str = chains_config.get("quick_chain_params", "").strip()
        steps_str = chains_config.get("quick_chain_steps", "").strip()
        
        # 验证必填字段
        if not chain_name:
            logger.warning("快速添加工具链: 名称不能为空")
            self._clear_quick_chain_fields()
            return
        
        if not chain_desc:
            logger.warning("快速添加工具链: 描述不能为空")
            self._clear_quick_chain_fields()
            return
        
        if not steps_str:
            logger.warning("快速添加工具链: 步骤不能为空")
            self._clear_quick_chain_fields()
            return
        
        # 解析输入参数
        input_params = {}
        if params_str:
            for line in params_str.split("\n"):
                line = line.strip()
                if not line or "=" not in line:
                    continue
                parts = line.split("=", 1)
                param_name = parts[0].strip()
                param_desc = parts[1].strip() if len(parts) > 1 else param_name
                input_params[param_name] = param_desc
        
        # 解析步骤
        steps = []
        for line in steps_str.split("\n"):
            line = line.strip()
            if not line:
                continue
            
            parts = line.split("|")
            if len(parts) < 2:
                logger.warning(f"快速添加工具链: 步骤格式错误: {line}")
                continue
            
            tool_name = parts[0].strip()
            args_str = parts[1].strip() if len(parts) > 1 else "{}"
            output_key = parts[2].strip() if len(parts) > 2 else ""
            
            # 解析参数 JSON
            try:
                args_template = json.loads(args_str) if args_str else {}
            except json.JSONDecodeError:
                logger.warning(f"快速添加工具链: 参数 JSON 格式错误: {args_str}")
                args_template = {}
            
            steps.append({
                "tool_name": tool_name,
                "args_template": args_template,
                "output_key": output_key,
            })
        
        if not steps:
            logger.warning("快速添加工具链: 没有有效的步骤")
            self._clear_quick_chain_fields()
            return
        
        # 构建新工具链
        new_chain = {
            "name": chain_name,
            "description": chain_desc,
            "input_params": input_params,
            "steps": steps,
            "enabled": True,
        }
        
        # 获取现有工具链列表
        chains_json = chains_config.get("chains_list", "[]")
        try:
            chains_list = json.loads(chains_json) if chains_json.strip() else []
        except json.JSONDecodeError:
            chains_list = []
        
        # 检查是否已存在同名工具链
        for existing in chains_list:
            if existing.get("name") == chain_name:
                logger.info(f"快速添加: 工具链 {chain_name} 已存在，将更新")
                chains_list.remove(existing)
                break
        
        # 添加新工具链
        chains_list.append(new_chain)
        new_chains_json = json.dumps(chains_list, ensure_ascii=False, indent=2)
        
        # 更新配置
        self.config["tool_chains"]["chains_list"] = new_chains_json
        
        # 清空表单字段
        self._clear_quick_chain_fields()
        
        # 保存到配置文件
        self._save_chains_list(new_chains_json)
        
        logger.info(f"快速添加: 已添加工具链 {chain_name} ({len(steps)} 个步骤)")
    
    def _clear_quick_chain_fields(self) -> None:
        """清空快速添加工具链表单字段"""
        if "tool_chains" not in self.config:
            self.config["tool_chains"] = {}
        self.config["tool_chains"]["quick_chain_name"] = ""
        self.config["tool_chains"]["quick_chain_desc"] = ""
        self.config["tool_chains"]["quick_chain_params"] = ""
        self.config["tool_chains"]["quick_chain_steps"] = ""
        self.config["tool_chains"]["quick_chain_add"] = ""
    
    def _save_chains_list(self, chains_json: str) -> None:
        """保存工具链列表到配置文件"""
        try:
            config_path = Path(self.plugin_dir) / self.config_file_name
            self._save_config_to_file(self.config, str(config_path))
            logger.info("工具链列表已保存到配置文件")
        except Exception as e:
            logger.warning(f"保存工具链列表失败: {e}")
    
    def _load_tool_chains(self) -> None:
        """v1.8.0: 加载工具链配置"""
        # 先处理快速添加
        self._process_quick_add_chain()
        
        chains_config = self.config.get("tool_chains", {})
        if not isinstance(chains_config, dict):
            chains_config = {}

        # 兼容旧版本：部分版本可能使用 tool_chain 或其他字段名
        if not chains_config:
            legacy_section = self.config.get("tool_chain")
            if isinstance(legacy_section, dict):
                chains_config = legacy_section
                self.config["tool_chains"] = legacy_section

        # 兼容旧版本：chains_list 字段名变化
        chains_json = str(chains_config.get("chains_list", "") or "")
        if not chains_json.strip():
            for legacy_key in ("list", "chains", "workflow_list", "workflows", "toolchains"):
                legacy_val = chains_config.get(legacy_key)
                if legacy_val is None:
                    continue

                if isinstance(legacy_val, str) and legacy_val.strip():
                    chains_json = legacy_val
                    break

                if isinstance(legacy_val, list):
                    chains_json = json.dumps(legacy_val, ensure_ascii=False, indent=2)
                    break

                if isinstance(legacy_val, dict):
                    chains_json = json.dumps([legacy_val], ensure_ascii=False, indent=2)
                    break

            if chains_json.strip():
                if "tool_chains" not in self.config or not isinstance(self.config.get("tool_chains"), dict):
                    self.config["tool_chains"] = {}
                self.config["tool_chains"]["chains_list"] = chains_json
                logger.info("检测到旧版 Workflow 配置字段，已自动迁移为 tool_chains.chains_list（请在 WebUI 保存一次以固化）")

        chains_config = self.config.get("tool_chains", {})
        if not isinstance(chains_config, dict):
            chains_config = {}

        if not chains_config.get("chains_enabled", True):
            logger.info("工具链功能已禁用")
            return
        
        chains_json = str(chains_config.get("chains_list", "[]") or "")
        if not chains_json or not chains_json.strip():
            return
        
        # 清空现有工具链
        tool_chain_manager.clear()
        tool_chain_registry.clear()
        
        # 加载新配置
        loaded, errors = tool_chain_manager.load_from_json(chains_json)
        
        if errors:
            for err in errors:
                logger.warning(f"工具链配置错误: {err}")
        
        if loaded > 0:
            logger.info(f"已加载 {loaded} 个工具链")
            # 注册工具链到组件系统
            self._register_tool_chains()
            self._update_chains_status_display()
    
    def _register_tool_chains(self) -> None:
        """v1.8.1: 将工具链注册到 MaiBot 组件系统，使 LLM 可调用"""
        from src.plugin_system.core.component_registry import component_registry
        
        chain_count = 0
        for chain_name, chain in tool_chain_manager.get_enabled_chains().items():
            try:
                expected_tool_name = f"chain_{chain.name}".replace("-", "_").replace(".", "_")
                if component_registry.get_component_info(expected_tool_name, ComponentType.TOOL):
                    chain_count += 1
                    logger.debug(f"🔗 工具链已存在，跳过重复注册: {expected_tool_name}")
                    continue

                info, tool_class = tool_chain_registry.register_chain(chain)
                info.plugin_name = self.plugin_name

                if component_registry.register_component(info, tool_class):
                    chain_count += 1
                    logger.info(f"🔗 注册工具链: {tool_class.name}")
                else:
                    logger.warning(f"⚠️ 工具链注册被跳过（可能已存在）: {tool_class.name}")
            except Exception as e:
                logger.error(f"注册工具链 {chain_name} 失败: {e}")
        
        if chain_count > 0:
            logger.info(f"已注册 {chain_count} 个工具链到组件系统")
    
    def _register_tools_to_react(self) -> int:
        """v1.9.0: 将 MCP 工具注册到记忆检索 ReAct 系统（软流程）
        
        这样 MaiBot 的 ReAct Agent 在检索记忆时可以调用 MCP 工具，
        实现 LLM 自主决策的多轮工具调用。
        
        Returns:
            int: 成功注册的工具数量
        """
        try:
            from src.memory_system.retrieval_tools import register_memory_retrieval_tool
        except ImportError:
            logger.warning("无法导入记忆检索工具注册模块，跳过 ReAct 工具注册")
            return 0
        
        react_config = self.config.get("react", {})
        filter_mode = react_config.get("filter_mode", "whitelist")
        tool_filter = react_config.get("tool_filter", "").strip()
        
        # 解析过滤列表（支持 # 注释）
        filter_patterns = []
        for line in tool_filter.split("\n"):
            line = line.strip()
            if line and not line.startswith("#"):
                filter_patterns.append(line)
        
        registered_count = 0
        disabled_tools = self._get_disabled_tools()
        registered_tools = []  # 记录已注册的工具名
        
        for tool_key, (tool_info, _) in mcp_manager.all_tools.items():
            tool_name = tool_key.replace("-", "_").replace(".", "_")
            
            # 跳过禁用的工具
            if tool_name in disabled_tools:
                continue
            
            # 应用过滤器
            if filter_patterns:
                matched = any(
                    fnmatch.fnmatch(tool_name, p) or tool_name == p
                    for p in filter_patterns
                )
                
                if filter_mode == "whitelist":
                    # 白名单模式：只注册匹配的
                    if not matched:
                        continue
                else:
                    # 黑名单模式：排除匹配的
                    if matched:
                        continue
            
            try:
                # 转换参数格式
                parameters = self._convert_mcp_params_to_react_format(tool_info.input_schema)
                
                # 创建异步执行函数（使用闭包捕获 tool_key）
                def make_execute_func(tk: str):
                    async def execute_func(**kwargs) -> str:
                        result = await mcp_manager.call_tool(tk, kwargs)
                        if result.success:
                            return result.content or "(无返回内容)"
                        else:
                            return f"工具调用失败: {result.error}"
                    return execute_func
                
                execute_func = make_execute_func(tool_key)
                
                # 注册到 ReAct 系统
                register_memory_retrieval_tool(
                    name=f"mcp_{tool_name}",
                    description=f"{tool_info.description} [MCP: {tool_info.server_name}]",
                    parameters=parameters,
                    execute_func=execute_func,
                )
                
                registered_count += 1
                registered_tools.append(f"mcp_{tool_name}")
                logger.debug(f"🔄 注册 ReAct 工具: mcp_{tool_name}")
                
            except Exception as e:
                logger.warning(f"注册 ReAct 工具 {tool_name} 失败: {e}")
        
        if registered_count > 0:
            mode_str = "白名单" if filter_mode == "whitelist" else "黑名单"
            logger.info(f"已注册 {registered_count} 个 MCP 工具到 ReAct 系统 (过滤模式: {mode_str})")
        
        # 更新状态显示
        self._update_react_status_display(registered_tools, filter_mode, filter_patterns)
        
        return registered_count
    
    def _update_react_status_display(self, registered_tools: List[str], filter_mode: str, filter_patterns: List[str]) -> None:
        """更新 ReAct 工具状态显示"""
        if not registered_tools:
            status_text = "(未注册任何工具)"
        else:
            mode_str = "白名单" if filter_mode == "whitelist" else "黑名单"
            lines = [f"📊 已注册 {len(registered_tools)} 个工具 (模式: {mode_str})"]
            if filter_patterns:
                lines.append(f"过滤规则: {len(filter_patterns)} 条")
            lines.append("")
            for tool in registered_tools[:20]:
                lines.append(f"  • {tool}")
            if len(registered_tools) > 20:
                lines.append(f"  ... 还有 {len(registered_tools) - 20} 个")
            status_text = "\n".join(lines)
        
        # 更新内存配置
        if "react" not in self.config:
            self.config["react"] = {}
        self.config["react"]["react_status"] = status_text
    
    def _convert_mcp_params_to_react_format(self, input_schema: Dict) -> List[Dict[str, Any]]:
        """将 MCP 工具参数转换为 ReAct 工具参数格式"""
        parameters = []
        
        if not input_schema:
            return parameters
        
        properties = input_schema.get("properties", {})
        required = input_schema.get("required", [])
        
        for param_name, param_info in properties.items():
            param_type = param_info.get("type", "string")
            description = param_info.get("description", f"参数 {param_name}")
            is_required = param_name in required
            
            parameters.append({
                "name": param_name,
                "type": param_type,
                "description": description,
                "required": is_required,
            })
        
        return parameters
    
    def _update_chains_status_display(self) -> None:
        """v1.8.0: 更新工具链状态显示"""
        chains = tool_chain_manager.get_all_chains()
        
        if not chains:
            status_text = "(无工具链配置)"
        else:
            lines = [f"📊 已配置 {len(chains)} 个工具链:\n"]
            for name, chain in chains.items():
                status = "✅" if chain.enabled else "❌"
                # 显示工具链基本信息
                lines.append(f"{status} chain_{name}")
                lines.append(f"   描述: {chain.description[:40]}{'...' if len(chain.description) > 40 else ''}")
                
                # 显示输入参数
                if chain.input_params:
                    params = ", ".join(chain.input_params.keys())
                    lines.append(f"   参数: {params}")
                
                # 显示步骤
                lines.append(f"   步骤: {len(chain.steps)} 个")
                for i, step in enumerate(chain.steps):
                    opt = " (可选)" if step.optional else ""
                    out = f" → {step.output_key}" if step.output_key else ""
                    lines.append(f"      {i+1}. {step.tool_name}{out}{opt}")
                lines.append("")
            
            status_text = "\n".join(lines)
        
        # 更新内存配置
        if "tool_chains" not in self.config:
            self.config["tool_chains"] = {}
        self.config["tool_chains"]["chains_status"] = status_text
    
    def _get_disabled_tools(self) -> set:
        """v1.4.0: 获取禁用的工具列表"""
        tools_config = self.config.get("tools", {})
        disabled_str = tools_config.get("disabled_tools", "")
        return {t.strip() for t in disabled_str.strip().split("\n") if t.strip()}
    
    async def _async_connect_servers(self) -> None:
        """异步连接所有配置的 MCP 服务器（v1.5.0: 并行连接优化）"""
        import asyncio
        settings = self.config.get("settings", {})

        servers_config = self._load_mcp_servers_config()
        
        if not servers_config:
            logger.warning("未配置任何 MCP 服务器")
            self._initialized = True
            self._update_status_display()
            self._update_tool_list_display()
            self._update_chains_status_display()
            self._start_status_refresher()
            self._persist_runtime_displays()
            return
        
        auto_connect = settings.get("auto_connect", True)
        if not auto_connect:
            logger.info("auto_connect 已禁用，跳过自动连接")
            self._initialized = True
            self._update_status_display()
            self._update_tool_list_display()
            self._update_chains_status_display()
            self._start_status_refresher()
            self._persist_runtime_displays()
            return
        
        tool_prefix = settings.get("tool_prefix", "mcp")
        disabled_tools = self._get_disabled_tools()
        enable_resources = settings.get("enable_resources", False)
        enable_prompts = settings.get("enable_prompts", False)
        
        # 解析所有服务器配置
        enabled_configs: List[MCPServerConfig] = []
        for idx, server_conf in enumerate(servers_config):
            server_name = server_conf.get("name", f"unknown_{idx}")
            
            if not server_conf.get("enabled", True):
                logger.info(f"服务器 {server_name} 已禁用，跳过")
                continue
            
            try:
                config = self._parse_server_config(server_conf)
                enabled_configs.append(config)
            except Exception as e:
                logger.error(f"解析服务器 {server_name} 配置失败: {e}")
        
        if not enabled_configs:
            logger.warning("没有已启用的 MCP 服务器")
            self._initialized = True
            self._update_status_display()
            self._update_tool_list_display()
            self._update_chains_status_display()
            self._start_status_refresher()
            self._persist_runtime_displays()
            return
        
        logger.info(f"准备并行连接 {len(enabled_configs)} 个 MCP 服务器")
        
        # v1.5.0: 并行连接所有服务器
        async def connect_single_server(config: MCPServerConfig) -> Tuple[MCPServerConfig, bool]:
            """连接单个服务器"""
            logger.info(f"正在连接服务器: {config.name} ({config.transport.value})")
            try:
                success = await mcp_manager.add_server(config)
                if success:
                    logger.info(f"✅ 服务器 {config.name} 连接成功")
                    # 获取资源和提示模板
                    if enable_resources:
                        try:
                            await mcp_manager.fetch_resources_for_server(config.name)
                        except Exception as e:
                            logger.warning(f"服务器 {config.name} 获取资源列表失败: {e}")
                    if enable_prompts:
                        try:
                            await mcp_manager.fetch_prompts_for_server(config.name)
                        except Exception as e:
                            logger.warning(f"服务器 {config.name} 获取提示模板列表失败: {e}")
                else:
                    logger.warning(f"❌ 服务器 {config.name} 连接失败")
                return config, success
            except Exception as e:
                logger.error(f"❌ 服务器 {config.name} 连接异常: {e}")
                return config, False
        
        # 并行执行所有连接
        start_time = time.time()
        results = await asyncio.gather(
            *[connect_single_server(cfg) for cfg in enabled_configs],
            return_exceptions=True
        )
        connect_duration = time.time() - start_time
        
        # 统计连接结果
        success_count = 0
        failed_count = 0
        for result in results:
            if isinstance(result, Exception):
                failed_count += 1
                logger.error(f"连接任务异常: {result}")
            elif isinstance(result, tuple):
                _, success = result
                if success:
                    success_count += 1
                else:
                    failed_count += 1
        
        logger.info(f"并行连接完成: {success_count} 成功, {failed_count} 失败, 耗时 {connect_duration:.2f}s")
        
        # 注册所有工具
        from src.plugin_system.core.component_registry import component_registry
        registered_count = 0
        
        for tool_key, (tool_info, _) in mcp_manager.all_tools.items():
            tool_name = tool_key.replace("-", "_").replace(".", "_")
            is_disabled = tool_name in disabled_tools
            
            info, tool_class = mcp_tool_registry.register_tool(
                tool_key, tool_info, tool_prefix, disabled=is_disabled
            )
            info.plugin_name = self.plugin_name
            
            if component_registry.register_component(info, tool_class):
                registered_count += 1
                status = "🚫" if is_disabled else "✅"
                logger.info(f"{status} 注册 MCP 工具: {tool_class.name}")
            else:
                logger.warning(f"❌ 注册 MCP 工具失败: {tool_class.name}")
        
        chains_config = self.config.get("tool_chains", {})
        chains_enabled = bool(chains_config.get("chains_enabled", True)) if isinstance(chains_config, dict) else True
        chain_count = len(tool_chain_manager.get_enabled_chains()) if chains_enabled else 0
        
        # v1.9.0: 注册 MCP 工具到记忆检索 ReAct 系统（软流程）
        react_count = 0
        react_config = self.config.get("react", {})
        if react_config.get("react_enabled", False):
            react_count = self._register_tools_to_react()
        
        self._initialized = True
        logger.info(f"MCP 桥接插件初始化完成，已注册 {registered_count} 个工具，{chain_count} 个工具链，{react_count} 个 ReAct 工具")
        
        # 更新状态显示
        self._update_status_display()
        self._update_tool_list_display()
        self._update_chains_status_display()
        self._start_status_refresher()
        self._persist_runtime_displays()
    
    def _start_status_refresher(self) -> None:
        """启动 WebUI 状态刷新任务（不写入磁盘）"""
        task = getattr(self, "_status_refresh_task", None)
        if task and not task.done():
            return

        self._status_refresh_running = True
        self._status_refresh_task = asyncio.create_task(self._status_refresh_loop())

    async def _stop_status_refresher(self) -> None:
        """停止 WebUI 状态刷新任务"""
        self._status_refresh_running = False
        task = getattr(self, "_status_refresh_task", None)
        if task:
            task.cancel()
            try:
                await task
            except asyncio.CancelledError:
                pass
        self._status_refresh_task = None

    async def _status_refresh_loop(self) -> None:
        """定期刷新 WebUI 展示字段（状态/工具列表/工具链状态）"""
        while getattr(self, "_status_refresh_running", False):
            try:
                settings = self.config.get("settings", {})
                enabled = bool(settings.get("status_refresh_enabled", True))
                interval = float(settings.get("status_refresh_interval", 10.0) or 10.0)
                interval = max(5.0, min(interval, 60.0))

                if enabled and self._initialized:
                    self._update_status_display()
                    self._update_tool_list_display()
                    self._update_chains_status_display()
                    self._persist_runtime_displays()

                await asyncio.sleep(interval if enabled else 5.0)
            except asyncio.CancelledError:
                break
            except Exception as e:
                logger.debug(f"状态刷新任务异常: {e}")
                await asyncio.sleep(5.0)

    def _load_mcp_servers_config(self) -> List[Dict[str, Any]]:
        """v2.0: 从 Claude mcpServers JSON 加载服务器配置。

        - 唯一主入口：config.servers.claude_config_json
        - 兼容：若旧版 servers.list 存在且 claude_config_json 为空，会自动迁移并写回内存配置
        """
        servers_section = self.config.get("servers", {})
        if not isinstance(servers_section, dict):
            servers_section = {}

        claude_json = str(servers_section.get("claude_config_json", "") or "")

        if not claude_json.strip():
            legacy_list = str(servers_section.get("list", "") or "")
            migrated = legacy_servers_list_to_claude_config(legacy_list)
            if migrated:
                claude_json = migrated
                if "servers" not in self.config:
                    self.config["servers"] = {}
                self.config["servers"]["claude_config_json"] = migrated
                logger.info("检测到旧版 servers.list，已自动迁移为 Claude mcpServers（请在 WebUI 保存一次以固化）")

        if not claude_json.strip():
            self._last_servers_config_error = "未配置任何 MCP 服务器（请在 WebUI 的「MCP Servers（Claude）」粘贴 mcpServers JSON）"
            return []

        try:
            servers = parse_claude_mcp_config(claude_json)
        except ClaudeConfigError as e:
            self._last_servers_config_error = str(e)
            logger.error(f"Claude mcpServers 配置解析失败: {e}")
            return []
        except Exception as e:
            self._last_servers_config_error = str(e)
            logger.error(f"Claude mcpServers 配置解析异常: {e}")
            return []

        self._last_servers_config_error = ""

        # 保留未知字段（如 post_process）供旧功能使用
        raw_mapping: Dict[str, Any] = {}
        try:
            parsed = json.loads(claude_json)
            mapping = parsed.get("mcpServers", parsed)
            if isinstance(mapping, dict):
                raw_mapping = mapping
        except Exception:
            raw_mapping = {}

        configs: List[Dict[str, Any]] = []
        for srv in servers:
            raw = raw_mapping.get(srv.name, {})
            cfg: Dict[str, Any] = raw.copy() if isinstance(raw, dict) else {}
            cfg.update(
                {
                    "name": srv.name,
                    "enabled": srv.enabled,
                    "transport": srv.transport,
                    "command": srv.command,
                    "args": srv.args,
                    "env": srv.env,
                    "url": srv.url,
                    "headers": srv.headers,
                }
            )
            configs.append(cfg)

        return configs
    
    def _parse_server_config(self, conf: Dict) -> MCPServerConfig:
        """解析服务器配置字典"""
        transport_str = conf.get("transport", "stdio").lower()
        
        transport_map = {
            "stdio": TransportType.STDIO,
            "sse": TransportType.SSE,
            "http": TransportType.HTTP,
            "streamable_http": TransportType.STREAMABLE_HTTP,
        }
        transport = transport_map.get(transport_str, TransportType.STDIO)
        
        return MCPServerConfig(
            name=conf.get("name", "unnamed"),
            enabled=conf.get("enabled", True),
            transport=transport,
            command=conf.get("command", ""),
            args=conf.get("args", []),
            env=conf.get("env", {}),
            url=conf.get("url", ""),
            headers=conf.get("headers", {}),  # v1.4.2: 鉴权头支持
        )
    
    def _update_tool_list_display(self) -> None:
        """v1.4.0: 更新工具列表显示"""
        tools = mcp_manager.all_tools
        disabled_tools = self._get_disabled_tools()
        
        lines = []
        by_server: Dict[str, List[str]] = {}
        
        for tool_key, (tool_info, _) in tools.items():
            tool_name = tool_key.replace("-", "_").replace(".", "_")
            if tool_info.server_name not in by_server:
                by_server[tool_info.server_name] = []
            
            is_disabled = tool_name in disabled_tools
            status = " ❌" if is_disabled else ""
            by_server[tool_info.server_name].append(f"  • {tool_name}{status}")
        
        for srv_name, tool_list in by_server.items():
            lines.append(f"📦 {srv_name} ({len(tool_list)}个工具):")
            lines.extend(tool_list)
            lines.append("")
        
        if not by_server:
            lines.append("(无已注册工具)")
        
        tool_list_text = "\n".join(lines)
        
        # 更新内存配置
        if "tools" not in self.config:
            self.config["tools"] = {}
        self.config["tools"]["tool_list"] = tool_list_text
    
    def _update_status_display(self) -> None:
        """更新配置文件中的状态显示字段"""
        status = mcp_manager.get_status()
        settings = self.config.get("settings", {})
        lines = []

        cfg_err = str(getattr(self, "_last_servers_config_error", "") or "").strip()
        if cfg_err:
            lines.append(f"⚠️ 配置: {cfg_err}")
            lines.append("")
        
        lines.append(f"服务器: {status['connected_servers']}/{status['total_servers']} 已连接")
        lines.append(f"工具数: {status['total_tools']}")
        if settings.get("enable_resources", False):
            lines.append(f"资源数: {status.get('total_resources', 0)}")
        if settings.get("enable_prompts", False):
            lines.append(f"模板数: {status.get('total_prompts', 0)}")
        lines.append(f"心跳: {'运行中' if status['heartbeat_running'] else '已停止'}")
        lines.append("")
        
        tools = mcp_manager.all_tools
        
        for name, info in status.get("servers", {}).items():
            icon = "✅" if info["connected"] else "❌"
            lines.append(f"{icon} {name} ({info['transport']})")
            
            # v1.7.0: 显示断路器状态
            cb_status = info.get("circuit_breaker", {})
            cb_state = cb_status.get("state", "closed")
            if cb_state == "open":
                lines.append("   ⚡ 断路器: 熔断中")
            elif cb_state == "half_open":
                lines.append("   ⚡ 断路器: 试探中")
            
            server_tools = [t.name for key, (t, _) in tools.items() if t.server_name == name]
            if server_tools:
                for tool_name in server_tools:
                    lines.append(f"   • {tool_name}")
            else:
                lines.append("   (无工具)")
        
        if not status.get("servers"):
            lines.append("(无服务器)")
        
        status_text = "\n".join(lines)
        
        if "status" not in self.config:
            self.config["status"] = {}
        self.config["status"]["connection_status"] = status_text
    
    def get_plugin_components(self) -> List[Tuple[ComponentInfo, Type]]:
        """返回插件的所有组件"""
        components: List[Tuple[ComponentInfo, Type]] = []
        
        # 事件处理器
        components.append((MCPStartupHandler.get_handler_info(), MCPStartupHandler))
        components.append((MCPStopHandler.get_handler_info(), MCPStopHandler))
        
        # 命令
        components.append((MCPStatusCommand.get_command_info(), MCPStatusCommand))
        components.append((MCPImportCommand.get_command_info(), MCPImportCommand))
        
        # 内置工具
        status_tool_info = ToolInfo(
            name=MCPStatusTool.name,
            tool_description=MCPStatusTool.description,
            enabled=True,
            tool_parameters=MCPStatusTool.parameters,
            component_type=ComponentType.TOOL,
        )
        components.append((status_tool_info, MCPStatusTool))
        
        settings = self.config.get("settings", {})
        
        if settings.get("enable_resources", False):
            read_resource_info = ToolInfo(
                name=MCPReadResourceTool.name,
                tool_description=MCPReadResourceTool.description,
                enabled=True,
                tool_parameters=MCPReadResourceTool.parameters,
                component_type=ComponentType.TOOL,
            )
            components.append((read_resource_info, MCPReadResourceTool))
        
        if settings.get("enable_prompts", False):
            get_prompt_info = ToolInfo(
                name=MCPGetPromptTool.name,
                tool_description=MCPGetPromptTool.description,
                enabled=True,
                tool_parameters=MCPGetPromptTool.parameters,
                component_type=ComponentType.TOOL,
            )
            components.append((get_prompt_info, MCPGetPromptTool))
        
        return components
    
    def get_status(self) -> Dict[str, Any]:
        """获取插件状态"""
        return {
            "initialized": self._initialized,
            "mcp_manager": mcp_manager.get_status(),
            "registered_tools": len(mcp_tool_registry._tool_classes),
            "trace_records": tool_call_tracer.total_records,
            "cache_stats": tool_call_cache.get_stats(),
        }
    
    def get_stats(self) -> Dict[str, Any]:
        """获取详细统计信息"""
        return mcp_manager.get_all_stats()
