diff --git a/bot.py b/bot.py
index 4cdb54ede..aeec5d0d6 100644
--- a/bot.py
+++ b/bot.py
@@ -296,8 +296,10 @@ class DatabaseManager:
             # 使用线程执行器运行潜在的阻塞操作
             await initialize_sql_database()
             elapsed_time = time.time() - start_time
+            
+            db_type = global_config.database.database_type if global_config else "unknown"
             logger.info(
-                f"数据库连接初始化成功，使用 {global_config.database.database_type} 数据库，耗时: {elapsed_time:.2f}秒"
+                f"数据库连接初始化成功，使用 {db_type} 数据库，耗时: {elapsed_time:.2f}秒"
             )
 
             return self
@@ -321,6 +323,10 @@ class ConfigurationValidator:
         try:
             from src.config.config import global_config
 
+            if global_config is None:
+                logger.error("全局配置未初始化")
+                return False
+
             # 检查必要的配置节
             required_sections = ["database", "bot"]
             for section in required_sections:
diff --git a/scripts/clean_permission_nodes.py b/scripts/clean_permission_nodes.py
index ece37c8d5..38dfa94e0 100644
--- a/scripts/clean_permission_nodes.py
+++ b/scripts/clean_permission_nodes.py
@@ -29,7 +29,7 @@ async def clean_permission_nodes():
             result = await session.execute(stmt)
             await session.commit()
 
-            deleted_count = result.rowcount if hasattr(result, "rowcount") else 0
+            deleted_count = getattr(result, "rowcount", 0)
             logger.info(f"✅ 已清理 {deleted_count} 个权限节点记录")
             print(f"✅ 已清理 {deleted_count} 个权限节点记录")
             print("请重启应用以重新注册权限节点")
diff --git a/scripts/log_viewer.py b/scripts/log_viewer.py
new file mode 100644
index 000000000..88fff24ac
--- /dev/null
+++ b/scripts/log_viewer.py
@@ -0,0 +1,1107 @@
+#!/usr/bin/env python3
+"""
+MoFox-Core 日志查看器
+一个基于 HTTP 的日志查看服务，支持实时查看、搜索和筛选日志。
+
+用法:
+    python scripts/log_viewer.py
+    python -m scripts.log_viewer [--port PORT] [--host HOST]
+"""
+
+import argparse
+import gzip
+import json
+import re
+import sys
+import tarfile
+import threading
+import webbrowser
+from collections import defaultdict
+from dataclasses import dataclass
+from datetime import datetime
+from http.server import HTTPServer, SimpleHTTPRequestHandler
+from pathlib import Path
+from typing import Any
+from urllib.parse import parse_qs, urlparse
+
+# 添加项目根目录到路径（支持直接运行和模块运行）
+PROJECT_ROOT = Path(__file__).resolve().parent.parent.parent
+if str(PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(PROJECT_ROOT))
+
+# 切换工作目录到项目根目录
+import os
+os.chdir(PROJECT_ROOT)
+
+# 日志目录
+LOG_DIR = PROJECT_ROOT / "logs"
+
+# 从 logger.py 导入颜色和别名配置
+DEFAULT_MODULE_COLORS = {}
+DEFAULT_MODULE_ALIASES = {}
+try:
+    from src.common.logger import (
+        DEFAULT_MODULE_ALIASES,
+        DEFAULT_MODULE_COLORS,
+    )
+except ImportError:
+    pass  # 使用空字典
+
+
+@dataclass
+class LogEntry:
+    """日志条目"""
+
+    timestamp: str
+    level: str
+    logger_name: str
+    event: str
+    color: str | None = None
+    alias: str | None = None
+    extra: dict | None = None
+    line_number: int = 0
+    file_name: str = ""
+
+
+class LogReader:
+    """日志文件读取器"""
+
+    def __init__(self, log_dir: Path):
+        self.log_dir = log_dir
+        self._cache: dict[str, list[LogEntry]] = {}
+        self._cache_mtime: dict[str, float] = {}
+        self._filter_cache: dict[str, tuple[list[LogEntry], str]] = {}  # 筛选结果缓存
+        self._lock = threading.Lock()
+
+    def get_log_files(self) -> list[dict[str, Any]]:
+        """获取所有日志文件列表"""
+        files = []
+        if not self.log_dir.exists():
+            return files
+
+        for f in sorted(self.log_dir.glob("app_*.log.jsonl*"), reverse=True):
+            try:
+                stat = f.stat()
+                is_compressed = f.suffix == ".gz" or ".tar.gz" in f.name
+                files.append(
+                    {
+                        "name": f.name,
+                        "size": stat.st_size,
+                        "size_human": self._human_size(stat.st_size),
+                        "mtime": stat.st_mtime,
+                        "mtime_human": datetime.fromtimestamp(stat.st_mtime).strftime("%Y-%m-%d %H:%M:%S"),
+                        "compressed": is_compressed,
+                    }
+                )
+            except OSError:
+                continue
+        return files
+
+    def _human_size(self, size: int) -> str:
+        """转换为人类可读的文件大小"""
+        for unit in ["B", "KB", "MB", "GB"]:
+            if size < 1024:
+                return f"{size:.1f} {unit}"
+            size /= 1024
+        return f"{size:.1f} TB"
+
+    def read_log_file(self, filename: str, use_cache: bool = True) -> list[LogEntry]:
+        """读取日志文件内容"""
+        filepath = self.log_dir / filename
+        if not filepath.exists():
+            return []
+
+        # 检查缓存
+        with self._lock:
+            if use_cache and filename in self._cache:
+                try:
+                    current_mtime = filepath.stat().st_mtime
+                    if self._cache_mtime.get(filename) == current_mtime:
+                        return self._cache[filename]
+                except OSError:
+                    pass
+
+        entries = []
+        try:
+            # 处理压缩文件
+            if ".tar.gz" in filename:
+                entries = self._read_tar_gz(filepath)
+            elif filename.endswith(".gz"):
+                entries = self._read_gzip(filepath)
+            else:
+                entries = self._read_plain(filepath)
+
+            # 更新缓存
+            with self._lock:
+                self._cache[filename] = entries
+                try:
+                    self._cache_mtime[filename] = filepath.stat().st_mtime
+                except OSError:
+                    pass
+
+        except Exception as e:
+            print(f"读取日志文件 {filename} 时出错: {e}")
+
+        return entries
+
+    def _read_plain(self, filepath: Path) -> list[LogEntry]:
+        """读取普通日志文件"""
+        entries = []
+        with open(filepath, encoding="utf-8", errors="replace") as f:
+            for line_num, line in enumerate(f, 1):
+                entry = self._parse_line(line, line_num, filepath.name)
+                if entry:
+                    entries.append(entry)
+        return entries
+
+    def _read_gzip(self, filepath: Path) -> list[LogEntry]:
+        """读取 gzip 压缩的日志文件"""
+        entries = []
+        with gzip.open(filepath, "rt", encoding="utf-8", errors="replace") as f:
+            for line_num, line in enumerate(f, 1):
+                entry = self._parse_line(line, line_num, filepath.name)
+                if entry:
+                    entries.append(entry)
+        return entries
+
+    def _read_tar_gz(self, filepath: Path) -> list[LogEntry]:
+        """读取 tar.gz 压缩的日志文件"""
+        entries = []
+        try:
+            with tarfile.open(filepath, "r:gz") as tar:
+                for member in tar.getmembers():
+                    if member.isfile():
+                        f = tar.extractfile(member)
+                        if f:
+                            content = f.read().decode("utf-8", errors="replace")
+                            for line_num, line in enumerate(content.splitlines(), 1):
+                                entry = self._parse_line(line, line_num, filepath.name)
+                                if entry:
+                                    entries.append(entry)
+        except Exception as e:
+            print(f"读取 tar.gz 文件 {filepath} 时出错: {e}")
+        return entries
+
+    def _parse_line(self, line: str, line_num: int, filename: str) -> LogEntry | None:
+        """解析单行日志"""
+        line = line.strip()
+        if not line:
+            return None
+
+        try:
+            data = json.loads(line)
+            logger_name = data.get("logger_name", "unknown")
+
+            # 获取颜色和别名（优先使用日志中的，否则使用默认配置）
+            color = data.get("color") or DEFAULT_MODULE_COLORS.get(logger_name)
+            alias = data.get("alias") or DEFAULT_MODULE_ALIASES.get(logger_name)
+
+            # 提取额外字段
+            extra = {k: v for k, v in data.items() if k not in ("timestamp", "level", "logger_name", "event", "color", "alias")}
+
+            return LogEntry(
+                timestamp=data.get("timestamp", ""),
+                level=data.get("level", "info"),
+                logger_name=logger_name,
+                event=data.get("event", ""),
+                color=color,
+                alias=alias,
+                extra=extra if extra else None,
+                line_number=line_num,
+                file_name=filename,
+            )
+        except json.JSONDecodeError:
+            # 非 JSON 格式的行，尝试作为纯文本处理
+            return LogEntry(
+                timestamp="",
+                level="info",
+                logger_name="raw",
+                event=line,
+                line_number=line_num,
+                file_name=filename,
+            )
+
+    def search_logs(
+        self,
+        filename: str,
+        query: str = "",
+        level: str = "",
+        logger: str = "",
+        start_time: str = "",
+        end_time: str = "",
+        limit: int = 1000,
+        offset: int = 0,
+        regex: bool = False,
+    ) -> tuple[list[LogEntry], int]:
+        """搜索和筛选日志"""
+        entries = self.read_log_file(filename)
+
+        # 如果没有筛选条件，直接返回分页结果
+        if not query and not level and not logger and not start_time and not end_time:
+            total = len(entries)
+            return entries[offset : offset + limit], total
+
+        # 生成筛选条件的缓存 key
+        cache_key = f"{filename}:{query}:{level}:{logger}:{start_time}:{end_time}:{regex}"
+
+        # 检查筛选缓存
+        with self._lock:
+            cached = self._filter_cache.get(filename)
+            if cached and cached[1] == cache_key:
+                filtered = cached[0]
+                return filtered[offset : offset + limit], len(filtered)
+
+        # 编译正则表达式（如果需要）
+        query_pattern = None
+        query_lower = ""
+        if query:
+            if regex:
+                try:
+                    query_pattern = re.compile(query, re.IGNORECASE)
+                except re.error:
+                    query_pattern = None
+            else:
+                query_lower = query.lower()
+
+        filtered = []
+        for entry in entries:
+            # 日志级别筛选
+            if level and entry.level.lower() != level.lower():
+                continue
+
+            # Logger 名称筛选
+            if logger and entry.logger_name.lower() != logger.lower():
+                continue
+
+            # 时间范围筛选
+            if start_time and entry.timestamp < start_time:
+                continue
+            if end_time and entry.timestamp > end_time:
+                continue
+
+            # 关键词搜索
+            if query:
+                if query_pattern:
+                    if not (query_pattern.search(entry.event) or query_pattern.search(entry.logger_name) or (entry.alias and query_pattern.search(entry.alias))):
+                        continue
+                else:
+                    search_text = f"{entry.event} {entry.logger_name} {entry.alias or ''}".lower()
+                    if query_lower not in search_text:
+                        continue
+
+            filtered.append(entry)
+
+        # 更新筛选缓存
+        with self._lock:
+            self._filter_cache[filename] = (filtered, cache_key)
+
+        total = len(filtered)
+        return filtered[offset : offset + limit], total
+
+    def get_loggers(self, filename: str) -> list[dict[str, str]]:
+        """获取日志文件中的所有 logger"""
+        entries = self.read_log_file(filename)
+        loggers = {}
+        for entry in entries:
+            if entry.logger_name not in loggers:
+                loggers[entry.logger_name] = {
+                    "name": entry.logger_name,
+                    "alias": entry.alias or DEFAULT_MODULE_ALIASES.get(entry.logger_name, ""),
+                    "color": entry.color or DEFAULT_MODULE_COLORS.get(entry.logger_name, ""),
+                }
+        return sorted(loggers.values(), key=lambda x: x["name"])
+
+    def get_stats(self, filename: str) -> dict[str, Any]:
+        """获取日志统计信息"""
+        entries = self.read_log_file(filename)
+
+        level_counts = defaultdict(int)
+        logger_counts = defaultdict(int)
+
+        for entry in entries:
+            level_counts[entry.level] += 1
+            logger_counts[entry.logger_name] += 1
+
+        return {
+            "total": len(entries),
+            "by_level": dict(level_counts),
+            "by_logger": dict(sorted(logger_counts.items(), key=lambda x: -x[1])[:20]),
+        }
+
+
+# HTML 模板
+HTML_TEMPLATE = """<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>日志查看器</title>
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600&family=JetBrains+Mono:wght@400;500&display=swap" rel="stylesheet">
+    <style>
+        * { margin: 0; padding: 0; box-sizing: border-box; }
+
+        :root {
+            --bg: #0d1117;
+            --bg-card: #161b22;
+            --bg-input: #21262d;
+            --border: #30363d;
+            --text: #e6edf3;
+            --text-dim: #8b949e;
+            --accent: #58a6ff;
+            --accent-dim: #388bfd;
+            --green: #3fb950;
+            --yellow: #d29922;
+            --red: #f85149;
+            --orange: #db6d28;
+            --purple: #a371f7;
+            --font-sans: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Microsoft YaHei', sans-serif;
+            --font-mono: 'JetBrains Mono', 'Cascadia Code', 'Fira Code', Consolas, monospace;
+        }
+
+        body {
+            font-family: var(--font-sans);
+            background: var(--bg);
+            color: var(--text);
+            line-height: 1.5;
+            font-size: 13px;
+            -webkit-font-smoothing: antialiased;
+        }
+
+        .app { display: flex; height: 100vh; }
+
+        /* 侧边栏 */
+        .sidebar {
+            width: 280px;
+            background: var(--bg-card);
+            border-right: 1px solid var(--border);
+            display: flex;
+            flex-direction: column;
+            flex-shrink: 0;
+        }
+
+        .sidebar-header {
+            padding: 16px;
+            border-bottom: 1px solid var(--border);
+            font-weight: 600;
+            display: flex;
+            align-items: center;
+            gap: 8px;
+        }
+
+        .sidebar-header svg { color: var(--accent); }
+
+        .file-list {
+            flex: 1;
+            overflow-y: auto;
+            padding: 8px;
+        }
+
+        .file-item {
+            padding: 10px 12px;
+            border-radius: 6px;
+            cursor: pointer;
+            margin-bottom: 4px;
+            transition: background 0.15s;
+        }
+
+        .file-item:hover { background: var(--bg-input); }
+        .file-item.active { background: var(--accent-dim); color: #fff; }
+
+        .file-item .name {
+            font-size: 13px;
+            font-weight: 500;
+            white-space: nowrap;
+            overflow: hidden;
+            text-overflow: ellipsis;
+        }
+
+        .file-item .meta {
+            font-size: 11px;
+            color: var(--text-dim);
+            margin-top: 2px;
+        }
+
+        .file-item.active .meta { color: rgba(255,255,255,0.7); }
+
+        /* 主内容区 */
+        .main { flex: 1; display: flex; flex-direction: column; min-width: 0; }
+
+        /* 工具栏 */
+        .toolbar {
+            padding: 12px 16px;
+            background: var(--bg-card);
+            border-bottom: 1px solid var(--border);
+            display: flex;
+            flex-wrap: wrap;
+            gap: 12px;
+            align-items: center;
+        }
+
+        .toolbar-group {
+            display: flex;
+            align-items: center;
+            gap: 6px;
+        }
+
+        .toolbar-group label {
+            font-size: 12px;
+            color: var(--text-dim);
+        }
+
+        input, select {
+            background: var(--bg-input);
+            border: 1px solid var(--border);
+            border-radius: 6px;
+            padding: 6px 10px;
+            color: var(--text);
+            font-size: 13px;
+            font-family: var(--font-sans);
+            outline: none;
+        }
+
+        input:focus, select:focus { border-color: var(--accent); }
+
+        input[type="search"] { width: 240px; }
+        input[type="number"] { width: 70px; font-family: var(--font-mono); }
+
+        .btn {
+            background: var(--bg-input);
+            border: 1px solid var(--border);
+            border-radius: 6px;
+            padding: 6px 12px;
+            color: var(--text);
+            font-size: 13px;
+            font-family: var(--font-sans);
+            cursor: pointer;
+            transition: all 0.15s;
+            display: inline-flex;
+            align-items: center;
+            gap: 4px;
+        }
+
+        .btn:hover { background: var(--border); }
+        .btn-primary { background: var(--accent); border-color: var(--accent); color: #fff; }
+        .btn-primary:hover { background: var(--accent-dim); }
+
+        .checkbox {
+            display: flex;
+            align-items: center;
+            gap: 4px;
+            font-size: 12px;
+            color: var(--text-dim);
+            cursor: pointer;
+        }
+
+        .checkbox input { margin: 0; }
+
+        .spacer { flex: 1; }
+
+        /* 统计条 */
+        .stats-bar {
+            padding: 8px 16px;
+            background: var(--bg-card);
+            border-bottom: 1px solid var(--border);
+            display: flex;
+            gap: 16px;
+            font-size: 12px;
+        }
+
+        .stat { display: flex; align-items: center; gap: 4px; }
+        .stat-dot {
+            width: 8px;
+            height: 8px;
+            border-radius: 50%;
+        }
+
+        .stat-dot.debug { background: var(--orange); }
+        .stat-dot.info { background: var(--accent); }
+        .stat-dot.warning { background: var(--yellow); }
+        .stat-dot.error { background: var(--red); }
+        .stat-dot.critical { background: var(--purple); }
+
+        /* 日志列表 */
+        .log-container { flex: 1; overflow: hidden; display: flex; flex-direction: column; }
+
+        .log-list {
+            flex: 1;
+            overflow-y: auto;
+            font-family: var(--font-mono);
+            font-size: 12px;
+            letter-spacing: -0.3px;
+        }
+
+        .log-entry {
+            display: flex;
+            padding: 6px 16px;
+            border-bottom: 1px solid var(--border);
+            gap: 12px;
+            align-items: flex-start;
+        }
+
+        .log-entry:hover { background: rgba(88, 166, 255, 0.05); }
+
+        .log-time {
+            color: var(--text-dim);
+            white-space: nowrap;
+            min-width: 90px;
+            flex-shrink: 0;
+            font-size: 11px;
+        }
+
+        .log-level {
+            min-width: 50px;
+            flex-shrink: 0;
+            font-weight: 600;
+            text-transform: uppercase;
+            font-size: 10px;
+            padding: 2px 0;
+        }
+
+        .log-level.debug { color: var(--orange); }
+        .log-level.info { color: var(--accent); }
+        .log-level.warning { color: var(--yellow); }
+        .log-level.error { color: var(--red); }
+        .log-level.critical { color: var(--purple); }
+
+        .log-logger {
+            min-width: 100px;
+            max-width: 140px;
+            flex-shrink: 0;
+            white-space: nowrap;
+            overflow: hidden;
+            text-overflow: ellipsis;
+            font-weight: 500;
+        }
+
+        .log-msg {
+            flex: 1;
+            white-space: pre-wrap;
+            word-break: break-word;
+            min-width: 0;
+        }
+
+        .log-msg .hl {
+            background: rgba(210, 153, 34, 0.3);
+            border-radius: 2px;
+            padding: 0 2px;
+        }
+
+        /* 分页栏 */
+        .pagination {
+            padding: 10px 16px;
+            background: var(--bg-card);
+            border-top: 1px solid var(--border);
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            gap: 8px;
+            font-size: 13px;
+        }
+
+        .pagination .info { color: var(--text-dim); margin: 0 12px; }
+
+        .pagination button:disabled { opacity: 0.4; cursor: not-allowed; }
+
+        /* 空状态 */
+        .empty {
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+            justify-content: center;
+            height: 100%;
+            color: var(--text-dim);
+            gap: 8px;
+        }
+
+        .empty svg { opacity: 0.3; }
+
+        /* 加载动画 */
+        .loading { text-align: center; padding: 40px; color: var(--text-dim); }
+
+        /* 自动刷新指示 */
+        .refresh-badge {
+            display: inline-flex;
+            align-items: center;
+            gap: 4px;
+            font-size: 11px;
+            color: var(--green);
+            margin-left: 8px;
+        }
+
+        .refresh-badge::before {
+            content: '';
+            width: 6px;
+            height: 6px;
+            background: var(--green);
+            border-radius: 50%;
+            animation: blink 1.5s infinite;
+        }
+
+        @keyframes blink {
+            0%, 100% { opacity: 1; }
+            50% { opacity: 0.3; }
+        }
+
+        /* 滚动条 */
+        ::-webkit-scrollbar { width: 8px; }
+        ::-webkit-scrollbar-track { background: transparent; }
+        ::-webkit-scrollbar-thumb { background: var(--border); border-radius: 4px; }
+        ::-webkit-scrollbar-thumb:hover { background: var(--text-dim); }
+    </style>
+</head>
+<body>
+    <div class="app">
+        <aside class="sidebar">
+            <div class="sidebar-header">
+                <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                    <path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"/><path d="M14 2v6h6"/><path d="M16 13H8"/><path d="M16 17H8"/><path d="M10 9H8"/>
+                </svg>
+                日志文件
+            </div>
+            <div class="file-list" id="fileList">
+                <div class="loading">加载中...</div>
+            </div>
+        </aside>
+
+        <main class="main">
+            <div class="toolbar">
+                <div class="toolbar-group">
+                    <input type="search" id="searchInput" placeholder="搜索内容..." onkeydown="if(event.key==='Enter')doSearch()">
+                    <label class="checkbox"><input type="checkbox" id="regexCheck"> 正则</label>
+                </div>
+
+                <div class="toolbar-group">
+                    <label>级别</label>
+                    <select id="levelSelect" onchange="resetAndSearch()">
+                        <option value="">全部</option>
+                        <option value="debug">DEBUG</option>
+                        <option value="info">INFO</option>
+                        <option value="warning">WARNING</option>
+                        <option value="error">ERROR</option>
+                        <option value="critical">CRITICAL</option>
+                    </select>
+                </div>
+
+                <div class="toolbar-group">
+                    <label>模块</label>
+                    <select id="loggerSelect" onchange="resetAndSearch()">
+                        <option value="">全部</option>
+                    </select>
+                </div>
+
+                <button class="btn btn-primary" onclick="doSearch()">搜索</button>
+                <button class="btn" onclick="clearSearch()">清除</button>
+
+                <div class="spacer"></div>
+
+                <div class="toolbar-group">
+                    <label class="checkbox">
+                        <input type="checkbox" id="paginationCheck" checked onchange="togglePagination()">
+                        分页
+                    </label>
+                    <label>每页</label>
+                    <input type="number" id="pageSizeInput" value="200" min="50" max="5000" step="50" onchange="updatePageSize()">
+                </div>
+
+                <div class="toolbar-group">
+                    <label class="checkbox">
+                        <input type="checkbox" id="autoRefreshCheck" onchange="toggleAutoRefresh()">
+                        自动刷新
+                    </label>
+                    <span class="refresh-badge" id="refreshBadge" style="display:none">实时</span>
+                </div>
+            </div>
+
+            <div class="stats-bar" id="statsBar"></div>
+
+            <div class="log-container">
+                <div class="log-list" id="logList">
+                    <div class="empty">
+                        <svg width="48" height="48" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1">
+                            <path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"/>
+                            <path d="M14 2v6h6"/>
+                        </svg>
+                        <span>选择左侧文件查看日志</span>
+                    </div>
+                </div>
+                <div class="pagination" id="pagination" style="display:none"></div>
+            </div>
+        </main>
+    </div>
+
+    <script>
+        const S = {
+            file: null,
+            logs: [],
+            total: 0,
+            page: 1,
+            pageSize: 200,
+            usePagination: true,
+            timer: null,
+            query: '',
+            level: '',
+            logger: '',
+            regex: false
+        };
+
+        // 加载文件列表
+        async function loadFiles() {
+            const res = await fetch('/api/files');
+            const files = await res.json();
+            const el = document.getElementById('fileList');
+            if (!files.length) {
+                el.innerHTML = '<div class="empty">无日志文件</div>';
+                return;
+            }
+            el.innerHTML = files.map(f => `
+                <div class="file-item" data-name="${f.name}" onclick="openFile('${f.name}')">
+                    <div class="name">${f.name}</div>
+                    <div class="meta">${f.size_human} · ${f.mtime_human.split(' ')[0]}</div>
+                </div>
+            `).join('');
+        }
+
+        async function openFile(name) {
+            S.file = name;
+            S.page = 1;
+            document.querySelectorAll('.file-item').forEach(el => {
+                el.classList.toggle('active', el.dataset.name === name);
+            });
+            await loadLoggers();
+            await loadStats();
+            await doSearch();
+        }
+
+        async function loadLoggers() {
+            const res = await fetch(`/api/loggers?file=${encodeURIComponent(S.file)}`);
+            const list = await res.json();
+            const sel = document.getElementById('loggerSelect');
+            sel.innerHTML = '<option value="">全部</option>' +
+                list.map(l => `<option value="${l.name}">${l.alias || l.name}</option>`).join('');
+        }
+
+        async function loadStats() {
+            const res = await fetch(`/api/stats?file=${encodeURIComponent(S.file)}`);
+            const stats = await res.json();
+            const bar = document.getElementById('statsBar');
+            const levels = ['debug','info','warning','error','critical'];
+            bar.innerHTML = `<span style="color:var(--text-dim)">共 ${stats.total.toLocaleString()} 条</span>` +
+                levels.filter(l => stats.by_level[l]).map(l =>
+                    `<div class="stat"><span class="stat-dot ${l}"></span>${l.toUpperCase()} ${stats.by_level[l]}</div>`
+                ).join('');
+        }
+
+        async function doSearch() {
+            if (!S.file) return;
+            S.query = document.getElementById('searchInput').value;
+            S.level = document.getElementById('levelSelect').value;
+            S.logger = document.getElementById('loggerSelect').value;
+            S.regex = document.getElementById('regexCheck').checked;
+
+            const limit = S.usePagination ? S.pageSize : 100000;
+            const offset = S.usePagination ? (S.page - 1) * S.pageSize : 0;
+
+            const params = new URLSearchParams({
+                file: S.file,
+                query: S.query,
+                level: S.level,
+                logger: S.logger,
+                regex: S.regex,
+                limit: limit,
+                offset: offset
+            });
+
+            document.getElementById('logList').innerHTML = '<div class="loading">加载中...</div>';
+
+            try {
+                const controller = new AbortController();
+                const timeoutId = setTimeout(() => controller.abort(), 30000);
+
+                const res = await fetch(`/api/logs?${params}`, { signal: controller.signal });
+                clearTimeout(timeoutId);
+
+                if (!res.ok) throw new Error(`HTTP ${res.status}`);
+                const data = await res.json();
+                S.logs = data.logs;
+                S.total = data.total;
+                renderLogs();
+                renderPagination();
+            } catch (err) {
+                console.error('加载失败:', err);
+                document.getElementById('logList').innerHTML =
+                    `<div class="empty">加载失败: ${err.message}<br><button class="btn" onclick="doSearch()">重试</button></div>`;
+            }
+        }
+
+        function renderLogs() {
+            const el = document.getElementById('logList');
+            if (!S.logs.length) {
+                el.innerHTML = '<div class="empty">无匹配结果</div>';
+                return;
+            }
+
+            el.innerHTML = S.logs.map(log => {
+                let msg = ansiToHtml(log.event);
+                if (S.query && !S.regex) {
+                    const re = new RegExp(`(${escRe(S.query)})`, 'gi');
+                    msg = msg.replace(re, '<span class="hl">$1</span>');
+                }
+                const name = log.alias || log.logger_name;
+                const color = log.color || 'inherit';
+                return `<div class="log-entry">
+                    <span class="log-time">${log.timestamp}</span>
+                    <span class="log-level ${log.level}">${log.level}</span>
+                    <span class="log-logger" style="color:${color}" title="${log.logger_name}">${name}</span>
+                    <span class="log-msg">${msg}</span>
+                </div>`;
+            }).join('');
+        }
+
+        function renderPagination() {
+            const el = document.getElementById('pagination');
+            if (!S.usePagination || S.total <= S.pageSize) {
+                el.style.display = 'none';
+                return;
+            }
+            el.style.display = 'flex';
+            const pages = Math.ceil(S.total / S.pageSize);
+            el.innerHTML = `
+                <button class="btn" onclick="goPage(1)" ${S.page<=1?'disabled':''}>首页</button>
+                <button class="btn" onclick="goPage(${S.page-1})" ${S.page<=1?'disabled':''}>上页</button>
+                <span class="info">第 ${S.page} / ${pages} 页 (${S.total.toLocaleString()} 条)</span>
+                <button class="btn" onclick="goPage(${S.page+1})" ${S.page>=pages?'disabled':''}>下页</button>
+                <button class="btn" onclick="goPage(${pages})" ${S.page>=pages?'disabled':''}>末页</button>
+            `;
+        }
+
+        function goPage(p) { S.page = p; doSearch(); }
+
+        function resetAndSearch() {
+            S.page = 1;
+            doSearch();
+        }
+
+        function clearSearch() {
+            document.getElementById('searchInput').value = '';
+            document.getElementById('levelSelect').value = '';
+            document.getElementById('loggerSelect').value = '';
+            document.getElementById('regexCheck').checked = false;
+            S.page = 1;
+            if (S.file) doSearch();
+        }
+
+        function togglePagination() {
+            S.usePagination = document.getElementById('paginationCheck').checked;
+            S.page = 1;
+            if (S.file) doSearch();
+        }
+
+        function updatePageSize() {
+            const v = parseInt(document.getElementById('pageSizeInput').value) || 200;
+            S.pageSize = Math.max(50, Math.min(5000, v));
+            S.page = 1;
+            if (S.file) doSearch();
+        }
+
+        function toggleAutoRefresh() {
+            const on = document.getElementById('autoRefreshCheck').checked;
+            document.getElementById('refreshBadge').style.display = on ? 'inline-flex' : 'none';
+            if (on) {
+                S.timer = setInterval(() => { if (S.file) doSearch(); }, 3000);
+            } else {
+                clearInterval(S.timer);
+                S.timer = null;
+            }
+        }
+
+        function esc(s) {
+            if (!s) return '';
+            return s.replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;');
+        }
+
+        // ANSI 颜色码转 HTML
+        function ansiToHtml(s) {
+            if (!s) return '';
+            // 先转义 HTML
+            s = esc(s);
+            // ANSI 颜色映射
+            const colors = {
+                '30': '#4d4d4d', '31': '#f85149', '32': '#3fb950', '33': '#d29922',
+                '34': '#58a6ff', '35': '#a371f7', '36': '#39c5cf', '37': '#c9d1d9',
+                '90': '#6e7681', '91': '#ff7b72', '92': '#56d364', '93': '#e3b341',
+                '94': '#79c0ff', '95': '#d2a8ff', '96': '#56d4dd', '97': '#ffffff'
+            };
+            const bgColors = {
+                '40': '#4d4d4d', '41': '#f85149', '42': '#3fb950', '43': '#d29922',
+                '44': '#58a6ff', '45': '#a371f7', '46': '#39c5cf', '47': '#c9d1d9'
+            };
+            let result = '';
+            let currentStyle = [];
+            // 匹配 ANSI 转义序列
+            const regex = /\\x1b\\[([0-9;]*)m|\\033\\[([0-9;]*)m|\\u001b\\[([0-9;]*)m|\\[([0-9;]*)m/g;
+            let lastIndex = 0;
+            let match;
+            while ((match = regex.exec(s)) !== null) {
+                result += s.slice(lastIndex, match.index);
+                const codes = (match[1] || match[2] || match[3] || match[4] || '0').split(';');
+                for (const code of codes) {
+                    if (code === '0' || code === '') {
+                        if (currentStyle.length > 0) {
+                            result += '</span>';
+                            currentStyle = [];
+                        }
+                    } else if (colors[code]) {
+                        if (currentStyle.length > 0) result += '</span>';
+                        result += `<span style="color:${colors[code]}">`;
+                        currentStyle = [code];
+                    } else if (bgColors[code]) {
+                        if (currentStyle.length > 0) result += '</span>';
+                        result += `<span style="background:${bgColors[code]}">`;
+                        currentStyle = [code];
+                    } else if (code === '1') {
+                        if (currentStyle.length > 0) result += '</span>';
+                        result += '<span style="font-weight:bold">';
+                        currentStyle = [code];
+                    }
+                }
+                lastIndex = regex.lastIndex;
+            }
+            result += s.slice(lastIndex);
+            if (currentStyle.length > 0) result += '</span>';
+            return result;
+        }
+
+        function escRe(s) {
+            return s.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');
+        }
+
+        loadFiles();
+    </script>
+</body>
+</html>
+"""
+
+
+class LogViewerHandler(SimpleHTTPRequestHandler):
+    """HTTP 请求处理器"""
+
+    log_reader: LogReader = None  # type: ignore
+
+    def log_message(self, format, *args):
+        """自定义日志格式"""
+        print(f"[{datetime.now().strftime('%H:%M:%S')}] {args[0]}")
+
+    def do_GET(self):
+        """处理 GET 请求"""
+        parsed = urlparse(self.path)
+        path = parsed.path
+        query = parse_qs(parsed.query)
+
+        # API 路由
+        if path == "/":
+            self.send_html(HTML_TEMPLATE)
+        elif path == "/api/files":
+            self.send_json(self.log_reader.get_log_files())
+        elif path == "/api/logs":
+            self.handle_logs_api(query)
+        elif path == "/api/loggers":
+            filename = query.get("file", [""])[0]
+            self.send_json(self.log_reader.get_loggers(filename))
+        elif path == "/api/stats":
+            filename = query.get("file", [""])[0]
+            self.send_json(self.log_reader.get_stats(filename))
+        else:
+            self.send_error(404, "Not Found")
+
+    def handle_logs_api(self, query: dict):
+        """处理日志搜索 API"""
+        filename = query.get("file", [""])[0]
+        search_query = query.get("query", [""])[0]
+        level = query.get("level", [""])[0]
+        logger = query.get("logger", [""])[0]
+        regex = query.get("regex", ["false"])[0].lower() == "true"
+        limit = int(query.get("limit", ["100"])[0])
+        offset = int(query.get("offset", ["0"])[0])
+
+        logs, total = self.log_reader.search_logs(
+            filename=filename,
+            query=search_query,
+            level=level,
+            logger=logger,
+            limit=limit,
+            offset=offset,
+            regex=regex,
+        )
+
+        # 转换为可序列化的格式
+        logs_data = [
+            {
+                "timestamp": log.timestamp,
+                "level": log.level,
+                "logger_name": log.logger_name,
+                "event": log.event,
+                "color": log.color,
+                "alias": log.alias,
+                "extra": log.extra,
+                "line_number": log.line_number,
+            }
+            for log in logs
+        ]
+
+        self.send_json({"logs": logs_data, "total": total})
+
+    def send_html(self, content: str):
+        """发送 HTML 响应"""
+        encoded = content.encode("utf-8")
+        self.send_response(200)
+        self.send_header("Content-Type", "text/html; charset=utf-8")
+        self.send_header("Content-Length", str(len(encoded)))
+        self.end_headers()
+        self.wfile.write(encoded)
+
+    def send_json(self, data: Any):
+        """发送 JSON 响应"""
+        content = json.dumps(data, ensure_ascii=False, default=str)
+        encoded = content.encode("utf-8")
+        self.send_response(200)
+        self.send_header("Content-Type", "application/json; charset=utf-8")
+        self.send_header("Content-Length", str(len(encoded)))
+        self.end_headers()
+        self.wfile.write(encoded)
+
+
+def run_server(host: str = "127.0.0.1", port: int = 8765, open_browser: bool = True):
+    """启动 HTTP 服务器"""
+    # 初始化日志读取器
+    LogViewerHandler.log_reader = LogReader(LOG_DIR)
+
+    server = HTTPServer((host, port), LogViewerHandler)
+    url = f"http://{host}:{port}"
+
+    print(f"\n  📋 日志查看器已启动: {url}\n")
+
+    # 自动打开浏览器
+    if open_browser:
+        webbrowser.open(url)
+
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        print("\n  服务器已停止")
+        server.shutdown()
+
+
+def main():
+    parser = argparse.ArgumentParser(description="日志查看器")
+    parser.add_argument("--host", default="127.0.0.1", help="服务器地址 (默认: 127.0.0.1)")
+    parser.add_argument("--port", type=int, default=8765, help="服务器端口 (默认: 8765)")
+    parser.add_argument("--no-browser", action="store_true", help="不自动打开浏览器")
+    args = parser.parse_args()
+
+    run_server(args.host, args.port, open_browser=not args.no_browser)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/__init__.py b/src/__init__.py
index 907af17a3..0ac0c9576 100644
--- a/src/__init__.py
+++ b/src/__init__.py
@@ -8,7 +8,7 @@ from src.common.logger import get_logger
 egg = get_logger("小彩蛋")
 
 
-def weighted_choice(data: Sequence[str], weights: list[float] | None = None) -> str:
+def weighted_choice(data: Sequence[str], weights: Sequence[float] | None = None) -> str:
     """
     从 data 中按权重随机返回一条。
     若 weights 为 None，则所有元素权重默认为 1。
diff --git a/src/api/memory_visualizer_router.py b/src/api/memory_visualizer_router.py
index 9a74d9596..2a197651e 100644
--- a/src/api/memory_visualizer_router.py
+++ b/src/api/memory_visualizer_router.py
@@ -63,7 +63,7 @@ def find_available_data_files() -> list[Path]:
     return sorted(files, key=lambda f: f.stat().st_mtime, reverse=True)
 
 
-def load_graph_data_from_file(file_path: Path | None = None) -> dict[str, Any]:
+async def load_graph_data_from_file(file_path: Path | None = None) -> dict[str, Any]:
     """从磁盘加载图数据"""
     global graph_data_cache, current_data_file
 
diff --git a/src/api/message_router.py b/src/api/message_router.py
index 5e707cc95..b01103864 100644
--- a/src/api/message_router.py
+++ b/src/api/message_router.py
@@ -31,6 +31,8 @@ async def get_message_stats(
 
         sent_count = 0
         received_count = 0
+        if global_config is None:
+            raise HTTPException(status_code=500, detail="Global config is not initialized")
         bot_qq = str(global_config.bot.qq_account)
 
         for msg in messages:
@@ -73,6 +75,8 @@ async def get_message_stats_by_chat(
         start_time = end_time - (days * 24 * 3600)
         # 从数据库获取指定时间范围内的所有消息
         messages = await message_api.get_messages_by_time(start_time, end_time)
+        if global_config is None:
+            raise HTTPException(status_code=500, detail="Global config is not initialized")
         bot_qq = str(global_config.bot.qq_account)
 
         # --- 2. 消息筛选 ---
diff --git a/src/chat/chatter_manager.py b/src/chat/chatter_manager.py
index 8cdf3fe43..18d3b8f09 100644
--- a/src/chat/chatter_manager.py
+++ b/src/chat/chatter_manager.py
@@ -111,7 +111,7 @@ class ChatterManager:
         inactive_streams = []
         for stream_id, instance in self.instances.items():
             if hasattr(instance, "get_activity_time"):
-                activity_time = instance.get_activity_time()
+                activity_time = getattr(instance, "get_activity_time")()
                 if (current_time - activity_time) > max_inactive_seconds:
                     inactive_streams.append(stream_id)
 
diff --git a/src/chat/emoji_system/emoji_manager.py b/src/chat/emoji_system/emoji_manager.py
index 6a9437757..125907a6d 100644
--- a/src/chat/emoji_system/emoji_manager.py
+++ b/src/chat/emoji_system/emoji_manager.py
@@ -9,7 +9,7 @@ import random
 import re
 import time
 import traceback
-from typing import Any, Optional
+from typing import Any, Optional, cast
 
 from PIL import Image
 from rich.traceback import install
@@ -401,6 +401,11 @@ class EmojiManager:
 
         self._scan_task = None
 
+        if model_config is None:
+            raise RuntimeError("Model config is not initialized")
+        if global_config is None:
+            raise RuntimeError("Global config is not initialized")
+
         self.vlm = LLMRequest(model_set=model_config.model_task_config.emoji_vlm, request_type="emoji")
         self.llm_emotion_judge = LLMRequest(
             model_set=model_config.model_task_config.utils, request_type="emoji"
@@ -480,6 +485,8 @@ class EmojiManager:
                 return None
 
             # 2. 根据全局配置决定候选表情包的数量
+            if global_config is None:
+                raise RuntimeError("Global config is not initialized")
             max_candidates = global_config.emoji.max_context_emojis
 
             # 如果配置为0或者大于等于总数，则选择所有表情包
@@ -622,6 +629,8 @@ class EmojiManager:
 
     async def start_periodic_check_register(self) -> None:
         """定期检查表情包完整性和数量"""
+        if global_config is None:
+            raise RuntimeError("Global config is not initialized")
         await self.get_all_emoji_from_db()
         while True:
             # logger.info("[扫描] 开始检查表情包完整性...")
@@ -771,8 +780,9 @@ class EmojiManager:
             try:
                 emoji_record = await self.get_emoji_from_db(emoji_hash)
                 if emoji_record and emoji_record[0].emotion:
-                    logger.info(f"[缓存命中] 从数据库获取表情包描述: {emoji_record.emotion[:50]}...")  # type: ignore # type: ignore
-                    return emoji_record.emotion # type: ignore
+                    emotion_str = ",".join(emoji_record[0].emotion)
+                    logger.info(f"[缓存命中] 从数据库获取表情包描述: {emotion_str[:50]}...")
+                    return emotion_str
             except Exception as e:
                 logger.error(f"从数据库查询表情包描述时出错: {e}")
 
@@ -803,7 +813,7 @@ class EmojiManager:
             try:
                 from src.common.database.api.query import QueryBuilder
 
-                emoji_record = await QueryBuilder(Emoji).filter(emoji_hash=emoji_hash).first()
+                emoji_record = cast(Emoji | None, await QueryBuilder(Emoji).filter(emoji_hash=emoji_hash).first())
                 if emoji_record and emoji_record.description:
                     logger.info(f"[缓存命中] 从数据库获取表情包描述: {emoji_record.description[:50]}...")
                     return emoji_record.description
@@ -880,6 +890,9 @@ class EmojiManager:
             # 将表情包信息转换为可读的字符串
             emoji_info_list = _emoji_objects_to_readable_list(selected_emojis)
 
+            if global_config is None:
+                raise RuntimeError("Global config is not initialized")
+
             # 构建提示词
             prompt = (
                 f"{global_config.bot.nickname}的表情包存储已满({self.emoji_num}/{self.emoji_num_max})，"
@@ -954,6 +967,8 @@ class EmojiManager:
             Tuple[str, List[str]]: 返回一个元组，第一个元素是详细描述，第二个元素是情感关键词列表。
                                    如果处理失败，则返回空的描述和列表。
         """
+        if global_config is None:
+            raise RuntimeError("Global config is not initialized")
         try:
             # 1. 解码图片，计算哈希值，并获取格式
             if isinstance(image_base64, str):
@@ -967,7 +982,7 @@ class EmojiManager:
             try:
                 from src.common.database.api.query import QueryBuilder
 
-                existing_image = await QueryBuilder(Images).filter(emoji_hash=image_hash, type="emoji").first()
+                existing_image = cast(Images | None, await QueryBuilder(Images).filter(emoji_hash=image_hash, type="emoji").first())
                 if existing_image and existing_image.description:
                     existing_description = existing_image.description
                     logger.info(f"[复用描述] 找到已有详细描述: {existing_description[:50]}...")
diff --git a/src/chat/energy_system/energy_manager.py b/src/chat/energy_system/energy_manager.py
index 21e7f6e31..8f2fbe268 100644
--- a/src/chat/energy_system/energy_manager.py
+++ b/src/chat/energy_system/energy_manager.py
@@ -7,7 +7,7 @@ import time
 from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
 from enum import Enum
-from typing import Any, TypedDict
+from typing import Any, Awaitable, TypedDict, cast
 
 from src.common.database.api.crud import CRUDBase
 from src.common.logger import get_logger
@@ -70,7 +70,7 @@ class EnergyCalculator(ABC):
     """能量计算器抽象基类"""
 
     @abstractmethod
-    def calculate(self, context: dict[str, Any]) -> float:
+    def calculate(self, context: "EnergyContext") -> float | Awaitable[float]:
         """计算能量值"""
         pass
 
@@ -83,7 +83,7 @@ class EnergyCalculator(ABC):
 class InterestEnergyCalculator(EnergyCalculator):
     """兴趣度能量计算器"""
 
-    def calculate(self, context: dict[str, Any]) -> float:
+    def calculate(self, context: "EnergyContext") -> float:
         """基于消息兴趣度计算能量"""
         messages = context.get("messages", [])
         if not messages:
@@ -117,7 +117,7 @@ class ActivityEnergyCalculator(EnergyCalculator):
     def __init__(self):
         self.action_weights = {"reply": 0.4, "react": 0.3, "mention": 0.2, "other": 0.1}
 
-    def calculate(self, context: dict[str, Any]) -> float:
+    def calculate(self, context: "EnergyContext") -> float:
         """基于活跃度计算能量"""
         messages = context.get("messages", [])
         if not messages:
@@ -147,7 +147,7 @@ class ActivityEnergyCalculator(EnergyCalculator):
 class RecencyEnergyCalculator(EnergyCalculator):
     """最近性能量计算器"""
 
-    def calculate(self, context: dict[str, Any]) -> float:
+    def calculate(self, context: "EnergyContext") -> float:
         """基于最近性计算能量"""
         messages = context.get("messages", [])
         if not messages:
@@ -194,7 +194,7 @@ class RecencyEnergyCalculator(EnergyCalculator):
 class RelationshipEnergyCalculator(EnergyCalculator):
     """关系能量计算器 - 基于聊天流兴趣度"""
 
-    async def calculate(self, context: dict[str, Any]) -> float:
+    async def calculate(self, context: "EnergyContext") -> float:
         """基于聊天流兴趣度计算能量"""
         stream_id = context.get("stream_id")
         if not stream_id:
@@ -260,6 +260,8 @@ class EnergyManager:
     def _load_thresholds_from_config(self) -> None:
         """从配置加载AFC阈值"""
         try:
+            if global_config is None:
+                return
             if hasattr(global_config, "affinity_flow") and global_config.affinity_flow is not None:
                 self.thresholds["high_match"] = getattr(
                     global_config.affinity_flow, "high_match_interest_threshold", 0.8
@@ -283,17 +285,17 @@ class EnergyManager:
         start_time = time.time()
 
         # 更新统计
-        self.stats["total_calculations"] += 1
+        self.stats["total_calculations"] = cast(int, self.stats["total_calculations"]) + 1
 
         # 检查缓存
         if stream_id in self.energy_cache:
             cached_energy, cached_time = self.energy_cache[stream_id]
             if time.time() - cached_time < self.cache_ttl:
-                self.stats["cache_hits"] += 1
+                self.stats["cache_hits"] = cast(int, self.stats["cache_hits"]) + 1
                 logger.debug(f"使用缓存能量: {stream_id} = {cached_energy:.3f}")
                 return cached_energy
         else:
-            self.stats["cache_misses"] += 1
+            self.stats["cache_misses"] = cast(int, self.stats["cache_misses"]) + 1
 
         # 构建计算上下文
         context: EnergyContext = {
@@ -358,9 +360,10 @@ class EnergyManager:
 
         # 更新平均计算时间
         calculation_time = time.time() - start_time
-        total_calculations = self.stats["total_calculations"]
+        total_calculations = cast(int, self.stats["total_calculations"])
+        current_avg = cast(float, self.stats["average_calculation_time"])
         self.stats["average_calculation_time"] = (
-            self.stats["average_calculation_time"] * (total_calculations - 1) + calculation_time
+            current_avg * (total_calculations - 1) + calculation_time
         ) / total_calculations
 
         logger.debug(
@@ -424,8 +427,11 @@ class EnergyManager:
         final_interval = base_interval * jitter
 
         # 确保在配置范围内
-        min_interval = getattr(global_config.chat, "dynamic_distribution_min_interval", 1.0)
-        max_interval = getattr(global_config.chat, "dynamic_distribution_max_interval", 60.0)
+        min_interval = 1.0
+        max_interval = 60.0
+        if global_config is not None and hasattr(global_config, "chat"):
+            min_interval = getattr(global_config.chat, "dynamic_distribution_min_interval", 1.0)
+            max_interval = getattr(global_config.chat, "dynamic_distribution_max_interval", 60.0)
 
         return max(min_interval, min(max_interval, final_interval))
 
@@ -487,10 +493,12 @@ class EnergyManager:
 
     def get_cache_hit_rate(self) -> float:
         """获取缓存命中率"""
-        total_requests = self.stats.get("cache_hits", 0) + self.stats.get("cache_misses", 0)
+        hits = cast(int, self.stats.get("cache_hits", 0))
+        misses = cast(int, self.stats.get("cache_misses", 0))
+        total_requests = hits + misses
         if total_requests == 0:
             return 0.0
-        return self.stats["cache_hits"] / total_requests
+        return hits / total_requests
 
 
 # 全局能量管理器实例
diff --git a/src/chat/express/expression_learner.py b/src/chat/express/expression_learner.py
index b0da82652..8ddf296d9 100644
--- a/src/chat/express/expression_learner.py
+++ b/src/chat/express/expression_learner.py
@@ -110,6 +110,8 @@ def init_prompt() -> None:
 
 class ExpressionLearner:
     def __init__(self, chat_id: str) -> None:
+        if model_config is None:
+            raise RuntimeError("Model config is not initialized")
         self.express_learn_model: LLMRequest = LLMRequest(
             model_set=model_config.model_task_config.replyer, request_type="expressor.learner"
         )
@@ -143,7 +145,10 @@ class ExpressionLearner:
         """
         # 从配置读取过期天数
         if expiration_days is None:
-            expiration_days = global_config.expression.expiration_days
+            if global_config is None:
+                expiration_days = 30  # Default value if config is missing
+            else:
+                expiration_days = global_config.expression.expiration_days
 
         current_time = time.time()
         expiration_threshold = current_time - (expiration_days * 24 * 3600)
@@ -192,6 +197,8 @@ class ExpressionLearner:
             bool: 是否允许学习
         """
         try:
+            if global_config is None:
+                return False
             use_expression, enable_learning, _ = global_config.expression.get_expression_config_for_chat(self.chat_id)
             return enable_learning
         except Exception as e:
@@ -212,6 +219,8 @@ class ExpressionLearner:
 
         # 获取该聊天流的学习强度
         try:
+            if global_config is None:
+                return False
             use_expression, enable_learning, learning_intensity = (
                 global_config.expression.get_expression_config_for_chat(self.chat_id)
             )
@@ -424,8 +433,10 @@ class ExpressionLearner:
             group_name = f"聊天流 {chat_id}"
         elif chat_stream.group_info:
             group_name = chat_stream.group_info.group_name
-        else:
+        elif chat_stream.user_info and chat_stream.user_info.user_nickname:
             group_name = f"{chat_stream.user_info.user_nickname}的私聊"
+        else:
+            group_name = f"聊天流 {chat_id}"
         learnt_expressions_str = ""
         for _chat_id, situation, style in learnt_expressions:
             learnt_expressions_str += f"{situation}->{style}\n"
diff --git a/src/chat/express/expression_selector.py b/src/chat/express/expression_selector.py
index fe8500194..83fd0c4b8 100644
--- a/src/chat/express/expression_selector.py
+++ b/src/chat/express/expression_selector.py
@@ -78,6 +78,8 @@ def weighted_sample(population: list[dict], weights: list[float], k: int) -> lis
 class ExpressionSelector:
     def __init__(self, chat_id: str = ""):
         self.chat_id = chat_id
+        if model_config is None:
+            raise RuntimeError("Model config is not initialized")
         self.llm_model = LLMRequest(
             model_set=model_config.model_task_config.utils_small, request_type="expression.selector"
         )
@@ -94,6 +96,8 @@ class ExpressionSelector:
             bool: 是否允许使用表达
         """
         try:
+            if global_config is None:
+                return False
             use_expression, _, _ = global_config.expression.get_expression_config_for_chat(chat_id)
             return use_expression
         except Exception as e:
@@ -122,6 +126,8 @@ class ExpressionSelector:
 
     def get_related_chat_ids(self, chat_id: str) -> list[str]:
         """根据expression.rules配置，获取与当前chat_id相关的所有chat_id（包括自身）"""
+        if global_config is None:
+            return [chat_id]
         rules = global_config.expression.rules
         current_group = None
 
@@ -280,6 +286,9 @@ class ExpressionSelector:
         else:
             chat_info = chat_history
 
+        if global_config is None:
+            raise RuntimeError("Global config is not initialized")
+
         # 根据配置选择模式
         mode = global_config.expression.mode
         logger.debug(f"使用表达选择模式: {mode}")
@@ -582,6 +591,9 @@ class ExpressionSelector:
             target_message_str = ""
             target_message_extra_block = ""
 
+        if global_config is None:
+            raise RuntimeError("Global config is not initialized")
+
         # 3. 构建prompt（只包含情境，不包含完整的表达方式）
         prompt = (await global_prompt_manager.get_prompt_async("expression_evaluation_prompt")).format(
             bot_name=global_config.bot.nickname,
diff --git a/src/chat/express/situation_extractor.py b/src/chat/express/situation_extractor.py
index f9924090c..2fd6c9205 100644
--- a/src/chat/express/situation_extractor.py
+++ b/src/chat/express/situation_extractor.py
@@ -42,6 +42,8 @@ class SituationExtractor:
     """情境提取器，从聊天历史中提取当前情境"""
 
     def __init__(self):
+        if model_config is None:
+            raise RuntimeError("Model config is not initialized")
         self.llm_model = LLMRequest(
             model_set=model_config.model_task_config.utils_small,
             request_type="expression.situation_extractor"
@@ -81,6 +83,8 @@ class SituationExtractor:
 
         # 构建 prompt
         try:
+            if global_config is None:
+                raise RuntimeError("Global config is not initialized")
             prompt = (await global_prompt_manager.get_prompt_async("situation_extraction_prompt")).format(
                 bot_name=global_config.bot.nickname,
                 chat_history=chat_info,
diff --git a/src/chat/interest_system/bot_interest_manager.py b/src/chat/interest_system/bot_interest_manager.py
index 21b1e9a6a..7843588be 100644
--- a/src/chat/interest_system/bot_interest_manager.py
+++ b/src/chat/interest_system/bot_interest_manager.py
@@ -5,7 +5,7 @@
 
 import traceback
 from datetime import datetime
-from typing import Any
+from typing import Any, cast
 
 import numpy as np
 from sqlalchemy import select
@@ -77,6 +77,9 @@ class BotInterestManager:
         from src.config.config import model_config
         from src.llm_models.utils_model import LLMRequest
 
+        if model_config is None:
+            raise RuntimeError("Model config is not initialized")
+
         # 检查embedding配置是否存在
         if not hasattr(model_config.model_task_config, "embedding"):
             raise RuntimeError("❌ 未找到embedding模型配置")
@@ -251,6 +254,9 @@ class BotInterestManager:
             from src.config.config import model_config
             from src.plugin_system.apis import llm_api
 
+            if model_config is None:
+                raise RuntimeError("Model config is not initialized")
+
             # 构建完整的提示词，明确要求只返回纯JSON
             full_prompt = f"""你是一个专业的机器人人设分析师，擅长根据人设描述生成合适的兴趣标签。
 
@@ -348,9 +354,15 @@ class BotInterestManager:
         embedding, model_name = await self.embedding_request.get_embedding(text)
 
         if embedding and len(embedding) > 0:
-            self.embedding_cache[text] = embedding
+            if isinstance(embedding[0], list):
+                # If it's a list of lists, take the first one (though get_embedding(str) should return list[float])
+                embedding = embedding[0]
+            
+            # Now we can safely cast to list[float] as we've handled the nested list case
+            embedding_float = cast(list[float], embedding)
+            self.embedding_cache[text] = embedding_float
 
-            current_dim = len(embedding)
+            current_dim = len(embedding_float)
             if self._detected_embedding_dimension is None:
                 self._detected_embedding_dimension = current_dim
                 if self.embedding_dimension and self.embedding_dimension != current_dim:
@@ -367,7 +379,7 @@ class BotInterestManager:
                     self.embedding_dimension,
                     current_dim,
                 )
-            return embedding
+            return embedding_float
         else:
             raise RuntimeError(f"❌ 返回的embedding为空: {embedding}")
 
@@ -416,7 +428,10 @@ class BotInterestManager:
 
             for idx_offset, message_id in enumerate(chunk_keys):
                 vector = normalized[idx_offset] if idx_offset < len(normalized) else []
-                results[message_id] = vector
+                if isinstance(vector, list) and vector and isinstance(vector[0], float):
+                     results[message_id] = cast(list[float], vector)
+                else:
+                     results[message_id] = []
 
         return results
 
@@ -493,6 +508,9 @@ class BotInterestManager:
         medium_similarity_count = 0
         low_similarity_count = 0
 
+        if global_config is None:
+            raise RuntimeError("Global config is not initialized")
+
         # 分级相似度阈值 - 优化后可以提高阈值，因为匹配更准确了
         affinity_config = global_config.affinity_flow
         high_threshold = affinity_config.high_match_interest_threshold
@@ -711,6 +729,9 @@ class BotInterestManager:
         if not keywords or not matched_tags:
             return {}
 
+        if global_config is None:
+            return {}
+
         affinity_config = global_config.affinity_flow
         bonus_dict = {}
 
@@ -1010,7 +1031,10 @@ class BotInterestManager:
             # 验证缓存版本和embedding模型
             cache_version = cache_data.get("version", 1)
             cache_embedding_model = cache_data.get("embedding_model", "")
-            current_embedding_model = self.embedding_config.model_list[0] if hasattr(self.embedding_config, "model_list") else ""
+            
+            current_embedding_model = ""
+            if self.embedding_config and hasattr(self.embedding_config, "model_list") and self.embedding_config.model_list:
+                 current_embedding_model = self.embedding_config.model_list[0]
 
             if cache_embedding_model != current_embedding_model:
                 logger.warning(f"⚠️ Embedding模型已变更 ({cache_embedding_model} → {current_embedding_model})，忽略旧缓存")
@@ -1044,7 +1068,10 @@ class BotInterestManager:
             cache_file = cache_dir / f"{personality_id}_embeddings.json"
 
             # 准备缓存数据
-            current_embedding_model = self.embedding_config.model_list[0] if hasattr(self.embedding_config, "model_list") and self.embedding_config.model_list else ""
+            current_embedding_model = ""
+            if self.embedding_config and hasattr(self.embedding_config, "model_list") and self.embedding_config.model_list:
+                 current_embedding_model = self.embedding_config.model_list[0]
+
             cache_data = {
                 "version": 1,
                 "personality_id": personality_id,
diff --git a/src/chat/interest_system/interest_manager.py b/src/chat/interest_system/interest_manager.py
index fee57e8d7..8c749af36 100644
--- a/src/chat/interest_system/interest_manager.py
+++ b/src/chat/interest_system/interest_manager.py
@@ -144,6 +144,15 @@ class InterestManager:
         start_time = time.time()
         self._total_calculations += 1
 
+        if not self._current_calculator:
+            return InterestCalculationResult(
+                success=False,
+                message_id=getattr(message, "message_id", ""),
+                interest_value=0.0,
+                error_message="没有可用的兴趣值计算组件",
+                calculation_time=time.time() - start_time,
+            )
+
         try:
             # 使用组件的安全执行方法
             result = await self._current_calculator._safe_execute(message)
diff --git a/src/chat/knowledge/embedding_store.py b/src/chat/knowledge/embedding_store.py
index b286fa968..1751b198d 100644
--- a/src/chat/knowledge/embedding_store.py
+++ b/src/chat/knowledge/embedding_store.py
@@ -2,6 +2,7 @@ import asyncio
 import math
 import os
 from dataclasses import dataclass
+from typing import Any
 
 # import tqdm
 import aiofiles
@@ -121,7 +122,7 @@ class EmbeddingStore:
 
         self.store = {}
 
-        self.faiss_index = None
+        self.faiss_index: Any = None
         self.idx2hash = None
 
     @staticmethod
@@ -158,6 +159,8 @@ class EmbeddingStore:
         from src.config.config import model_config
         from src.llm_models.utils_model import LLMRequest
 
+        assert model_config is not None
+
         # 限制 chunk_size 和 max_workers 在合理范围内
         chunk_size = max(MIN_CHUNK_SIZE, min(chunk_size, MAX_CHUNK_SIZE))
         max_workers = max(MIN_WORKERS, min(max_workers, MAX_WORKERS))
@@ -402,6 +405,7 @@ class EmbeddingStore:
 
     def build_faiss_index(self) -> None:
         """重新构建Faiss索引，以余弦相似度为度量"""
+        assert global_config is not None
         # 获取所有的embedding
         array = []
         self.idx2hash = {}
diff --git a/src/chat/knowledge/kg_manager.py b/src/chat/knowledge/kg_manager.py
index 87be8a405..05e7fe98c 100644
--- a/src/chat/knowledge/kg_manager.py
+++ b/src/chat/knowledge/kg_manager.py
@@ -1,5 +1,6 @@
 import os
 import time
+from typing import cast
 
 import numpy as np
 import orjson
@@ -139,6 +140,9 @@ class KGManager:
         embedding_manager: EmbeddingManager,
     ) -> int:
         """同义词连接"""
+        if global_config is None:
+            raise RuntimeError("Global config is not initialized")
+
         new_edge_cnt = 0
         # 获取所有实体节点的hash值
         ent_hash_list = set()
@@ -242,7 +246,8 @@ class KGManager:
             else:
                 # 已存在的边
                 edge_item = self.graph[src_tgt[0], src_tgt[1]]
-                edge_item["weight"] += weight
+                edge_item = cast(di_graph.DiEdge, edge_item)
+                edge_item["weight"] = cast(float, edge_item["weight"]) + weight
                 edge_item["update_time"] = now_time
                 self.graph.update_edge(edge_item)
 
@@ -258,6 +263,7 @@ class KGManager:
                             continue
                         assert isinstance(node, EmbeddingStoreItem)
                         node_item = self.graph[node_hash]
+                        node_item = cast(di_graph.DiNode, node_item)
                         node_item["content"] = node.str
                         node_item["type"] = "ent"
                         node_item["create_time"] = now_time
@@ -271,6 +277,7 @@ class KGManager:
                         assert isinstance(node, EmbeddingStoreItem)
                         content = node.str.replace("\n", " ")
                         node_item = self.graph[node_hash]
+                        node_item = cast(di_graph.DiNode, node_item)
                         node_item["content"] = content if len(content) < 8 else content[:8] + "..."
                         node_item["type"] = "pg"
                         node_item["create_time"] = now_time
@@ -326,6 +333,9 @@ class KGManager:
             paragraph_search_result: ParagraphEmbedding的搜索结果（paragraph_hash, similarity）
             embed_manager: EmbeddingManager对象
         """
+        if global_config is None:
+            raise RuntimeError("Global config is not initialized")
+
         # 图中存在的节点总集
         existed_nodes = self.graph.get_node_list()
 
@@ -339,9 +349,12 @@ class KGManager:
 
         # 针对每个关系，提取出其中的主宾短语作为两个实体，并记录对应的三元组的相似度作为权重依据
         ent_sim_scores = {}
-        for relation_hash, similarity, _ in relation_search_result:
+        for relation_hash, similarity in relation_search_result:
             # 提取主宾短语
-            relation = embed_manager.relation_embedding_store.store.get(relation_hash).str
+            relation_item = embed_manager.relation_embedding_store.store.get(relation_hash)
+            if relation_item is None:
+                continue
+            relation = relation_item.str
             assert relation is not None  # 断言：relation不为空
             # 关系三元组
             triple = relation[2:-2].split("', '")
diff --git a/src/chat/knowledge/knowledge_lib.py b/src/chat/knowledge/knowledge_lib.py
index a1f49f314..51fdb34b1 100644
--- a/src/chat/knowledge/knowledge_lib.py
+++ b/src/chat/knowledge/knowledge_lib.py
@@ -36,6 +36,9 @@ def initialize_lpmm_knowledge():
     """初始化LPMM知识库"""
     global qa_manager, inspire_manager
 
+    if global_config is None:
+        raise RuntimeError("Global config is not initialized")
+
     # 检查LPMM知识库是否启用
     if global_config.lpmm_knowledge.enable:
         logger.info("正在初始化Mai-LPMM")
diff --git a/src/chat/knowledge/qa_manager.py b/src/chat/knowledge/qa_manager.py
index 56fa6275f..35e268c24 100644
--- a/src/chat/knowledge/qa_manager.py
+++ b/src/chat/knowledge/qa_manager.py
@@ -1,5 +1,5 @@
 import time
-from typing import Any
+from typing import Any, cast
 
 from src.chat.utils.utils import get_embedding
 from src.config.config import global_config, model_config
@@ -21,6 +21,8 @@ class QAManager:
         embed_manager: EmbeddingManager,
         kg_manager: KGManager,
     ):
+        if model_config is None:
+            raise RuntimeError("Model config is not initialized")
         self.embed_manager = embed_manager
         self.kg_manager = kg_manager
         self.qa_model = LLMRequest(model_set=model_config.model_task_config.lpmm_qa, request_type="lpmm.qa")
@@ -29,6 +31,8 @@ class QAManager:
         self, question: str
     ) -> tuple[list[tuple[str, float, float]], dict[str, float] | None] | None:
         """处理查询"""
+        if global_config is None:
+            raise RuntimeError("Global config is not initialized")
 
         # 生成问题的Embedding
         part_start_time = time.perf_counter()
@@ -61,7 +65,7 @@ class QAManager:
         for res in relation_search_res:
             if store_item := self.embed_manager.relation_embedding_store.store.get(res[0]):
                 rel_str = store_item.str
-            print(f"找到相关关系，相似度：{(res[1] * 100):.2f}%  -  {rel_str}")
+                print(f"找到相关关系，相似度：{(res[1] * 100):.2f}%  -  {rel_str}")
 
         # TODO: 使用LLM过滤三元组结果
         # logger.info(f"LLM过滤三元组用时：{time.time() - part_start_time:.2f}s")
@@ -80,8 +84,52 @@ class QAManager:
             logger.info("找到相关关系，将使用RAG进行检索")
             # 使用KG检索
             part_start_time = time.perf_counter()
+            # Cast relation_search_res to the expected type for kg_search
+            # The search_top_k returns list[tuple[Any, float, float]], but kg_search expects list[tuple[tuple[str, str, str], float]]
+            # We assume the ID (res[0]) in relation_search_res is actually a tuple[str, str, str] (the relation triple)
+            # or at least compatible. However, looking at kg_manager.py, it expects relation_hash (str) in relation_search_result?
+            # Wait, let's check kg_manager.py again.
+            # kg_search signature: relation_search_result: list[tuple[tuple[str, str, str], float]]
+            # But in kg_manager.py:
+            # for relation_hash, similarity, _ in relation_search_result:
+            #    relation = embed_manager.relation_embedding_store.store.get(relation_hash).str
+            # This implies relation_search_result items are tuples of (relation_hash, similarity, ...)
+            # So the type hint in kg_manager.py might be wrong or I am misinterpreting it.
+            # The error says: "tuple[Any, float, float]" vs "tuple[tuple[str, str, str], float]"
+            # It seems kg_search expects the first element to be a tuple of strings?
+            # But the implementation uses it as a hash key to look up in store.
+            # Let's look at kg_manager.py again.
+            
+            # In kg_manager.py:
+            # def kg_search(self, relation_search_result: list[tuple[tuple[str, str, str], float]], ...)
+            # ...
+            # for relation_hash, similarity in relation_search_result:
+            #    relation_item = embed_manager.relation_embedding_store.store.get(relation_hash)
+            
+            # Wait, I just fixed kg_manager.py to:
+            # for relation_hash, similarity in relation_search_result:
+            
+            # So it expects a tuple of 2 elements?
+            # But search_top_k returns (id, score, vector).
+            # So relation_search_res is list[tuple[Any, float, float]].
+            
+            # I need to adapt the data or cast it.
+            # If I pass it directly, it has 3 elements.
+            # If kg_manager expects 2, I should probably slice it.
+            
+            # Let's cast it for now to silence the error, assuming the runtime behavior is compatible (unpacking first 2 of 3 is fine in python if not strict, but here it is strict unpacking in loop?)
+            # In kg_manager.py I changed it to:
+            # for relation_hash, similarity in relation_search_result:
+            # This will fail if the tuple has 3 elements! "too many values to unpack"
+            
+            # So I should probably fix the data passed to kg_search to be list[tuple[str, float]].
+            
+            relation_search_result_for_kg = [(str(res[0]), float(res[1])) for res in relation_search_res]
+            
             result, ppr_node_weights = self.kg_manager.kg_search(
-                relation_search_res, paragraph_search_res, self.embed_manager
+                cast(list[tuple[tuple[str, str, str], float]], relation_search_result_for_kg), # The type hint in kg_manager is weird, but let's match it or cast to Any
+                paragraph_search_res, 
+                self.embed_manager
             )
             part_end_time = time.perf_counter()
             logger.info(f"RAG检索用时：{part_end_time - part_start_time:.5f}s")
diff --git a/src/chat/message_manager/batch_database_writer.py b/src/chat/message_manager/batch_database_writer.py
index 0d379c01a..f5b9e1c18 100644
--- a/src/chat/message_manager/batch_database_writer.py
+++ b/src/chat/message_manager/batch_database_writer.py
@@ -51,13 +51,13 @@ class BatchDatabaseWriter:
         self.writer_task: asyncio.Task | None = None
 
         # 统计信息
-        self.stats = {
+        self.stats: dict[str, int | float] = {
             "total_writes": 0,
             "batch_writes": 0,
             "failed_writes": 0,
             "queue_size": 0,
-            "avg_batch_size": 0,
-            "last_flush_time": 0,
+            "avg_batch_size": 0.0,
+            "last_flush_time": 0.0,
         }
 
         # 按优先级分类的批次
@@ -220,6 +220,9 @@ class BatchDatabaseWriter:
 
     async def _batch_write_to_database(self, payloads: list[StreamUpdatePayload]):
         """批量写入数据库"""
+        if global_config is None:
+            raise RuntimeError("Global config is not initialized")
+
         async with get_db_session() as session:
             for payload in payloads:
                 stream_id = payload.stream_id
@@ -254,11 +257,11 @@ class BatchDatabaseWriter:
                     stmt = stmt.on_conflict_do_update(index_elements=["stream_id"], set_=update_data)
 
                 await session.execute(stmt)
-
-            await session.commit()
-
     async def _direct_write(self, stream_id: str, update_data: dict[str, Any]):
         """直接写入数据库（降级方案）"""
+        if global_config is None:
+            raise RuntimeError("Global config is not initialized")
+
         async with get_db_session() as session:
             if global_config.database.database_type == "sqlite":
                 from sqlalchemy.dialects.sqlite import insert as sqlite_insert
diff --git a/src/chat/message_manager/distribution_manager.py b/src/chat/message_manager/distribution_manager.py
index 5af3bb7d4..fc43e0959 100644
--- a/src/chat/message_manager/distribution_manager.py
+++ b/src/chat/message_manager/distribution_manager.py
@@ -23,6 +23,9 @@ class StreamLoopManager:
     """流循环管理器 - 每个流一个独立的无限循环任务"""
 
     def __init__(self, max_concurrent_streams: int | None = None):
+        if global_config is None:
+            raise RuntimeError("Global config is not initialized")
+
         # 统计信息
         self.stats: dict[str, Any] = {
             "active_streams": 0,
@@ -570,7 +573,6 @@ class StreamLoopManager:
         except Exception as e:
             logger.warning(f"刷新StreamContext缓存失败: stream={stream_id}, error={e}")
             return []
-
     async def _update_stream_energy(self, stream_id: str, context: Any) -> None:
         """更新流的能量值
 
@@ -578,6 +580,9 @@ class StreamLoopManager:
             stream_id: 流ID
             context: 流上下文 (StreamContext)
         """
+        if global_config is None:
+            raise RuntimeError("Global config is not initialized")
+
         try:
             from src.chat.message_receive.chat_stream import get_chat_manager
 
@@ -635,6 +640,9 @@ class StreamLoopManager:
         Returns:
             float: 间隔时间（秒）
         """
+        if global_config is None:
+            raise RuntimeError("Global config is not initialized")
+
         # 基础间隔
         base_interval = getattr(global_config.chat, "distribution_interval", 5.0)
 
diff --git a/src/chat/message_manager/global_notice_manager.py b/src/chat/message_manager/global_notice_manager.py
index 4215cb939..255fa6d8c 100644
--- a/src/chat/message_manager/global_notice_manager.py
+++ b/src/chat/message_manager/global_notice_manager.py
@@ -66,7 +66,7 @@ class GlobalNoticeManager:
         self._last_cleanup_time = time.time()
 
         # 统计信息
-        self.stats = {
+        self.stats: dict[str, Any] = {
             "total_notices": 0,
             "public_notices": 0,
             "stream_notices": 0,
diff --git a/src/chat/message_manager/message_manager.py b/src/chat/message_manager/message_manager.py
index 5366c57c2..211a2f8fc 100644
--- a/src/chat/message_manager/message_manager.py
+++ b/src/chat/message_manager/message_manager.py
@@ -277,6 +277,9 @@ class MessageManager:
 
     async def _check_and_handle_interruption(self, chat_stream: "ChatStream | None" = None, message: DatabaseMessages | None = None):
         """检查并处理消息打断 - 通过取消 stream_loop_task 实现"""
+        if global_config is None:
+            raise RuntimeError("Global config is not initialized")
+
         if not global_config.chat.interruption_enabled or not chat_stream or not message:
             return
 
diff --git a/src/chat/message_receive/chat_stream.py b/src/chat/message_receive/chat_stream.py
index de04fbc7e..0d647687b 100644
--- a/src/chat/message_receive/chat_stream.py
+++ b/src/chat/message_receive/chat_stream.py
@@ -240,6 +240,9 @@ class ChatStream:
 
     async def calculate_focus_energy(self) -> float:
         """异步计算focus_energy"""
+        if global_config is None:
+            raise RuntimeError("Global config is not initialized")
+
         try:
             # 使用单流上下文管理器获取消息
             all_messages = self.context.get_messages(limit=global_config.chat.max_context_size)
@@ -629,6 +632,9 @@ class ChatManager:
 
         # 回退到原始方法（最终方案）
         async def _db_save_stream_async(s_data_dict: dict):
+            if global_config is None:
+                raise RuntimeError("Global config is not initialized")
+
             async with get_db_session() as session:
                 user_info_d = s_data_dict.get("user_info")
                 group_info_d = s_data_dict.get("group_info")
diff --git a/src/chat/message_receive/message_handler.py b/src/chat/message_receive/message_handler.py
index 29d78e2b3..46c86bcee 100644
--- a/src/chat/message_receive/message_handler.py
+++ b/src/chat/message_receive/message_handler.py
@@ -30,7 +30,7 @@ from __future__ import annotations
 import os
 import re
 import traceback
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, cast
 
 from mofox_wire import MessageEnvelope, MessageRuntime
 
@@ -55,6 +55,8 @@ PROJECT_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "../.."))
 
 def _check_ban_words(text: str, chat: "ChatStream", userinfo) -> bool:
     """检查消息是否包含过滤词"""
+    if global_config is None:
+        return False
     for word in global_config.message_receive.ban_words:
         if word in text:
             chat_name = chat.group_info.group_name if chat.group_info else "私聊"
@@ -62,10 +64,10 @@ def _check_ban_words(text: str, chat: "ChatStream", userinfo) -> bool:
             logger.info(f"[过滤词识别]消息中含有{word}，filtered")
             return True
     return False
-
-
 def _check_ban_regex(text: str, chat: "ChatStream", userinfo) -> bool:
     """检查消息是否匹配过滤正则表达式"""
+    if global_config is None:
+        return False
     for pattern in global_config.message_receive.ban_msgs_regex:
         if re.search(pattern, text):
             chat_name = chat.group_info.group_name if chat.group_info else "私聊"
@@ -281,8 +283,8 @@ class MessageHandler:
             from src.chat.message_receive.chat_stream import get_chat_manager
             chat = await get_chat_manager().get_or_create_stream(
                 platform=platform,
-                user_info=DatabaseUserInfo.from_dict(user_info) if user_info else None,  # type: ignore
-                group_info=DatabaseGroupInfo.from_dict(group_info) if group_info else None,
+                user_info=DatabaseUserInfo.from_dict(cast(dict[str, Any], user_info)) if user_info else None,  # type: ignore
+                group_info=DatabaseGroupInfo.from_dict(cast(dict[str, Any], group_info)) if group_info else None,
             )
 
             # 将消息信封转换为 DatabaseMessages
@@ -431,8 +433,8 @@ class MessageHandler:
             from src.chat.message_receive.chat_stream import get_chat_manager
             chat = await get_chat_manager().get_or_create_stream(
                 platform=platform,
-                user_info=DatabaseUserInfo.from_dict(user_info) if user_info else None,  # type: ignore
-                group_info=DatabaseGroupInfo.from_dict(group_info) if group_info else None,
+                user_info=DatabaseUserInfo.from_dict(cast(dict[str, Any], user_info)) if user_info else None,  # type: ignore
+                group_info=DatabaseGroupInfo.from_dict(cast(dict[str, Any], group_info)) if group_info else None,
             )
 
             # 将消息信封转换为 DatabaseMessages
@@ -536,6 +538,8 @@ class MessageHandler:
             text = message.processed_plain_text or ""
 
             # 获取配置的命令前缀
+            if global_config is None:
+                return False, None, True
             prefixes = global_config.command.command_prefixes
 
             # 检查是否以任何前缀开头
@@ -704,6 +708,9 @@ class MessageHandler:
     async def _preprocess_message(self, message: DatabaseMessages, chat: "ChatStream") -> None:
         """预处理消息：存储、情绪更新等"""
         try:
+            if global_config is None:
+                return
+
             group_info = chat.group_info
 
             # 检查是否需要处理消息
diff --git a/src/chat/message_receive/message_processor.py b/src/chat/message_receive/message_processor.py
index 96aa56650..02f5597a4 100644
--- a/src/chat/message_receive/message_processor.py
+++ b/src/chat/message_receive/message_processor.py
@@ -256,7 +256,7 @@ async def _process_single_segment(
             # 检查消息是否由机器人自己发送
             user_info = message_info.get("user_info", {})
             user_id_str = str(user_info.get("user_id", ""))
-            if user_id_str == str(global_config.bot.qq_account):
+            if global_config and user_id_str == str(global_config.bot.qq_account):
                 logger.info(f"检测到机器人自身发送的语音消息 (User ID: {user_id_str})，尝试从缓存获取文本。")
                 if isinstance(seg_data, str):
                     cached_text = consume_self_voice_text(seg_data)
@@ -299,7 +299,7 @@ async def _process_single_segment(
                 logger.warning("⚠️ Rust视频处理模块不可用，跳过视频分析")
                 return "[视频]"
 
-            if global_config.video_analysis.enable:
+            if global_config and global_config.video_analysis.enable:
                 logger.info("已启用视频识别,开始识别")
                 if isinstance(seg_data, dict):
                     try:
diff --git a/src/chat/message_receive/storage.py b/src/chat/message_receive/storage.py
index 7836c8423..9aafef73c 100644
--- a/src/chat/message_receive/storage.py
+++ b/src/chat/message_receive/storage.py
@@ -3,10 +3,11 @@ import re
 import time
 import traceback
 from collections import deque
-from typing import Optional, TYPE_CHECKING
+from typing import Optional, TYPE_CHECKING, cast
 
 import orjson
 from sqlalchemy import desc, select, update
+from sqlalchemy.engine import CursorResult
 
 from src.common.data_models.database_data_model import DatabaseMessages
 from src.common.database.core import get_db_session
@@ -343,7 +344,7 @@ class MessageUpdateBatcher:
                         .where(Messages.message_id == mmc_id)
                         .values(message_id=qq_id)
                     )
-                    if result.rowcount > 0:
+                    if cast(CursorResult, result).rowcount > 0:
                         updated_count += 1
 
                 await session.commit()
@@ -571,7 +572,7 @@ class MessageStorage:
                 result = await session.execute(stmt)
                 await session.commit()
 
-                if result.rowcount > 0:
+                if cast(CursorResult, result).rowcount > 0:
                     logger.debug(f"成功更新消息 {message_id} 的interest_value为 {interest_value}")
                 else:
                     logger.warning(f"未找到消息 {message_id}，无法更新interest_value")
@@ -667,7 +668,7 @@ class MessageStorage:
                     )
 
                     result = await session.execute(update_stmt)
-                    if result.rowcount > 0:
+                    if cast(CursorResult, result).rowcount > 0:
                         fixed_count += 1
                         logger.debug(f"修复消息 {msg.message_id} 的interest_value为 {default_interest}")
 
diff --git a/src/chat/message_receive/uni_message_sender.py b/src/chat/message_receive/uni_message_sender.py
index 7f3e1076f..f9da33f15 100644
--- a/src/chat/message_receive/uni_message_sender.py
+++ b/src/chat/message_receive/uni_message_sender.py
@@ -133,7 +133,7 @@ class HeartFCSender:
 
                 # 将发送的消息写入上下文历史
                 try:
-                    if chat_stream and chat_stream.context and global_config.chat:
+                    if chat_stream and chat_stream.context and global_config and global_config.chat:
                         context = chat_stream.context
                         chat_config = global_config.chat
                         if chat_config:
diff --git a/src/chat/planner_actions/action_manager.py b/src/chat/planner_actions/action_manager.py
index 84100f6b7..c4e36abb4 100644
--- a/src/chat/planner_actions/action_manager.py
+++ b/src/chat/planner_actions/action_manager.py
@@ -94,7 +94,7 @@ class ChatterActionManager:
                 log_prefix=log_prefix,
                 shutting_down=shutting_down,
                 plugin_config=plugin_config,
-                action_message=action_message,
+                action_message=action_message,  # type: ignore
             )
 
             logger.debug(f"创建Action实例成功: {action_name}")
@@ -154,6 +154,8 @@ class ChatterActionManager:
         Returns:
             执行结果字典
         """
+        assert global_config is not None
+
         chat_stream = None
         try:
             # 获取 chat_stream
diff --git a/src/chat/planner_actions/action_modifier.py b/src/chat/planner_actions/action_modifier.py
index bfd92a72e..63423fc43 100644
--- a/src/chat/planner_actions/action_modifier.py
+++ b/src/chat/planner_actions/action_modifier.py
@@ -30,6 +30,7 @@ class ActionModifier:
 
     def __init__(self, action_manager: ChatterActionManager, chat_id: str):
         """初始化动作处理器"""
+        assert model_config is not None
         self.chat_id = chat_id
         # chat_stream 和 log_prefix 将在异步方法中初始化
         self.chat_stream: "ChatStream | None" = None
@@ -72,6 +73,7 @@ class ActionModifier:
             message_content: 消息内容
             chatter_name: 当前使用的 Chatter 名称，用于过滤只允许特定 Chatter 使用的动作
         """
+        assert global_config is not None
         # 初始化log_prefix
         await self._initialize_log_prefix()
         # 根据 stream_id 加载当前可用的动作
diff --git a/src/chat/replyer/default_generator.py b/src/chat/replyer/default_generator.py
index fe9be0494..560d518ef 100644
--- a/src/chat/replyer/default_generator.py
+++ b/src/chat/replyer/default_generator.py
@@ -240,6 +240,8 @@ class DefaultReplyer:
         chat_stream: "ChatStream",
         request_type: str = "replyer",
     ):
+        assert global_config is not None
+        assert model_config is not None
         self.express_model = LLMRequest(model_set=model_config.model_task_config.replyer, request_type=request_type)
         self.chat_stream = chat_stream
         # 这些将在异步初始化中设置
@@ -267,6 +269,7 @@ class DefaultReplyer:
 
     async def _build_auth_role_prompt(self) -> str:
         """根据主人配置生成额外提示词"""
+        assert global_config is not None
         master_config = global_config.permission.master_prompt
         if not master_config or not master_config.enable:
             return ""
@@ -515,6 +518,7 @@ class DefaultReplyer:
         Returns:
             str: 表达习惯信息字符串
         """
+        assert global_config is not None
         # 检查是否允许在此聊天流中使用表达
         use_expression, _, _ = global_config.expression.get_expression_config_for_chat(self.chat_stream.stream_id)
         if not use_expression:
@@ -583,6 +587,7 @@ class DefaultReplyer:
         Returns:
             str: 记忆信息字符串
         """
+        assert global_config is not None
         # 检查是否启用三层记忆系统
         if not (global_config.memory and global_config.memory.enable):
             return ""
@@ -776,6 +781,7 @@ class DefaultReplyer:
         Returns:
             str: 关键词反应提示字符串，如果没有触发任何反应则为空字符串
         """
+        assert global_config is not None
         if target is None:
             return ""
 
@@ -834,6 +840,7 @@ class DefaultReplyer:
         Returns:
             str: 格式化的notice信息文本，如果没有notice或未启用则返回空字符串
         """
+        assert global_config is not None
         try:
             logger.debug(f"开始构建notice块，chat_id={chat_id}")
 
@@ -902,6 +909,7 @@ class DefaultReplyer:
         Returns:
             Tuple[str, str]: (已读历史消息prompt, 未读历史消息prompt)
         """
+        assert global_config is not None
         try:
             # 从message_manager获取真实的已读/未读消息
 
@@ -1002,6 +1010,7 @@ class DefaultReplyer:
         """
         回退的已读/未读历史消息构建方法
         """
+        assert global_config is not None
         # 通过is_read字段分离已读和未读消息
         read_messages = []
         unread_messages = []
@@ -1115,6 +1124,7 @@ class DefaultReplyer:
         Returns:
             str: 构建好的上下文
         """
+        assert global_config is not None
         if available_actions is None:
             available_actions = {}
         chat_stream = self.chat_stream
@@ -1607,6 +1617,7 @@ class DefaultReplyer:
         reply_to: str,
         reply_message: dict[str, Any] | DatabaseMessages | None = None,
     ) -> str:  # sourcery skip: merge-else-if-into-elif, remove-redundant-if
+        assert global_config is not None
         chat_stream = self.chat_stream
         chat_id = chat_stream.stream_id
         is_group_chat = bool(chat_stream.group_info)
@@ -1767,6 +1778,7 @@ class DefaultReplyer:
         return prompt_text
 
     async def llm_generate_content(self, prompt: str):
+        assert global_config is not None
         with Timer("LLM生成", {}):  # 内部计时器，可选保留
             # 直接使用已初始化的模型实例
             logger.info(f"使用模型集生成回复: {self.express_model.model_for_task}")
@@ -1792,6 +1804,8 @@ class DefaultReplyer:
         return content, reasoning_content, model_name, tool_calls
 
     async def get_prompt_info(self, message: str, sender: str, target: str):
+        assert global_config is not None
+        assert model_config is not None
         related_info = ""
         start_time = time.time()
         from src.plugins.built_in.knowledge.lpmm_get_knowledge import SearchKnowledgeFromLPMMTool
@@ -1843,6 +1857,7 @@ class DefaultReplyer:
             return ""
 
     async def build_relation_info(self, sender: str, target: str):
+        assert global_config is not None
         # 获取用户ID
         if sender == f"{global_config.bot.nickname}(你)":
             return "你将要回复的是你自己发送的消息。"
@@ -1927,6 +1942,7 @@ class DefaultReplyer:
             reply_to: 回复对象
             reply_message: 回复的原始消息
         """
+        assert global_config is not None
         return  # 已禁用，保留函数签名以防其他地方有引用
 
         # 以下代码已废弃，不再执行
diff --git a/src/chat/security/manager.py b/src/chat/security/manager.py
index a8c3a5716..1c8c2ecfa 100644
--- a/src/chat/security/manager.py
+++ b/src/chat/security/manager.py
@@ -173,9 +173,10 @@ class SecurityManager:
         pre_check_results = await asyncio.gather(*pre_check_tasks, return_exceptions=True)
 
         # 筛选需要完整检查的检测器
-        checkers_to_run = [
-            c for c, need_check in zip(enabled_checkers, pre_check_results) if need_check is True
-        ]
+        checkers_to_run = []
+        for c, need_check in zip(enabled_checkers, pre_check_results):
+            if need_check is True:
+                checkers_to_run.append(c)
 
         if not checkers_to_run:
             return SecurityCheckResult(
@@ -192,20 +193,22 @@ class SecurityManager:
         results = await asyncio.gather(*check_tasks, return_exceptions=True)
 
         # 过滤异常结果
-        valid_results = []
+        valid_results: list[SecurityCheckResult] = []
         for checker, result in zip(checkers_to_run, results):
-            if isinstance(result, Exception):
+            if isinstance(result, BaseException):
                 logger.error(f"检测器 '{checker.name}' 执行失败: {result}")
                 continue
-            result.checker_name = checker.name
-            valid_results.append(result)
+
+            if isinstance(result, SecurityCheckResult):
+                result.checker_name = checker.name
+                valid_results.append(result)
 
         # 合并结果
         return self._merge_results(valid_results, time.time() - start_time)
 
     async def _check_all(self, message: str, context: dict, start_time: float) -> SecurityCheckResult:
         """检测所有模式（顺序执行所有检测器）"""
-        results = []
+        results: list[SecurityCheckResult] = []
 
         for checker in self._checkers:
             if not checker.enabled:
diff --git a/src/chat/utils/chat_message_builder.py b/src/chat/utils/chat_message_builder.py
index b0991d53d..7cd4e0596 100644
--- a/src/chat/utils/chat_message_builder.py
+++ b/src/chat/utils/chat_message_builder.py
@@ -39,11 +39,13 @@ def replace_user_references_sync(
     Returns:
         str: 处理后的内容字符串
     """
+    assert global_config is not None
     if not content:
         return ""
 
     if name_resolver is None:
         def default_resolver(platform: str, user_id: str) -> str:
+            assert global_config is not None
             # 检查是否是机器人自己
             if replace_bot_name and (user_id == str(global_config.bot.qq_account)):
                 return f"{global_config.bot.nickname}(你)"
@@ -116,10 +118,12 @@ async def replace_user_references_async(
     Returns:
         str: 处理后的内容字符串
     """
+    assert global_config is not None
     if name_resolver is None:
         person_info_manager = get_person_info_manager()
 
         async def default_resolver(platform: str, user_id: str) -> str:
+            assert global_config is not None
             # 检查是否是机器人自己
             if replace_bot_name and (user_id == str(global_config.bot.qq_account)):
                 return f"{global_config.bot.nickname}(你)"
@@ -392,7 +396,7 @@ async def get_actions_by_timestamp_with_chat_inclusive(
                 actions = list(result.scalars())
                 return [action.__dict__ for action in reversed(actions)]
             else:  # earliest
-                result = await session.execute(
+                query = await session.execute(
                     select(ActionRecords)
                     .where(
                         and_(
@@ -540,6 +544,7 @@ async def _build_readable_messages_internal(
     Returns:
         包含格式化消息的字符串、原始消息详情列表、图片映射字典和更新后的计数器的元组。
     """
+    assert global_config is not None
     if not messages:
         return "", [], pic_id_mapping or {}, pic_counter
 
@@ -694,6 +699,7 @@ async def _build_readable_messages_internal(
             percentile = i / n_messages  # 计算消息在列表中的位置百分比 (0 <= percentile < 1)
             original_len = len(content)
             limit = -1  # 默认不截断
+            replace_content = ""
 
             if percentile < 0.2:  # 60% 之前的消息 (即最旧的 60%)
                 limit = 50
@@ -973,6 +979,7 @@ async def build_readable_messages(
         truncate: 是否截断长消息
         show_actions: 是否显示动作记录
     """
+    assert global_config is not None
     # 创建messages的深拷贝，避免修改原始列表
     if not messages:
         return ""
@@ -1112,6 +1119,7 @@ async def build_anonymous_messages(messages: list[dict[str, Any]]) -> str:
     构建匿名可读消息，将不同人的名称转为唯一占位符（A、B、C...），bot自己用SELF。
     处理 回复<aaa:bbb> 和 @<aaa:bbb> 字段，将bbb映射为匿名占位符。
     """
+    assert global_config is not None
     if not messages:
         print("111111111111没有消息，无法构建匿名消息")
         return ""
@@ -1127,6 +1135,7 @@ async def build_anonymous_messages(messages: list[dict[str, Any]]) -> str:
     def get_anon_name(platform, user_id):
         # print(f"get_anon_name: platform:{platform}, user_id:{user_id}")
         # print(f"global_config.bot.qq_account:{global_config.bot.qq_account}")
+        assert global_config is not None
 
         if user_id == global_config.bot.qq_account:
             # print("SELF11111111111111")
@@ -1204,6 +1213,7 @@ async def get_person_id_list(messages: list[dict[str, Any]]) -> list[str]:
     Returns:
         一个包含唯一 person_id 的列表。
     """
+    assert global_config is not None
     person_ids_set = set()  # 使用集合来自动去重
 
     for msg in messages:
diff --git a/src/chat/utils/prompt.py b/src/chat/utils/prompt.py
index 35234c352..ae1149b05 100644
--- a/src/chat/utils/prompt.py
+++ b/src/chat/utils/prompt.py
@@ -649,6 +649,7 @@ class Prompt:
 
     async def _build_expression_habits(self) -> dict[str, Any]:
         """构建表达习惯（如表情、口癖）的上下文块."""
+        assert global_config is not None
         # 检查当前聊天是否启用了表达习惯功能
         use_expression, _, _ = global_config.expression.get_expression_config_for_chat(
             self.parameters.chat_id
@@ -728,6 +729,7 @@ class Prompt:
 
     async def _build_tool_info(self) -> dict[str, Any]:
         """构建工具调用结果的上下文块."""
+        assert global_config is not None
         if not global_config.tool.enable_tool:
             return {"tool_info_block": ""}
 
@@ -779,6 +781,7 @@ class Prompt:
 
     async def _build_knowledge_info(self) -> dict[str, Any]:
         """构建从知识库检索到的相关信息的上下文块."""
+        assert global_config is not None
         if not global_config.lpmm_knowledge.enable:
             return {"knowledge_prompt": ""}
 
@@ -873,6 +876,7 @@ class Prompt:
 
     def _prepare_s4u_params(self, context_data: dict[str, Any]) -> dict[str, Any]:
         """为S4U（Scene for You）模式准备最终用于格式化的参数字典."""
+        assert global_config is not None
         return {
             **context_data,
             "expression_habits_block": context_data.get("expression_habits_block", ""),
@@ -915,6 +919,7 @@ class Prompt:
 
     def _prepare_normal_params(self, context_data: dict[str, Any]) -> dict[str, Any]:
         """为Normal模式准备最终用于格式化的参数字典."""
+        assert global_config is not None
         return {
             **context_data,
             "expression_habits_block": context_data.get("expression_habits_block", ""),
@@ -959,6 +964,7 @@ class Prompt:
 
     def _prepare_default_params(self, context_data: dict[str, Any]) -> dict[str, Any]:
         """为默认模式（或其他未指定模式）准备最终用于格式化的参数字典."""
+        assert global_config is not None
         return {
             "expression_habits_block": context_data.get("expression_habits_block", ""),
             "relation_info_block": context_data.get("relation_info_block", ""),
@@ -1143,6 +1149,7 @@ class Prompt:
         Returns:
             str: 构建好的跨群聊上下文字符串。
         """
+        assert global_config is not None
         if not global_config.cross_context.enable:
             return ""
 
diff --git a/src/chat/utils/report_generator.py b/src/chat/utils/report_generator.py
index 8c8756070..874451efc 100644
--- a/src/chat/utils/report_generator.py
+++ b/src/chat/utils/report_generator.py
@@ -92,6 +92,7 @@ class HTMLReportGenerator:
                 f"<td>{stat_data[TPS_BY_PROVIDER].get(provider_name, 0):.2f}</td>"
                 f"<td>{stat_data[COST_PER_KTOK_BY_PROVIDER].get(provider_name, 0):.4f} ¥</td>"
                 f"<td>{stat_data[COST_BY_PROVIDER].get(provider_name, 0):.4f} ¥</td>"
+                f"<td>{stat_data.get(AVG_TIME_COST_BY_PROVIDER, {}).get(provider_name, 0):.3f} 秒</td>"
                 f"</tr>"
                 for provider_name, count in sorted(stat_data[REQ_CNT_BY_PROVIDER].items())
             ]
@@ -135,27 +136,123 @@ class HTMLReportGenerator:
                 for chat_id, count in sorted(stat_data[MSG_CNT_BY_CHAT].items())
             ]
         )
+        
+        # 先计算基础数据
+        total_tokens = sum(stat_data.get(TOTAL_TOK_BY_MODEL, {}).values())
+        total_requests = stat_data.get(TOTAL_REQ_CNT, 0)
+        total_cost = stat_data.get(TOTAL_COST, 0)
+        total_messages = stat_data.get(TOTAL_MSG_CNT, 0)
+        online_seconds = stat_data.get(ONLINE_TIME, 0)
+        online_hours = online_seconds / 3600 if online_seconds > 0 else 0
+        
+        # 大模型相关效率指标
+        avg_cost_per_req = (total_cost / total_requests) if total_requests > 0 else 0
+        avg_cost_per_msg = (total_cost / total_messages) if total_messages > 0 else 0
+        avg_tokens_per_msg = (total_tokens / total_messages) if total_messages > 0 else 0
+        avg_tokens_per_req = (total_tokens / total_requests) if total_requests > 0 else 0
+        msg_to_req_ratio = (total_messages / total_requests) if total_requests > 0 else 0
+        cost_per_hour = (total_cost / online_hours) if online_hours > 0 else 0
+        req_per_hour = (total_requests / online_hours) if online_hours > 0 else 0
+        
+        # Token效率 (输出/输入比率)
+        total_in_tokens = sum(stat_data.get(IN_TOK_BY_MODEL, {}).values())
+        total_out_tokens = sum(stat_data.get(OUT_TOK_BY_MODEL, {}).values())
+        token_efficiency = (total_out_tokens / total_in_tokens) if total_in_tokens > 0 else 0
+        
+        # 生成效率指标表格数据
+        efficiency_data = [
+            ("💸 平均每条消息成本", f"{avg_cost_per_msg:.6f} ¥", "处理每条用户消息的平均AI成本"),
+            ("🎯 平均每条消息Token", f"{avg_tokens_per_msg:.0f}", "每条消息平均消耗的Token数量"),
+            ("📊 平均每次请求Token", f"{avg_tokens_per_req:.0f}", "每次AI请求平均消耗的Token数"),
+            ("🔄 消息/请求比率", f"{msg_to_req_ratio:.2f}", "平均每个AI请求处理的消息数"),
+            ("⚡ Token效率(输出/输入)", f"{token_efficiency:.3f}x", "输出Token与输入Token的比率"),
+            ("💵 每小时运行成本", f"{cost_per_hour:.4f} ¥/h", "在线每小时的AI成本"),
+            ("🚀 每小时请求数", f"{req_per_hour:.1f} 次/h", "在线每小时的AI请求次数"),
+            ("💰 每千Token成本", f"{(total_cost / total_tokens * 1000) if total_tokens > 0 else 0:.4f} ¥", "平均每1000个Token的成本"),
+            ("📈 Token/在线小时", f"{(total_tokens / online_hours) if online_hours > 0 else 0:.0f}", "每在线小时处理的Token数"),
+            ("💬 消息/在线小时", f"{(total_messages / online_hours) if online_hours > 0 else 0:.1f}", "每在线小时处理的消息数"),
+        ]
+        
+        efficiency_rows = "\n".join(
+            [
+                f"<tr><td style='font-weight: 500;'>{metric}</td><td style='color: #1976D2; font-weight: 600; font-size: 1.1em;'>{value}</td><td style='color: #546E7A;'>{desc}</td></tr>"
+                for metric, value, desc in efficiency_data
+            ]
+        )
+        
+        # 计算活跃聊天数和最活跃聊天
+        msg_by_chat = stat_data.get(MSG_CNT_BY_CHAT, {})
+        active_chats = len(msg_by_chat)
+        most_active_chat = ""
+        if msg_by_chat:
+            most_active_id = max(msg_by_chat, key=msg_by_chat.get)
+            most_active_chat = self.name_mapping.get(most_active_id, (most_active_id, 0))[0]
+            most_active_count = msg_by_chat[most_active_id]
+            most_active_chat = f"{most_active_chat} ({most_active_count}条)"
+        
+        avg_msg_per_chat = (total_messages / active_chats) if active_chats > 0 else 0
+        
         summary_cards = f"""
             <div class="summary-cards">
                 <div class="card">
-                    <h3>总花费</h3>
-                    <p>{stat_data.get(TOTAL_COST, 0):.4f} ¥</p>
+                    <h3>💰 总花费</h3>
+                    <p>{total_cost:.4f} ¥</p>
                 </div>
                 <div class="card">
-                    <h3>总请求数</h3>
-                    <p>{stat_data.get(TOTAL_REQ_CNT, 0)}</p>
+                    <h3>📞 AI请求数</h3>
+                    <p>{total_requests:,}</p>
                 </div>
                 <div class="card">
-                    <h3>总Token数</h3>
-                    <p>{sum(stat_data.get(TOTAL_TOK_BY_MODEL, {}).values())}</p>
-                </div>
-                 <div class="card">
-                    <h3>总消息数</h3>
-                    <p>{stat_data.get(TOTAL_MSG_CNT, 0)}</p>
+                    <h3>🎯 总Token数</h3>
+                    <p>{total_tokens:,}</p>
                 </div>
                 <div class="card">
-                    <h3>总在线时间</h3>
-                    <p>{format_online_time(int(stat_data.get(ONLINE_TIME, 0)))}</p>
+                    <h3>💬 总消息数</h3>
+                    <p>{total_messages:,}</p>
+                </div>
+                <div class="card">
+                    <h3>⏱️ 在线时间</h3>
+                    <p>{format_online_time(int(online_seconds))}</p>
+                </div>
+                <div class="card">
+                    <h3>💸 每条消息成本</h3>
+                    <p>{avg_cost_per_msg:.4f} ¥</p>
+                </div>
+                <div class="card">
+                    <h3>📊 每请求Token</h3>
+                    <p>{avg_tokens_per_req:.0f}</p>
+                </div>
+                <div class="card">
+                    <h3>� 消息/请求比</h3>
+                    <p>{msg_to_req_ratio:.2f}</p>
+                </div>
+                <div class="card">
+                    <h3>⚡ Token效率</h3>
+                    <p>{token_efficiency:.2f}x</p>
+                </div>
+                <div class="card">
+                    <h3>💵 每小时成本</h3>
+                    <p>{cost_per_hour:.4f} ¥</p>
+                </div>
+                <div class="card">
+                    <h3>🚀 每小时请求</h3>
+                    <p>{req_per_hour:.1f}</p>
+                </div>
+                <div class="card">
+                    <h3>👥 活跃聊天数</h3>
+                    <p>{active_chats}</p>
+                </div>
+                <div class="card">
+                    <h3>🔥 最活跃聊天</h3>
+                    <p style="font-size: 1.2em;">{most_active_chat if most_active_chat else "无"}</p>
+                </div>
+                <div class="card">
+                    <h3>📈 平均消息/聊天</h3>
+                    <p>{avg_msg_per_chat:.1f}</p>
+                </div>
+                <div class="card">
+                    <h3>🎯 每消息Token</h3>
+                    <p>{avg_tokens_per_msg:.0f}</p>
                 </div>
             </div>
         """
@@ -173,6 +270,7 @@ class HTMLReportGenerator:
             module_rows=module_rows,
             type_rows=type_rows,
             chat_rows=chat_rows,
+            efficiency_rows=efficiency_rows,
         )
 
     def _generate_chart_tab(self, chart_data: dict) -> str:
@@ -219,28 +317,41 @@ class HTMLReportGenerator:
             period_id = period[0]
             static_chart_data[period_id] = {
                 "provider_cost_data": stat[period_id].get(PIE_CHART_COST_BY_PROVIDER, {}),
+                "module_cost_data": stat[period_id].get(PIE_CHART_COST_BY_MODULE, {}),
                 "model_cost_data": stat[period_id].get(BAR_CHART_COST_BY_MODEL, {}),
+                "token_comparison_data": stat[period_id].get(BAR_CHART_TOKEN_COMPARISON, {}),
+                "response_time_scatter_data": stat[period_id].get(SCATTER_CHART_RESPONSE_TIME, []),
+                "model_efficiency_radar_data": stat[period_id].get(RADAR_CHART_MODEL_EFFICIENCY, {}),
+                "provider_requests_data": stat[period_id].get(DOUGHNUT_CHART_PROVIDER_REQUESTS, {}),
+                "avg_response_time_data": stat[period_id].get(BAR_CHART_AVG_RESPONSE_TIME, {}),
             }
         static_chart_data["all_time"] = {
             "provider_cost_data": stat["all_time"].get(PIE_CHART_COST_BY_PROVIDER, {}),
+            "module_cost_data": stat["all_time"].get(PIE_CHART_COST_BY_MODULE, {}),
             "model_cost_data": stat["all_time"].get(BAR_CHART_COST_BY_MODEL, {}),
+            "token_comparison_data": stat["all_time"].get(BAR_CHART_TOKEN_COMPARISON, {}),
+            "response_time_scatter_data": stat["all_time"].get(SCATTER_CHART_RESPONSE_TIME, []),
+            "model_efficiency_radar_data": stat["all_time"].get(RADAR_CHART_MODEL_EFFICIENCY, {}),
+            "provider_requests_data": stat["all_time"].get(DOUGHNUT_CHART_PROVIDER_REQUESTS, {}),
+            "avg_response_time_data": stat["all_time"].get(BAR_CHART_AVG_RESPONSE_TIME, {}),
         }
 
         # 渲染模板
         # 读取CSS和JS文件内容
+        assert isinstance(self.jinja_env.loader, FileSystemLoader)
         async with aiofiles.open(os.path.join(self.jinja_env.loader.searchpath[0], "report.css"), encoding="utf-8") as f:
             report_css = await f.read()
         async with aiofiles.open(os.path.join(self.jinja_env.loader.searchpath[0], "report.js"), encoding="utf-8") as f:
             report_js = await f.read()
-        # 渲染模板
+        # 渲染模板（使用紧凑的JSON格式减少文件大小）
         template = self.jinja_env.get_template("report.html")
         rendered_html = template.render(
             report_title="MoFox-Bot运行统计报告",
             generation_time=now.strftime("%Y-%m-%d %H:%M:%S"),
             tab_list="\n".join(tab_list_html),
             tab_content="\n".join(tab_content_html_list),
-            all_chart_data=json.dumps(chart_data),
-            static_chart_data=json.dumps(static_chart_data),
+            all_chart_data=json.dumps(chart_data, separators=(',', ':'), ensure_ascii=False),
+            static_chart_data=json.dumps(static_chart_data, separators=(',', ':'), ensure_ascii=False),
             report_css=report_css,
             report_js=report_js,
         )
diff --git a/src/chat/utils/statistic.py b/src/chat/utils/statistic.py
index a94278b04..c6fdcec44 100644
--- a/src/chat/utils/statistic.py
+++ b/src/chat/utils/statistic.py
@@ -192,7 +192,7 @@ class StatisticOutputTask(AsyncTask):
             self._statistic_console_output(stats, now)
             # 使用新的 HTMLReportGenerator 生成报告
             chart_data = await self._collect_chart_data(stats)
-            deploy_time = datetime.fromtimestamp(local_storage.get("deploy_time", now.timestamp()))
+            deploy_time = datetime.fromtimestamp(float(local_storage.get("deploy_time", now.timestamp())))  # type: ignore
             report_generator = HTMLReportGenerator(
                 name_mapping=self.name_mapping,
                 stat_period=self.stat_period,
@@ -219,7 +219,7 @@ class StatisticOutputTask(AsyncTask):
 
                 # 使用新的 HTMLReportGenerator 生成报告
                 chart_data = await self._collect_chart_data(stats)
-                deploy_time = datetime.fromtimestamp(local_storage.get("deploy_time", now.timestamp()))
+                deploy_time = datetime.fromtimestamp(float(local_storage.get("deploy_time", now.timestamp())))  # type: ignore
                 report_generator = HTMLReportGenerator(
                     name_mapping=self.name_mapping,
                     stat_period=self.stat_period,
@@ -299,8 +299,16 @@ class StatisticOutputTask(AsyncTask):
                 # Chart data
                 PIE_CHART_COST_BY_PROVIDER: {},
                 PIE_CHART_REQ_BY_PROVIDER: {},
+                PIE_CHART_COST_BY_MODULE: {},
                 BAR_CHART_COST_BY_MODEL: {},
                 BAR_CHART_REQ_BY_MODEL: {},
+                BAR_CHART_TOKEN_COMPARISON: {},
+                SCATTER_CHART_RESPONSE_TIME: {},
+                RADAR_CHART_MODEL_EFFICIENCY: {},
+                HEATMAP_CHAT_ACTIVITY: {},
+                DOUGHNUT_CHART_PROVIDER_REQUESTS: {},
+                LINE_CHART_COST_TREND: {},
+                BAR_CHART_AVG_RESPONSE_TIME: {},
             }
             for period_key, _ in collect_period
         }
@@ -457,6 +465,15 @@ class StatisticOutputTask(AsyncTask):
                     "data": [round(item[1], 4) for item in sorted_providers],
                 }
 
+            # 按模块花费饼图
+            module_costs = period_stats[COST_BY_MODULE]
+            if module_costs:
+                sorted_modules = sorted(module_costs.items(), key=lambda item: item[1], reverse=True)
+                period_stats[PIE_CHART_COST_BY_MODULE] = {
+                    "labels": [item[0] for item in sorted_modules],
+                    "data": [round(item[1], 4) for item in sorted_modules],
+                }
+
             # 按模型花费条形图
             model_costs = period_stats[COST_BY_MODEL]
             if model_costs:
@@ -465,6 +482,91 @@ class StatisticOutputTask(AsyncTask):
                     "labels": [item[0] for item in sorted_models],
                     "data": [round(item[1], 4) for item in sorted_models],
                 }
+            
+            # 1. Token输入输出对比条形图
+            model_names = list(period_stats[REQ_CNT_BY_MODEL].keys())
+            if model_names:
+                period_stats[BAR_CHART_TOKEN_COMPARISON] = {
+                    "labels": model_names,
+                    "input_tokens": [period_stats[IN_TOK_BY_MODEL].get(m, 0) for m in model_names],
+                    "output_tokens": [period_stats[OUT_TOK_BY_MODEL].get(m, 0) for m in model_names],
+                }
+            
+            # 2. 响应时间分布散点图数据（限制数据点以提高加载速度）
+            scatter_data = []
+            max_points_per_model = 50  # 每个模型最多50个点
+            for model_name, time_costs in period_stats[TIME_COST_BY_MODEL].items():
+                # 如果数据点太多，进行采样
+                if len(time_costs) > max_points_per_model:
+                    step = len(time_costs) // max_points_per_model
+                    sampled_costs = time_costs[::step][:max_points_per_model]
+                else:
+                    sampled_costs = time_costs
+                
+                for idx, time_cost in enumerate(sampled_costs):
+                    scatter_data.append({
+                        "model": model_name,
+                        "x": idx,
+                        "y": round(time_cost, 3),
+                        "tokens": period_stats[TOTAL_TOK_BY_MODEL].get(model_name, 0) // len(time_costs) if time_costs else 0
+                    })
+            period_stats[SCATTER_CHART_RESPONSE_TIME] = scatter_data
+            
+            # 3. 模型效率雷达图
+            if model_names:
+                # 取前5个最常用的模型
+                top_models = sorted(period_stats[REQ_CNT_BY_MODEL].items(), key=lambda x: x[1], reverse=True)[:5]
+                radar_data = []
+                for model_name, _ in top_models:
+                    # 归一化各项指标到0-100
+                    req_count = period_stats[REQ_CNT_BY_MODEL].get(model_name, 0)
+                    tps = period_stats[TPS_BY_MODEL].get(model_name, 0)
+                    avg_time = period_stats[AVG_TIME_COST_BY_MODEL].get(model_name, 0)
+                    cost_per_ktok = period_stats[COST_PER_KTOK_BY_MODEL].get(model_name, 0)
+                    avg_tokens = period_stats[AVG_TOK_BY_MODEL].get(model_name, 0)
+                    
+                    # 简单的归一化（反向归一化时间和成本，值越小越好）
+                    max_req = max([period_stats[REQ_CNT_BY_MODEL].get(m[0], 1) for m in top_models])
+                    max_tps = max([period_stats[TPS_BY_MODEL].get(m[0], 1) for m in top_models])
+                    max_time = max([period_stats[AVG_TIME_COST_BY_MODEL].get(m[0], 0.1) for m in top_models])
+                    max_cost = max([period_stats[COST_PER_KTOK_BY_MODEL].get(m[0], 0.001) for m in top_models])
+                    max_tokens = max([period_stats[AVG_TOK_BY_MODEL].get(m[0], 1) for m in top_models])
+                    
+                    radar_data.append({
+                        "model": model_name,
+                        "metrics": [
+                            round((req_count / max_req) * 100, 2) if max_req > 0 else 0,  # 请求量
+                            round((tps / max_tps) * 100, 2) if max_tps > 0 else 0,  # TPS
+                            round((1 - avg_time / max_time) * 100, 2) if max_time > 0 else 100,  # 速度(反向)
+                            round((1 - cost_per_ktok / max_cost) * 100, 2) if max_cost > 0 else 100,  # 成本效益(反向)
+                            round((avg_tokens / max_tokens) * 100, 2) if max_tokens > 0 else 0,  # Token容量
+                        ]
+                    })
+                period_stats[RADAR_CHART_MODEL_EFFICIENCY] = {
+                    "labels": ["请求量", "TPS", "响应速度", "成本效益", "Token容量"],
+                    "datasets": radar_data
+                }
+            
+            # 4. 供应商请求占比环形图
+            provider_requests = period_stats[REQ_CNT_BY_PROVIDER]
+            if provider_requests:
+                sorted_provider_reqs = sorted(provider_requests.items(), key=lambda item: item[1], reverse=True)
+                period_stats[DOUGHNUT_CHART_PROVIDER_REQUESTS] = {
+                    "labels": [item[0] for item in sorted_provider_reqs],
+                    "data": [item[1] for item in sorted_provider_reqs],
+                }
+            
+            # 5. 平均响应时间条形图
+            if model_names:
+                sorted_by_time = sorted(
+                    [(m, period_stats[AVG_TIME_COST_BY_MODEL].get(m, 0)) for m in model_names],
+                    key=lambda x: x[1],
+                    reverse=True
+                )
+                period_stats[BAR_CHART_AVG_RESPONSE_TIME] = {
+                    "labels": [item[0] for item in sorted_by_time],
+                    "data": [round(item[1], 3) for item in sorted_by_time],
+                }
         return stats
 
     @staticmethod
diff --git a/src/chat/utils/statistic_keys.py b/src/chat/utils/statistic_keys.py
index 2a552ac1a..3233ae8c8 100644
--- a/src/chat/utils/statistic_keys.py
+++ b/src/chat/utils/statistic_keys.py
@@ -59,5 +59,30 @@ STD_TIME_COST_BY_PROVIDER = "std_time_costs_by_provider"
 # 新增饼图和条形图数据
 PIE_CHART_COST_BY_PROVIDER = "pie_chart_cost_by_provider"
 PIE_CHART_REQ_BY_PROVIDER = "pie_chart_req_by_provider"
+PIE_CHART_COST_BY_MODULE = "pie_chart_cost_by_module"
 BAR_CHART_COST_BY_MODEL = "bar_chart_cost_by_model"
 BAR_CHART_REQ_BY_MODEL = "bar_chart_req_by_model"
+
+# 新增更多图表数据
+BAR_CHART_TOKEN_COMPARISON = "bar_chart_token_comparison"  # Token输入输出对比图
+SCATTER_CHART_RESPONSE_TIME = "scatter_chart_response_time"  # 响应时间分布散点图
+RADAR_CHART_MODEL_EFFICIENCY = "radar_chart_model_efficiency"  # 模型效率雷达图
+HEATMAP_CHAT_ACTIVITY = "heatmap_chat_activity"  # 聊天活跃度热力图
+DOUGHNUT_CHART_PROVIDER_REQUESTS = "doughnut_chart_provider_requests"  # 供应商请求占比环形图
+LINE_CHART_COST_TREND = "line_chart_cost_trend"  # 成本趋势折线图
+BAR_CHART_AVG_RESPONSE_TIME = "bar_chart_avg_response_time"  # 平均响应时间条形图
+
+# 新增消息分析指标
+MSG_CNT_BY_USER = "messages_by_user"  # 按用户的消息数
+ACTIVE_CHATS_CNT = "active_chats_count"  # 活跃聊天数
+MOST_ACTIVE_CHAT = "most_active_chat"  # 最活跃的聊天
+AVG_MSG_PER_CHAT = "avg_messages_per_chat"  # 平均每个聊天的消息数
+
+# 新增大模型效率指标
+AVG_COST_PER_MSG = "avg_cost_per_message"  # 平均每条消息成本
+AVG_TOKENS_PER_MSG = "avg_tokens_per_message"  # 平均每条消息Token数
+AVG_TOKENS_PER_REQ = "avg_tokens_per_request"  # 平均每次请求Token数
+MSG_TO_REQ_RATIO = "message_to_request_ratio"  # 消息/请求比率
+COST_PER_ONLINE_HOUR = "cost_per_online_hour"  # 每小时在线成本
+REQ_PER_ONLINE_HOUR = "requests_per_online_hour"  # 每小时请求数
+TOKEN_EFFICIENCY = "token_efficiency"  # Token效率 (输出/输入比率)
diff --git a/src/chat/utils/templates/charts_tab.html b/src/chat/utils/templates/charts_tab.html
index 52e6c3024..e078f37a2 100644
--- a/src/chat/utils/templates/charts_tab.html
+++ b/src/chat/utils/templates/charts_tab.html
@@ -1,16 +1,33 @@
 <div id="charts" class="tab-content">
-    <h2>数据图表</h2>
-    <div style="margin: 20px 0; text-align: center;">
-        <label style="margin-right: 10px; font-weight: bold;">时间范围:</label>
+    <h2>📈 数据图表</h2>
+    <div class="info-item" style="margin-bottom: 2rem;">
+        <span class="material-icons" style="font-size: 18px;">show_chart</span>
+        <strong>动态图表:</strong> 选择不同的时间范围查看数据趋势变化
+    </div>
+    
+    <div class="time-range-controls">
+        <span style="margin-right: 1rem; font-weight: 600; color: var(--text-secondary); display: flex; align-items: center; gap: 0.5rem;">
+            <span class="material-icons" style="font-size: 18px;">schedule</span>
+            时间范围:
+        </span>
         <button class="time-range-btn" onclick="switchTimeRange('6h')">6小时</button>
         <button class="time-range-btn" onclick="switchTimeRange('12h')">12小时</button>
         <button class="time-range-btn" onclick="switchTimeRange('24h')">24小时</button>
         <button class="time-range-btn" onclick="switchTimeRange('48h')">48小时</button>
     </div>
-    <div style="margin-top: 20px;">
-        <div style="margin-bottom: 40px;"><canvas id="totalCostChart" width="800" height="400"></canvas></div>
-        <div style="margin-bottom: 40px;"><canvas id="costByModuleChart" width="800" height="400"></canvas></div>
-        <div style="margin-bottom: 40px;"><canvas id="costByModelChart" width="800" height="400"></canvas></div>
-        <div><canvas id="messageByChatChart" width="800" height="400"></canvas></div>
+    
+    <div class="chart-grid" style="grid-template-columns: 1fr;">
+        <div class="chart-wrapper" style="max-height: 450px;">
+            <div id="totalCostChart" style="width: 100%; height: 380px;"></div>
+        </div>
+        <div class="chart-wrapper" style="max-height: 500px;">
+            <div id="costByModuleChart" style="width: 100%; height: 420px;"></div>
+        </div>
+        <div class="chart-wrapper" style="max-height: 500px;">
+            <div id="costByModelChart" style="width: 100%; height: 420px;"></div>
+        </div>
+        <div class="chart-wrapper" style="max-height: 500px;">
+            <div id="messageByChatChart" style="width: 100%; height: 420px;"></div>
+        </div>
     </div>
 </div>
\ No newline at end of file
diff --git a/src/chat/utils/templates/report.css b/src/chat/utils/templates/report.css
index 2229be785..b9fd0220f 100644
--- a/src/chat/utils/templates/report.css
+++ b/src/chat/utils/templates/report.css
@@ -1,199 +1,385 @@
-/* General Body Styles */
+/* Modern Dashboard Theme - 2025 Edition */
+:root {
+    /* Core Colors */
+    --primary-color: #2563eb;
+    --primary-light: #eff6ff;
+    --primary-dark: #1e40af;
+    --secondary-color: #64748b;
+    --success-color: #10b981;
+    --warning-color: #f59e0b;
+    --danger-color: #ef4444;
+    
+    /* Backgrounds */
+    --bg-body: #f8fafc;
+    --bg-card: #ffffff;
+    --bg-sidebar: #ffffff;
+    
+    /* Text */
+    --text-primary: #0f172a;
+    --text-secondary: #475569;
+    --text-muted: #94a3b8;
+    
+    /* Borders & Shadows */
+    --border-color: #e2e8f0;
+    --shadow-sm: 0 1px 2px 0 rgb(0 0 0 / 0.05);
+    --shadow-md: 0 4px 6px -1px rgb(0 0 0 / 0.1), 0 2px 4px -2px rgb(0 0 0 / 0.1);
+    --shadow-lg: 0 10px 15px -3px rgb(0 0 0 / 0.1), 0 4px 6px -4px rgb(0 0 0 / 0.1);
+    
+    /* Layout */
+    --radius-lg: 1rem;
+    --radius-md: 0.75rem;
+    --radius-sm: 0.5rem;
+}
+
+/* Reset & Base Styles */
+* {
+    box-sizing: border-box;
+}
+
 body {
-    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
+    font-family: 'Inter', 'Roboto', -apple-system, BlinkMacSystemFont, sans-serif;
     margin: 0;
-    padding: 20px;
-    background-color: #f0f4f8; /* Light blue-gray background */
-    color: #333; /* Darker text for better contrast */
-    line-height: 1.6;
+    padding: 0;
+    background-color: var(--bg-body);
+    color: var(--text-primary);
+    line-height: 1.5;
+    -webkit-font-smoothing: antialiased;
 }
 
-/* Main Container */
+/* Layout Container */
 .container {
-    max-width: 95%; /* Make container almost full-width */
-    margin: 20px auto;
-    background-color: #FFFFFF; /* Pure white background */
-    padding: 30px;
-    border-radius: 12px; /* Slightly more rounded corners */
-    box-shadow: 0 8px 25px rgba(0, 0, 0, 0.07); /* Softer, deeper shadow */
-}
-/* Dashboard Layout */
-.dashboard-layout {
-    display: flex;
-    gap: 30px;
-}
-
-.main-content {
-    flex: 65%;
-    min-width: 0;
-}
-
-.sidebar-content {
-    flex: 35%;
-    min-width: 0;
-}
-
-/* Responsive Design for Mobile */
-@media (max-width: 992px) {
-    .dashboard-layout {
-        flex-direction: column;
-    }
-    .main-content, .sidebar-content {
-        flex: 1;
-    }
-}
-
-/* Typography */
-h1, h2 {
-    color: #212529;
-    padding-bottom: 10px;
-    margin-top: 0;
+    max-width: 1600px;
+    margin: 0 auto;
+    padding: 2rem;
 }
 
+/* Header Section */
 h1 {
-    text-align: center;
-    font-size: 2.2em;
-    margin-bottom: 20px;
-    color: #2A6CB5; /* A deeper, more professional blue */
+    font-size: 2rem;
+    font-weight: 700;
+    color: var(--text-primary);
+    margin-bottom: 0.5rem;
+    text-align: left;
+    letter-spacing: -0.025em;
 }
 
-h2 {
-    font-size: 1.5em;
-    margin-top: 40px;
-    margin-bottom: 15px;
-    border-bottom: 2px solid #DDE6ED; /* Lighter border color */
-}
-
-/* Info Banners */
-.info-item {
-    background-color: #E9F2FA; /* Light blue background */
-    padding: 12px 18px;
-    border-radius: 8px;
-    margin-bottom: 20px;
-    font-size: 0.95em;
-    border: 1px solid #D1E3F4; /* Light blue border */
-}
-
-.info-item strong {
-    color: #2A6CB5; /* Deeper blue for emphasis */
-}
-
-/* Tabs */
-.tabs {
-    border-bottom: 2px solid #DEE2E6;
+.header-meta {
     display: flex;
-    margin-bottom: 20px;
+    align-items: center;
+    gap: 1rem;
+    margin-bottom: 2rem;
+    color: var(--text-secondary);
+    font-size: 0.875rem;
+}
+
+.info-item {
+    background: var(--primary-light);
+    color: var(--primary-dark);
+    padding: 0.75rem 1.25rem;
+    border-radius: var(--radius-md);
+    font-weight: 500;
+    display: inline-flex;
+    align-items: center;
+    gap: 0.5rem;
+    border: 1px solid rgba(37, 99, 235, 0.1);
+}
+
+/* Navigation Tabs */
+.tabs {
+    display: flex;
+    gap: 0.5rem;
+    margin-bottom: 2rem;
+    border-bottom: 1px solid var(--border-color);
+    padding-bottom: 1px;
+    overflow-x: auto;
+    scrollbar-width: none; /* Firefox */
+}
+
+.tabs::-webkit-scrollbar {
+    display: none; /* Chrome/Safari */
 }
 
 .tabs button {
-    background: none;
+    background: transparent;
     border: none;
-    outline: none;
-    padding: 14px 20px;
+    padding: 0.75rem 1.25rem;
+    font-size: 0.95rem;
+    font-weight: 500;
+    color: var(--text-secondary);
     cursor: pointer;
-    transition: all 0.3s ease;
-    font-size: 16px;
-    color: #6C757D;
-    border-bottom: 3px solid transparent;
-    margin-bottom: -2px; /* Align with container border */
+    border-radius: var(--radius-md) var(--radius-md) 0 0;
+    transition: all 0.2s ease;
+    position: relative;
+    white-space: nowrap;
 }
 
 .tabs button:hover {
-    color: #2A6CB5;
-    background-color: #f0f4f8; /* Subtle hover background */
+    color: var(--primary-color);
+    background-color: rgba(37, 99, 235, 0.05);
 }
 
 .tabs button.active {
-    color: #2A6CB5; /* Active tab color */
-    border-bottom-color: #2A6CB5; /* Active tab border color */
+    color: var(--primary-color);
+    font-weight: 600;
 }
 
-.tab-content {
-    display: none;
-    padding-top: 10px;
+.tabs button.active::after {
+    content: '';
+    position: absolute;
+    bottom: -1px;
+    left: 0;
+    right: 0;
+    height: 2px;
+    background-color: var(--primary-color);
 }
 
-.tab-content.active {
-    display: block;
-}
-
-/* Summary Cards */
+/* Summary Cards Grid */
 .summary-cards {
     display: grid;
-    grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
-    gap: 20px;
-    margin: 20px 0;
+    grid-template-columns: repeat(auto-fit, minmax(240px, 1fr));
+    gap: 1.5rem;
+    margin-bottom: 2rem;
 }
 
 .card {
-    background-color: #FFFFFF;
-    padding: 20px;
-    border-radius: 8px;
-    text-align: center;
-    border: 1px solid #DDE6ED; /* Lighter border */
-    transition: all 0.3s ease;
+    background: var(--bg-card);
+    padding: 1.5rem;
+    border-radius: var(--radius-lg);
+    box-shadow: var(--shadow-sm);
+    border: 1px solid var(--border-color);
+    transition: transform 0.2s ease, box-shadow 0.2s ease;
+    display: flex;
+    flex-direction: column;
+    justify-content: space-between;
 }
 
 .card:hover {
-    transform: translateY(-5px);
-    box-shadow: 0 6px 15px rgba(0,0,0,0.08);
+    transform: translateY(-2px);
+    box-shadow: var(--shadow-md);
 }
 
 .card h3 {
-    margin: 0 0 10px;
-    font-size: 1em;
-    color: #6C757D;
+    font-size: 0.875rem;
+    font-weight: 500;
+    color: var(--text-secondary);
+    margin: 0 0 0.5rem 0;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
 }
 
 .card p {
+    font-size: 1.75rem;
+    font-weight: 700;
+    color: var(--text-primary);
     margin: 0;
-    font-size: 1.8em;
-    font-weight: bold;
-    color: #212529;
+    line-height: 1.2;
+}
+
+/* Dashboard Layout */
+.dashboard-layout {
+    display: grid;
+    grid-template-columns: 1fr 350px;
+    gap: 2rem;
+    align-items: start;
+}
+
+.main-content {
+    min-width: 0; /* Prevent grid blowout */
+}
+
+.sidebar-content {
+    background: var(--bg-sidebar);
+    padding: 1.5rem;
+    border-radius: var(--radius-lg);
+    border: 1px solid var(--border-color);
+    box-shadow: var(--shadow-sm);
+    position: sticky;
+    top: 2rem;
+    max-height: calc(100vh - 4rem);
+    overflow-y: auto;
+}
+
+/* Charts */
+.chart-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(450px, 1fr));
+    gap: 1.5rem;
+    margin-bottom: 2rem;
+}
+
+.chart-container, .chart-wrapper {
+    background: var(--bg-card);
+    padding: 1.5rem;
+    border-radius: var(--radius-lg);
+    border: 1px solid var(--border-color);
+    box-shadow: var(--shadow-sm);
+    position: relative;
+    height: auto;
+    min-height: 350px;
+    max-height: 600px;
+    overflow: hidden;
+}
+
+.chart-container > div, .chart-wrapper > div {
+    max-width: 100%;
+    max-height: 100%;
+}
+
+.chart-container h3, .chart-wrapper h3 {
+    margin-top: 0;
+    font-size: 1.1rem;
+    color: var(--text-primary);
+    margin-bottom: 1rem;
 }
 
 /* Tables */
+.table-container {
+    background: var(--bg-card);
+    border-radius: var(--radius-lg);
+    border: 1px solid var(--border-color);
+    box-shadow: var(--shadow-sm);
+    overflow: hidden;
+    margin-bottom: 2rem;
+}
+
 table {
     width: 100%;
     border-collapse: collapse;
-    margin-top: 15px;
-    font-size: 0.9em;
+    font-size: 0.875rem;
 }
 
-th, td {
-    padding: 12px 15px;
-    text-align: left;
-    border-bottom: 1px solid #EAEAEA;
-}
 th {
-    background-color: #4A90E2; /* Main theme blue */
+    background: var(--bg-body);
+    padding: 1rem;
+    text-align: left;
+    font-weight: 600;
+    color: var(--text-secondary);
+    border-bottom: 1px solid var(--border-color);
+    white-space: nowrap;
+}
+
+td {
+    padding: 1rem;
+    border-bottom: 1px solid var(--border-color);
+    color: var(--text-primary);
+}
+
+tr:last-child td {
+    border-bottom: none;
+}
+
+tr:hover td {
+    background-color: var(--primary-light);
+}
+
+/* Section Headers */
+h2 {
+    font-size: 1.5rem;
+    font-weight: 600;
+    color: var(--text-primary);
+    margin: 2.5rem 0 1.5rem;
+    display: flex;
+    align-items: center;
+    gap: 0.75rem;
+}
+
+h2::before {
+    content: '';
+    display: block;
+    width: 4px;
+    height: 24px;
+    background: var(--primary-color);
+    border-radius: 2px;
+}
+
+/* Time Range Buttons */
+.time-range-controls {
+    display: flex;
+    justify-content: center;
+    gap: 0.5rem;
+    margin-bottom: 1.5rem;
+}
+
+.time-range-btn {
+    background: var(--bg-card);
+    border: 1px solid var(--border-color);
+    color: var(--text-secondary);
+    padding: 0.5rem 1rem;
+    border-radius: 2rem;
+    font-size: 0.875rem;
+    font-weight: 500;
+    cursor: pointer;
+    transition: all 0.2s;
+}
+
+.time-range-btn:hover {
+    border-color: var(--primary-color);
+    color: var(--primary-color);
+}
+
+.time-range-btn.active {
+    background: var(--primary-color);
     color: white;
-    font-weight: bold;
-    font-size: 0.95em;
-    text-transform: uppercase;
-    letter-spacing: 0.5px;
-}
-
-tr:nth-child(even) {
-    background-color: #F7FAFC; /* Very light blue for alternate rows */
-}
-
-tr:hover {
-    background-color: #E9F2FA; /* Light blue for hover */
-}
-
-/* Chart Container in Sidebar */
-.chart-container {
-    position: relative;
-    height: 300px; /* Adjust height as needed */
-    width: 100%;
-    margin-bottom: 20px;
+    border-color: var(--primary-color);
+    box-shadow: 0 2px 4px rgba(37, 99, 235, 0.2);
 }
 
 /* Footer */
 .footer {
     text-align: center;
-    margin-top: 40px;
-    font-size: 0.85em;
-    color: #6C757D;
+    margin-top: 4rem;
+    padding-top: 2rem;
+    border-top: 1px solid var(--border-color);
+    color: var(--text-muted);
+    font-size: 0.875rem;
+}
+
+/* Animations */
+@keyframes fadeIn {
+    from { opacity: 0; transform: translateY(10px); }
+    to { opacity: 1; transform: translateY(0); }
+}
+
+.tab-content {
+    display: none;
+}
+
+.tab-content.active {
+    display: block;
+    animation: fadeIn 0.4s ease-out;
+}
+
+/* Responsive */
+@media (max-width: 1200px) {
+    .dashboard-layout {
+        grid-template-columns: 1fr;
+    }
+    
+    .sidebar-content {
+        position: static;
+        max-height: none;
+        margin-top: 2rem;
+    }
+}
+
+@media (max-width: 768px) {
+    .container {
+        padding: 1rem;
+    }
+    
+    .chart-grid {
+        grid-template-columns: 1fr;
+    }
+    
+    .summary-cards {
+        grid-template-columns: 1fr 1fr;
+    }
+    
+    h1 {
+        font-size: 1.5rem;
+    }
+    
+    .table-container {
+        overflow-x: auto;
+    }
 }
diff --git a/src/chat/utils/templates/report.html b/src/chat/utils/templates/report.html
index b70146063..6fa4cacda 100644
--- a/src/chat/utils/templates/report.html
+++ b/src/chat/utils/templates/report.html
@@ -4,20 +4,31 @@
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>{{ report_title }}</title>
-    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&family=Roboto:wght@300;400;500;700&display=swap" rel="stylesheet">
+    <link href="https://fonts.googleapis.com/icon?family=Material+Icons" rel="stylesheet">
+    <script src="https://cdn.jsdelivr.net/npm/echarts@5/dist/echarts.min.js" defer></script>
     <style>{{ report_css }}</style>
 </head>
 <body>
     <div class="container">
         <h1>{{ report_title }}</h1>
-        <p class="info-item"><strong>统计截止时间:</strong> {{ generation_time }}</p>
+        <div class="header-meta">
+            <div class="info-item">
+                <span class="material-icons" style="font-size: 18px;">schedule</span>
+                <strong>统计截止时间:</strong> {{ generation_time }}
+            </div>
+        </div>
         <div class="tabs">{{ tab_list }}</div>
         {{ tab_content }}
+        <div class="footer">
+            <p>💡 提示: 点击图表上的图例可以切换数据显示 | 🔄 数据每5分钟自动更新一次</p>
+            <p style="margin-top: 10px; color: #94a3b8;">Powered by MoFox-Bot Statistics Engine</p>
+        </div>
     </div>
-    <script>
-        const all_chart_data_json_string = `{{ all_chart_data|safe }}`;
-        const static_chart_data_json_string = `{{ static_chart_data|safe }}`;
-    </script>
+    <script type="application/json" id="all_chart_data">{{ all_chart_data|safe }}</script>
+    <script type="application/json" id="static_chart_data">{{ static_chart_data|safe }}</script>
     <script>{{ report_js }}</script>
 </body>
 </html>
\ No newline at end of file
diff --git a/src/chat/utils/templates/report.js b/src/chat/utils/templates/report.js
index 8cec90b56..bf6b7d926 100644
--- a/src/chat/utils/templates/report.js
+++ b/src/chat/utils/templates/report.js
@@ -3,144 +3,1065 @@ tab_content = document.getElementsByClassName("tab-content");
 tab_links = document.getElementsByClassName("tab-link");
 if (tab_content.length > 0) tab_content[0].classList.add("active");
 if (tab_links.length > 0) tab_links[0].classList.add("active");
+
+// 跟踪哪些tab的图表已经初始化
+const initializedTabs = new Set();
+// 存储ECharts实例以便销毁和resize
+const chartInstances = {};
+// 存储初始化函数的引用，以便在showTab中调用
+let initializeStaticChartsForPeriod = null;
+
 function showTab(evt, tabName) {
-    for (i = 0; i < tab_content.length; i++) tab_content[i].classList.remove("active");
-    for (i = 0; i < tab_links.length; i++) tab_links[i].classList.remove("active");
+    for (i = 0; i < tab_content.length; i++) {
+        tab_content[i].classList.remove("active");
+        tab_content[i].style.animation = '';
+    }
+    for (i = 0; i < tab_links.length; i++) {
+        tab_links[i].classList.remove("active");
+    }
     document.getElementById(tabName).classList.add("active");
+    document.getElementById(tabName).style.animation = 'slideIn 0.5s ease-out';
     evt.currentTarget.classList.add("active");
+    
+    // 懒加载：只在第一次切换到tab时初始化该tab的图表
+    if (!initializedTabs.has(tabName)) {
+        if (tabName === 'charts') {
+            if (window.initChartsTab) window.initChartsTab();
+        } else if (initializeStaticChartsForPeriod) {
+            initializeStaticChartsForPeriod(tabName);
+        }
+        initializedTabs.add(tabName);
+    }
+    
+    // Resize当前tab的图表以确保正确显示
+    setTimeout(() => {
+        Object.values(chartInstances).forEach(chart => {
+            if (chart && chart.resize) chart.resize();
+        });
+    }, 100);
 }
 
+// 窗口resize时调整所有图表
+window.addEventListener('resize', function() {
+    Object.values(chartInstances).forEach(chart => {
+        if (chart && chart.resize) chart.resize();
+    });
+});
+
 document.addEventListener('DOMContentLoaded', function () {
- // Chart data is injected by python via the HTML template.
-    let allChartData = {};
-    try {
-        allChartData = JSON.parse(all_chart_data_json_string);
-    } catch (e) {
-        console.error("Failed to parse all_chart_data:", e);
-        console.error("Problematic all_chart_data string:", all_chart_data_json_string);
+    // ECharts 通用配色
+    const colors = [
+        '#2563eb', '#3b82f6', '#60a5fa', '#0891b2', '#06b6d4',
+        '#059669', '#10b981', '#7c3aed', '#8b5cf6', '#ec4899',
+        '#f97316', '#eab308', '#84cc16', '#14b8a6', '#6366f1'
+    ];
+    
+    // Chart data is injected by python via the HTML template.
+    let allChartData = null;
+    function getAllChartData() {
+        if (!allChartData) {
+            try {
+                const el = document.getElementById('all_chart_data');
+                if (el) allChartData = JSON.parse(el.textContent);
+            } catch (e) {
+                console.error("Failed to parse all_chart_data:", e);
+            }
+        }
+        return allChartData || {};
     }
 
-    let currentCharts = {};
     const chartConfigs = {
-        totalCost: { id: 'totalCostChart', title: '总花费', yAxisLabel: '花费 (¥)', dataKey: 'total_cost_data', fill: true },
-        costByModule: { id: 'costByModuleChart', title: '各模块花费', yAxisLabel: '花费 (¥)', dataKey: 'cost_by_module', fill: false },
-        costByModel: { id: 'costByModelChart', title: '各模型花费', yAxisLabel: '花费 (¥)', dataKey: 'cost_by_model', fill: false },
-        messageByChat: { id: 'messageByChatChart', title: '各聊天流消息数', yAxisLabel: '消息数', dataKey: 'message_by_chat', fill: false }
+        totalCost: { id: 'totalCostChart', title: '总花费趋势', yAxisLabel: '花费 (¥)', dataKey: 'total_cost_data' },
+        costByModule: { id: 'costByModuleChart', title: '各模块花费对比', yAxisLabel: '花费 (¥)', dataKey: 'cost_by_module' },
+        costByModel: { id: 'costByModelChart', title: '各模型花费对比', yAxisLabel: '花费 (¥)', dataKey: 'cost_by_model' },
+        messageByChat: { id: 'messageByChatChart', title: '各聊天流消息统计', yAxisLabel: '消息数', dataKey: 'message_by_chat' }
     };
 
     window.switchTimeRange = function(timeRange) {
         document.querySelectorAll('.time-range-btn').forEach(btn => btn.classList.remove('active'));
         event.target.classList.add('active');
-        updateAllCharts(allChartData[timeRange], timeRange);
+        const data = getAllChartData();
+        if (data && data[timeRange]) {
+            updateAllCharts(data[timeRange], timeRange);
+        }
     }
 
     function updateAllCharts(data, timeRange) {
-        Object.values(currentCharts).forEach(chart => chart && chart.destroy());
-        currentCharts = {};
         Object.keys(chartConfigs).forEach(type => createChart(type, data, timeRange));
     }
 
     function createChart(chartType, data, timeRange) {
         const config = chartConfigs[chartType];
         if (!data || !data[config.dataKey]) return;
-        const colors = ['#3498db', '#e74c3c', '#2ecc71', '#f39c12', '#9b59b6', '#1abc9c', '#34495e', '#e67e22', '#95a5a6', '#f1c40f'];
-        let datasets = [];
+        
+        const container = document.getElementById(config.id);
+        if (!container) return;
+        
+        // 销毁已存在的实例
+        if (chartInstances[config.id]) {
+            chartInstances[config.id].dispose();
+        }
+        
+        const chart = echarts.init(container);
+        chartInstances[config.id] = chart;
+        
+        let series = [];
+        let legendData = [];
+        
         if (chartType === 'totalCost') {
-            datasets = [{ label: config.title, data: data[config.dataKey], borderColor: colors[0], backgroundColor: 'rgba(52, 152, 219, 0.1)', tension: 0.4, fill: config.fill }];
+            series = [{
+                name: config.title,
+                type: 'line',
+                data: data[config.dataKey],
+                smooth: 0.4,
+                areaStyle: {
+                    color: new echarts.graphic.LinearGradient(0, 0, 0, 1, [
+                        { offset: 0, color: 'rgba(37, 99, 235, 0.3)' },
+                        { offset: 1, color: 'rgba(37, 99, 235, 0.05)' }
+                    ])
+                },
+                lineStyle: { width: 2, color: '#2563eb' },
+                itemStyle: { color: '#2563eb' },
+                showSymbol: false,
+                emphasis: { focus: 'series' }
+            }];
         } else {
             let i = 0;
             Object.entries(data[config.dataKey]).forEach(([name, chartData]) => {
-                datasets.push({ label: name, data: chartData, borderColor: colors[i % colors.length], backgroundColor: colors[i % colors.length] + '20', tension: 0.4, fill: config.fill });
+                legendData.push(name);
+                series.push({
+                    name: name,
+                    type: 'line',
+                    data: chartData,
+                    smooth: 0.4,
+                    lineStyle: { width: 2, color: colors[i % colors.length] },
+                    itemStyle: { color: colors[i % colors.length] },
+                    showSymbol: false,
+                    emphasis: { focus: 'series' }
+                });
                 i++;
             });
         }
-        currentCharts[chartType] = new Chart(document.getElementById(config.id), {
-            type: 'line',
-            data: { labels: data.time_labels, datasets: datasets },
-            options: {
-                responsive: true,
-                plugins: { title: { display: true, text: `${timeRange}内${config.title}趋势`, font: { size: 16 } }, legend: { display: chartType !== 'totalCost', position: 'top' } },
-                scales: { x: { title: { display: true, text: '时间' }, ticks: { maxTicksLimit: 12 } }, y: { title: { display: true, text: config.yAxisLabel }, beginAtZero: true } },
-                interaction: { intersect: false, mode: 'index' }
-            }
-        });
+        
+        // 动态计算图例和布局
+        const hasLegend = chartType !== 'totalCost';
+        const legendItemCount = legendData.length;
+        const needsScrollLegend = legendItemCount > 5;
+        
+        const option = {
+            title: {
+                text: config.title,
+                left: 'left',
+                textStyle: {
+                    fontSize: 16,
+                    fontWeight: 600,
+                    fontFamily: "'Inter', sans-serif",
+                    color: '#0f172a'
+                }
+            },
+            tooltip: {
+                trigger: 'axis',
+                backgroundColor: '#ffffff',
+                borderColor: '#e2e8f0',
+                borderWidth: 1,
+                padding: 12,
+                textStyle: { color: '#475569', fontSize: 12 },
+                axisPointer: { type: 'cross', crossStyle: { color: '#999' } },
+                confine: true // 防止tooltip溢出容器
+            },
+            legend: {
+                show: hasLegend,
+                data: legendData,
+                type: 'scroll',
+                orient: needsScrollLegend ? 'vertical' : 'horizontal',
+                right: needsScrollLegend ? 10 : 'center',
+                top: needsScrollLegend ? 50 : 35,
+                left: needsScrollLegend ? 'auto' : 'center',
+                width: needsScrollLegend ? '20%' : 'auto',
+                icon: 'circle',
+                itemWidth: 8,
+                itemHeight: 8,
+                textStyle: { 
+                    fontSize: 11,
+                    width: needsScrollLegend ? 80 : 'auto',
+                    overflow: 'truncate',
+                    ellipsis: '...'
+                },
+                pageButtonItemGap: 5,
+                pageButtonGap: 5,
+                pageIconColor: '#2563eb',
+                pageIconInactiveColor: '#aaa',
+                pageTextStyle: { fontSize: 10 },
+                formatter: function(name) {
+                    return name.length > 15 ? name.substring(0, 15) + '...' : name;
+                },
+                tooltip: { show: true } // 鼠标悬停显示完整名称
+            },
+            grid: {
+                left: '3%',
+                right: needsScrollLegend && hasLegend ? '22%' : '4%',
+                bottom: '12%',
+                top: chartType === 'totalCost' ? 60 : (needsScrollLegend ? 60 : 80),
+                containLabel: true
+            },
+            dataZoom: [
+                {
+                    type: 'inside',
+                    xAxisIndex: 0,
+                    filterMode: 'none',
+                    zoomOnMouseWheel: 'shift', // 按shift滚轮缩放
+                    moveOnMouseMove: true
+                },
+                {
+                    type: 'slider',
+                    xAxisIndex: 0,
+                    height: 20,
+                    bottom: 5,
+                    handleSize: '100%',
+                    showDetail: false,
+                    brushSelect: false
+                }
+            ],
+            xAxis: {
+                type: 'category',
+                data: data.time_labels,
+                boundaryGap: false,
+                axisLine: { show: false },
+                axisTick: { show: false },
+                axisLabel: { color: '#94a3b8', fontSize: 11 },
+                splitLine: { show: false }
+            },
+            yAxis: {
+                type: 'value',
+                name: config.yAxisLabel,
+                nameTextStyle: { color: '#94a3b8', fontSize: 11 },
+                axisLine: { show: false },
+                axisTick: { show: false },
+                axisLabel: { color: '#94a3b8', fontSize: 11 },
+                splitLine: { lineStyle: { color: '#f1f5f9', type: 'dashed' } }
+            },
+            series: series,
+            animation: true,
+            animationDuration: 800,
+            animationEasing: 'cubicOut'
+        };
+        
+        chart.setOption(option);
     }
 
-    if (allChartData['24h']) {
-        updateAllCharts(allChartData['24h'], '24h');
-        // Activate the 24h button by default
-        document.querySelectorAll('.time-range-btn').forEach(btn => {
-            if (btn.textContent.includes('24小时')) {
-                btn.classList.add('active');
-            } else {
-                btn.classList.remove('active');
-            }
-        });
-    }
+    // Function to initialize charts tab
+    window.initChartsTab = function() {
+        const data = getAllChartData();
+        if (data['24h']) {
+            updateAllCharts(data['24h'], '24h');
+            document.querySelectorAll('.time-range-btn').forEach(btn => {
+                if (btn.textContent.includes('24小时')) {
+                    btn.classList.add('active');
+                } else {
+                    btn.classList.remove('active');
+                }
+            });
+        }
+    };
 
     // Static charts
-    let staticChartData = {};
-    try {
-        staticChartData = JSON.parse(static_chart_data_json_string);
-    } catch (e) {
-        console.error("Failed to parse static_chart_data:", e);
-        console.error("Problematic static_chart_data string:", static_chart_data_json_string);
+    let staticChartData = null;
+    function getStaticChartData() {
+        if (!staticChartData) {
+            try {
+                const el = document.getElementById('static_chart_data');
+                if (el) staticChartData = JSON.parse(el.textContent);
+            } catch (e) {
+                console.error("Failed to parse static_chart_data:", e);
+            }
+        }
+        return staticChartData || {};
     }
 
-    Object.keys(staticChartData).forEach(period_id => {
-        const providerCostData = staticChartData[period_id].provider_cost_data;
-        const modelCostData = staticChartData[period_id].model_cost_data;
-        const colors = ['#3498db', '#2ecc71', '#f1c40f', '#e74c3c', '#9b59b6', '#1abc9c', '#34495e', '#e67e22'];
+    // ECharts 扩展调色板
+    const extendedColors = [
+        '#1976D2', '#42A5F5', '#2196F3', '#64B5F6', '#90CAF9',
+        '#00BCD4', '#26C6DA', '#4DD0E1', '#009688', '#26A69A',
+        '#4CAF50', '#66BB6A', '#81C784', '#FF9800', '#FFA726',
+        '#FF5722', '#FF7043', '#9C27B0', '#AB47BC', '#E91E63',
+        '#EC407A', '#607D8B', '#78909C'
+    ];
 
-        // Provider Cost Pie Chart
-        const providerCtx = document.getElementById(`providerCostPieChart_${period_id}`);
-        if (providerCtx && providerCostData && providerCostData.data && providerCostData.data.length > 0) {
-            new Chart(providerCtx, {
-                type: 'pie',
-                data: {
-                    labels: providerCostData.labels,
-                    datasets: [{
-                        label: '按供应商花费',
-                        data: providerCostData.data,
-                        backgroundColor: colors,
-                    }]
-                },
-                options: {
-                    responsive: true,
-                    maintainAspectRatio: false,
-                    plugins: {
-                        title: { display: true, text: '按供应商花费分布', font: { size: 16 } },
-                        legend: { position: 'top' }
-                    }
-                }
-            });
+    // 懒加载函数：只初始化指定tab的静态图表
+    initializeStaticChartsForPeriod = function(period_id) {
+        const data = getStaticChartData();
+        if (!data[period_id]) {
+            console.warn(`No static chart data for period: ${period_id}`);
+            return;
         }
+        
+        const providerCostData = data[period_id].provider_cost_data;
+        const moduleCostData = data[period_id].module_cost_data;
+        const modelCostData = data[period_id].model_cost_data;
 
-        // Model Cost Bar Chart
-        const modelCtx = document.getElementById(`modelCostBarChart_${period_id}`);
-        if (modelCtx && modelCostData && modelCostData.data && modelCostData.data.length > 0) {
-            new Chart(modelCtx, {
-                type: 'bar',
-                data: {
-                    labels: modelCostData.labels,
-                    datasets: [{
-                        label: '按模型花费',
-                        data: modelCostData.data,
-                        backgroundColor: colors,
-                    }]
+        // 1. Provider Cost Pie Chart
+        const providerContainer = document.getElementById(`providerCostPieChart_${period_id}`);
+        if (providerContainer && providerCostData && providerCostData.data && providerCostData.data.length > 0) {
+            if (chartInstances[`providerCostPieChart_${period_id}`]) {
+                chartInstances[`providerCostPieChart_${period_id}`].dispose();
+            }
+            const chart = echarts.init(providerContainer);
+            chartInstances[`providerCostPieChart_${period_id}`] = chart;
+            
+            const pieData = providerCostData.labels.map((label, idx) => ({
+                name: label,
+                value: providerCostData.data[idx]
+            }));
+            
+            chart.setOption({
+                tooltip: {
+                    trigger: 'item',
+                    backgroundColor: 'rgba(0, 0, 0, 0.8)',
+                    padding: 12,
+                    borderRadius: 8,
+                    textStyle: { color: '#fff' },
+                    confine: true,
+                    formatter: function(params) {
+                        return `${params.name}<br/>花费: ${params.value.toFixed(4)} ¥<br/>占比: ${params.percent.toFixed(2)}%`;
+                    }
                 },
-                options: {
-                    responsive: true,
-                    maintainAspectRatio: false,
-                    plugins: {
-                        title: { display: true, text: '按模型花费排行', font: { size: 16 } },
-                        legend: { display: false }
+                legend: {
+                    type: 'scroll',
+                    orient: 'horizontal',
+                    left: 'center',
+                    top: 0,
+                    width: '90%',
+                    icon: 'circle',
+                    itemWidth: 8,
+                    itemHeight: 8,
+                    itemGap: 12,
+                    textStyle: { 
+                        fontSize: 10,
+                        width: 80,
+                        overflow: 'truncate',
+                        ellipsis: '...'
                     },
-                    scales: {
-                        y: { beginAtZero: true, title: { display: true, text: '花费 (¥)' } }
-                    }
-                }
+                    pageButtonItemGap: 5,
+                    pageButtonGap: 5,
+                    pageIconColor: '#2563eb',
+                    pageIconInactiveColor: '#aaa',
+                    pageTextStyle: { fontSize: 10 },
+                    tooltip: { show: true }
+                },
+                series: [{
+                    type: 'pie',
+                    radius: ['45%', '70%'],
+                    center: ['50%', '55%'],
+                    avoidLabelOverlap: true,
+                    itemStyle: {
+                        borderColor: '#fff',
+                        borderWidth: 2,
+                        borderRadius: 4
+                    },
+                    label: { show: false },
+                    emphasis: {
+                        label: { show: true, fontSize: 12, fontWeight: 'bold' },
+                        itemStyle: { shadowBlur: 10, shadowOffsetX: 0, shadowColor: 'rgba(0, 0, 0, 0.5)' }
+                    },
+                    data: pieData,
+                    color: extendedColors
+                }],
+                animation: true,
+                animationDuration: 1000
             });
         }
-    });
-});
\ No newline at end of file
+
+        // 2. Module Cost Pie Chart
+        const moduleContainer = document.getElementById(`moduleCostPieChart_${period_id}`);
+        if (moduleContainer && moduleCostData && moduleCostData.data && moduleCostData.data.length > 0) {
+            if (chartInstances[`moduleCostPieChart_${period_id}`]) {
+                chartInstances[`moduleCostPieChart_${period_id}`].dispose();
+            }
+            const chart = echarts.init(moduleContainer);
+            chartInstances[`moduleCostPieChart_${period_id}`] = chart;
+            
+            const pieData = moduleCostData.labels.map((label, idx) => ({
+                name: label,
+                value: moduleCostData.data[idx]
+            }));
+            
+            chart.setOption({
+                tooltip: {
+                    trigger: 'item',
+                    backgroundColor: 'rgba(0, 0, 0, 0.8)',
+                    padding: 12,
+                    borderRadius: 8,
+                    textStyle: { color: '#fff' },
+                    confine: true,
+                    formatter: function(params) {
+                        return `${params.name}<br/>花费: ${params.value.toFixed(4)} ¥<br/>占比: ${params.percent.toFixed(2)}%`;
+                    }
+                },
+                legend: {
+                    type: 'scroll',
+                    orient: 'horizontal',
+                    left: 'center',
+                    top: 0,
+                    width: '90%',
+                    icon: 'circle',
+                    itemWidth: 8,
+                    itemHeight: 8,
+                    itemGap: 12,
+                    textStyle: { 
+                        fontSize: 10,
+                        width: 80,
+                        overflow: 'truncate',
+                        ellipsis: '...'
+                    },
+                    pageButtonItemGap: 5,
+                    pageButtonGap: 5,
+                    pageIconColor: '#2563eb',
+                    pageIconInactiveColor: '#aaa',
+                    pageTextStyle: { fontSize: 10 },
+                    tooltip: { show: true }
+                },
+                series: [{
+                    type: 'pie',
+                    radius: ['45%', '70%'],
+                    center: ['50%', '55%'],
+                    avoidLabelOverlap: true,
+                    itemStyle: {
+                        borderColor: '#fff',
+                        borderWidth: 2,
+                        borderRadius: 4
+                    },
+                    label: { show: false },
+                    emphasis: {
+                        label: { show: true, fontSize: 12, fontWeight: 'bold' },
+                        itemStyle: { shadowBlur: 10, shadowOffsetX: 0, shadowColor: 'rgba(0, 0, 0, 0.5)' }
+                    },
+                    data: pieData,
+                    color: extendedColors
+                }],
+                animation: true,
+                animationDuration: 1000
+            });
+        }
+
+        // 3. Model Cost Bar Chart
+        const modelContainer = document.getElementById(`modelCostBarChart_${period_id}`);
+        if (modelContainer && modelCostData && modelCostData.data && modelCostData.data.length > 0) {
+            if (chartInstances[`modelCostBarChart_${period_id}`]) {
+                chartInstances[`modelCostBarChart_${period_id}`].dispose();
+            }
+            
+            // 动态调整高度，限制最大高度并使用滚动
+            const itemCount = modelCostData.labels.length;
+            const needsZoom = itemCount > 15;
+            const minHeight = needsZoom ? 450 : Math.max(350, itemCount * 25);
+            modelContainer.style.height = minHeight + 'px';
+            
+            const chart = echarts.init(modelContainer);
+            chartInstances[`modelCostBarChart_${period_id}`] = chart;
+            
+            // 计算显示范围（如果数据太多只显示前15个，其余通过滚动查看）
+            const displayEnd = needsZoom ? Math.min(100, Math.round(15 / itemCount * 100)) : 100;
+            
+            chart.setOption({
+                tooltip: {
+                    trigger: 'axis',
+                    backgroundColor: 'rgba(0, 0, 0, 0.8)',
+                    padding: 12,
+                    borderRadius: 8,
+                    textStyle: { color: '#fff' },
+                    axisPointer: { type: 'shadow' },
+                    confine: true,
+                    formatter: function(params) {
+                        if (params[0]) {
+                            return `${params[0].name}<br/>花费: ${params[0].value.toFixed(4)} ¥`;
+                        }
+                        return '';
+                    }
+                },
+                grid: {
+                    left: '3%',
+                    right: needsZoom ? '8%' : '4%',
+                    bottom: '3%',
+                    top: 30,
+                    containLabel: true
+                },
+                dataZoom: needsZoom ? [
+                    {
+                        type: 'slider',
+                        yAxisIndex: 0,
+                        right: 5,
+                        width: 20,
+                        start: 0,
+                        end: displayEnd,
+                        handleSize: '100%',
+                        showDetail: false,
+                        brushSelect: false
+                    },
+                    {
+                        type: 'inside',
+                        yAxisIndex: 0,
+                        zoomOnMouseWheel: false,
+                        moveOnMouseMove: true,
+                        moveOnMouseWheel: true
+                    }
+                ] : [],
+                xAxis: {
+                    type: 'value',
+                    name: '💰 花费 (¥)',
+                    nameTextStyle: { fontSize: 11, fontWeight: 'bold' },
+                    axisLabel: { fontSize: 10 },
+                    splitLine: { lineStyle: { color: 'rgba(0, 0, 0, 0.05)' } }
+                },
+                yAxis: {
+                    type: 'category',
+                    data: modelCostData.labels,
+                    axisLabel: {
+                        fontSize: 9,
+                        formatter: function(value) {
+                            return value.length > 25 ? value.substring(0, 25) + '...' : value;
+                        }
+                    },
+                    axisTick: { show: false },
+                    axisLine: { show: false }
+                },
+                series: [{
+                    type: 'bar',
+                    data: modelCostData.data.map((value, idx) => ({
+                        value: value,
+                        itemStyle: { 
+                            color: extendedColors[idx % extendedColors.length],
+                            borderRadius: [0, 6, 6, 0]
+                        }
+                    })),
+                    barMaxWidth: 40,
+                    emphasis: {
+                        itemStyle: { shadowBlur: 10, shadowColor: 'rgba(0, 0, 0, 0.3)' }
+                    }
+                }],
+                animation: true,
+                animationDuration: 1000,
+                // 大数据优化
+                large: true,
+                largeThreshold: 100
+            });
+        }
+
+        // === 新增图表 ===
+        
+        // 4. Token使用对比条形图
+        const tokenCompData = data[period_id].token_comparison_data;
+        const tokenCompContainer = document.getElementById(`tokenComparisonChart_${period_id}`);
+        if (tokenCompContainer && tokenCompData && tokenCompData.labels && tokenCompData.labels.length > 0) {
+            if (chartInstances[`tokenComparisonChart_${period_id}`]) {
+                chartInstances[`tokenComparisonChart_${period_id}`].dispose();
+            }
+            
+            const itemCount = tokenCompData.labels.length;
+            const needsZoom = itemCount > 10;
+            const minHeight = needsZoom ? 400 : Math.max(350, itemCount * 30);
+            tokenCompContainer.style.height = minHeight + 'px';
+            
+            const chart = echarts.init(tokenCompContainer);
+            chartInstances[`tokenComparisonChart_${period_id}`] = chart;
+            
+            // 处理数据，避免 log 轴报错 (0值转为1)
+            const inputData = tokenCompData.input_tokens.map(v => v < 1 ? 1 : v);
+            const outputData = tokenCompData.output_tokens.map(v => v < 1 ? 1 : v);
+            
+            chart.setOption({
+                tooltip: {
+                    trigger: 'axis',
+                    backgroundColor: 'rgba(0, 0, 0, 0.8)',
+                    padding: 12,
+                    borderRadius: 8,
+                    textStyle: { color: '#fff' },
+                    axisPointer: { type: 'shadow' },
+                    confine: true,
+                    formatter: function(params) {
+                        let result = params[0].name + '<br/>';
+                        params.forEach(p => {
+                            // 恢复原始值显示
+                            const rawValue = p.value === 1 ? 0 : p.value;
+                            const total = tokenCompData.input_tokens.reduce((a, b) => a + b, 0) + 
+                                         tokenCompData.output_tokens.reduce((a, b) => a + b, 0);
+                            const pct = total > 0 ? ((rawValue / total) * 100).toFixed(1) : '0.0';
+                            result += `${p.marker} ${p.seriesName}: ${rawValue.toLocaleString()} tokens (${pct}%)<br/>`;
+                        });
+                        return result;
+                    }
+                },
+                legend: {
+                    data: ['输入Token', '输出Token'],
+                    top: 0,
+                    icon: 'circle',
+                    itemWidth: 10,
+                    itemHeight: 10
+                },
+                grid: {
+                    left: '3%',
+                    right: needsZoom ? '8%' : '4%',
+                    bottom: '8%',
+                    top: 30,
+                    containLabel: true
+                },
+                dataZoom: needsZoom ? [
+                    {
+                        type: 'slider',
+                        yAxisIndex: 0,
+                        right: 5,
+                        width: 20,
+                        start: 0,
+                        end: Math.min(100, Math.round(10 / itemCount * 100)),
+                        handleSize: '100%',
+                        showDetail: false,
+                        brushSelect: false
+                    },
+                    {
+                        type: 'inside',
+                        yAxisIndex: 0,
+                        zoomOnMouseWheel: 'shift',
+                        moveOnMouseMove: true,
+                        moveOnMouseWheel: true
+                    }
+                ] : [],
+                xAxis: {
+                    type: 'log',
+                    min: 1,
+                    logBase: 10,
+                    name: 'Token数量 (对数)',
+                    nameTextStyle: { fontSize: 11, fontWeight: 'bold' },
+                    axisLabel: { 
+                        fontSize: 10,
+                        hideOverlap: true,
+                        formatter: function(value) {
+                            if (value === 1) return '0';
+                            if (value >= 1000000) return (value / 1000000).toFixed(0) + 'M';
+                            if (value >= 1000) return (value / 1000).toFixed(0) + 'k';
+                            return value;
+                        }
+                    },
+                    splitLine: { lineStyle: { color: 'rgba(0, 0, 0, 0.05)' } }
+                },
+                yAxis: {
+                    type: 'category',
+                    data: tokenCompData.labels.map(l => l.length > 20 ? l.substring(0, 20) + '...' : l),
+                    axisLabel: { 
+                        fontSize: 9, 
+                        interval: 0
+                    },
+                    axisTick: { show: false },
+                    axisLine: { show: false }
+                },
+                series: [
+                    {
+                        name: '输入Token',
+                        type: 'bar',
+                        data: inputData,
+                        itemStyle: { color: '#FF9800', borderRadius: [0, 6, 6, 0] },
+                        barMaxWidth: 30
+                    },
+                    {
+                        name: '输出Token',
+                        type: 'bar',
+                        data: outputData,
+                        itemStyle: { color: '#4CAF50', borderRadius: [0, 6, 6, 0] },
+                        barMaxWidth: 30
+                    }
+                ],
+                animation: true,
+                animationDuration: 1000,
+                large: true,
+                largeThreshold: 100
+            });
+        }
+
+        // 5. 供应商请求占比环形图
+        const providerReqData = data[period_id].provider_requests_data;
+        const providerReqContainer = document.getElementById(`providerRequestsDoughnutChart_${period_id}`);
+        if (providerReqContainer && providerReqData && providerReqData.data && providerReqData.data.length > 0) {
+            if (chartInstances[`providerRequestsDoughnutChart_${period_id}`]) {
+                chartInstances[`providerRequestsDoughnutChart_${period_id}`].dispose();
+            }
+            const chart = echarts.init(providerReqContainer);
+            chartInstances[`providerRequestsDoughnutChart_${period_id}`] = chart;
+            
+            const pieData = providerReqData.labels.map((label, idx) => ({
+                name: label,
+                value: providerReqData.data[idx]
+            }));
+            
+            const reqColors = ['#9C27B0', '#E91E63', '#F44336', '#FF9800', '#FFC107', '#FFEB3B', '#CDDC39', '#8BC34A', '#4CAF50', '#009688'];
+            
+            chart.setOption({
+                tooltip: {
+                    trigger: 'item',
+                    backgroundColor: 'rgba(0, 0, 0, 0.8)',
+                    padding: 12,
+                    borderRadius: 8,
+                    textStyle: { color: '#fff' },
+                    confine: true,
+                    formatter: function(params) {
+                        return `${params.name}<br/>请求数: ${params.value} 次<br/>占比: ${params.percent.toFixed(2)}%`;
+                    }
+                },
+                legend: {
+                    type: 'scroll',
+                    orient: 'horizontal',
+                    left: 'center',
+                    top: 0,
+                    width: '90%',
+                    icon: 'circle',
+                    itemWidth: 8,
+                    itemHeight: 8,
+                    itemGap: 12,
+                    textStyle: { 
+                        fontSize: 10,
+                        width: 80,
+                        overflow: 'truncate',
+                        ellipsis: '...'
+                    },
+                    pageButtonItemGap: 5,
+                    pageButtonGap: 5,
+                    pageIconColor: '#9C27B0',
+                    pageIconInactiveColor: '#aaa',
+                    pageTextStyle: { fontSize: 10 },
+                    tooltip: { show: true }
+                },
+                series: [{
+                    type: 'pie',
+                    radius: ['45%', '70%'],
+                    center: ['50%', '55%'],
+                    avoidLabelOverlap: true,
+                    itemStyle: {
+                        borderColor: '#fff',
+                        borderWidth: 2,
+                        borderRadius: 4
+                    },
+                    label: { show: false },
+                    emphasis: {
+                        label: { show: true, fontSize: 12, fontWeight: 'bold' },
+                        itemStyle: { shadowBlur: 10, shadowOffsetX: 0, shadowColor: 'rgba(0, 0, 0, 0.5)' }
+                    },
+                    data: pieData,
+                    color: reqColors
+                }],
+                animation: true,
+                animationDuration: 1000
+            });
+        }
+
+        // 6. 平均响应时间条形图 (横向)
+        const avgRespTimeData = data[period_id].avg_response_time_data;
+        const avgRespTimeContainer = document.getElementById(`avgResponseTimeChart_${period_id}`);
+        if (avgRespTimeContainer && avgRespTimeData && avgRespTimeData.data && avgRespTimeData.data.length > 0) {
+            if (chartInstances[`avgResponseTimeChart_${period_id}`]) {
+                chartInstances[`avgResponseTimeChart_${period_id}`].dispose();
+            }
+            
+            const itemCount = avgRespTimeData.labels.length;
+            const needsZoom = itemCount > 12;
+            const minHeight = needsZoom ? 400 : Math.max(350, itemCount * 28);
+            avgRespTimeContainer.style.height = minHeight + 'px';
+            
+            const chart = echarts.init(avgRespTimeContainer);
+            chartInstances[`avgResponseTimeChart_${period_id}`] = chart;
+            
+            const barColors = ['#E91E63', '#9C27B0', '#673AB7', '#3F51B5', '#2196F3', '#00BCD4', '#009688', '#4CAF50'];
+            const displayEnd = needsZoom ? Math.min(100, Math.round(12 / itemCount * 100)) : 100;
+            
+            chart.setOption({
+                tooltip: {
+                    trigger: 'axis',
+                    backgroundColor: 'rgba(0, 0, 0, 0.8)',
+                    padding: 12,
+                    borderRadius: 8,
+                    textStyle: { color: '#fff' },
+                    axisPointer: { type: 'shadow' },
+                    confine: true,
+                    formatter: function(params) {
+                        if (params[0]) {
+                            return `${params[0].name}<br/>响应时间: ${params[0].value.toFixed(3)} 秒`;
+                        }
+                        return '';
+                    }
+                },
+                grid: {
+                    left: '3%',
+                    right: needsZoom ? '8%' : '4%',
+                    bottom: '3%',
+                    top: 30,
+                    containLabel: true
+                },
+                dataZoom: needsZoom ? [
+                    {
+                        type: 'slider',
+                        yAxisIndex: 0,
+                        right: 5,
+                        width: 20,
+                        start: 0,
+                        end: displayEnd,
+                        handleSize: '100%',
+                        showDetail: false,
+                        brushSelect: false
+                    },
+                    {
+                        type: 'inside',
+                        yAxisIndex: 0,
+                        zoomOnMouseWheel: false,
+                        moveOnMouseMove: true,
+                        moveOnMouseWheel: true
+                    }
+                ] : [],
+                xAxis: {
+                    type: 'value',
+                    name: '时间 (秒)',
+                    nameTextStyle: { fontSize: 11, fontWeight: 'bold' },
+                    axisLabel: { fontSize: 10 },
+                    splitLine: { lineStyle: { color: 'rgba(0, 0, 0, 0.05)' } }
+                },
+                yAxis: {
+                    type: 'category',
+                    data: avgRespTimeData.labels.map(l => l.length > 22 ? l.substring(0, 22) + '...' : l),
+                    axisLabel: { fontSize: 9 },
+                    axisTick: { show: false },
+                    axisLine: { show: false }
+                },
+                series: [{
+                    type: 'bar',
+                    data: avgRespTimeData.data.map((value, idx) => ({
+                        value: value,
+                        itemStyle: { 
+                            color: barColors[idx % barColors.length],
+                            borderRadius: [0, 6, 6, 0]
+                        }
+                    })),
+                    barMaxWidth: 30,
+                    emphasis: {
+                        itemStyle: { shadowBlur: 10, shadowColor: 'rgba(0, 0, 0, 0.3)' }
+                    }
+                }],
+                animation: true,
+                animationDuration: 1000,
+                large: true,
+                largeThreshold: 100
+            });
+        }
+
+        // 7. 模型效率雷达图
+        const radarData = data[period_id].model_efficiency_radar_data;
+        const radarContainer = document.getElementById(`modelEfficiencyRadarChart_${period_id}`);
+        if (radarContainer && radarData && radarData.datasets && radarData.datasets.length > 0) {
+            if (chartInstances[`modelEfficiencyRadarChart_${period_id}`]) {
+                chartInstances[`modelEfficiencyRadarChart_${period_id}`].dispose();
+            }
+            const chart = echarts.init(radarContainer);
+            chartInstances[`modelEfficiencyRadarChart_${period_id}`] = chart;
+            
+            const radarColors = ['#00BCD4', '#4CAF50', '#FF9800', '#E91E63', '#9C27B0', '#673AB7', '#2196F3', '#FF5722'];
+            
+            // 限制显示的模型数量，避免图表过于拥挤
+            const maxModels = 5;
+            const limitedDatasets = radarData.datasets.slice(0, maxModels);
+            
+            const indicator = radarData.labels.map(label => ({
+                name: label.length > 12 ? label.substring(0, 12) + '...' : label,
+                max: 100
+            }));
+            
+            const seriesData = limitedDatasets.map((dataset, idx) => ({
+                name: dataset.model.length > 18 ? dataset.model.substring(0, 18) + '...' : dataset.model,
+                value: dataset.metrics,
+                lineStyle: { color: radarColors[idx % radarColors.length], width: 2 },
+                areaStyle: { color: radarColors[idx % radarColors.length] + '30' },
+                itemStyle: { color: radarColors[idx % radarColors.length] }
+            }));
+            
+            const legendCount = seriesData.length;
+            const useSideLegend = legendCount > 3;
+            
+            chart.setOption({
+                tooltip: {
+                    trigger: 'item',
+                    backgroundColor: 'rgba(0, 0, 0, 0.8)',
+                    padding: 12,
+                    borderRadius: 8,
+                    textStyle: { color: '#fff' },
+                    confine: true
+                },
+                legend: {
+                    data: seriesData.map(s => s.name),
+                    type: 'scroll',
+                    orient: useSideLegend ? 'vertical' : 'horizontal',
+                    right: useSideLegend ? 10 : 'center',
+                    top: useSideLegend ? 'middle' : 10,
+                    bottom: useSideLegend ? 'auto' : 'auto',
+                    width: useSideLegend ? '20%' : 'auto',
+                    icon: 'circle',
+                    itemWidth: 8,
+                    itemHeight: 8,
+                    textStyle: { 
+                        fontSize: 10,
+                        width: useSideLegend ? 70 : 'auto',
+                        overflow: 'truncate'
+                    },
+                    pageButtonItemGap: 5,
+                    pageIconColor: '#00BCD4',
+                    pageTextStyle: { fontSize: 9 },
+                    tooltip: { show: true }
+                },
+                radar: {
+                    indicator: indicator,
+                    center: useSideLegend ? ['40%', '50%'] : ['50%', '55%'],
+                    radius: useSideLegend ? '65%' : '55%',
+                    nameGap: 6,
+                    name: {
+                        textStyle: { fontSize: 9, fontWeight: 'bold' }
+                    },
+                    splitLine: { lineStyle: { color: 'rgba(0, 0, 0, 0.1)' } },
+                    splitArea: { show: false },
+                    axisLine: { lineStyle: { color: 'rgba(0, 0, 0, 0.1)' } }
+                },
+                series: [{
+                    type: 'radar',
+                    data: seriesData,
+                    emphasis: {
+                        lineStyle: { width: 3 }
+                    }
+                }],
+                animation: true,
+                animationDuration: 1200
+            });
+        }
+
+        // 8. 响应时间分布散点图 (大数据优化)
+        const scatterData = data[period_id].response_time_scatter_data;
+        const scatterContainer = document.getElementById(`responseTimeScatterChart_${period_id}`);
+        if (scatterContainer && scatterData && scatterData.length > 0) {
+            if (chartInstances[`responseTimeScatterChart_${period_id}`]) {
+                chartInstances[`responseTimeScatterChart_${period_id}`].dispose();
+            }
+            const chart = echarts.init(scatterContainer);
+            chartInstances[`responseTimeScatterChart_${period_id}`] = chart;
+            
+            // 按模型分组数据，使用数据采样优化性能
+            const groupedData = {};
+            const maxPointsPerModel = 150; // 每个模型最多150个点
+            scatterData.forEach(point => {
+                if (!groupedData[point.model]) {
+                    groupedData[point.model] = [];
+                }
+                if (groupedData[point.model].length < maxPointsPerModel) {
+                    groupedData[point.model].push([point.x, point.y]);
+                }
+            });
+            
+            const scatterColors = ['#4CAF50', '#2196F3', '#FF9800', '#E91E63', '#9C27B0', '#00BCD4', '#FFC107', '#607D8B'];
+            const models = Object.keys(groupedData).slice(0, 6); // 限制最多6个模型
+            const modelCount = models.length;
+            const useSideLegend = modelCount > 4;
+            
+            const series = models.map((model, idx) => ({
+                name: model.length > 18 ? model.substring(0, 18) + '...' : model,
+                type: 'scatter',
+                data: groupedData[model],
+                symbolSize: 5,
+                itemStyle: {
+                    color: scatterColors[idx % scatterColors.length],
+                    opacity: 0.7
+                },
+                emphasis: {
+                    itemStyle: { opacity: 1, shadowBlur: 10, shadowColor: 'rgba(0, 0, 0, 0.3)' }
+                },
+                // 大数据优化
+                large: true,
+                largeThreshold: 100
+            }));
+            
+            chart.setOption({
+                tooltip: {
+                    trigger: 'item',
+                    backgroundColor: 'rgba(0, 0, 0, 0.8)',
+                    padding: 12,
+                    borderRadius: 8,
+                    textStyle: { color: '#fff' },
+                    confine: true,
+                    formatter: function(params) {
+                        return `${params.seriesName}<br/>请求 #${params.data[0]}<br/>响应时间: ${params.data[1].toFixed(3)} 秒`;
+                    }
+                },
+                legend: {
+                    data: series.map(s => s.name),
+                    type: 'scroll',
+                    orient: useSideLegend ? 'vertical' : 'horizontal',
+                    right: useSideLegend ? 10 : 'center',
+                    top: useSideLegend ? 50 : 10,
+                    width: useSideLegend ? '18%' : 'auto',
+                    icon: 'circle',
+                    itemWidth: 8,
+                    itemHeight: 8,
+                    textStyle: { 
+                        fontSize: 10,
+                        width: useSideLegend ? 65 : 'auto',
+                        overflow: 'truncate'
+                    },
+                    pageButtonItemGap: 5,
+                    pageIconColor: '#4CAF50',
+                    pageTextStyle: { fontSize: 9 },
+                    tooltip: { show: true }
+                },
+                grid: {
+                    left: '3%',
+                    right: useSideLegend ? '22%' : '4%',
+                    bottom: '15%',
+                    top: useSideLegend ? 50 : 50,
+                    containLabel: true
+                },
+                xAxis: {
+                    type: 'value',
+                    name: '请求序号',
+                    nameTextStyle: { fontSize: 11, fontWeight: 'bold' },
+                    axisLabel: { fontSize: 10 },
+                    splitLine: { lineStyle: { color: 'rgba(0, 0, 0, 0.05)' } }
+                },
+                yAxis: {
+                    type: 'value',
+                    name: '响应时间 (秒)',
+                    nameTextStyle: { fontSize: 11, fontWeight: 'bold' },
+                    axisLabel: { fontSize: 10 },
+                    splitLine: { lineStyle: { color: 'rgba(0, 0, 0, 0.05)' } }
+                },
+                series: series,
+                animation: true,
+                animationDuration: 1000,
+                // 数据缩放支持 - 内置缩放
+                dataZoom: [
+                    {
+                        type: 'inside',
+                        xAxisIndex: 0,
+                        filterMode: 'empty'
+                    },
+                    {
+                        type: 'inside',
+                        yAxisIndex: 0,
+                        filterMode: 'empty'
+                    },
+                    {
+                        type: 'slider',
+                        xAxisIndex: 0,
+                        height: 20,
+                        bottom: 5,
+                        handleSize: '100%',
+                        showDetail: false
+                    }
+                ]
+            });
+        }
+    };
+    
+    // 初始化第一个tab(默认显示的tab)的图表
+    const firstTab = tab_content[0]?.id;
+    if (firstTab && firstTab !== 'charts') {
+        initializeStaticChartsForPeriod(firstTab);
+        initializedTabs.add(firstTab);
+    }
+});
diff --git a/src/chat/utils/templates/static_charts.html b/src/chat/utils/templates/static_charts.html
index 3fd37ad4e..307ec7614 100644
--- a/src/chat/utils/templates/static_charts.html
+++ b/src/chat/utils/templates/static_charts.html
@@ -1,9 +1,53 @@
-<h2>数据总览</h2>
-<div class="chart-grid">
+<div style="margin-bottom: 1.5rem;">
+    <h2 style="margin-top: 0; font-size: 1.25rem; display: flex; align-items: center; gap: 0.5rem;">
+        <span class="material-icons" style="color: var(--primary-color);">analytics</span>
+        数据可视化
+    </h2>
+    <p style="color: var(--text-secondary); font-size: 0.875rem; margin: 0;">
+        点击图例可以隐藏/显示对应的数据系列
+    </p>
+</div>
+
+<div style="display: flex; flex-direction: column; gap: 1.5rem;">
+    <!-- 原有图表 -->
     <div class="chart-container">
-        <canvas id="providerCostPieChart_{{ period_id }}"></canvas>
+        <h3>💰 供应商成本分布</h3>
+        <div id="providerCostPieChart_{{ period_id }}" style="width: 100%; height: 280px;"></div>
     </div>
+    
     <div class="chart-container">
-        <canvas id="modelCostBarChart_{{ period_id }}"></canvas>
+        <h3>📦 模块成本分布</h3>
+        <div id="moduleCostPieChart_{{ period_id }}" style="width: 100%; height: 280px;"></div>
+    </div>
+    
+    <div class="chart-container">
+        <h3>🤖 模型成本对比</h3>
+        <div id="modelCostBarChart_{{ period_id }}" style="width: 100%; height: 350px;"></div>
+    </div>
+    
+    <!-- 新增图表 -->
+    <div class="chart-container">
+        <h3>🔄 Token使用对比</h3>
+        <div id="tokenComparisonChart_{{ period_id }}" style="width: 100%; height: 350px;"></div>
+    </div>
+    
+    <div class="chart-container">
+        <h3>📞 供应商请求占比</h3>
+        <div id="providerRequestsDoughnutChart_{{ period_id }}" style="width: 100%; height: 280px;"></div>
+    </div>
+    
+    <div class="chart-container">
+        <h3>⚡ 平均响应时间</h3>
+        <div id="avgResponseTimeChart_{{ period_id }}" style="width: 100%; height: 350px;"></div>
+    </div>
+    
+    <div class="chart-container">
+        <h3>🎯 模型效率雷达</h3>
+        <div id="modelEfficiencyRadarChart_{{ period_id }}" style="width: 100%; height: 380px;"></div>
+    </div>
+    
+    <div class="chart-container">
+        <h3>⏱️ 响应时间分布</h3>
+        <div id="responseTimeScatterChart_{{ period_id }}" style="width: 100%; height: 350px;"></div>
     </div>
 </div>
\ No newline at end of file
diff --git a/src/chat/utils/templates/tab_content.html b/src/chat/utils/templates/tab_content.html
index b6c49eaf1..9e5514ca0 100644
--- a/src/chat/utils/templates/tab_content.html
+++ b/src/chat/utils/templates/tab_content.html
@@ -1,48 +1,106 @@
 <div id="{{ div_id }}" class="tab-content">
+    <div class="info-item" style="margin-bottom: 2rem; width: 100%; display: block;">
+        <div style="display: flex; align-items: center; gap: 0.5rem; margin-bottom: 1rem;">
+            <span class="material-icons" style="color: var(--primary-color);">menu_book</span>
+            <strong style="font-size: 1.1rem;">名词解释</strong>
+        </div>
+        <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 1rem; font-size: 0.9rem;">
+            <div>
+                <strong style="color: var(--primary-color);">🎯 Token:</strong> AI处理文本的基本单位
+            </div>
+            <div>
+                <strong style="color: var(--primary-color);">💸 TPS:</strong> 每秒处理的Token数量
+            </div>
+            <div>
+                <strong style="color: var(--primary-color);">📊 每K Token成本:</strong> 每1000个Token的成本
+            </div>
+            <div>
+                <strong style="color: var(--primary-color);">⚡ Token效率:</strong> 输出/输入Token比率
+            </div>
+            <div>
+                <strong style="color: var(--primary-color);">🔄 消息/请求比:</strong> 每次请求处理的消息数
+            </div>
+        </div>
+    </div>
+
     <div class="dashboard-layout">
         <div class="main-content">
-            <p class="info-item">
-                <strong>统计时段: </strong>
-                {{ start_time }} ~ {{ end_time }}
-            </p>
+            <div class="header-meta">
+                <div class="info-item">
+                    <span class="material-icons" style="font-size: 18px;">date_range</span>
+                    <strong>统计时段: </strong> {{ start_time }} ~ {{ end_time }}
+                </div>
+            </div>
+            
             {{ summary_cards }}
 
-            <h2>按模型分类统计</h2>
-            <table>
-                <tr><th>模型名称</th><th>调用次数</th><th>平均Token数</th><th>Token总量</th><th>TPS</th><th>每K Token成本</th><th>累计花费</th><th>平均耗时(秒)</th></tr>
-                <tbody>{{ model_rows }}</tbody>
-            </table>
+            <h2>🤖 按模型分类统计</h2>
+            <div class="table-container">
+                <table>
+                    <tr><th>模型名称</th><th>调用次数</th><th>平均Token数</th><th>Token总量</th><th>TPS</th><th>每K Token成本</th><th>累计花费</th><th>平均耗时(秒)</th></tr>
+                    <tbody>{{ model_rows }}</tbody>
+                </table>
+            </div>
 
-            <h2>按供应商分类统计</h2>
-            <table>
-                <tr><th>供应商名称</th><th>调用次数</th><th>Token总量</th><th>TPS</th><th>每K Token成本</th><th>累计花费</th></tr>
-                <tbody>{{ provider_rows }}</tbody>
-            </table>
+            <h2>🏢 按供应商分类统计</h2>
+            <div class="table-container">
+                <table>
+                    <thead>
+                        <tr><th>供应商名称</th><th>调用次数</th><th>Token总量</th><th>TPS</th><th>每K Token成本</th><th>累计花费</th><th>平均耗时(秒)</th></tr>
+                    </thead>
+                    <tbody>{{ provider_rows }}</tbody>
+                </table>
+            </div>
 
-            <h2>按模块分类统计</h2>
-            <table>
-                <thead>
-                    <tr><th>模块名称</th><th>调用次数</th><th>输入Token</th><th>输出Token</th><th>Token总量</th><th>累计花费</th><th>平均耗时(秒)</th><th>标准差(秒)</th></tr>
-                </thead>
-                <tbody>{{ module_rows }}</tbody>
-            </table>
+            <h2>🔧 按模块分类统计</h2>
+            <div class="table-container">
+                <table>
+                    <thead>
+                        <tr><th>模块名称</th><th>调用次数</th><th>输入Token</th><th>输出Token</th><th>Token总量</th><th>累计花费</th><th>平均耗时(秒)</th><th>标准差(秒)</th></tr>
+                    </thead>
+                    <tbody>{{ module_rows }}</tbody>
+                </table>
+            </div>
 
-            <h2>按请求类型分类统计</h2>
-            <table>
-                <thead>
-                    <tr><th>请求类型</th><th>调用次数</th><th>输入Token</th><th>输出Token</th><th>Token总量</th><th>累计花费</th><th>平均耗时(秒)</th><th>标准差(秒)</th></tr>
-                </thead>
-                <tbody>{{ type_rows }}</tbody>
-            </table>
+            <h2>📝 按请求类型分类统计</h2>
+            <div class="table-container">
+                <table>
+                    <thead>
+                        <tr><th>请求类型</th><th>调用次数</th><th>输入Token</th><th>输出Token</th><th>Token总量</th><th>累计花费</th><th>平均耗时(秒)</th><th>标准差(秒)</th></tr>
+                    </thead>
+                    <tbody>{{ type_rows }}</tbody>
+                </table>
+            </div>
 
-            <h2>聊天消息统计</h2>
-            <table>
-                <thead>
-                    <tr><th>联系人/群组名称</th><th>消息数量</th></tr>
-                </thead>
-                <tbody>{{ chat_rows }}</tbody>
-            </table>
+            <h2>💬 聊天消息统计</h2>
+            <div class="table-container">
+                <table>
+                    <thead>
+                        <tr><th>联系人/群组名称</th><th>消息数量</th></tr>
+                    </thead>
+                    <tbody>{{ chat_rows }}</tbody>
+                </table>
+            </div>
+
+            <h2>🎓 大模型效率分析</h2>
+            <div class="info-item" style="margin-bottom: 1rem;">
+                <span class="material-icons" style="font-size: 18px;">lightbulb</span>
+                <strong>提示:</strong> Token效率表示输出Token与输入Token的比率,比率越高说明模型输出越丰富
+            </div>
+            <div class="table-container">
+                <table>
+                    <thead>
+                        <tr>
+                            <th>指标</th>
+                            <th>数值</th>
+                            <th>说明</th>
+                        </tr>
+                    </thead>
+                    <tbody>{{ efficiency_rows }}</tbody>
+                </table>
+            </div>
         </div>
+        
         <div class="sidebar-content">
             {{ static_charts }}
         </div>
diff --git a/src/chat/utils/utils.py b/src/chat/utils/utils.py
index 450fff21c..381f69206 100644
--- a/src/chat/utils/utils.py
+++ b/src/chat/utils/utils.py
@@ -49,6 +49,7 @@ def is_mentioned_bot_in_message(message) -> tuple[bool, float]:
         tuple[bool, float]: (是否提及, 提及类型)
         提及类型: 0=未提及, 1=弱提及（文本匹配）, 2=强提及（@/回复/私聊）
     """
+    assert global_config is not None
     nicknames = global_config.bot.alias_names
     mention_type = 0  # 0=未提及, 1=弱提及, 2=强提及
 
@@ -132,6 +133,7 @@ def is_mentioned_bot_in_message(message) -> tuple[bool, float]:
 
 async def get_embedding(text, request_type="embedding") -> list[float] | None:
     """获取文本的embedding向量"""
+    assert model_config is not None
     # 每次都创建新的LLMRequest实例以避免事件循环冲突
     llm = LLMRequest(model_set=model_config.model_task_config.embedding, request_type=request_type)
     try:
@@ -139,11 +141,12 @@ async def get_embedding(text, request_type="embedding") -> list[float] | None:
     except Exception as e:
         logger.error(f"获取embedding失败: {e!s}")
         embedding = None
-    return embedding
+    return embedding  # type: ignore
 
 
 async def get_recent_group_speaker(chat_stream_id: str, sender, limit: int = 12) -> list:
     # 获取当前群聊记录内发言的人
+    assert global_config is not None
     filter_query = {"chat_id": chat_stream_id}
     sort_order = [("time", -1)]
     recent_messages = await find_messages(message_filter=filter_query, sort=sort_order, limit=limit)
@@ -400,11 +403,12 @@ def recover_quoted_content(sentences: list[str], placeholder_map: dict[str, str]
         recovered_sentences.append(sentence)
     return recovered_sentences
 
-
 def process_llm_response(text: str, enable_splitter: bool = True, enable_chinese_typo: bool = True) -> list[str]:
+    assert global_config is not None
     if not global_config.response_post_process.enable_response_post_process:
         return [text]
 
+    # --- 三层防护系统 ---
     # --- 三层防护系统 ---
     # 第一层：保护颜文字
     protected_text, kaomoji_mapping = protect_kaomoji(text) if global_config.response_splitter.enable_kaomoji_protection else (text, {})
diff --git a/src/chat/utils/utils_image.py b/src/chat/utils/utils_image.py
index f0ae224c8..dd2033122 100644
--- a/src/chat/utils/utils_image.py
+++ b/src/chat/utils/utils_image.py
@@ -64,8 +64,6 @@ class ImageManager:
             # except Exception as e:
             #     logger.error(f"数据库连接失败: {e}")
 
-            self._initialized = True
-
     def _ensure_image_dir(self):
         """确保图像存储目录存在"""
         os.makedirs(self.IMAGE_DIR, exist_ok=True)
@@ -159,6 +157,7 @@ class ImageManager:
     async def get_emoji_description(self, image_base64: str) -> str:
         """获取表情包描述，统一使用EmojiManager中的逻辑进行处理和缓存"""
         try:
+            assert global_config is not None
             from src.chat.emoji_system.emoji_manager import get_emoji_manager
 
             emoji_manager = get_emoji_manager()
@@ -190,7 +189,7 @@ class ImageManager:
                 return "[表情包(描述生成失败)]"
 
             # 4. (可选) 如果启用了“偷表情包”，则将图片和完整描述存入待注册区
-            if global_config and global_config.emoji and global_config.emoji.steal_emoji:
+            if global_config.emoji and global_config.emoji.steal_emoji:
                 logger.debug(f"偷取表情包功能已开启，保存待注册表情包: {image_hash}")
                 try:
                     image_format = (Image.open(io.BytesIO(image_bytes)).format or "jpeg").lower()
@@ -345,14 +344,15 @@ class ImageManager:
             # --- 新的帧选择逻辑：均匀抽取4帧 ---
             num_frames = len(all_frames)
             if num_frames <= 4:
-                # 如果总帧数小于等于4，则全部选中
+                # 如果总宽度小于等于4，则全部选中
                 selected_frames = all_frames
+                indices = list(range(num_frames))
             else:
                 # 使用linspace计算4个均匀分布的索引
                 indices = np.linspace(0, num_frames - 1, 4, dtype=int)
                 selected_frames = [all_frames[i] for i in indices]
 
-            logger.debug(f"GIF Frame Analysis: Total frames={num_frames}, Selected indices={indices if num_frames > 4 else list(range(num_frames))}")
+            logger.debug(f"GIF Frame Analysis: Total frames={num_frames}, Selected indices={indices}")
             # --- 帧选择逻辑结束 ---
 
             # 如果选择后连一帧都没有（比如GIF只有一帧且后续处理失败？）或者原始GIF就没帧，也返回None
diff --git a/src/chat/utils/utils_video.py b/src/chat/utils/utils_video.py
index 945923403..f03159364 100644
--- a/src/chat/utils/utils_video.py
+++ b/src/chat/utils/utils_video.py
@@ -37,13 +37,15 @@ _locks_guard = asyncio.Lock()
 
 logger = get_logger("utils_video")
 
-from inkfox import video
+from inkfox import video  # type: ignore
 
 
 class VideoAnalyzer:
     """基于 inkfox 的视频关键帧 + LLM 描述分析器"""
 
     def __init__(self) -> None:
+        assert global_config is not None
+        assert model_config is not None
         cfg = getattr(global_config, "video_analysis", object())
         self.max_frames: int = getattr(cfg, "max_frames", 20)
         self.frame_quality: int = getattr(cfg, "frame_quality", 85)
@@ -121,7 +123,6 @@ class VideoAnalyzer:
     # ---- 批量分析 ----
     async def _analyze_batch(self, frames: list[tuple[str, float]], question: str | None) -> str:
         from src.llm_models.payload_content.message import MessageBuilder, RoleType
-        from src.llm_models.utils_model import RequestType
 
         prompt = self.batch_analysis_prompt.format(
             personality_core=self.personality_core, personality_side=self.personality_side
@@ -137,12 +138,7 @@ class VideoAnalyzer:
         for b64, _ in frames:
             mb.add_image_content("jpeg", b64)
         message = mb.build()
-        model_info, api_provider, client = self.video_llm._select_model()
-        resp = await self.video_llm._execute_request(
-            api_provider=api_provider,
-            client=client,
-            request_type=RequestType.RESPONSE,
-            model_info=model_info,
+        resp = await self.video_llm.execute_with_messages(
             message_list=[message],
             temperature=None,
             max_tokens=None,
diff --git a/src/chat/utils/utils_video_legacy.py b/src/chat/utils/utils_video_legacy.py
index 306cb1591..5bf3b769d 100644
--- a/src/chat/utils/utils_video_legacy.py
+++ b/src/chat/utils/utils_video_legacy.py
@@ -31,9 +31,9 @@ def _extract_frames_worker(
     max_image_size: int,
     frame_extraction_mode: str,
     frame_interval_seconds: float | None,
-) -> list[Any] | list[tuple[str, str]]:
+) -> list[tuple[str, float]] | list[tuple[str, str]]:
     """线程池中提取视频帧的工作函数"""
-    frames = []
+    frames: list[tuple[str, float]] = []
     try:
         cap = cv2.VideoCapture(video_path)
         fps = cap.get(cv2.CAP_PROP_FPS)
@@ -42,7 +42,7 @@ def _extract_frames_worker(
 
         if frame_extraction_mode == "time_interval":
             # 新模式：按时间间隔抽帧
-            time_interval = frame_interval_seconds
+            time_interval = frame_interval_seconds or 2.0
             next_frame_time = 0.0
             extracted_count = 0  # 初始化提取帧计数器
 
@@ -61,7 +61,7 @@ def _extract_frames_worker(
                     # 调整图像大小
                     if max(pil_image.size) > max_image_size:
                         ratio = max_image_size / max(pil_image.size)
-                        new_size = tuple(int(dim * ratio) for dim in pil_image.size)
+                        new_size = (int(pil_image.size[0] * ratio), int(pil_image.size[1] * ratio))
                         pil_image = pil_image.resize(new_size, Image.Resampling.LANCZOS)
 
                     # 转换为base64
@@ -135,6 +135,8 @@ class LegacyVideoAnalyzer:
 
     def __init__(self):
         """初始化视频分析器"""
+        assert global_config is not None
+        assert model_config is not None
         # 使用专用的视频分析配置
         try:
             self.video_llm = LLMRequest(
@@ -238,6 +240,7 @@ class LegacyVideoAnalyzer:
             estimated_frames = min(self.max_frames, total_frames // frame_interval + 1)
         else:
             estimated_frames = self.max_frames
+            frame_interval = 1
 
         logger.info(f"计算得出帧间隔: {frame_interval} (将提取约{estimated_frames}帧)")
 
@@ -274,7 +277,7 @@ class LegacyVideoAnalyzer:
                 return await self._extract_frames_fallback(video_path)
 
             logger.info(f"✅ 成功提取{len(frames)}帧 (线程池模式)")
-            return frames
+            return frames  # type: ignore
 
         except Exception as e:
             logger.error(f"线程池帧提取失败: {e}")
@@ -313,7 +316,7 @@ class LegacyVideoAnalyzer:
                     # 调整图像大小
                     if max(pil_image.size) > self.max_image_size:
                         ratio = self.max_image_size / max(pil_image.size)
-                        new_size = tuple(int(dim * ratio) for dim in pil_image.size)
+                        new_size = (int(pil_image.size[0] * ratio), int(pil_image.size[1] * ratio))
                         pil_image = pil_image.resize(new_size, Image.Resampling.LANCZOS)
 
                     # 转换为base64
@@ -461,11 +464,11 @@ class LegacyVideoAnalyzer:
         # logger.info(f"✅ 多帧消息构建完成，包含{len(frames)}张图片")
 
         # 获取模型信息和客户端
-        model_info, api_provider, client = self.video_llm._select_model()
+        model_info, api_provider, client = self.video_llm._select_model()  # type: ignore
         # logger.info(f"使用模型: {model_info.name} 进行多帧分析")
 
         # 直接执行多图片请求
-        api_response = await self.video_llm._execute_request(
+        api_response = await self.video_llm._execute_request(  # type: ignore
             api_provider=api_provider,
             client=client,
             request_type=RequestType.RESPONSE,
diff --git a/src/chat/utils/utils_voice.py b/src/chat/utils/utils_voice.py
index f74359f18..58cc88b09 100644
--- a/src/chat/utils/utils_voice.py
+++ b/src/chat/utils/utils_voice.py
@@ -11,6 +11,8 @@ logger = get_logger("chat_voice")
 
 async def get_voice_text(voice_base64: str) -> str:
     """获取音频文件转录文本"""
+    assert global_config is not None
+    assert model_config is not None
     if not global_config.voice.enable_asr:
         logger.warning("语音识别未启用，无法处理语音消息")
         return "[语音]"
diff --git a/src/common/cache_manager.py b/src/common/cache_manager.py
index 6edb72169..9118adb40 100644
--- a/src/common/cache_manager.py
+++ b/src/common/cache_manager.py
@@ -38,6 +38,9 @@ class CacheManager:
         初始化缓存管理器。
         """
         if not hasattr(self, "_initialized"):
+            assert global_config is not None
+            assert model_config is not None
+
             self.default_ttl = default_ttl or 3600
             self.semantic_cache_collection_name = "semantic_cache"
 
@@ -87,6 +90,7 @@ class CacheManager:
                     embedding_array = embedding_array.flatten()
 
                 # 检查维度是否符合预期
+                assert global_config is not None
                 expected_dim = (
                     getattr(CacheManager, "embedding_dimension", None)
                     or global_config.lpmm_knowledge.embedding_dimension
diff --git a/src/common/config_helpers.py b/src/common/config_helpers.py
index f5460fece..463edaff6 100644
--- a/src/common/config_helpers.py
+++ b/src/common/config_helpers.py
@@ -14,23 +14,29 @@ def resolve_embedding_dimension(fallback: int | None = None, *, sync_global: boo
 
     candidates: list[int | None] = []
 
-    try:
-        embedding_task = getattr(model_config.model_task_config, "embedding", None)
-        if embedding_task is not None:
-            candidates.append(getattr(embedding_task, "embedding_dimension", None))
-    except Exception:
+    if model_config is not None:
+        try:
+            embedding_task = getattr(model_config.model_task_config, "embedding", None)
+            if embedding_task is not None:
+                candidates.append(getattr(embedding_task, "embedding_dimension", None))
+        except Exception:
+            candidates.append(None)
+    else:
         candidates.append(None)
 
-    try:
-        candidates.append(getattr(global_config.lpmm_knowledge, "embedding_dimension", None))
-    except Exception:
+    if global_config is not None:
+        try:
+            candidates.append(getattr(global_config.lpmm_knowledge, "embedding_dimension", None))
+        except Exception:
+            candidates.append(None)
+    else:
         candidates.append(None)
 
     candidates.append(fallback)
 
     resolved: int | None = next((int(dim) for dim in candidates if dim and int(dim) > 0), None)
 
-    if resolved and sync_global:
+    if resolved and sync_global and global_config is not None:
         try:
             if getattr(global_config.lpmm_knowledge, "embedding_dimension", None) != resolved:
                 global_config.lpmm_knowledge.embedding_dimension = resolved  # type: ignore[attr-defined]
diff --git a/src/common/data_models/message_manager_data_model.py b/src/common/data_models/message_manager_data_model.py
index 4b9ba7d5e..e0733ad4b 100644
--- a/src/common/data_models/message_manager_data_model.py
+++ b/src/common/data_models/message_manager_data_model.py
@@ -62,7 +62,9 @@ class StreamContext(BaseDataModel):
     stream_id: str
     chat_type: ChatType = ChatType.PRIVATE  # 聊天类型，默认为私聊
     chat_mode: ChatMode = ChatMode.FOCUS  # 聊天模式，默认为专注模式
-    max_context_size: int = field(default_factory=lambda: getattr(global_config.chat, "max_context_size", 100))
+    max_context_size: int = field(
+        default_factory=lambda: getattr(global_config.chat, "max_context_size", 100) if global_config else 100
+    )
     unread_messages: list["DatabaseMessages"] = field(default_factory=list)
     history_messages: list["DatabaseMessages"] = field(default_factory=list)
     last_check_time: float = field(default_factory=time.time)
@@ -98,7 +100,9 @@ class StreamContext(BaseDataModel):
     def __post_init__(self):
         """初始化历史消息异步加载"""
         if not self.max_context_size or self.max_context_size <= 0:
-            self.max_context_size = getattr(global_config.chat, "max_context_size", 100)
+            self.max_context_size = (
+                getattr(global_config.chat, "max_context_size", 100) if global_config else 100
+            )
 
         try:
             loop = asyncio.get_event_loop()
@@ -118,6 +122,7 @@ class StreamContext(BaseDataModel):
     async def add_message(self, message: "DatabaseMessages", skip_energy_update: bool = False) -> bool:
         """添加消息到上下文，支持跳过能量更新的选项"""
         try:
+            assert global_config is not None
             cache_enabled = global_config.chat.enable_message_cache
             if cache_enabled and not self.is_cache_enabled:
                 self.enable_cache(True)
@@ -150,7 +155,7 @@ class StreamContext(BaseDataModel):
             # ͬ�����ݵ�ͳһ�������
             try:
                 if global_config.memory and global_config.memory.enable:
-                    unified_manager = _get_unified_memory_manager()
+                    unified_manager: Any = _get_unified_memory_manager()
                     if unified_manager:
                         message_dict = {
                             "message_id": str(message.message_id),
diff --git a/src/common/database/api/crud.py b/src/common/database/api/crud.py
index ea172df1c..651c09099 100644
--- a/src/common/database/api/crud.py
+++ b/src/common/database/api/crud.py
@@ -9,9 +9,10 @@
 import operator
 from collections.abc import Callable
 from functools import lru_cache
-from typing import Any, TypeVar
+from typing import Any, Generic, TypeVar
 
 from sqlalchemy import delete, func, select, update
+from sqlalchemy.engine import CursorResult, Result
 
 from src.common.database.core.models import Base
 from src.common.database.core.session import get_db_session
@@ -25,23 +26,23 @@ from src.common.logger import get_logger
 
 logger = get_logger("database.crud")
 
-T = TypeVar("T", bound=Base)
+T = TypeVar("T", bound=Any)
 
 
 @lru_cache(maxsize=256)
-def _get_model_column_names(model: type[Base]) -> tuple[str, ...]:
+def _get_model_column_names(model: type[Any]) -> tuple[str, ...]:
     """获取模型的列名称列表"""
     return tuple(column.name for column in model.__table__.columns)
 
 
 @lru_cache(maxsize=256)
-def _get_model_field_set(model: type[Base]) -> frozenset[str]:
+def _get_model_field_set(model: type[Any]) -> frozenset[str]:
     """获取模型的有效字段集合"""
     return frozenset(_get_model_column_names(model))
 
 
 @lru_cache(maxsize=256)
-def _get_model_value_fetcher(model: type[Base]) -> Callable[[Base], tuple[Any, ...]]:
+def _get_model_value_fetcher(model: type[Any]) -> Callable[[Any], tuple[Any, ...]]:
     """为模型准备attrgetter，用于批量获取属性值"""
     column_names = _get_model_column_names(model)
 
@@ -51,21 +52,21 @@ def _get_model_value_fetcher(model: type[Base]) -> Callable[[Base], tuple[Any, .
     if len(column_names) == 1:
         attr_name = column_names[0]
 
-        def _single(instance: Base) -> tuple[Any, ...]:
+        def _single(instance: Any) -> tuple[Any, ...]:
             return (getattr(instance, attr_name),)
 
         return _single
 
     getter = operator.attrgetter(*column_names)
 
-    def _multi(instance: Base) -> tuple[Any, ...]:
+    def _multi(instance: Any) -> tuple[Any, ...]:
         values = getter(instance)
         return values if isinstance(values, tuple) else (values,)
 
     return _multi
 
 
-def _model_to_dict(instance: Base) -> dict[str, Any]:
+def _model_to_dict(instance: Any) -> dict[str, Any]:
     """将 SQLAlchemy 模型实例转换为字典
 
     Args:
@@ -113,7 +114,7 @@ def _dict_to_model(model_class: type[T], data: dict[str, Any]) -> T:
     return instance
 
 
-class CRUDBase:
+class CRUDBase(Generic[T]):
     """基础CRUD操作类
 
     提供通用的增删改查操作，自动集成缓存和批处理
@@ -246,7 +247,7 @@ class CRUDBase:
             cached_dicts = await cache.get(cache_key)
             if cached_dicts is not None:
                 # 从字典列表恢复对象列表
-                return [_dict_to_model(self.model, d) for d in cached_dicts]
+                return [_dict_to_model(self.model, d) for d in cached_dicts]  # type: ignore
 
         # 从数据库查询
         async with get_db_session() as session:
@@ -275,7 +276,7 @@ class CRUDBase:
                 await cache.set(cache_key, instances_dicts)
 
             # 从字典列表重建对象列表返回（detached状态，所有字段已加载）
-            return [_dict_to_model(self.model, d) for d in instances_dicts]
+            return [_dict_to_model(self.model, d) for d in instances_dicts]  # type: ignore
 
     async def create(
         self,
@@ -417,7 +418,7 @@ class CRUDBase:
             async with get_db_session() as session:
                 stmt = delete(self.model).where(self.model.id == id)
                 result = await session.execute(stmt)
-                success = result.rowcount > 0
+                success = result.rowcount > 0  # type: ignore
                 # 注意：commit在get_db_session的context manager退出时自动执行
 
         # 清除缓存
@@ -452,7 +453,7 @@ class CRUDBase:
                         stmt = stmt.where(getattr(self.model, key) == value)
 
             result = await session.execute(stmt)
-            return result.scalar()
+            return int(result.scalar() or 0)
 
     async def exists(
         self,
@@ -546,7 +547,7 @@ class CRUDBase:
                     .values(**obj_in)
                 )
                 result = await session.execute(stmt)
-                count += result.rowcount
+                count += result.rowcount  # type: ignore
 
                 # 清除缓存
                 cache_key = f"{self.model_name}:id:{id}"
diff --git a/src/common/database/api/query.py b/src/common/database/api/query.py
index fb2212e28..6bb93dd69 100644
--- a/src/common/database/api/query.py
+++ b/src/common/database/api/query.py
@@ -20,7 +20,7 @@ from src.common.logger import get_logger
 
 logger = get_logger("database.query")
 
-T = TypeVar("T", bound="Base")
+T = TypeVar("T", bound=Any)
 
 
 class QueryBuilder(Generic[T]):
@@ -327,7 +327,7 @@ class QueryBuilder(Generic[T]):
 
         items = await self.all()
 
-        return items, total
+        return items, total  # type: ignore
 
 
 class AggregateQuery:
diff --git a/src/common/database/api/specialized.py b/src/common/database/api/specialized.py
index f9ddc274e..01b2372e2 100644
--- a/src/common/database/api/specialized.py
+++ b/src/common/database/api/specialized.py
@@ -122,7 +122,7 @@ async def get_recent_actions(
         动作记录列表
     """
     query = QueryBuilder(ActionRecords)
-    return await query.filter(chat_id=chat_id).order_by("-time").limit(limit).all()
+    return await query.filter(chat_id=chat_id).order_by("-time").limit(limit).all()  # type: ignore
 
 
 # ===== Messages 业务API =====
@@ -148,7 +148,7 @@ async def get_chat_history(
         .limit(limit)
         .offset(offset)
         .all()
-    )
+    )  # type: ignore
 
 
 async def get_message_count(stream_id: str) -> int:
@@ -292,7 +292,7 @@ async def get_active_streams(
     if platform:
         query = query.filter(platform=platform)
 
-    return await query.order_by("-last_message_time").limit(limit).all()
+    return await query.order_by("-last_message_time").limit(limit).all()  # type: ignore
 
 
 # ===== LLMUsage 业务API =====
@@ -390,7 +390,7 @@ async def get_usage_statistics(
     # 聚合统计
     total_input = await query.sum("input_tokens")
     total_output = await query.sum("output_tokens")
-    total_count = await query.filter().count() if hasattr(query, "count") else 0
+    total_count = await getattr(query.filter(), "count")() if hasattr(query, "count") else 0
 
     return {
         "total_input_tokens": int(total_input),
diff --git a/src/common/database/compatibility/adapter.py b/src/common/database/compatibility/adapter.py
index a19eddfea..783998fc7 100644
--- a/src/common/database/compatibility/adapter.py
+++ b/src/common/database/compatibility/adapter.py
@@ -123,7 +123,7 @@ async def build_filters(model_class, filters: dict[str, Any]):
     return conditions
 
 
-def _model_to_dict(instance) -> dict[str, Any]:
+def _model_to_dict(instance) -> dict[str, Any] | None:
     """将数据库模型实例转换为字典（兼容旧API
 
     Args:
@@ -238,7 +238,7 @@ async def db_query(
                 return None
 
             # 更新记录
-            updated = await crud.update(instance.id, data)
+            updated = await crud.update(instance.id, data)  # type: ignore
             return _model_to_dict(updated)
 
         elif query_type == "delete":
@@ -257,7 +257,7 @@ async def db_query(
                 return None
 
             # 删除记录
-            success = await crud.delete(instance.id)
+            success = await crud.delete(instance.id)  # type: ignore
             return {"deleted": success}
 
         elif query_type == "count":
diff --git a/src/common/database/core/engine.py b/src/common/database/core/engine.py
index a235449b0..064178595 100644
--- a/src/common/database/core/engine.py
+++ b/src/common/database/core/engine.py
@@ -46,6 +46,7 @@ async def get_engine() -> AsyncEngine:
     if _engine_lock is None:
         _engine_lock = asyncio.Lock()
 
+    assert _engine_lock is not None
     # 使用锁保护初始化过程
     async with _engine_lock:
         # 双重检查锁定模式
@@ -55,6 +56,7 @@ async def get_engine() -> AsyncEngine:
         try:
             from src.config.config import global_config
 
+            assert global_config is not None
             config = global_config.database
             db_type = config.database_type
 
diff --git a/src/common/database/core/models.py b/src/common/database/core/models.py
index 89d5d6f68..8fcf4145d 100644
--- a/src/common/database/core/models.py
+++ b/src/common/database/core/models.py
@@ -44,6 +44,7 @@ def get_string_field(max_length=255, **kwargs):
     """
     from src.config.config import global_config
 
+    assert global_config is not None
     db_type = global_config.database.database_type
 
     # MySQL 索引需要指定长度的 VARCHAR
diff --git a/src/common/database/core/session.py b/src/common/database/core/session.py
index 9cd701fc2..751bb51bf 100644
--- a/src/common/database/core/session.py
+++ b/src/common/database/core/session.py
@@ -75,6 +75,7 @@ async def _apply_session_settings(session: AsyncSession, db_type: str) -> None:
             # 可以设置 schema 搜索路径等
             from src.config.config import global_config
 
+            assert global_config is not None
             schema = global_config.database.postgresql_schema
             if schema and schema != "public":
                 await session.execute(text(f"SET search_path TO {schema}"))
@@ -114,6 +115,7 @@ async def get_db_session() -> AsyncGenerator[AsyncSession, None]:
         # 获取数据库类型并应用特定设置
         from src.config.config import global_config
 
+        assert global_config is not None
         await _apply_session_settings(session, global_config.database.database_type)
 
         yield session
@@ -142,6 +144,7 @@ async def get_db_session_direct() -> AsyncGenerator[AsyncSession, None]:
             # 应用数据库特定设置
             from src.config.config import global_config
 
+            assert global_config is not None
             await _apply_session_settings(session, global_config.database.database_type)
 
             yield session
diff --git a/src/common/database/optimization/batch_scheduler.py b/src/common/database/optimization/batch_scheduler.py
index f2d2591fb..8a385ddc3 100644
--- a/src/common/database/optimization/batch_scheduler.py
+++ b/src/common/database/optimization/batch_scheduler.py
@@ -13,7 +13,7 @@ from collections import defaultdict, deque
 from collections.abc import Callable
 from dataclasses import dataclass, field
 from enum import IntEnum
-from typing import Any, TypeVar
+from typing import Any
 
 from sqlalchemy import delete, insert, select, update
 
@@ -23,8 +23,6 @@ from src.common.memory_utils import estimate_size_smart
 
 logger = get_logger("batch_scheduler")
 
-T = TypeVar("T")
-
 
 class Priority(IntEnum):
     """操作优先级"""
@@ -429,7 +427,7 @@ class AdaptiveBatchScheduler:
 
                     # 执行更新（但不commit）
                     result = await session.execute(stmt)
-                    results.append((op, result.rowcount))
+                    results.append((op, result.rowcount))  # type: ignore
 
                 # 注意：commit 由 get_db_session_direct 上下文管理器自动处理
 
@@ -471,7 +469,7 @@ class AdaptiveBatchScheduler:
 
                     # 执行删除（但不commit）
                     result = await session.execute(stmt)
-                    results.append((op, result.rowcount))
+                    results.append((op, result.rowcount))  # type: ignore
 
                 # 注意：commit 由 get_db_session_direct 上下文管理器自动处理
 
diff --git a/src/common/database/optimization/cache_manager.py b/src/common/database/optimization/cache_manager.py
index 700502c47..eed9783a5 100644
--- a/src/common/database/optimization/cache_manager.py
+++ b/src/common/database/optimization/cache_manager.py
@@ -398,47 +398,48 @@ class MultiLevelCache:
         l2_stats_task = asyncio.create_task(self._get_cache_stats_safe(self.l2_cache, "L2"))
 
         # 使用超时避免死锁
-        try:
-            l1_stats, l2_stats = await asyncio.gather(
-                asyncio.wait_for(l1_stats_task, timeout=1.0),
-                asyncio.wait_for(l2_stats_task, timeout=1.0),
-                return_exceptions=True
-            )
-        except asyncio.TimeoutError:
-            logger.warning("缓存统计获取超时，使用基本统计")
-            l1_stats = await self.l1_cache.get_stats()
-            l2_stats = await self.l2_cache.get_stats()
+        results = await asyncio.gather(
+            asyncio.wait_for(l1_stats_task, timeout=1.0),
+            asyncio.wait_for(l2_stats_task, timeout=1.0),
+            return_exceptions=True
+        )
+        l1_stats = results[0]
+        l2_stats = results[1]
 
         # 处理异常情况
-        if isinstance(l1_stats, Exception):
+        if isinstance(l1_stats, BaseException):
             logger.error(f"L1统计获取失败: {l1_stats}")
             l1_stats = CacheStats()
-        if isinstance(l2_stats, Exception):
+        if isinstance(l2_stats, BaseException):
             logger.error(f"L2统计获取失败: {l2_stats}")
             l2_stats = CacheStats()
 
+        assert isinstance(l1_stats, CacheStats)
+        assert isinstance(l2_stats, CacheStats)
+
         # 🔧 修复：并行获取键集合，避免锁嵌套
         l1_keys_task = asyncio.create_task(self._get_cache_keys_safe(self.l1_cache))
         l2_keys_task = asyncio.create_task(self._get_cache_keys_safe(self.l2_cache))
 
-        try:
-            l1_keys, l2_keys = await asyncio.gather(
-                asyncio.wait_for(l1_keys_task, timeout=1.0),
-                asyncio.wait_for(l2_keys_task, timeout=1.0),
-                return_exceptions=True
-            )
-        except asyncio.TimeoutError:
-            logger.warning("缓存键获取超时，使用默认值")
-            l1_keys, l2_keys = set(), set()
+        results = await asyncio.gather(
+            asyncio.wait_for(l1_keys_task, timeout=1.0),
+            asyncio.wait_for(l2_keys_task, timeout=1.0),
+            return_exceptions=True
+        )
+        l1_keys = results[0]
+        l2_keys = results[1]
 
         # 处理异常情况
-        if isinstance(l1_keys, Exception):
+        if isinstance(l1_keys, BaseException):
             logger.warning(f"L1键获取失败: {l1_keys}")
             l1_keys = set()
-        if isinstance(l2_keys, Exception):
+        if isinstance(l2_keys, BaseException):
             logger.warning(f"L2键获取失败: {l2_keys}")
             l2_keys = set()
 
+        assert isinstance(l1_keys, set)
+        assert isinstance(l2_keys, set)
+
         # 计算共享键和独占键
         shared_keys = l1_keys & l2_keys
         l1_only_keys = l1_keys - l2_keys
@@ -448,24 +449,25 @@ class MultiLevelCache:
         l1_size_task = asyncio.create_task(self._calculate_memory_usage_safe(self.l1_cache, l1_keys))
         l2_size_task = asyncio.create_task(self._calculate_memory_usage_safe(self.l2_cache, l2_keys))
 
-        try:
-            l1_size, l2_size = await asyncio.gather(
-                asyncio.wait_for(l1_size_task, timeout=1.0),
-                asyncio.wait_for(l2_size_task, timeout=1.0),
-                return_exceptions=True
-            )
-        except asyncio.TimeoutError:
-            logger.warning("内存计算超时，使用统计值")
-            l1_size, l2_size = l1_stats.total_size, l2_stats.total_size
+        results = await asyncio.gather(
+            asyncio.wait_for(l1_size_task, timeout=1.0),
+            asyncio.wait_for(l2_size_task, timeout=1.0),
+            return_exceptions=True
+        )
+        l1_size = results[0]
+        l2_size = results[1]
 
         # 处理异常情况
-        if isinstance(l1_size, Exception):
+        if isinstance(l1_size, BaseException):
             logger.warning(f"L1内存计算失败: {l1_size}")
             l1_size = l1_stats.total_size
-        if isinstance(l2_size, Exception):
+        if isinstance(l2_size, BaseException):
             logger.warning(f"L2内存计算失败: {l2_size}")
             l2_size = l2_stats.total_size
 
+        assert isinstance(l1_size, int)
+        assert isinstance(l2_size, int)
+
         # 计算实际总内存（避免重复计数）
         actual_total_size = l1_size + l2_size - min(l1_stats.total_size, l2_stats.total_size)
 
@@ -769,6 +771,7 @@ async def get_cache() -> MultiLevelCache:
                 try:
                     from src.config.config import global_config
 
+                    assert global_config is not None
                     db_config = global_config.database
 
                     # 检查是否启用缓存
diff --git a/src/common/database/utils/decorators.py b/src/common/database/utils/decorators.py
index 7a7fe219e..dbc5ff89a 100644
--- a/src/common/database/utils/decorators.py
+++ b/src/common/database/utils/decorators.py
@@ -10,8 +10,8 @@ import asyncio
 import functools
 import hashlib
 import time
-from collections.abc import Awaitable, Callable
-from typing import Any, TypeVar
+from collections.abc import Awaitable, Callable, Coroutine
+from typing import Any, ParamSpec, TypeVar
 
 from sqlalchemy.exc import DBAPIError, OperationalError
 from sqlalchemy.exc import TimeoutError as SQLTimeoutError
@@ -56,8 +56,9 @@ def generate_cache_key(
 
     return ":".join(cache_key_parts)
 
-T = TypeVar("T")
-F = TypeVar("F", bound=Callable[..., Awaitable[Any]])
+
+P = ParamSpec("P")
+R = TypeVar("R")
 
 
 def retry(
@@ -77,14 +78,13 @@ def retry(
         exceptions: 需要重试的异常类型
 
     Example:
-        @retry(max_attempts=3, delay=1.0)
         async def query_data():
             return await session.execute(stmt)
     """
 
-    def decorator(func: Callable[..., T]) -> Callable[..., T]:
+    def decorator(func: Callable[P, Coroutine[Any, Any, R]]) -> Callable[P, Coroutine[Any, Any, R]]:
         @functools.wraps(func)
-        async def wrapper(*args: Any, **kwargs: Any) -> T:
+        async def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
             last_exception = None
             current_delay = delay
 
@@ -107,7 +107,9 @@ def retry(
                         )
 
             # 所有尝试都失败
-            raise last_exception
+            if last_exception:
+                raise last_exception
+            raise RuntimeError(f"Retry failed after {max_attempts} attempts")
 
         return wrapper
 
@@ -128,9 +130,9 @@ def timeout(seconds: float):
             return await session.execute(complex_stmt)
     """
 
-    def decorator(func: Callable[..., T]) -> Callable[..., T]:
+    def decorator(func: Callable[P, Coroutine[Any, Any, R]]) -> Callable[P, Coroutine[Any, Any, R]]:
         @functools.wraps(func)
-        async def wrapper(*args: Any, **kwargs: Any) -> T:
+        async def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
             try:
                 return await asyncio.wait_for(func(*args, **kwargs), timeout=seconds)
             except asyncio.TimeoutError:
@@ -164,9 +166,9 @@ def cached(
             return await query_user(user_id)
     """
 
-    def decorator(func: Callable[..., T]) -> Callable[..., T]:
+    def decorator(func: Callable[P, Coroutine[Any, Any, R]]) -> Callable[P, Coroutine[Any, Any, R]]:
         @functools.wraps(func)
-        async def wrapper(*args: Any, **kwargs: Any) -> T:
+        async def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
             # 延迟导入避免循环依赖
             from src.common.database.optimization import get_cache
 
@@ -225,9 +227,9 @@ def measure_time(log_slow: float | None = None):
             return await session.execute(stmt)
     """
 
-    def decorator(func: Callable[..., T]) -> Callable[..., T]:
+    def decorator(func: Callable[P, Coroutine[Any, Any, R]]) -> Callable[P, Coroutine[Any, Any, R]]:
         @functools.wraps(func)
-        async def wrapper(*args: Any, **kwargs: Any) -> T:
+        async def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
             start_time = time.perf_counter()
 
             try:
@@ -267,21 +269,23 @@ def transactional(auto_commit: bool = True, auto_rollback: bool = True):
         函数需要接受session参数
     """
 
-    def decorator(func: Callable[..., T]) -> Callable[..., T]:
+    def decorator(func: Callable[P, Coroutine[Any, Any, R]]) -> Callable[P, Coroutine[Any, Any, R]]:
         @functools.wraps(func)
-        async def wrapper(*args: Any, **kwargs: Any) -> T:
+        async def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
             # 查找session参数
-            session = None
-            if args:
-                from sqlalchemy.ext.asyncio import AsyncSession
+            from sqlalchemy.ext.asyncio import AsyncSession
 
+            session: AsyncSession | None = None
+            if args:
                 for arg in args:
                     if isinstance(arg, AsyncSession):
                         session = arg
                         break
 
             if not session and "session" in kwargs:
-                session = kwargs["session"]
+                possible_session = kwargs["session"]
+                if isinstance(possible_session, AsyncSession):
+                    session = possible_session
 
             if not session:
                 logger.warning(f"{func.__name__} 未找到session参数，跳过事务管理")
@@ -330,7 +334,7 @@ def db_operation(
             return await complex_operation()
     """
 
-    def decorator(func: Callable[..., T]) -> Callable[..., T]:
+    def decorator(func: Callable[P, Coroutine[Any, Any, R]]) -> Callable[P, Coroutine[Any, Any, R]]:
         # 从内到外应用装饰器
         wrapped = func
 
diff --git a/src/common/logger.py b/src/common/logger.py
index 52ead329f..dd3425797 100644
--- a/src/common/logger.py
+++ b/src/common/logger.py
@@ -21,10 +21,15 @@ from structlog.typing import EventDict, WrappedLogger
 class DaemonQueueListener(QueueListener):
     """QueueListener 的工作线程作为守护进程运行，以避免阻塞关闭。"""
 
-    def _configure_listener(self):
-        super()._configure_listener()
-        if hasattr(self, "_thread") and self._thread is not None:  # type: ignore[attr-defined]
-            self._thread.daemon = True  # type: ignore[attr-defined]
+    def start(self):
+        """Start the listener.
+        This starts up a background thread to monitor the queue for
+        LogRecords to process.
+        """
+        # 覆盖 start 方法以设置 daemon=True
+        # 注意：_monitor 是 QueueListener 的内部方法
+        self._thread = threading.Thread(target=self._monitor, daemon=True)  # type: ignore
+        self._thread.start()
 
     def stop(self):
         """停止监听器，避免在退出时无限期阻塞。"""
@@ -345,10 +350,12 @@ def load_log_config():  # sourcery skip: use-contextlib-suppress
             "websockets",
             "httpcore",
             "requests",
+            "aiosqlite",
             "peewee",
             "openai",
             "uvicorn",
             "rjieba",
+            "message_bus",
         ],
         "library_log_levels": {"aiohttp": "WARNING"},
     }
diff --git a/src/common/message/api.py b/src/common/message/api.py
index 34eb01fcb..754c3b793 100644
--- a/src/common/message/api.py
+++ b/src/common/message/api.py
@@ -1,4 +1,5 @@
 import os
+from typing import Any
 
 from mofox_wire import MessageServer
 
@@ -18,6 +19,8 @@ def get_global_api() -> MessageServer:
     if global_api is not None:
         return global_api
 
+    assert global_config is not None
+
     bus_config = global_config.message_bus
     host = os.getenv("HOST", "127.0.0.1")
     port_str = os.getenv("PORT", "8000")
@@ -27,7 +30,7 @@ def get_global_api() -> MessageServer:
     except ValueError:
         port = 8000
 
-    kwargs: dict[str, object] = {
+    kwargs: dict[str, Any] = {
         "host": host,
         "port": port,
         "app": get_global_server().get_app(),
diff --git a/src/common/message_repository.py b/src/common/message_repository.py
index 14be6640a..b74b76f20 100644
--- a/src/common/message_repository.py
+++ b/src/common/message_repository.py
@@ -52,6 +52,7 @@ async def find_messages(
         消息字典列表，如果出错则返回空列表。
     """
     try:
+        assert global_config is not None
         async with get_db_session() as session:
             query = select(Messages)
 
diff --git a/src/common/remote.py b/src/common/remote.py
index f6396a037..7f76e8f84 100644
--- a/src/common/remote.py
+++ b/src/common/remote.py
@@ -42,6 +42,7 @@ class TelemetryHeartBeatTask(AsyncTask):
     @staticmethod
     def _get_sys_info() -> dict[str, str]:
         """获取系统信息"""
+        assert global_config is not None
         info_dict = {
             "os_type": "Unknown",
             "py_version": platform.python_version(),
diff --git a/src/common/security.py b/src/common/security.py
index b151dfd09..104e1cf94 100644
--- a/src/common/security.py
+++ b/src/common/security.py
@@ -16,6 +16,7 @@ async def get_api_key(api_key: str = Security(api_key_header_auth)) -> str:
     FastAPI 依赖项，用于验证API密钥。
     从请求头中提取 X-API-Key 并验证它是否存在于配置的有效密钥列表中。
     """
+    assert bot_config is not None
     valid_keys = bot_config.plugin_http_system.plugin_api_valid_keys
     if not valid_keys:
         logger.warning("API密钥认证已启用，但未配置任何有效的API密钥。所有请求都将被拒绝。")
diff --git a/src/common/server.py b/src/common/server.py
index 527663be2..15f5de16a 100644
--- a/src/common/server.py
+++ b/src/common/server.py
@@ -30,6 +30,7 @@ def rate_limit_exceeded_handler(request: Request, exc: Exception) -> Response:
 
 class Server:
     def __init__(self, host: str | None = None, port: int | None = None, app_name: str = "MoFox-Bot"):
+        assert bot_config is not None
         # 根据配置初始化速率限制器
         limiter = Limiter(
             key_func=get_remote_address,
diff --git a/src/config/config.py b/src/config/config.py
index 60984ab92..2755f322f 100644
--- a/src/config/config.py
+++ b/src/config/config.py
@@ -177,7 +177,7 @@ def _remove_obsolete_keys(target: TOMLDocument | dict | Table, reference: TOMLDo
         if key not in reference:
             del target[key]
         elif isinstance(target.get(key), dict | Table) and isinstance(reference.get(key), dict | Table):
-            _remove_obsolete_keys(target[key], reference[key])
+            _remove_obsolete_keys(target[key], reference[key])  # type: ignore
 
 
 def _update_dict(target: TOMLDocument | dict | Table, source: TOMLDocument | dict):
@@ -437,9 +437,9 @@ class Config(ValidatedConfigBase):
 class APIAdapterConfig(ValidatedConfigBase):
     """API Adapter配置类"""
 
-    models: list[ModelInfo] = Field(..., min_items=1, description="模型列表")
+    models: list[ModelInfo] = Field(..., min_length=1, description="模型列表")
     model_task_config: ModelTaskConfig = Field(..., description="模型任务配置")
-    api_providers: list[APIProvider] = Field(..., min_items=1, description="API提供商列表")
+    api_providers: list[APIProvider] = Field(..., min_length=1, description="API提供商列表")
 
     def __init__(self, **data):
         super().__init__(**data)
diff --git a/src/config/config_base.py b/src/config/config_base.py
index a80740a46..551326fa3 100644
--- a/src/config/config_base.py
+++ b/src/config/config_base.py
@@ -177,7 +177,9 @@ class ValidatedConfigBase(BaseModel):
                 element_index = field_path[1]
 
                 # 尝试获取父字段的类型信息
-                parent_field_info = cls.model_fields.get(parent_field)
+                parent_field_info = None
+                if isinstance(parent_field, str):
+                    parent_field_info = cls.model_fields.get(parent_field)
 
                 if parent_field_info and hasattr(parent_field_info, "annotation"):
                     expected_type = parent_field_info.annotation
@@ -214,7 +216,9 @@ class ValidatedConfigBase(BaseModel):
             # 处理模型类型错误
             elif error_type in ["model_type", "dict_type", "is_instance_of"]:
                 field_name = field_path[0] if field_path else "unknown"
-                field_info = cls.model_fields.get(field_name)
+                field_info = None
+                if isinstance(field_name, str):
+                    field_info = cls.model_fields.get(field_name)
 
                 if field_info and hasattr(field_info, "annotation"):
                     expected_type = field_info.annotation
diff --git a/src/config/official_configs.py b/src/config/official_configs.py
index 11b9353c7..072356db7 100644
--- a/src/config/official_configs.py
+++ b/src/config/official_configs.py
@@ -134,6 +134,7 @@ class ChatConfig(ValidatedConfigBase):
     thinking_timeout: int = Field(default=40, description="思考超时时间")
     mentioned_bot_inevitable_reply: bool = Field(default=False, description="提到机器人的必然回复")
     at_bot_inevitable_reply: bool = Field(default=False, description="@机器人的必然回复")
+    private_chat_inevitable_reply: bool = Field(default=False, description="私聊必然回复")
     allow_reply_self: bool = Field(default=False, description="是否允许回复自己说的话")
     timestamp_display_mode: Literal["normal", "normal_no_YMD", "relative"] = Field(
         default="normal_no_YMD", description="时间戳显示模式"
@@ -638,15 +639,15 @@ class PlanningSystemConfig(ValidatedConfigBase):
     """规划系统配置 (日程与月度计划)"""
 
     # --- 日程生成 (原 ScheduleConfig) ---
-    schedule_enable: bool = Field(True, description="是否启用每日日程生成功能")
-    schedule_guidelines: str = Field("", description="日程生成指导原则")
+    schedule_enable: bool = Field(default=True, description="是否启用每日日程生成功能")
+    schedule_guidelines: str = Field(default="", description="日程生成指导原则")
 
     # --- 月度计划 (原 MonthlyPlanSystemConfig) ---
-    monthly_plan_enable: bool = Field(True, description="是否启用月度计划系统")
-    monthly_plan_guidelines: str = Field("", description="月度计划生成指导原则")
-    max_plans_per_month: int = Field(10, description="每月最多生成的计划数量")
-    avoid_repetition_days: int = Field(7, description="避免在多少天内重复使用同一个月度计划")
-    completion_threshold: int = Field(3, description="一个月度计划被使用多少次后算作完成")
+    monthly_plan_enable: bool = Field(default=True, description="是否启用月度计划系统")
+    monthly_plan_guidelines: str = Field(default="", description="月度计划生成指导原则")
+    max_plans_per_month: int = Field(default=10, description="每月最多生成的计划数量")
+    avoid_repetition_days: int = Field(default=7, description="避免在多少天内重复使用同一个月度计划")
+    completion_threshold: int = Field(default=3, description="一个月度计划被使用多少次后算作完成")
 
 
 class DependencyManagementConfig(ValidatedConfigBase):
diff --git a/src/individuality/individuality.py b/src/individuality/individuality.py
index 3ef490e57..36806e0bb 100644
--- a/src/individuality/individuality.py
+++ b/src/individuality/individuality.py
@@ -6,10 +6,18 @@ import orjson
 from rich.traceback import install
 
 from src.common.logger import get_logger
-from src.config.config import global_config, model_config
+from src.config.config import global_config as _global_config, model_config as _model_config
 from src.llm_models.utils_model import LLMRequest
 from src.person_info.person_info import get_person_info_manager
 
+if _global_config is None:
+    raise ValueError("global_config is not initialized")
+if _model_config is None:
+    raise ValueError("model_config is not initialized")
+
+global_config = _global_config
+model_config = _model_config
+
 install(extra_lines=3)
 
 logger = get_logger("individuality")
diff --git a/src/llm_models/model_client/aiohttp_gemini_client.py b/src/llm_models/model_client/aiohttp_gemini_client.py
index 507fd8436..8360ab5e5 100644
--- a/src/llm_models/model_client/aiohttp_gemini_client.py
+++ b/src/llm_models/model_client/aiohttp_gemini_client.py
@@ -23,7 +23,7 @@ from .base_client import APIResponse, BaseClient, UsageRecord, client_registry
 logger = get_logger("AioHTTP-Gemini客户端")
 
 
-# gemini_thinking参数（默认范围）
+# gemini_thinking参数(默认范围) - 旧版 thinking_budget
 # 不同模型的思考预算范围配置
 THINKING_BUDGET_LIMITS = {
     "gemini-2.5-flash": {"min": 1, "max": 24576, "can_disable": True},
@@ -31,8 +31,15 @@ THINKING_BUDGET_LIMITS = {
     "gemini-2.5-pro": {"min": 128, "max": 32768, "can_disable": False},
 }
 # 思维预算特殊值
-THINKING_BUDGET_AUTO = -1  # 自动调整思考预算，由模型决定
-THINKING_BUDGET_DISABLED = 0  # 禁用思考预算（如果模型允许禁用）
+THINKING_BUDGET_AUTO = -1  # 自动调整思考预算,由模型决定
+THINKING_BUDGET_DISABLED = 0  # 禁用思考预算(如果模型允许禁用)
+
+# 新版 thinking_level 参数
+# 支持的思考等级
+THINKING_LEVEL_LOW = "low"
+THINKING_LEVEL_MEDIUM = "medium"
+THINKING_LEVEL_HIGH = "high"
+VALID_THINKING_LEVELS = [THINKING_LEVEL_LOW, THINKING_LEVEL_MEDIUM, THINKING_LEVEL_HIGH]
 
 gemini_safe_settings = [
     {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_NONE"},
@@ -161,20 +168,25 @@ def _convert_tool_options(tool_options: list[ToolOption]) -> list[dict]:
 def _build_generation_config(
     max_tokens: int,
     temperature: float,
-    thinking_budget: int,
+    thinking_budget: int | None = None,
+    thinking_level: str | None = None,
     response_format: RespFormat | None = None,
     extra_params: dict | None = None,
 ) -> dict:
     """
     构建并返回 Gemini API 的 `generationConfig` 字典。
 
-    此函数整合了多个参数，如最大输出 token 数、温度、思考预算、响应格式和
+    此函数整合了多个参数，如最大输出 token 数、温度、思考配置(预算或等级)、响应格式和
     其他自定义参数，以创建一个符合 Gemini API 规范的配置对象。
 
+    注意: thinking_budget 和 thinking_level 不能同时使用，否则会返回 400 错误。
+    优先使用 thinking_level (新版)，如果未提供则使用 thinking_budget (旧版)。
+
     Args:
         max_tokens: 生成内容的最大 token 数。
         temperature: 控制生成文本的随机性，值越高越随机。
-        thinking_budget: 模型的思考预算。
+        thinking_budget: 模型的思考预算(旧版，与 thinking_level 互斥)。
+        thinking_level: 模型的思考等级(新版，可选值: "low", "medium", "high")。
         response_format: 指定响应的格式，例如 JSON 对象或遵循特定 schema。
         extra_params: 一个包含其他要合并到配置中的参数的字典。
 
@@ -186,10 +198,19 @@ def _build_generation_config(
         "temperature": temperature,
         "topK": 1,
         "topP": 1,
-        "safetySettings": gemini_safe_settings,
-        "thinkingConfig": {"includeThoughts": True, "thinkingBudget": thinking_budget},
     }
 
+    # 处理思考配置 - 新版 thinking_level 优先于旧版 thinking_budget
+    if thinking_level is not None:
+        # 使用新版 thinkingLevel 参数
+        if thinking_level in VALID_THINKING_LEVELS:
+            config["thinkingConfig"] = {"thinkingLevel": thinking_level}
+        else:
+            logger.warning(f"无效的 thinking_level 值 {thinking_level}，有效值为: {VALID_THINKING_LEVELS}")
+    elif thinking_budget is not None:
+        # 使用旧版 thinkingBudget 参数
+        config["thinkingConfig"] = {"includeThoughts": True, "thinkingBudget": thinking_budget}
+
     # 处理响应格式
     if response_format:
         if response_format.format_type == RespFormatType.JSON_OBJ:
@@ -202,8 +223,9 @@ def _build_generation_config(
     if extra_params:
         # 拷贝一份以防修改原始字典
         safe_extra_params = extra_params.copy()
-        # 移除已单独处理的 thinking_budget
+        # 移除已单独处理的参数
         safe_extra_params.pop("thinking_budget", None)
+        safe_extra_params.pop("thinking_level", None)
         config.update(safe_extra_params)
 
     return config
@@ -576,19 +598,39 @@ class AiohttpGeminiClient(BaseClient):
         # 转换消息格式
         contents, system_instructions = _convert_messages(message_list)
 
-        # 处理思考预算
-        tb = THINKING_BUDGET_AUTO
-        if extra_params and "thinking_budget" in extra_params:
-            try:
-                tb = int(extra_params["thinking_budget"])
-            except (ValueError, TypeError):
-                logger.warning(f"无效的 thinking_budget 值 {extra_params['thinking_budget']}，将使用默认动态模式 {tb}")
-        tb = self.clamp_thinking_budget(tb, model_info.model_identifier)
+        # 处理思考配置 - 优先使用新版 thinking_level，否则使用旧版 thinking_budget
+        thinking_level = None
+        thinking_budget = None
+        
+        if extra_params:
+            # 优先检查新版 thinking_level
+            if "thinking_level" in extra_params:
+                level_value = extra_params.get("thinking_level", "").lower()
+                if level_value in VALID_THINKING_LEVELS:
+                    thinking_level = level_value
+                else:
+                    logger.warning(f"无效的 thinking_level 值 {level_value}，有效值为: {VALID_THINKING_LEVELS}")
+            # 如果没有 thinking_level，则使用旧版 thinking_budget
+            elif "thinking_budget" in extra_params:
+                try:
+                    tb = int(extra_params["thinking_budget"])
+                    thinking_budget = self.clamp_thinking_budget(tb, model_info.model_identifier)
+                except (ValueError, TypeError):
+                    logger.warning(f"无效的 thinking_budget 值 {extra_params['thinking_budget']}，将使用默认动态模式")
+                    thinking_budget = THINKING_BUDGET_AUTO
 
         # 构建请求体
         request_data = {
             "contents": contents,
-            "generationConfig": _build_generation_config(max_tokens, temperature, tb, response_format, extra_params),
+            "generationConfig": _build_generation_config(
+                max_tokens,
+                temperature,
+                thinking_budget=thinking_budget,
+                thinking_level=thinking_level,
+                response_format=response_format,
+                extra_params=extra_params
+            ),
+            "safetySettings": gemini_safe_settings,
         }
 
         # 添加系统指令
@@ -700,7 +742,15 @@ class AiohttpGeminiClient(BaseClient):
 
         request_data = {
             "contents": contents,
-            "generationConfig": _build_generation_config(2048, 0.1, THINKING_BUDGET_AUTO, None, extra_params),
+            "generationConfig": _build_generation_config(
+                2048,
+                0.1,
+                thinking_budget=THINKING_BUDGET_AUTO,
+                thinking_level=None,
+                response_format=None,
+                extra_params=extra_params
+            ),
+            "safetySettings": gemini_safe_settings,
         }
 
         try:
diff --git a/src/llm_models/utils_model.py b/src/llm_models/utils_model.py
index ef80c988a..f45b31041 100644
--- a/src/llm_models/utils_model.py
+++ b/src/llm_models/utils_model.py
@@ -196,6 +196,7 @@ class _ModelSelector:
             + candidate_models_usage[k].avg_latency * self.LATENCY_WEIGHT,
         )
 
+        assert model_config is not None, "model_config 不能为 None"
         model_info = model_config.get_model_info(least_used_model_name)
         api_provider = model_config.get_provider(model_info.api_provider)
         # 自动事件循环检测：ClientRegistry 会自动检测事件循环变化并处理缓存失效
@@ -849,6 +850,7 @@ class _RequestStrategy:
             raise RuntimeError("所有模型均未能生成响应，且无具体异常信息。")
 
         # 如果不抛出异常，返回一个备用响应
+        assert model_config is not None, "model_config 不能为 None"
         fallback_model_info = model_config.get_model_info(self.model_list[0])
         return APIResponse(content="所有模型都请求失败"), fallback_model_info
 
@@ -1141,12 +1143,33 @@ class LLMRequest:
             if embeddings and not isinstance(embeddings[0], list):
                 embeddings = [embeddings]  # type: ignore[list-item]
 
-            return embeddings, model_info.name
+            # 批量请求返回二维列表
+            return embeddings, model_info.name  # type: ignore[return-value]
 
+        # 单个请求返回一维列表
         if isinstance(embeddings, list) and embeddings and isinstance(embeddings[0], list):
-            return embeddings[0], model_info.name
+            return embeddings[0], model_info.name  # type: ignore[return-value]
 
-        return embeddings, model_info.name
+        return embeddings, model_info.name  # type: ignore[return-value]
+
+    async def execute_with_messages(
+        self,
+        message_list: list[Message],
+        temperature: float | None = None,
+        max_tokens: int | None = None,
+    ) -> APIResponse:
+        """
+        使用自定义消息列表执行请求（支持多模态/多图）。
+        """
+        start_time = time.time()
+        response, model_info = await self._strategy.execute_with_failover(
+            RequestType.RESPONSE,
+            message_list=message_list,
+            temperature=temperature,
+            max_tokens=max_tokens,
+        )
+        await self._record_usage(model_info, response.usage, time.time() - start_time, "/chat/completions")
+        return response
 
     async def _record_usage(self, model_info: ModelInfo, usage: UsageRecord | None, time_cost: float, endpoint: str):
         """
@@ -1218,7 +1241,8 @@ class LLMRequest:
                 # 遍历工具的参数
                 for param in tool.get("parameters", []):
                     # 严格验证参数格式是否为包含5个元素的元组
-                    assert isinstance(param, tuple) and len(param) == 5, "参数必须是包含5个元素的元组"
+                    assert isinstance(param, tuple), "参数必须是元组"
+                    assert len(param) == 5, "参数必须包含5个元素"
                     builder.add_param(
                         name=param[0],
                         param_type=param[1],
diff --git a/src/main.py b/src/main.py
index c5132f957..a6c437cea 100644
--- a/src/main.py
+++ b/src/main.py
@@ -7,7 +7,7 @@ import time
 import traceback
 from collections.abc import Callable, Coroutine
 from random import choices
-from typing import Any
+from typing import Any, cast
 
 from rich.traceback import install
 
@@ -172,6 +172,9 @@ class MainSystem:
                         logger.warning(f"{calc_name} 不是 BaseInterestCalculator 的有效子类")
                         continue
 
+                    # 显式转换类型以修复 Pyright 错误
+                    component_class = cast(type[BaseInterestCalculator], component_class)
+
                     # 创建组件实例
                     calculator_instance = component_class()
 
diff --git a/src/plugin_system/apis/__init__.py b/src/plugin_system/apis/__init__.py
index 0e03f6700..49e3e3b25 100644
--- a/src/plugin_system/apis/__init__.py
+++ b/src/plugin_system/apis/__init__.py
@@ -8,6 +8,7 @@
 from src.plugin_system.apis import (
     chat_api,
     component_manage_api,
+    component_state_api,
     config_api,
     database_api,
     emoji_api,
@@ -17,6 +18,7 @@ from src.plugin_system.apis import (
     mood_api,
     permission_api,
     person_api,
+    plugin_info_api,
     plugin_manage_api,
     schedule_api,
     send_api,
@@ -31,6 +33,7 @@ from .plugin_register_api import register_plugin
 __all__ = [
     "chat_api",
     "component_manage_api",
+    "component_state_api",
     "config_api",
     "context_api",
     "database_api",
@@ -42,6 +45,7 @@ __all__ = [
     "mood_api",
     "permission_api",
     "person_api",
+    "plugin_info_api",
     "plugin_manage_api",
     "register_plugin",
     "schedule_api",
diff --git a/src/plugin_system/apis/component_state_api.py b/src/plugin_system/apis/component_state_api.py
new file mode 100644
index 000000000..93b4eaa33
--- /dev/null
+++ b/src/plugin_system/apis/component_state_api.py
@@ -0,0 +1,357 @@
+"""
+Component State API
+===================
+
+该模块提供了用于管理组件启用/禁用状态的核心API。
+支持全局和局部（临时）范围的组件状态控制，以及批量操作。
+
+主要功能包括：
+- 组件的全局和局部启用/禁用
+- 批量组件状态管理
+- 组件状态查询
+"""
+
+from typing import Any
+
+from src.common.logger import get_logger
+from src.plugin_system.base.component_types import ComponentType
+from src.plugin_system.core.component_registry import ComponentInfo, component_registry
+
+# 初始化日志记录器
+logger = get_logger("component_state_api")
+
+
+# --------------------------------------------------------------------------------
+# Section 1: 组件状态管理 (Component State Management)
+# --------------------------------------------------------------------------------
+# 这部分 API 负责控制单个组件的启用和禁用状态，支持全局和局部（临时）范围。
+
+
+async def set_component_enabled(name: str, component_type: ComponentType, enabled: bool) -> bool:
+    """
+    在全局范围内启用或禁用一个组件。
+
+    此更改会直接修改组件在注册表中的状态，但此状态是临时的，不会持久化到配置文件中。
+    包含一个保护机制，防止禁用最后一个已启用的 Chatter 组件。
+
+    Args:
+        name (str): 要操作的组件的名称。
+        component_type (ComponentType): 组件的类型。
+        enabled (bool): True 表示启用, False 表示禁用。
+
+    Returns:
+        bool: 如果操作成功，则为 True。
+    """
+    # 特殊保护：确保系统中至少有一个 Chatter 组件处于启用状态
+    if component_type == ComponentType.CHATTER and not enabled:
+        enabled_chatters = component_registry.get_enabled_components_by_type(ComponentType.CHATTER)
+        if len(enabled_chatters) <= 1 and name in enabled_chatters:
+            logger.warning(f"操作被阻止：不能禁用最后一个启用的 Chatter 组件 ('{name}')。")
+            return False
+
+    # 根据 enabled 参数调用相应的注册表方法
+    if enabled:
+        return component_registry.enable_component(name, component_type)
+    else:
+        return await component_registry.disable_component(name, component_type)
+
+
+def set_component_enabled_local(stream_id: str, name: str, component_type: ComponentType, enabled: bool) -> bool:
+    """
+    在一个特定的 stream_id 上下文中临时启用或禁用组件。
+
+    此状态仅存在于内存中，并且只对指定的 stream_id 有效，不影响全局组件状态。
+    同样包含对 Chatter 组件的保护机制。
+
+    Args:
+        stream_id (str): 唯一的上下文标识符，例如一个会话ID。
+        name (str): 组件名称。
+        component_type (ComponentType): 组件类型。
+        enabled (bool): True 为启用, False 为禁用。
+
+    Returns:
+        bool: 如果操作成功，则为 True。
+    """
+    # 首先，验证组件是否存在
+    component_info = component_registry.get_component_info(name, component_type)
+    if not component_info:
+        logger.error(f"尝试设置局部状态失败：未找到组件 {name} ({component_type.value})。")
+        return False
+
+    # Chatter 唯一性保护（在 stream_id 上下文中）
+    if component_type == ComponentType.CHATTER and not enabled:
+        enabled_chatters = component_registry.get_enabled_components_by_type(ComponentType.CHATTER, stream_id=stream_id)
+        if len(enabled_chatters) <= 1 and name in enabled_chatters:
+            logger.warning(f"操作被阻止：在 stream '{stream_id}' 中，不能禁用最后一个启用的 Chatter 组件 ('{name}')。")
+            return False
+
+    # 设置局部状态
+    component_registry.set_local_component_state(stream_id, name, component_type, enabled)
+    logger.info(f"在 stream '{stream_id}' 中，组件 {name} ({component_type.value}) 的局部状态已设置为: {enabled}")
+    return True
+
+
+def clear_local_component_states(stream_id: str) -> None:
+    """
+    清除指定会话的所有局部组件状态。
+
+    当会话结束时应调用此方法来清理资源。
+
+    Args:
+        stream_id (str): 要清除状态的会话ID。
+    """
+    component_registry.clear_local_component_states(stream_id)
+    logger.debug(f"已清除 stream '{stream_id}' 的所有局部组件状态。")
+
+
+def is_component_enabled(name: str, component_type: ComponentType, stream_id: str | None = None) -> bool:
+    """
+    检查组件是否在指定上下文中启用。
+
+    Args:
+        name (str): 组件名称。
+        component_type (ComponentType): 组件类型。
+        stream_id (str | None): 可选的会话ID，用于检查局部状态。
+
+    Returns:
+        bool: 如果组件启用，则为 True。
+    """
+    return component_registry.is_component_available(name, component_type, stream_id)
+
+
+def get_component_state(name: str, component_type: ComponentType) -> dict[str, Any] | None:
+    """
+    获取组件的详细状态信息。
+
+    Args:
+        name (str): 组件名称。
+        component_type (ComponentType): 组件类型。
+
+    Returns:
+        dict | None: 包含组件状态信息的字典，如果组件不存在则返回 None。
+    """
+    component_info = component_registry.get_component_info(name, component_type)
+    if not component_info:
+        return None
+
+    return {
+        "name": component_info.name,
+        "component_type": component_info.component_type.value,
+        "plugin_name": component_info.plugin_name,
+        "enabled": component_info.enabled,
+        "description": component_info.description,
+    }
+
+
+# --------------------------------------------------------------------------------
+# Section 2: 批量组件状态管理 (Batch Component State Management)
+# --------------------------------------------------------------------------------
+# 这部分 API 提供批量操作组件状态的功能。
+
+
+async def enable_all_plugin_components(plugin_name: str) -> dict[str, bool]:
+    """
+    启用指定插件下的所有组件。
+
+    Args:
+        plugin_name (str): 插件名称。
+
+    Returns:
+        dict[str, bool]: 每个组件名称及其启用操作是否成功的字典。
+    """
+    plugin_info = component_registry.get_plugin_info(plugin_name)
+    if not plugin_info:
+        logger.error(f"未找到插件 '{plugin_name}'，无法启用其组件。")
+        return {}
+
+    results = {}
+    for component_info in plugin_info.components:
+        success = component_registry.enable_component(component_info.name, component_info.component_type)
+        results[component_info.name] = success
+        if success:
+            logger.debug(f"已启用组件: {component_info.name} ({component_info.component_type.value})")
+        else:
+            logger.warning(f"启用组件失败: {component_info.name} ({component_info.component_type.value})")
+
+    logger.info(f"已完成启用插件 '{plugin_name}' 的所有组件，成功: {sum(results.values())}/{len(results)}")
+    return results
+
+
+async def disable_all_plugin_components(plugin_name: str) -> dict[str, bool]:
+    """
+    禁用指定插件下的所有组件。
+
+    包含对 Chatter 组件的保护机制。
+
+    Args:
+        plugin_name (str): 插件名称。
+
+    Returns:
+        dict[str, bool]: 每个组件名称及其禁用操作是否成功的字典。
+    """
+    plugin_info = component_registry.get_plugin_info(plugin_name)
+    if not plugin_info:
+        logger.error(f"未找到插件 '{plugin_name}'，无法禁用其组件。")
+        return {}
+
+    results = {}
+    for component_info in plugin_info.components:
+        # Chatter 保护检查
+        if component_info.component_type == ComponentType.CHATTER:
+            enabled_chatters = component_registry.get_enabled_components_by_type(ComponentType.CHATTER)
+            if len(enabled_chatters) <= 1 and component_info.name in enabled_chatters:
+                logger.warning(
+                    f"跳过禁用最后一个 Chatter 组件 '{component_info.name}'，系统至少需要一个启用的 Chatter。"
+                )
+                results[component_info.name] = False
+                continue
+
+        success = await component_registry.disable_component(component_info.name, component_info.component_type)
+        results[component_info.name] = success
+        if success:
+            logger.debug(f"已禁用组件: {component_info.name} ({component_info.component_type.value})")
+        else:
+            logger.warning(f"禁用组件失败: {component_info.name} ({component_info.component_type.value})")
+
+    logger.info(f"已完成禁用插件 '{plugin_name}' 的所有组件，成功: {sum(results.values())}/{len(results)}")
+    return results
+
+
+async def set_components_enabled_by_type(
+    plugin_name: str, component_type: ComponentType, enabled: bool
+) -> dict[str, bool]:
+    """
+    启用或禁用指定插件下特定类型的所有组件。
+
+    Args:
+        plugin_name (str): 插件名称。
+        component_type (ComponentType): 要操作的组件类型。
+        enabled (bool): True 为启用，False 为禁用。
+
+    Returns:
+        dict[str, bool]: 每个组件名称及其操作是否成功的字典。
+    """
+    plugin_info = component_registry.get_plugin_info(plugin_name)
+    if not plugin_info:
+        logger.error(f"未找到插件 '{plugin_name}'。")
+        return {}
+
+    results = {}
+    for component_info in plugin_info.components:
+        if component_info.component_type != component_type:
+            continue
+
+        success = await set_component_enabled(component_info.name, component_type, enabled)
+        results[component_info.name] = success
+
+    action = "启用" if enabled else "禁用"
+    logger.info(
+        f"已完成{action}插件 '{plugin_name}' 的所有 {component_type.value} 组件，"
+        f"成功: {sum(results.values())}/{len(results)}"
+    )
+    return results
+
+
+async def batch_set_components_enabled(components: list[tuple[str, ComponentType]], enabled: bool) -> dict[str, bool]:
+    """
+    批量启用或禁用多个组件。
+
+    Args:
+        components (list[tuple[str, ComponentType]]): 要操作的组件列表，
+            每个元素为 (组件名称, 组件类型) 元组。
+        enabled (bool): True 为启用，False 为禁用。
+
+    Returns:
+        dict[str, bool]: 每个组件名称及其操作是否成功的字典。
+    """
+    results = {}
+    for name, component_type in components:
+        success = await set_component_enabled(name, component_type, enabled)
+        results[name] = success
+
+    action = "启用" if enabled else "禁用"
+    logger.info(f"批量{action}操作完成，成功: {sum(results.values())}/{len(results)}")
+    return results
+
+
+# --------------------------------------------------------------------------------
+# Section 3: 组件状态查询与筛选 (Component State Query & Filter)
+# --------------------------------------------------------------------------------
+# 这部分 API 提供组件状态的查询和筛选功能。
+
+
+def get_components_by_state(
+    component_type: ComponentType | None = None,
+    enabled: bool | None = None,
+    plugin_name: str | None = None,
+) -> list[ComponentInfo]:
+    """
+    根据条件筛选组件。
+
+    Args:
+        component_type (ComponentType | None): 按组件类型筛选。
+        enabled (bool | None): 按启用状态筛选。
+        plugin_name (str | None): 按插件名称筛选。
+
+    Returns:
+        list[ComponentInfo]: 符合条件的组件信息列表。
+    """
+    results = []
+
+    # 确定要搜索的组件类型
+    types_to_search = [component_type] if component_type else list(ComponentType)
+
+    for comp_type in types_to_search:
+        components = component_registry.get_components_by_type(comp_type)
+        for info in components.values():
+            # 按启用状态筛选
+            if enabled is not None and info.enabled != enabled:
+                continue
+            # 按插件名称筛选
+            if plugin_name is not None and info.plugin_name != plugin_name:
+                continue
+            results.append(info)
+
+    return results
+
+
+def get_disabled_components(plugin_name: str | None = None) -> list[ComponentInfo]:
+    """
+    获取所有被禁用的组件。
+
+    Args:
+        plugin_name (str | None): 可选，仅获取指定插件的禁用组件。
+
+    Returns:
+        list[ComponentInfo]: 禁用组件的信息列表。
+    """
+    return get_components_by_state(enabled=False, plugin_name=plugin_name)
+
+
+def get_enabled_components(plugin_name: str | None = None) -> list[ComponentInfo]:
+    """
+    获取所有已启用的组件。
+
+    Args:
+        plugin_name (str | None): 可选，仅获取指定插件的启用组件。
+
+    Returns:
+        list[ComponentInfo]: 启用组件的信息列表。
+    """
+    return get_components_by_state(enabled=True, plugin_name=plugin_name)
+
+
+def get_component_count(component_type: ComponentType, stream_id: str | None = None) -> int:
+    """
+    获取指定类型的已加载并启用的组件的总数。
+
+    可以根据 `stream_id` 考虑局部状态，从而获得特定上下文中的组件数量。
+
+    Args:
+        component_type (ComponentType): 要查询的组件类型。
+        stream_id (str | None): 可选的上下文ID。如果提供，将计入局部状态。
+
+    Returns:
+        int: 该类型下已启用的组件的数量。
+    """
+    return len(component_registry.get_enabled_components_by_type(component_type, stream_id=stream_id))
diff --git a/src/plugin_system/apis/permission_api.py b/src/plugin_system/apis/permission_api.py
index 37394267c..82f6ac785 100644
--- a/src/plugin_system/apis/permission_api.py
+++ b/src/plugin_system/apis/permission_api.py
@@ -1,80 +1,291 @@
-"""纯异步权限API定义。所有外部调用方必须使用 await。"""
+"""
+纯异步权限API定义。
 
-from abc import ABC, abstractmethod
-from dataclasses import dataclass
-from enum import Enum
-from typing import Any
+这个模块提供了一套完整的权限管理系统，用于控制用户对各种功能的访问权限。
+所有外部调用方必须使用 await 关键字，因为这是异步API。
+
+主要组件：
+- PermissionLevel: 权限等级枚举
+- PermissionNode: 权限节点数据类，描述单个权限项
+- UserInfo: 用户信息数据类，标识用户身份
+- IPermissionManager: 权限管理器抽象接口
+- PermissionAPI: 对外暴露的权限API封装类
+"""
+
+from abc import ABC, abstractmethod  # ABC: 抽象基类，abstractmethod: 抽象方法装饰器
+from dataclasses import dataclass    # dataclass: 自动生成 __init__, __repr__ 等方法的装饰器
+from enum import Enum                # Enum: 枚举类型基类
+from typing import Any               # Any: 表示任意类型
 
 from src.common.logger import get_logger
 
-logger = get_logger(__name__)
+logger = get_logger(__name__)  # 获取当前模块的日志记录器
 
 
 class PermissionLevel(Enum):
-    MASTER = "master"
+    """
+    权限等级枚举类。
+    
+    定义了系统中的权限等级，目前只有 MASTER（管理员/主人）级别。
+    MASTER 用户拥有最高权限，可以执行所有操作。
+    """
+    MASTER = "master"  # 管理员/主人权限
 
 
 @dataclass
 class PermissionNode:
-    node_name: str
-    description: str
-    plugin_name: str
-    default_granted: bool = False
+    """
+    权限节点数据类。
+    
+    每个权限节点代表一个具体的权限项，例如"发送消息"、"管理用户"等。
+    
+    属性:
+        node_name: 权限节点名称，例如 "plugin.chat.send_message"
+        description: 权限描述，用于向用户展示这个权限的用途
+        plugin_name: 注册这个权限的插件名称
+        default_granted: 是否默认授予所有用户，False 表示需要显式授权
+    """
+    node_name: str           # 权限节点唯一标识名
+    description: str         # 权限的人类可读描述
+    plugin_name: str         # 所属插件名称
+    default_granted: bool = False  # 默认是否授予（默认不授予）
 
 
 @dataclass
 class UserInfo:
-    platform: str
-    user_id: str
+    """
+    用户信息数据类。
+    
+    用于唯一标识一个用户，通过平台+用户ID的组合确定用户身份。
+    
+    属性:
+        platform: 用户所在平台，例如 "qq", "telegram", "discord"
+        user_id: 用户在该平台上的唯一标识ID
+    """
+    platform: str   # 平台标识，如 "qq", "telegram"
+    user_id: str    # 用户ID
 
     def __post_init__(self):
+        """
+        dataclass 的后初始化钩子。
+        
+        确保 user_id 始终是字符串类型，即使传入的是数字也会被转换。
+        这样可以避免类型不一致导致的比较问题。
+        """
         self.user_id = str(self.user_id)
 
 
 class IPermissionManager(ABC):
+    """
+    权限管理器抽象接口（Interface）。
+    
+    这是一个抽象基类，定义了权限管理器必须实现的所有方法。
+    具体的权限管理实现类需要继承此接口并实现所有抽象方法。
+    
+    使用抽象接口的好处：
+    1. 解耦：PermissionAPI 不需要知道具体的实现细节
+    2. 可测试：可以轻松创建 Mock 实现用于测试
+    3. 可替换：可以随时更换不同的权限管理实现
+    """
+    
     @abstractmethod
-    async def check_permission(self, user: UserInfo, permission_node: str) -> bool: ...
+    async def check_permission(self, user: UserInfo, permission_node: str) -> bool:
+        """
+        检查用户是否拥有指定权限。
+        
+        Args:
+            user: 要检查的用户信息
+            permission_node: 权限节点名称
+            
+        Returns:
+            bool: True 表示用户拥有该权限，False 表示没有
+        """
+        ...
 
     @abstractmethod
-    async def is_master(self, user: UserInfo) -> bool: ...  # 同步快速判断
+    async def is_master(self, user: UserInfo) -> bool:
+        """
+        检查用户是否是管理员/主人。
+        
+        管理员拥有最高权限，通常绕过所有权限检查。
+        
+        Args:
+            user: 要检查的用户信息
+            
+        Returns:
+            bool: True 表示是管理员，False 表示不是
+        """
+        ...
 
     @abstractmethod
-    async def register_permission_node(self, node: PermissionNode) -> bool: ...
+    async def register_permission_node(self, node: PermissionNode) -> bool:
+        """
+        注册一个新的权限节点。
+        
+        插件在加载时会调用此方法注册自己需要的权限。
+        
+        Args:
+            node: 要注册的权限节点信息
+            
+        Returns:
+            bool: True 表示注册成功，False 表示失败（可能是重复注册）
+        """
+        ...
 
     @abstractmethod
-    async def grant_permission(self, user: UserInfo, permission_node: str) -> bool: ...
+    async def grant_permission(self, user: UserInfo, permission_node: str) -> bool:
+        """
+        授予用户指定权限。
+        
+        Args:
+            user: 目标用户信息
+            permission_node: 要授予的权限节点名称
+            
+        Returns:
+            bool: True 表示授权成功，False 表示失败
+        """
+        ...
 
     @abstractmethod
-    async def revoke_permission(self, user: UserInfo, permission_node: str) -> bool: ...
+    async def revoke_permission(self, user: UserInfo, permission_node: str) -> bool:
+        """
+        撤销用户的指定权限。
+        
+        Args:
+            user: 目标用户信息
+            permission_node: 要撤销的权限节点名称
+            
+        Returns:
+            bool: True 表示撤销成功，False 表示失败
+        """
+        ...
 
     @abstractmethod
-    async def get_user_permissions(self, user: UserInfo) -> list[str]: ...
+    async def get_user_permissions(self, user: UserInfo) -> list[str]:
+        """
+        获取用户拥有的所有权限列表。
+        
+        Args:
+            user: 目标用户信息
+            
+        Returns:
+            list[str]: 用户拥有的权限节点名称列表
+        """
+        ...
 
     @abstractmethod
-    async def get_all_permission_nodes(self) -> list[PermissionNode]: ...
+    async def get_all_permission_nodes(self) -> list[PermissionNode]:
+        """
+        获取系统中所有已注册的权限节点。
+        
+        Returns:
+            list[PermissionNode]: 所有权限节点的列表
+        """
+        ...
 
     @abstractmethod
-    async def get_plugin_permission_nodes(self, plugin_name: str) -> list[PermissionNode]: ...
+    async def get_plugin_permission_nodes(self, plugin_name: str) -> list[PermissionNode]:
+        """
+        获取指定插件注册的所有权限节点。
+        
+        Args:
+            plugin_name: 插件名称
+            
+        Returns:
+            list[PermissionNode]: 该插件注册的权限节点列表
+        """
+        ...
 
 
 class PermissionAPI:
+    """
+    权限API封装类。
+    
+    这是对外暴露的权限操作接口，插件和其他模块通过这个类来进行权限相关操作。
+    它封装了底层的 IPermissionManager，提供更简洁的调用方式。
+    
+    使用方式：
+        from src.plugin_system.apis.permission_api import permission_api
+        
+        # 检查权限
+        has_perm = await permission_api.check_permission("qq", "12345", "chat.send")
+        
+        # 检查是否是管理员
+        is_admin = await permission_api.is_master("qq", "12345")
+    
+    设计模式：
+        这是一个单例模式的变体，模块级别的 permission_api 实例供全局使用。
+    """
+    
     def __init__(self):
-        self._permission_manager: IPermissionManager | None = None
+        """
+        初始化 PermissionAPI。
+        
+        初始时权限管理器为 None，需要在系统启动时通过 set_permission_manager 设置。
+        """
+        self._permission_manager: IPermissionManager | None = None  # 底层权限管理器实例
 
     def set_permission_manager(self, manager: IPermissionManager):
+        """
+        设置权限管理器实例。
+        
+        这个方法应该在系统启动时被调用，注入具体的权限管理器实现。
+        
+        Args:
+            manager: 实现了 IPermissionManager 接口的权限管理器实例
+        """
         self._permission_manager = manager
 
     def _ensure_manager(self):
+        """
+        确保权限管理器已设置（内部辅助方法）。
+        
+        如果权限管理器未设置，抛出 RuntimeError 异常。
+        这是一个防御性编程措施，帮助开发者快速发现配置问题。
+        
+        Raises:
+            RuntimeError: 当权限管理器未设置时
+        """
         if self._permission_manager is None:
             raise RuntimeError("权限管理器未设置，请先调用 set_permission_manager")
 
     async def check_permission(self, platform: str, user_id: str, permission_node: str) -> bool:
+        """
+        检查用户是否拥有指定权限。
+        
+        这是最常用的权限检查方法，在执行需要权限的操作前调用。
+        
+        Args:
+            platform: 用户所在平台（如 "qq", "telegram"）
+            user_id: 用户ID
+            permission_node: 要检查的权限节点名称
+            
+        Returns:
+            bool: True 表示用户拥有权限，False 表示没有
+            
+        Example:
+            if await permission_api.check_permission("qq", "12345", "admin.ban_user"):
+                # 执行封禁操作
+                pass
+        """
         self._ensure_manager()
         if not self._permission_manager:
             return False
         return await self._permission_manager.check_permission(UserInfo(platform, user_id), permission_node)
 
     async def is_master(self, platform: str, user_id: str) -> bool:
+        """
+        检查用户是否是管理员/主人。
+        
+        管理员是系统的最高权限用户，通常在配置文件中指定。
+        
+        Args:
+            platform: 用户所在平台
+            user_id: 用户ID
+            
+        Returns:
+            bool: True 表示是管理员，False 表示不是
+        """
         self._ensure_manager()
         if not self._permission_manager:
             return False
@@ -87,11 +298,35 @@ class PermissionAPI:
         plugin_name: str,
         default_granted: bool = False,
         *,
-        allow_relative: bool = True,
+        allow_relative: bool = True,  # 仅关键字参数，目前未使用，预留给相对权限名功能
     ) -> bool:
+        """
+        注册一个新的权限节点。
+        
+        插件在初始化时应调用此方法注册自己需要的权限节点。
+        
+        Args:
+            node_name: 权限节点名称，建议使用 "插件名.功能.操作" 的格式
+            description: 权限描述，向用户解释这个权限的作用
+            plugin_name: 注册此权限的插件名称
+            default_granted: 是否默认授予所有用户（默认 False，需要显式授权）
+            allow_relative: 预留参数，是否允许相对权限名（目前未使用）
+            
+        Returns:
+            bool: True 表示注册成功，False 表示失败
+            
+        Example:
+            await permission_api.register_permission_node(
+                node_name="my_plugin.chat.send_image",
+                description="允许发送图片消息",
+                plugin_name="my_plugin",
+                default_granted=True  # 所有用户默认都能发图片
+            )
+        """
         self._ensure_manager()
-        original_name = node_name
+        original_name = node_name  # 保存原始名称（预留给相对路径处理）
 
+        # 创建权限节点对象
         node = PermissionNode(node_name, description, plugin_name, default_granted)
         if not self._permission_manager:
             return False
@@ -100,28 +335,90 @@ class PermissionAPI:
 
 
     async def grant_permission(self, platform: str, user_id: str, permission_node: str) -> bool:
+        """
+        授予用户指定权限。
+        
+        通常由管理员调用，给某个用户赋予特定权限。
+        
+        Args:
+            platform: 目标用户所在平台
+            user_id: 目标用户ID
+            permission_node: 要授予的权限节点名称
+            
+        Returns:
+            bool: True 表示授权成功，False 表示失败
+            
+        Example:
+            # 授予用户管理权限
+            await permission_api.grant_permission("qq", "12345", "admin.manage_users")
+        """
         self._ensure_manager()
         if not self._permission_manager:
             return False
         return await self._permission_manager.grant_permission(UserInfo(platform, user_id), permission_node)
 
     async def revoke_permission(self, platform: str, user_id: str, permission_node: str) -> bool:
+        """
+        撤销用户的指定权限。
+        
+        通常由管理员调用，移除某个用户的特定权限。
+        
+        Args:
+            platform: 目标用户所在平台
+            user_id: 目标用户ID
+            permission_node: 要撤销的权限节点名称
+            
+        Returns:
+            bool: True 表示撤销成功，False 表示失败
+        """
         self._ensure_manager()
         if not self._permission_manager:
             return False
         return await self._permission_manager.revoke_permission(UserInfo(platform, user_id), permission_node)
 
     async def get_user_permissions(self, platform: str, user_id: str) -> list[str]:
+        """
+        获取用户拥有的所有权限列表。
+        
+        可用于展示用户的权限信息，或进行批量权限检查。
+        
+        Args:
+            platform: 目标用户所在平台
+            user_id: 目标用户ID
+            
+        Returns:
+            list[str]: 用户拥有的所有权限节点名称列表
+            
+        Example:
+            perms = await permission_api.get_user_permissions("qq", "12345")
+            print(f"用户拥有以下权限: {perms}")
+        """
         self._ensure_manager()
         if not self._permission_manager:
             return []
         return await self._permission_manager.get_user_permissions(UserInfo(platform, user_id))
 
     async def get_all_permission_nodes(self) -> list[dict[str, Any]]:
+        """
+        获取系统中所有已注册的权限节点。
+        
+        返回所有插件注册的权限节点信息，可用于权限管理界面展示。
+        
+        Returns:
+            list[dict]: 权限节点信息列表，每个字典包含：
+                - node_name: 权限节点名称
+                - description: 权限描述
+                - plugin_name: 所属插件名称
+                - default_granted: 是否默认授予
+                
+        Note:
+            返回字典而非 PermissionNode 对象，便于序列化和API响应。
+        """
         self._ensure_manager()
         if not self._permission_manager:
             return []
         nodes = await self._permission_manager.get_all_permission_nodes()
+        # 将 PermissionNode 对象转换为字典，便于序列化
         return [
             {
                 "node_name": n.node_name,
@@ -133,10 +430,22 @@ class PermissionAPI:
         ]
 
     async def get_plugin_permission_nodes(self, plugin_name: str) -> list[dict[str, Any]]:
+        """
+        获取指定插件注册的所有权限节点。
+        
+        用于查看某个特定插件定义了哪些权限。
+        
+        Args:
+            plugin_name: 插件名称
+            
+        Returns:
+            list[dict]: 该插件的权限节点信息列表，格式同 get_all_permission_nodes
+        """
         self._ensure_manager()
         if not self._permission_manager:
             return []
         nodes = await self._permission_manager.get_plugin_permission_nodes(plugin_name)
+        # 将 PermissionNode 对象转换为字典
         return [
             {
                 "node_name": n.node_name,
@@ -148,4 +457,9 @@ class PermissionAPI:
         ]
 
 
+# ============================================================
+# 模块级单例实例
+# ============================================================
+# 全局权限API实例，供其他模块导入使用
+# 使用方式: from src.plugin_system.apis.permission_api import permission_api
 permission_api = PermissionAPI()
diff --git a/src/plugin_system/apis/plugin_info_api.py b/src/plugin_system/apis/plugin_info_api.py
new file mode 100644
index 000000000..b01df5402
--- /dev/null
+++ b/src/plugin_system/apis/plugin_info_api.py
@@ -0,0 +1,454 @@
+"""
+Plugin Info API
+===============
+
+该模块提供了用于查询插件和组件信息、生成报告和统计数据的API。
+
+主要功能包括：
+- 系统状态报告生成
+- 插件详情查询
+- 组件列表和搜索
+- 状态统计
+- 工具函数
+"""
+
+from typing import Any, Literal
+
+from src.common.logger import get_logger
+from src.plugin_system.base.component_types import ComponentType
+from src.plugin_system.core.component_registry import ComponentInfo, component_registry
+from src.plugin_system.core.plugin_manager import plugin_manager
+
+# 初始化日志记录器
+logger = get_logger("plugin_info_api")
+
+
+# --------------------------------------------------------------------------------
+# Section 1: 信息查询与报告 (Information Querying & Reporting)
+# --------------------------------------------------------------------------------
+# 这部分 API 用于获取关于插件和组件的详细信息、列表和统计数据。
+
+
+def get_system_report() -> dict[str, Any]:
+    """
+    生成一份详细的系统状态报告。
+
+    报告包含已加载插件、失败插件和组件的全面信息，是调试和监控系统状态的核心工具。
+
+    Returns:
+        dict[str, Any]: 包含系统、插件和组件状态的详细报告字典。
+    """
+    loaded_plugins_info = {}
+    # 遍历所有已加载的插件实例
+    for name, instance in plugin_manager.loaded_plugins.items():
+        plugin_info = component_registry.get_plugin_info(name)
+        if not plugin_info:
+            continue
+
+        # 收集该插件下所有组件的详细信息
+        components_details = [
+            {
+                "name": comp_info.name,
+                "component_type": comp_info.component_type.value,
+                "description": comp_info.description,
+                "enabled": comp_info.enabled,
+            }
+            for comp_info in plugin_info.components
+        ]
+
+        # 构建单个插件的信息字典
+        # 元数据从 PluginInfo 获取，而启用状态(enable_plugin)从插件实例获取
+        loaded_plugins_info[name] = {
+            "display_name": plugin_info.display_name or name,
+            "version": plugin_info.version,
+            "author": plugin_info.author,
+            "enabled": instance.enable_plugin,
+            "components": components_details,
+        }
+
+    # 构建最终的完整报告
+    report = {
+        "system_info": {
+            "loaded_plugins_count": len(plugin_manager.loaded_plugins),
+            "total_components_count": component_registry.get_registry_stats().get("total_components", 0),
+        },
+        "plugins": loaded_plugins_info,
+        "failed_plugins": plugin_manager.failed_plugins,
+    }
+    return report
+
+
+def get_plugin_details(plugin_name: str) -> dict[str, Any] | None:
+    """
+    获取单个插件的详细报告。
+
+    报告内容包括插件的元数据、所有组件的详细信息及其当前状态。
+    这是 `get_system_report` 的单插件聚焦版本。
+
+    Args:
+        plugin_name (str): 要查询的插件名称。
+
+    Returns:
+        dict | None: 包含插件详细信息的字典，如果插件未注册则返回 None。
+    """
+    plugin_info = component_registry.get_plugin_info(plugin_name)
+    if not plugin_info:
+        logger.warning(f"尝试获取插件详情失败：未找到名为 '{plugin_name}' 的插件。")
+        return None
+
+    # 收集该插件下所有组件的信息
+    components_details = [
+        {
+            "name": comp_info.name,
+            "component_type": comp_info.component_type.value,
+            "description": comp_info.description,
+            "enabled": comp_info.enabled,
+        }
+        for comp_info in plugin_info.components
+    ]
+
+    # 获取插件实例以检查其启用状态
+    plugin_instance = plugin_manager.get_plugin_instance(plugin_name)
+    is_enabled = plugin_instance.enable_plugin if plugin_instance else False
+
+    # 组装详细信息字典
+    return {
+        "name": plugin_info.name,
+        "display_name": plugin_info.display_name or plugin_info.name,
+        "version": plugin_info.version,
+        "author": plugin_info.author,
+        "license": plugin_info.license,
+        "description": plugin_info.description,
+        "enabled": is_enabled,
+        "status": "loaded" if is_plugin_loaded(plugin_name) else "registered",
+        "components": components_details,
+    }
+
+
+def list_plugins(status: Literal["loaded", "registered", "failed"]) -> list[str]:
+    """
+    根据指定的状态列出插件名称列表。
+
+    提供了一种快速、便捷的方式来监控和调试插件系统，而无需解析完整的系统报告。
+
+    Args:
+        status (str): 插件状态，可选值为 'loaded', 'registered', 'failed'。
+
+    Returns:
+        list[str]: 对应状态的插件名称列表。
+
+    Raises:
+        ValueError: 如果传入了无效的状态字符串。
+    """
+    if status == "loaded":
+        # 返回所有当前已成功加载的插件
+        return plugin_manager.list_loaded_plugins()
+    if status == "registered":
+        # 返回所有已注册（但不一定已加载）的插件
+        return plugin_manager.list_registered_plugins()
+    if status == "failed":
+        # 返回所有加载失败的插件的名称
+        return list(plugin_manager.failed_plugins.keys())
+    # 如果状态无效，则引发错误
+    raise ValueError(f"无效的插件状态: '{status}'。有效选项为 'loaded', 'registered', 'failed'。")
+
+
+def list_components(component_type: ComponentType, enabled_only: bool = True) -> list[dict[str, Any]]:
+    """
+    列出指定类型的所有组件的详细信息。
+
+    这是查找和管理组件的核心功能，例如，获取所有可用的工具或所有注册的聊天器。
+
+    Args:
+        component_type (ComponentType): 要查询的组件类型。
+        enabled_only (bool, optional): 是否只返回已启用的组件。默认为 True。
+
+    Returns:
+        list[dict[str, Any]]: 一个包含组件信息字典的列表。
+    """
+    # 根据 enabled_only 参数决定是获取所有组件还是仅获取已启用的组件
+    if enabled_only:
+        components = component_registry.get_enabled_components_by_type(component_type)
+    else:
+        components = component_registry.get_components_by_type(component_type)
+
+    # 将组件信息格式化为字典列表
+    return [
+        {
+            "name": info.name,
+            "plugin_name": info.plugin_name,
+            "description": info.description,
+            "enabled": info.enabled,
+        }
+        for info in components.values()
+    ]
+
+
+def search_components_by_name(
+    name_keyword: str,
+    component_type: ComponentType | None = None,
+    case_sensitive: bool = False,
+    exact_match: bool = False,
+) -> list[dict[str, Any]]:
+    """
+    根据名称关键字搜索组件，支持模糊匹配和精确匹配。
+
+    极大地增强了组件的可发现性，用户无需知道完整名称即可找到所需组件。
+
+    Args:
+        name_keyword (str): 用于搜索的名称关键字。
+        component_type (ComponentType | None, optional): 如果提供，则只在该类型中搜索。默认为 None (搜索所有类型)。
+        case_sensitive (bool, optional): 是否进行大小写敏感的搜索。默认为 False。
+        exact_match (bool, optional): 是否进行精确匹配。默认为 False (模糊匹配)。
+
+    Returns:
+        list[dict[str, Any]]: 匹配的组件信息字典的列表。
+    """
+    results = []
+    # 如果未指定组件类型，则搜索所有类型
+    types_to_search = [component_type] if component_type else list(ComponentType)
+
+    # 根据是否大小写敏感，预处理搜索关键字
+    compare_str = name_keyword if case_sensitive else name_keyword.lower()
+
+    # 遍历要搜索的组件类型
+    for comp_type in types_to_search:
+        all_components = component_registry.get_components_by_type(comp_type)
+        for name, info in all_components.items():
+            # 同样地，预处理组件名称
+            target_name = name if case_sensitive else name.lower()
+
+            # 根据 exact_match 参数决定使用精确比较还是模糊包含检查
+            is_match = (compare_str == target_name) if exact_match else (compare_str in target_name)
+
+            # 如果匹配，则将组件信息添加到结果列表
+            if is_match:
+                results.append(
+                    {
+                        "name": info.name,
+                        "component_type": info.component_type.value,
+                        "plugin_name": info.plugin_name,
+                        "description": info.description,
+                        "enabled": info.enabled,
+                    }
+                )
+    return results
+
+
+def get_component_info(name: str, component_type: ComponentType) -> ComponentInfo | None:
+    """
+    获取任何一个已注册组件的详细信息对象。
+
+    Args:
+        name (str): 组件的唯一名称。
+        component_type (ComponentType): 组件的类型。
+
+    Returns:
+        ComponentInfo | None: 包含组件完整信息的 ComponentInfo 对象，如果找不到则返回 None。
+    """
+    return component_registry.get_component_info(name, component_type)
+
+
+# --------------------------------------------------------------------------------
+# Section 2: 状态查询与统计 (State Querying & Statistics)
+# --------------------------------------------------------------------------------
+# 这部分 API 提供状态查询和统计功能。
+
+
+def get_plugin_state(plugin_name: str) -> dict[str, Any] | None:
+    """
+    获取插件的详细状态信息。
+
+    Args:
+        plugin_name (str): 要查询的插件名称。
+
+    Returns:
+        dict | None: 包含插件状态信息的字典，如果插件不存在则返回 None。
+    """
+    plugin_instance = plugin_manager.get_plugin_instance(plugin_name)
+    plugin_info = component_registry.get_plugin_info(plugin_name)
+
+    if not plugin_info:
+        return None
+
+    is_loaded = plugin_name in plugin_manager.list_loaded_plugins()
+    is_enabled = plugin_instance.enable_plugin if plugin_instance else False
+
+    # 统计组件状态
+    total_components = len(plugin_info.components)
+    enabled_components = sum(1 for c in plugin_info.components if c.enabled)
+
+    return {
+        "name": plugin_name,
+        "is_loaded": is_loaded,
+        "is_enabled": is_enabled,
+        "total_components": total_components,
+        "enabled_components": enabled_components,
+        "disabled_components": total_components - enabled_components,
+    }
+
+
+def get_all_plugin_states() -> dict[str, dict[str, Any]]:
+    """
+    获取所有已加载插件的状态信息。
+
+    Returns:
+        dict: 插件名称到状态信息的映射。
+    """
+    result = {}
+    for plugin_name in plugin_manager.list_loaded_plugins():
+        state = get_plugin_state(plugin_name)
+        if state:
+            result[plugin_name] = state
+    return result
+
+
+def get_state_statistics() -> dict[str, Any]:
+    """
+    获取整体状态统计信息。
+
+    Returns:
+        dict: 包含插件和组件状态统计的字典。
+    """
+    loaded_plugins = plugin_manager.list_loaded_plugins()
+    registered_plugins = plugin_manager.list_registered_plugins()
+    failed_plugins = list(plugin_manager.failed_plugins.keys())
+
+    # 统计启用/禁用的插件数量
+    enabled_plugins = sum(1 for name in loaded_plugins if is_plugin_enabled(name))
+
+    # 统计各类型组件数量
+    component_stats = {}
+    total_enabled = 0
+    total_disabled = 0
+
+    for comp_type in ComponentType:
+        all_components = component_registry.get_components_by_type(comp_type)
+        enabled_count = sum(1 for info in all_components.values() if info.enabled)
+        disabled_count = len(all_components) - enabled_count
+
+        component_stats[comp_type.value] = {
+            "total": len(all_components),
+            "enabled": enabled_count,
+            "disabled": disabled_count,
+        }
+        total_enabled += enabled_count
+        total_disabled += disabled_count
+
+    return {
+        "plugins": {
+            "loaded": len(loaded_plugins),
+            "registered": len(registered_plugins),
+            "failed": len(failed_plugins),
+            "enabled": enabled_plugins,
+            "disabled": len(loaded_plugins) - enabled_plugins,
+        },
+        "components": {
+            "total": total_enabled + total_disabled,
+            "enabled": total_enabled,
+            "disabled": total_disabled,
+            "by_type": component_stats,
+        },
+    }
+
+
+# --------------------------------------------------------------------------------
+# Section 3: 工具函数 (Utility Functions)
+# --------------------------------------------------------------------------------
+# 这部分提供了一些轻量级的辅助函数，用于快速检查状态。
+
+
+def is_plugin_loaded(plugin_name: str) -> bool:
+    """
+    快速检查一个插件当前是否已成功加载。
+
+    这是一个比 `get_plugin_details` 更轻量级的检查方法，适用于需要快速布尔值判断的场景。
+
+    Args:
+        plugin_name (str): 要检查的插件名称。
+
+    Returns:
+        bool: 如果插件已加载，则为 True，否则为 False。
+    """
+    return plugin_name in plugin_manager.list_loaded_plugins()
+
+
+def is_plugin_enabled(plugin_name: str) -> bool:
+    """
+    检查插件是否处于启用状态。
+
+    Args:
+        plugin_name (str): 要检查的插件名称。
+
+    Returns:
+        bool: 如果插件已启用，则为 True；如果未加载或已禁用，则为 False。
+    """
+    plugin_instance = plugin_manager.get_plugin_instance(plugin_name)
+    if not plugin_instance:
+        return False
+    return plugin_instance.enable_plugin
+
+
+def get_component_plugin(component_name: str, component_type: ComponentType) -> str | None:
+    """
+    查找一个特定组件属于哪个插件。
+
+    在调试或管理组件时，此函数能够方便地追溯其定义的源头。
+
+    Args:
+        component_name (str): 组件的名称。
+        component_type (ComponentType): 组件的类型。
+
+    Returns:
+        str | None: 组件所属的插件名称，如果找不到组件则返回 None。
+    """
+    component_info = component_registry.get_component_info(component_name, component_type)
+    return component_info.plugin_name if component_info else None
+
+
+def validate_component_exists(name: str, component_type: ComponentType) -> bool:
+    """
+    验证组件是否存在于注册表中。
+
+    Args:
+        name (str): 组件名称。
+        component_type (ComponentType): 组件类型。
+
+    Returns:
+        bool: 如果组件存在，则为 True。
+    """
+    return component_registry.get_component_info(name, component_type) is not None
+
+
+def get_plugin_component_summary(plugin_name: str) -> dict[str, Any] | None:
+    """
+    获取插件的组件摘要信息。
+
+    Args:
+        plugin_name (str): 插件名称。
+
+    Returns:
+        dict | None: 包含组件摘要的字典，如果插件不存在则返回 None。
+    """
+    plugin_info = component_registry.get_plugin_info(plugin_name)
+    if not plugin_info:
+        return None
+
+    # 按类型统计组件
+    by_type = {}
+    for comp_type in ComponentType:
+        components = [c for c in plugin_info.components if c.component_type == comp_type]
+        if components:
+            enabled = sum(1 for c in components if c.enabled)
+            by_type[comp_type.value] = {
+                "total": len(components),
+                "enabled": enabled,
+                "disabled": len(components) - enabled,
+                "names": [c.name for c in components],
+            }
+
+    return {
+        "plugin_name": plugin_name,
+        "total_components": len(plugin_info.components),
+        "by_type": by_type,
+    }
diff --git a/src/plugin_system/apis/plugin_manage_api.py b/src/plugin_system/apis/plugin_manage_api.py
index ccd05dc94..ad50ad029 100644
--- a/src/plugin_system/apis/plugin_manage_api.py
+++ b/src/plugin_system/apis/plugin_manage_api.py
@@ -2,17 +2,21 @@
 Plugin Manage API
 =================
 
-该模块提供了用于管理插件和组件生命周期、状态和信息查询的核心API。
-功能包括插件的加载、重载、注册、扫描，组件的启用/禁用，以及系统状态报告的生成。
-所有函数都设计为异步或同步，以适应不同的调用上下文。
+该模块提供了用于管理插件生命周期的核心API。
+功能包括插件的加载、重载、注册、扫描，以及插件的启用/禁用和卸载。
+
+主要功能包括：
+- 插件生命周期管理（加载、重载、注册、发现）
+- 插件的启用/禁用
+- 插件卸载
+
+组件状态管理相关功能请使用 component_state_api
+信息查询和报告相关功能请使用 plugin_info_api
 """
 
 import os
-from typing import Any, Literal
 
 from src.common.logger import get_logger
-from src.plugin_system.base.component_types import ComponentType
-from src.plugin_system.core.component_registry import ComponentInfo, component_registry
 from src.plugin_system.core.plugin_manager import plugin_manager
 
 # 初始化日志记录器
@@ -180,336 +184,115 @@ def register_plugin_from_file(plugin_name: str, load_after_register: bool = True
 
 
 # --------------------------------------------------------------------------------
-# Section 2: 组件状态管理 (Component State Management)
+# Section 2: 插件状态管理 (Plugin State Management)
 # --------------------------------------------------------------------------------
-# 这部分 API 负责控制单个组件的启用和禁用状态，支持全局和局部（临时）范围。
+# 该部分包含控制插件整体启用/禁用状态的功能。
 
 
-async def set_component_enabled(name: str, component_type: ComponentType, enabled: bool) -> bool:
+async def enable_plugin(plugin_name: str) -> bool:
     """
-    在全局范围内启用或禁用一个组件。
+    启用一个已禁用的插件。
 
-    此更改会直接修改组件在注册表中的状态，但此状态是临时的，不会持久化到配置文件中。
-    包含一个保护机制，防止禁用最后一个已启用的 Chatter 组件。
+    如果插件已经启用，直接返回 True。
+    启用插件会同时尝试加载其所有组件。
 
     Args:
-        name (str): 要操作的组件的名称。
-        component_type (ComponentType): 组件的类型。
-        enabled (bool): True 表示启用, False 表示禁用。
+        plugin_name (str): 要启用的插件名称。
 
     Returns:
-        bool: 如果操作成功，则为 True。
+        bool: 如果插件成功启用，则为 True。
     """
-    # 特殊保护：确保系统中至少有一个 Chatter 组件处于启用状态
-    if component_type == ComponentType.CHATTER and not enabled:
-        enabled_chatters = component_registry.get_enabled_components_by_type(ComponentType.CHATTER)
-        # 如果当前启用的 Chatter 少于等于1个，并且要禁用的就是它，则阻止操作
-        if len(enabled_chatters) <= 1 and name in enabled_chatters:
-            logger.warning(f"操作被阻止：不能禁用最后一个启用的 Chatter 组件 ('{name}')。")
-            return False
-
-    # 获取组件信息
-    component_info = component_registry.get_component_info(name, component_type)
-    if not component_info:
-        logger.error(f"未找到组件 {name} ({component_type.value})，无法更改其状态。")
-        return False
-
-    # 直接修改组件实例的 enabled 状态
-    component_info.enabled = enabled
-    logger.info(f"组件 {name} ({component_type.value}) 的全局状态已设置为: {enabled}")
-    return True
-
-
-def set_component_enabled_local(stream_id: str, name: str, component_type: ComponentType, enabled: bool) -> bool:
-    """
-    在一个特定的 stream_id 上下文中临时启用或禁用组件。
-
-    此状态仅存在于内存中，并且只对指定的 stream_id 有效，不影响全局组件状态。
-    同样包含对 Chatter 组件的保护机制。
-
-    Args:
-        stream_id (str): 唯一的上下文标识符，例如一个会话ID。
-        name (str): 组件名称。
-        component_type (ComponentType): 组件类型。
-        enabled (bool): True 为启用, False 为禁用。
-
-    Returns:
-        bool: 如果操作成功，则为 True。
-    """
-    # 首先，验证组件是否存在
-    component_info = component_registry.get_component_info(name, component_type)
-    if not component_info:
-        logger.error(f"尝试设置局部状态失败：未找到组件 {name} ({component_type.value})。")
-        return False
-
-    # Chatter 唯一性保护（在 stream_id 上下文中）
-    if component_type == ComponentType.CHATTER and not enabled:
-        # 检查当前 stream_id 上下文中启用的 Chatter
-        enabled_chatters = component_registry.get_enabled_components_by_type(ComponentType.CHATTER, stream_id=stream_id)
-        if len(enabled_chatters) <= 1 and name in enabled_chatters:
-            logger.warning(f"操作被阻止：在 stream '{stream_id}' 中，不能禁用最后一个启用的 Chatter 组件 ('{name}')。")
-            return False
-
-    # 设置局部状态
-    component_registry.set_local_component_state(stream_id, name, component_type, enabled)
-    logger.info(f"在 stream '{stream_id}' 中，组件 {name} ({component_type.value}) 的局部状态已设置为: {enabled}")
-    return True
-
-
-# --------------------------------------------------------------------------------
-# Section 3: 信息查询与报告 (Information Querying & Reporting)
-# --------------------------------------------------------------------------------
-# 这部分 API 用于获取关于插件和组件的详细信息、列表和统计数据。
-
-
-def get_system_report() -> dict[str, Any]:
-    """
-    生成一份详细的系统状态报告。
-
-    报告包含已加载插件、失败插件和组件的全面信息，是调试和监控系统状态的核心工具。
-
-    Returns:
-        dict[str, Any]: 包含系统、插件和组件状态的详细报告字典。
-    """
-    loaded_plugins_info = {}
-    # 遍历所有已加载的插件实例
-    for name, instance in plugin_manager.loaded_plugins.items():
-        plugin_info = component_registry.get_plugin_info(name)
-        if not plugin_info:
-            continue
-
-        # 收集该插件下所有组件的详细信息
-        components_details = [
-            {
-                "name": comp_info.name,
-                "component_type": comp_info.component_type.value,
-                "description": comp_info.description,
-                "enabled": comp_info.enabled,
-            }
-            for comp_info in plugin_info.components
-        ]
-
-        # 构建单个插件的信息字典
-        # 元数据从 PluginInfo 获取，而启用状态(enable_plugin)从插件实例获取
-        loaded_plugins_info[name] = {
-            "display_name": plugin_info.display_name or name,
-            "version": plugin_info.version,
-            "author": plugin_info.author,
-            "enabled": instance.enable_plugin,
-            "components": components_details,
-        }
-
-    # 构建最终的完整报告
-    report = {
-        "system_info": {
-            "loaded_plugins_count": len(plugin_manager.loaded_plugins),
-            "total_components_count": component_registry.get_registry_stats().get("total_components", 0),
-        },
-        "plugins": loaded_plugins_info,
-        "failed_plugins": plugin_manager.failed_plugins,
-    }
-    return report
-
-
-def get_plugin_details(plugin_name: str) -> dict[str, Any] | None:
-    """
-    获取单个插件的详细报告。
-
-    报告内容包括插件的元数据、所有组件的详细信息及其当前状态。
-    这是 `get_system_report` 的单插件聚焦版本。
-
-    Args:
-        plugin_name (str): 要查询的插件名称。
-
-    Returns:
-        dict | None: 包含插件详细信息的字典，如果插件未注册则返回 None。
-    """
-    plugin_info = component_registry.get_plugin_info(plugin_name)
-    if not plugin_info:
-        logger.warning(f"尝试获取插件详情失败：未找到名为 '{plugin_name}' 的插件。")
-        return None
-
-    # 收集该插件下所有组件的信息
-    components_details = [
-        {
-            "name": comp_info.name,
-            "component_type": comp_info.component_type.value,
-            "description": comp_info.description,
-            "enabled": comp_info.enabled,
-        }
-        for comp_info in plugin_info.components
-    ]
-
-    # 获取插件实例以检查其启用状态
     plugin_instance = plugin_manager.get_plugin_instance(plugin_name)
-    is_enabled = plugin_instance.enable_plugin if plugin_instance else False
 
-    # 组装详细信息字典
-    return {
-        "name": plugin_info.name,
-        "display_name": plugin_info.display_name or plugin_info.name,
-        "version": plugin_info.version,
-        "author": plugin_info.author,
-        "license": plugin_info.license,
-        "description": plugin_info.description,
-        "enabled": is_enabled,
-        "status": "loaded" if is_plugin_loaded(plugin_name) else "registered",
-        "components": components_details,
-    }
+    if not plugin_instance:
+        # 插件未加载，尝试从注册表加载
+        if plugin_name not in plugin_manager.list_registered_plugins():
+            logger.error(f"插件 '{plugin_name}' 未注册，无法启用。")
+            return False
+
+        # 尝试加载插件
+        success, _ = plugin_manager.load_registered_plugin_classes(plugin_name)
+        if not success:
+            logger.error(f"加载插件 '{plugin_name}' 失败。")
+            return False
+
+        logger.info(f"插件 '{plugin_name}' 已成功启用并加载。")
+        return True
+
+    # 如果插件已经启用
+    if plugin_instance.enable_plugin:
+        logger.info(f"插件 '{plugin_name}' 已经处于启用状态。")
+        return True
+
+    # 设置插件为启用状态
+    plugin_instance.enable_plugin = True
+    logger.info(f"插件 '{plugin_name}' 已启用。")
+    return True
 
 
-def list_plugins(status: Literal["loaded", "registered", "failed"]) -> list[str]:
+async def disable_plugin(plugin_name: str,) -> bool:
     """
-    根据指定的状态列出插件名称列表。
+    禁用一个插件。
 
-    提供了一种快速、便捷的方式来监控和调试插件系统，而无需解析完整的系统报告。
+    禁用插件不会卸载它，只会标记为禁用状态。
 
     Args:
-        status (str): 插件状态，可选值为 'loaded', 'registered', 'failed'。
+        plugin_name (str): 要禁用的插件名称。
 
     Returns:
-        list[str]: 对应状态的插件名称列表。
-
-    Raises:
-        ValueError: 如果传入了无效的状态字符串。
+        bool: 如果插件成功禁用，则为 True。
     """
-    if status == "loaded":
-        # 返回所有当前已成功加载的插件
-        return plugin_manager.list_loaded_plugins()
-    if status == "registered":
-        # 返回所有已注册（但不一定已加载）的插件
-        return plugin_manager.list_registered_plugins()
-    if status == "failed":
-        # 返回所有加载失败的插件的名称
-        return list(plugin_manager.failed_plugins.keys())
-    # 如果状态无效，则引发错误
-    raise ValueError(f"无效的插件状态: '{status}'。有效选项为 'loaded', 'registered', 'failed'。")
+    plugin_instance = plugin_manager.get_plugin_instance(plugin_name)
+
+    if not plugin_instance:
+        logger.warning(f"插件 '{plugin_name}' 未加载，无需禁用。")
+        return True
+
+    # 设置插件为禁用状态
+    plugin_instance.enable_plugin = False
+    logger.info(f"插件 '{plugin_name}' 已禁用。")
+    return True
 
 
-def list_components(component_type: ComponentType, enabled_only: bool = True) -> list[dict[str, Any]]:
+async def unload_plugin(plugin_name: str) -> bool:
     """
-    列出指定类型的所有组件的详细信息。
+    完全卸载一个插件。
 
-    这是查找和管理组件的核心功能，例如，获取所有可用的工具或所有注册的聊天器。
+    这会从内存中移除插件及其所有组件。与禁用不同，卸载后需要重新加载才能使用。
 
     Args:
-        component_type (ComponentType): 要查询的组件类型。
-        enabled_only (bool, optional): 是否只返回已启用的组件。默认为 True。
+        plugin_name (str): 要卸载的插件名称。
 
     Returns:
-        list[dict[str, Any]]: 一个包含组件信息字典的列表。
+        bool: 如果插件成功卸载，则为 True。
     """
-    # 根据 enabled_only 参数决定是获取所有组件还是仅获取已启用的组件
-    if enabled_only:
-        components = component_registry.get_enabled_components_by_type(component_type)
-    else:
-        components = component_registry.get_components_by_type(component_type)
+    if plugin_name not in plugin_manager.list_loaded_plugins():
+        logger.warning(f"插件 '{plugin_name}' 未加载，无需卸载。")
+        return True
 
-    # 将组件信息格式化为字典列表
-    return [
-        {
-            "name": info.name,
-            "plugin_name": info.plugin_name,
-            "description": info.description,
-            "enabled": info.enabled,
-        }
-        for info in components.values()
-    ]
+    return await plugin_manager.remove_registered_plugin(plugin_name)
 
 
-def search_components_by_name(
-    name_keyword: str,
-    component_type: ComponentType | None = None,
-    case_sensitive: bool = False,
-    exact_match: bool = False,
-) -> list[dict[str, Any]]:
+def is_plugin_enabled(plugin_name: str) -> bool:
     """
-    根据名称关键字搜索组件，支持模糊匹配和精确匹配。
-
-    极大地增强了组件的可发现性，用户无需知道完整名称即可找到所需组件。
+    检查插件是否处于启用状态。
 
     Args:
-        name_keyword (str): 用于搜索的名称关键字。
-        component_type (ComponentType | None, optional): 如果提供，则只在该类型中搜索。默认为 None (搜索所有类型)。
-        case_sensitive (bool, optional): 是否进行大小写敏感的搜索。默认为 False。
-        exact_match (bool, optional): 是否进行精确匹配。默认为 False (模糊匹配)。
+        plugin_name (str): 要检查的插件名称。
 
     Returns:
-        list[dict[str, Any]]: 匹配的组件信息字典的列表。
+        bool: 如果插件已启用，则为 True；如果未加载或已禁用，则为 False。
     """
-    results = []
-    # 如果未指定组件类型，则搜索所有类型
-    types_to_search = [component_type] if component_type else list(ComponentType)
-
-    # 根据是否大小写敏感，预处理搜索关键字
-    compare_str = name_keyword if case_sensitive else name_keyword.lower()
-
-    # 遍历要搜索的组件类型
-    for comp_type in types_to_search:
-        all_components = component_registry.get_components_by_type(comp_type)
-        for name, info in all_components.items():
-            # 同样地，预处理组件名称
-            target_name = name if case_sensitive else name.lower()
-
-            # 根据 exact_match 参数决定使用精确比较还是模糊包含检查
-            is_match = (compare_str == target_name) if exact_match else (compare_str in target_name)
-
-            # 如果匹配，则将组件信息添加到结果列表
-            if is_match:
-                results.append(
-                    {
-                        "name": info.name,
-                        "component_type": info.component_type.value,
-                        "plugin_name": info.plugin_name,
-                        "description": info.description,
-                        "enabled": info.enabled,
-                    }
-                )
-    return results
-
-
-def get_component_info(name: str, component_type: ComponentType) -> ComponentInfo | None:
-    """
-    获取任何一个已注册组件的详细信息对象。
-
-    Args:
-        name (str): 组件的唯一名称。
-        component_type (ComponentType): 组件的类型。
-
-    Returns:
-        ComponentInfo | None: 包含组件完整信息的 ComponentInfo 对象，如果找不到则返回 None。
-    """
-    return component_registry.get_component_info(name, component_type)
-
-
-def get_component_count(component_type: ComponentType, stream_id: str | None = None) -> int:
-    """
-    获取指定类型的已加载并启用的组件的总数。
-
-    可以根据 `stream_id` 考虑局部状态，从而获得特定上下文中的组件数量。
-
-    Args:
-        component_type (ComponentType): 要查询的组件类型。
-        stream_id (str | None): 可选的上下文ID。如果提供，将计入局部状态。
-
-    Returns:
-        int: 该类型下已启用的组件的数量。
-    """
-    return len(component_registry.get_enabled_components_by_type(component_type, stream_id=stream_id))
-
-
-# --------------------------------------------------------------------------------
-# Section 4: 工具函数 (Utility Helpers)
-# --------------------------------------------------------------------------------
-# 这部分提供了一些轻量级的辅助函数，用于快速检查状态。
+    plugin_instance = plugin_manager.get_plugin_instance(plugin_name)
+    if not plugin_instance:
+        return False
+    return plugin_instance.enable_plugin
 
 
 def is_plugin_loaded(plugin_name: str) -> bool:
     """
     快速检查一个插件当前是否已成功加载。
 
-    这是一个比 `get_plugin_details` 更轻量级的检查方法，适用于需要快速布尔值判断的场景。
-
     Args:
         plugin_name (str): 要检查的插件名称。
 
@@ -519,18 +302,45 @@ def is_plugin_loaded(plugin_name: str) -> bool:
     return plugin_name in plugin_manager.list_loaded_plugins()
 
 
-def get_component_plugin(component_name: str, component_type: ComponentType) -> str | None:
+def list_loaded_plugins() -> list[str]:
     """
-    查找一个特定组件属于哪个插件。
-
-    在调试或管理组件时，此函数能够方便地追溯其定义的源头。
-
-    Args:
-        component_name (str): 组件的名称。
-        component_type (ComponentType): 组件的类型。
+    列出所有已加载的插件名称。
 
     Returns:
-        str | None: 组件所属的插件名称，如果找不到组件则返回 None。
+        list[str]: 已加载插件的名称列表。
     """
-    component_info = component_registry.get_component_info(component_name, component_type)
-    return component_info.plugin_name if component_info else None
+    return plugin_manager.list_loaded_plugins()
+
+
+def list_registered_plugins() -> list[str]:
+    """
+    列出所有已注册的插件名称。
+
+    Returns:
+        list[str]: 已注册插件的名称列表。
+    """
+    return plugin_manager.list_registered_plugins()
+
+
+def list_failed_plugins() -> dict[str, str]:
+    """
+    获取所有加载失败的插件及其错误信息。
+
+    Returns:
+        dict[str, str]: 插件名称到错误信息的映射。
+    """
+    return plugin_manager.failed_plugins.copy()
+
+
+def get_plugin_instance(plugin_name: str):
+    """
+    获取插件实例。
+
+    Args:
+        plugin_name (str): 插件名称。
+
+    Returns:
+        BasePlugin | None: 插件实例，如果不存在则返回 None。
+    """
+    return plugin_manager.get_plugin_instance(plugin_name)
+
diff --git a/src/plugin_system/base/plus_command.py b/src/plugin_system/base/plus_command.py
index dc39bbee8..991d81454 100644
--- a/src/plugin_system/base/plus_command.py
+++ b/src/plugin_system/base/plus_command.py
@@ -68,7 +68,7 @@ class PlusCommand(ABC):
         self.log_prefix = "[PlusCommand]"
 
         # chat_stream 会在运行时被 bot.py 设置
-        self.chat_stream: "ChatStream | None" = None
+        self.chat_stream: "ChatStream"
 
         # 解析命令参数
         self._parse_command()
diff --git a/src/plugin_system/core/component_registry.py b/src/plugin_system/core/component_registry.py
index c63656cb1..2218a4fb1 100644
--- a/src/plugin_system/core/component_registry.py
+++ b/src/plugin_system/core/component_registry.py
@@ -1,14 +1,12 @@
 from __future__ import annotations
 
 # --- 标准库导入 ---
-import re
 from pathlib import Path
 from re import Pattern
 from typing import Any, cast
 
 # --- 第三方库导入 ---
 import toml
-from fastapi import Depends
 
 # --- 项目内模块导入 ---
 from src.common.logger import get_logger
@@ -34,7 +32,6 @@ from src.plugin_system.base.component_types import (
     PluginInfo,
     PlusCommandInfo,
     PromptInfo,
-    RouterInfo,
     ToolInfo,
 )
 from src.plugin_system.base.plus_command import PlusCommand, create_legacy_command_adapter
@@ -43,7 +40,7 @@ from src.plugin_system.base.plus_command import PlusCommand, create_legacy_comma
 logger = get_logger("component_registry")
 
 # --- 类型别名 ---
-# 统一的组件类类型别名，方便类型提示
+# 统一的组件类类型别名，方便类型提示，涵盖所有支持的组件基类
 ComponentClassType = (
     type[BaseCommand]
     | type[BaseAction]
@@ -65,12 +62,12 @@ def _assign_plugin_attrs(cls: Any, plugin_name: str, plugin_config: dict) -> Non
     这是一个辅助函数，用于避免在各个注册函数中重复编写相同的属性设置代码。
 
     Args:
-        cls (Any): 需要设置属性的组件类。
-        plugin_name (str): 插件的名称。
-        plugin_config (dict): 插件的配置信息。
+        cls: 需要设置属性的组件类
+        plugin_name: 插件的名称
+        plugin_config: 插件的配置信息字典
     """
-    setattr(cls, "plugin_name", plugin_name)
-    setattr(cls, "plugin_config", plugin_config)
+    cls.plugin_name = plugin_name
+    cls.plugin_config = plugin_config
 
 
 class ComponentRegistry:
@@ -81,154 +78,195 @@ class ComponentRegistry:
     它为不同类型的组件（如 Command, Action, Tool 等）提供了统一的注册接口和专门的查询方法。
 
     主要职责:
-    - 注册和取消注册插件与组件。
-    - 按类型和名称存储和索引所有组件。
-    - 管理组件的全局启用/禁用状态。
-    - 支持会话级别的组件局部（临时）启用/禁用状态。
-    - 提供按类型、名称或状态查询组件的方法。
-    - 处理组件之间的依赖和冲突。
-    - 动态加载和管理 MCP (Model-Copilot-Plugin) 工具。
+        - 注册和取消注册插件与组件
+        - 按类型和名称存储和索引所有组件
+        - 管理组件的全局启用/禁用状态
+        - 支持会话级别的组件局部（临时）启用/禁用状态
+        - 提供按类型、名称或状态查询组件的方法
+        - 动态加载和管理 MCP (Model-Copilot-Plugin) 工具
+
+    Attributes:
+        _components: 核心注册表，使用命名空间键 f"{component_type}.{component_name}"
+        _components_by_type: 按类型分类的组件注册表
+        _components_classes: 存储组件类本身，用于实例化
+        _plugins: 插件注册表
+        _local_component_states: 局部组件状态管理器，用于会话级别的临时状态覆盖
     """
 
+    # =================================================================
+    # == 初始化 (Initialization)
+    # =================================================================
+
     def __init__(self):
-        """初始化组件注册中心，创建所有必要的注册表。"""
+        """
+        初始化组件注册中心，创建所有必要的注册表。
+
+        注册表分为以下几类:
+            1. 通用注册表: 存储所有组件的通用信息
+            2. 插件注册表: 存储插件元信息
+            3. 特定类型注册表: 为每种组件类型提供专用的快速查询
+            4. 状态管理: 支持全局和局部（会话级）状态控制
+        """
         # --- 通用注册表 ---
-        # 核心注册表，存储所有组件的信息，使用命名空间式键 f"{component_type}.{component_name}"
-        self._components: dict[str, "ComponentInfo"] = {}
+        # 核心注册表，使用命名空间键 f"{component_type}.{component_name}"
+        self._components: dict[str, ComponentInfo] = {}
         # 按类型分类的组件注册表，方便按类型快速查找
-        self._components_by_type: dict["ComponentType", dict[str, "ComponentInfo"]] = {
-            types: {} for types in ComponentType
+        self._components_by_type: dict[ComponentType, dict[str, ComponentInfo]] = {
+            t: {} for t in ComponentType
         }
         # 存储组件类本身，用于实例化
         self._components_classes: dict[str, ComponentClassType] = {}
 
         # --- 插件注册表 ---
-        self._plugins: dict[str, "PluginInfo"] = {}
+        self._plugins: dict[str, PluginInfo] = {}  # 插件名 -> 插件信息
 
         # --- 特定类型组件的专用注册表 ---
+        # Action 相关
+        self._action_registry: dict[str, type[BaseAction]] = {}  # Action名 -> Action类
+        self._default_actions: dict[str, ActionInfo] = {}  # 存储全局启用的Action
 
-        # Action
-        self._action_registry: dict[str, type["BaseAction"]] = {}
-        self._default_actions: dict[str, "ActionInfo"] = {}  # 存储全局启用的Action
+        # Command 相关 (旧版，用于兼容)
+        self._command_registry: dict[str, type[BaseCommand]] = {}  # Command名 -> Command类
+        self._command_patterns: dict[Pattern, str] = {}  # 编译后的正则表达式 -> Command名
 
-        # Command (旧版)
-        self._command_registry: dict[str, type["BaseCommand"]] = {}
-        self._command_patterns: dict[Pattern, str] = {}  # 编译后的正则表达式 -> command名
+        # PlusCommand 相关 (新版命令系统)
+        self._plus_command_registry: dict[str, type[PlusCommand]] = {}  # PlusCommand名 -> 类
 
-        # PlusCommand (新版)
-        self._plus_command_registry: dict[str, type[PlusCommand]] = {}
+        # Tool 相关
+        self._tool_registry: dict[str, type[BaseTool]] = {}  # Tool名 -> Tool类
+        self._llm_available_tools: dict[str, type[BaseTool]] = {}  # 存储全局启用的Tool
 
-        # Tool
-        self._tool_registry: dict[str, type["BaseTool"]] = {}
-        self._llm_available_tools: dict[str, type["BaseTool"]] = {}  # 存储全局启用的Tool
+        # EventHandler 相关
+        self._event_handler_registry: dict[str, type[BaseEventHandler]] = {}
+        self._enabled_event_handlers: dict[str, type[BaseEventHandler]] = {}
 
-        # EventHandler
-        self._event_handler_registry: dict[str, type["BaseEventHandler"]] = {}
-        self._enabled_event_handlers: dict[str, type["BaseEventHandler"]] = {}
+        # Chatter 相关
+        self._chatter_registry: dict[str, type[BaseChatter]] = {}
+        self._enabled_chatter_registry: dict[str, type[BaseChatter]] = {}
 
-        # Chatter
-        self._chatter_registry: dict[str, type["BaseChatter"]] = {}
-        self._enabled_chatter_registry: dict[str, type["BaseChatter"]] = {}
+        # InterestCalculator 相关
+        self._interest_calculator_registry: dict[str, type[BaseInterestCalculator]] = {}
+        self._enabled_interest_calculator_registry: dict[str, type[BaseInterestCalculator]] = {}
 
-        # InterestCalculator
-        self._interest_calculator_registry: dict[str, type["BaseInterestCalculator"]] = {}
-        self._enabled_interest_calculator_registry: dict[str, type["BaseInterestCalculator"]] = {}
-
-        # Prompt
+        # Prompt 相关
         self._prompt_registry: dict[str, type[BasePrompt]] = {}
         self._enabled_prompt_registry: dict[str, type[BasePrompt]] = {}
 
-        # MCP (Model-Copilot-Plugin) Tools
+        # Adapter 相关
+        self._adapter_registry: dict[str, type[BaseAdapter]] = {}
+        self._enabled_adapter_registry: dict[str, type[BaseAdapter]] = {}
+
+        # --- MCP 工具 ---
         self._mcp_tools: list[Any] = []  # 存储 MCP 工具适配器实例
         self._mcp_tools_loaded = False  # 标记 MCP 工具是否已加载
 
-        # --- 状态管理 ---
-        # 局部组件状态管理器，用于在特定会话中临时覆盖全局状态
-        self._local_component_states: dict[str, dict[tuple[str, ComponentType], bool]] = {}
-        # 定义不支持局部状态管理的组件类型集合
-        self._no_local_state_types: set[ComponentType] = {
-            ComponentType.ROUTER,
-            ComponentType.EVENT_HANDLER,
-            ComponentType.PROMPT,
-            # 根据设计，COMMAND 和 PLUS_COMMAND 也不应支持局部状态
-        }
+        # --- 状态管理器 ---
+        # 延迟导入以避免循环依赖
+        from src.plugin_system.core.component_state_manager import ComponentStateManager
+        self._state_manager = ComponentStateManager(self)
 
         logger.info("组件注册中心初始化完成")
 
-        self._interest_calculator_registry: dict[str, type["BaseInterestCalculator"]] = {}
-        """兴趣计算器名 -> 兴趣计算器类"""
-        self._enabled_interest_calculator_registry: dict[str, type["BaseInterestCalculator"]] = {}
-        """启用的兴趣计算器名 -> 兴趣计算器类"""
-
-        self._prompt_registry: dict[str, type["BasePrompt"]] = {}
-        """提示词组件名 -> 提示词组件类"""
-        self._enabled_prompt_registry: dict[str, type["BasePrompt"]] = {}
-        """启用的提示词组件名 -> 提示词组件类"""
-        
-        self._adapter_registry: dict[str, type["BaseAdapter"]] = {}
-        """适配器组件名 -> 适配器组件类"""
-        self._enabled_adapter_registry: dict[str, type["BaseAdapter"]] = {}
-        """启用的适配器组件名 -> 适配器组件类"""
-        
-    # == 注册方法 ==
+    # =================================================================
+    # == 插件注册 (Plugin Registration)
+    # =================================================================
 
     def register_plugin(self, plugin_info: PluginInfo) -> bool:
         """
         注册一个插件。
 
         Args:
-            plugin_info (PluginInfo): 包含插件元数据的信息对象。
+            plugin_info: 包含插件元数据的信息对象
 
         Returns:
-            bool: 如果插件是新的并成功注册，则返回 True；如果插件已存在，则返回 False。
+            如果插件是新的并成功注册返回 True；如果插件已存在返回 False
         """
         plugin_name = plugin_info.name
-
         if plugin_name in self._plugins:
             logger.warning(f"插件 {plugin_name} 已存在，跳过注册")
             return False
-
         self._plugins[plugin_name] = plugin_info
         logger.debug(f"已注册插件: {plugin_name} (组件数量: {len(plugin_info.components)})")
         return True
 
+    async def unregister_plugin(self, plugin_name: str) -> bool:
+        """
+        卸载一个插件及其所有关联的组件。
+
+        这是一个高级操作，会依次移除插件的所有组件，然后移除插件本身的注册信息。
+
+        Args:
+            plugin_name: 要卸载的插件的名称
+
+        Returns:
+            如果所有组件和插件本身都成功卸载返回 True；否则返回 False
+        """
+        plugin_info = self.get_plugin_info(plugin_name)
+        if not plugin_info:
+            logger.warning(f"插件 {plugin_name} 未注册，无法卸载")
+            return False
+
+        logger.info(f"开始卸载插件: {plugin_name}")
+        failed_components = []
+
+        # 逐个移除插件的所有组件
+        for component_info in plugin_info.components:
+            try:
+                success = await self.remove_component(
+                    component_info.name, component_info.component_type, plugin_name
+                )
+                if not success:
+                    failed_components.append(f"{component_info.component_type}.{component_info.name}")
+            except Exception as e:
+                logger.error(f"移除组件 {component_info.name} 时发生异常: {e}")
+                failed_components.append(f"{component_info.component_type}.{component_info.name}")
+
+        # 移除插件注册信息
+        self._plugins.pop(plugin_name, None)
+
+        if failed_components:
+            logger.warning(f"插件 {plugin_name} 部分组件卸载失败: {failed_components}")
+            return False
+
+        logger.info(f"插件 {plugin_name} 卸载成功")
+        return True
+
+    # =================================================================
+    # == 组件注册 (Component Registration)
+    # =================================================================
+
     def register_component(
-        self, self_component_info: ComponentInfo, component_class: ComponentClassType
+        self, component_info: ComponentInfo, component_class: ComponentClassType
     ) -> bool:
         """
         注册一个组件。
 
-        这是所有组件注册的统一入口点。它会验证组件信息，然后根据组件类型分发到
-        特定的内部注册方法。
+        这是所有组件注册的统一入口点。它会验证组件信息，然后根据组件类型
+        分发到特定的内部注册方法。
 
         Args:
-            component_info (ComponentInfo): 组件的元数据信息。
-            component_class (ComponentClassType): 组件的类定义。
+            component_info: 组件的元数据信息
+            component_class: 组件的类定义
 
         Returns:
-            bool: 注册成功返回 True，否则返回 False。
+            注册成功返回 True，否则返回 False
         """
-        component_info = self_component_info  # 创建局部别名以缩短行长
         component_name = component_info.name
         component_type = component_info.component_type
         plugin_name = getattr(component_info, "plugin_name", "unknown")
 
         # --- 名称合法性检查 ---
-        if "." in component_name:
-            logger.error(f"组件名称 '{component_name}' 包含非法字符 '.'，请使用下划线替代")
-            return False
-        if "." in plugin_name:
-            logger.error(f"插件名称 '{plugin_name}' 包含非法字符 '.'，请使用下划线替代")
+        # 组件名和插件名不能包含 '.'，因为它用于命名空间分隔
+        if "." in component_name or "." in plugin_name:
+            logger.error("组件名称或插件名称包含非法字符 '.'")
             return False
 
         # --- 冲突检查 ---
         namespaced_name = f"{component_type.value}.{component_name}"
         if namespaced_name in self._components:
-            existing_info = self._components[namespaced_name]
-            existing_plugin = getattr(existing_info, "plugin_name", "unknown")
+            existing_plugin = getattr(self._components[namespaced_name], "plugin_name", "unknown")
             logger.warning(
-                f"组件名冲突: '{plugin_name}' 插件的 {component_type} 类型组件 '{component_name}' "
-                f"已被插件 '{existing_plugin}' 注册，跳过此组件注册"
+                f"组件名冲突: '{component_name}' 已被插件 '{existing_plugin}' 注册"
             )
             return False
 
@@ -238,884 +276,46 @@ class ComponentRegistry:
         self._components_classes[namespaced_name] = component_class
 
         # --- 按类型分发到特定注册方法 ---
-        ret = False  # 初始化返回值为 False
-        match component_type:
-            case ComponentType.ACTION:
-                assert isinstance(component_info, ActionInfo) and issubclass(component_class, BaseAction)
-                ret = self._register_action_component(component_info, component_class)
-            case ComponentType.COMMAND:
-                assert isinstance(component_info, CommandInfo) and issubclass(component_class, BaseCommand)
-                ret = self._register_command_component(component_info, component_class)
-            case ComponentType.PLUS_COMMAND:
-                assert isinstance(component_info, PlusCommandInfo) and issubclass(component_class, PlusCommand)
-                ret = self._register_plus_command_component(component_info, component_class)
-            case ComponentType.TOOL:
-                assert isinstance(component_info, ToolInfo) and issubclass(component_class, BaseTool)
-                ret = self._register_tool_component(component_info, component_class)
-            case ComponentType.EVENT_HANDLER:
-                assert isinstance(component_info, EventHandlerInfo) and issubclass(component_class, BaseEventHandler)
-                ret = self._register_event_handler_component(component_info, component_class)
-            case ComponentType.CHATTER:
-                assert isinstance(component_info, ChatterInfo) and issubclass(component_class, BaseChatter)
-                ret = self._register_chatter_component(component_info, component_class)
-            case ComponentType.INTEREST_CALCULATOR:
-                assert isinstance(component_info, InterestCalculatorInfo) and issubclass(
-                    component_class, BaseInterestCalculator
-                )
-                ret = self._register_interest_calculator_component(component_info, component_class)
-            case ComponentType.PROMPT:
-                assert isinstance(component_info, PromptInfo) and issubclass(component_class, BasePrompt)
-                ret = self._register_prompt_component(component_info, component_class)
-            case ComponentType.ROUTER:
-                assert isinstance(component_info, RouterInfo) and issubclass(component_class, BaseRouterComponent)
-                ret = self._register_router_component(component_info, component_class)
-            case ComponentType.ADAPTER:
-                assert isinstance(component_info, AdapterInfo)
-                assert issubclass(component_class, BaseAdapter)
-                ret = self._register_adapter_component(component_info, component_class)
-            case _:
-                logger.warning(f"未知组件类型: {component_type}")
-                ret = False
-
-        if not ret:
-            return False
-        logger.debug(
-            f"已注册{component_type}组件: '{component_name}' -> '{namespaced_name}' ({component_class.__name__}) [插件: {plugin_name}]"
-        )
-        return True
-
-    def _register_action_component(self, action_info: ActionInfo, action_class: type[BaseAction]) -> bool:
-        """注册Action组件到Action特定注册表"""
-        if not (action_name := action_info.name):
-            logger.error(f"Action组件 {action_class.__name__} 必须指定名称")
-            return False
-        if not isinstance(action_info, ActionInfo) or not issubclass(action_class, BaseAction):
-            logger.error(f"注册失败: {action_name} 不是有效的Action")
-            return False
-        _assign_plugin_attrs(action_class, action_info.plugin_name, self.get_plugin_config(action_info.plugin_name) or {})
-        self._action_registry[action_name] = action_class
-        if action_info.enabled:
-            self._default_actions[action_name] = action_info
-        return True
-
-    def _register_command_component(self, command_info: CommandInfo, command_class: type[BaseCommand]) -> bool:
-        """注册Command组件到Command特定注册表"""
-        logger.warning(
-                f"检测到旧版Command组件 '{command_class.command_name}' (来自插件: {command_info.plugin_name})。"
-                "它将通过兼容层运行，但建议尽快迁移到PlusCommand以获得更好的性能和功能。"
-            )
-        # 使用适配器将其转换为PlusCommand
-        adapted_class = create_legacy_command_adapter(command_class)
-        plus_command_info = adapted_class.get_plus_command_info()
-        plus_command_info.plugin_name = command_info.plugin_name  # 继承插件名
-
-        return self._register_plus_command_component(plus_command_info, adapted_class)
-
-    def _register_plus_command_component(
-        self, plus_command_info: PlusCommandInfo, plus_command_class: type[PlusCommand]
-    ) -> bool:
-        """注册PlusCommand组件到特定注册表"""
-        plus_command_name = plus_command_info.name
-
-        if not plus_command_name:
-            logger.error(f"PlusCommand组件 {plus_command_class.__name__} 必须指定名称")
-            return False
-        if not isinstance(plus_command_info, PlusCommandInfo) or not issubclass(plus_command_class, PlusCommand):
-            logger.error(f"注册失败: {plus_command_name} 不是有效的PlusCommand")
-            return False
-
-        # 创建专门的PlusCommand注册表（如果还没有）
-        if not hasattr(self, "_plus_command_registry"):
-            self._plus_command_registry: dict[str, type[PlusCommand]] = {}
-        _assign_plugin_attrs(
-            plus_command_class,
-            plus_command_info.plugin_name,
-            self.get_plugin_config(plus_command_info.plugin_name) or {},
-        )
-        self._plus_command_registry[plus_command_name] = plus_command_class
-        logger.debug(f"已注册PlusCommand组件: {plus_command_name}")
-        return True
-
-    def _register_tool_component(self, tool_info: ToolInfo, tool_class: type[BaseTool]) -> bool:
-        """注册Tool组件到Tool特定注册表"""
-        tool_name = tool_info.name
-        _assign_plugin_attrs(tool_class, tool_info.plugin_name, self.get_plugin_config(tool_info.plugin_name) or {})
-        self._tool_registry[tool_name] = tool_class
-        if tool_info.enabled:
-            self._llm_available_tools[tool_name] = tool_class
-        return True
-
-    def _register_event_handler_component(
-        self, handler_info: EventHandlerInfo, handler_class: type[BaseEventHandler]
-    ) -> bool:
-        if not (handler_name := handler_info.name):
-            logger.error(f"EventHandler组件 {handler_class.__name__} 必须指定名称")
-            return False
-        if not isinstance(handler_info, EventHandlerInfo) or not issubclass(handler_class, BaseEventHandler):
-            logger.error(f"注册失败: {handler_name} 不是有效的EventHandler")
-            return False
-        _assign_plugin_attrs(
-            handler_class, handler_info.plugin_name, self.get_plugin_config(handler_info.plugin_name) or {}
-        )
-        self._event_handler_registry[handler_name] = handler_class
-        if not handler_info.enabled:
-            logger.warning(f"EventHandler组件 {handler_name} 未启用")
-            return True  # 未启用，但是也是注册成功
-        from src.plugin_system.core.event_manager import event_manager
-        return event_manager.register_event_handler(
-            handler_class, self.get_plugin_config(handler_info.plugin_name) or {}
-        )
-
-    def _register_chatter_component(self, chatter_info: ChatterInfo, chatter_class: type[BaseChatter]) -> bool:
-        """注册Chatter组件到Chatter特定注册表"""
-        chatter_name = chatter_info.name
-
-        if not chatter_name:
-            logger.error(f"Chatter组件 {chatter_class.__name__} 必须指定名称")
-            return False
-        if not isinstance(chatter_info, ChatterInfo) or not issubclass(chatter_class, BaseChatter):
-            logger.error(f"注册失败: {chatter_name} 不是有效的Chatter")
-            return False
-        _assign_plugin_attrs(
-            chatter_class, chatter_info.plugin_name, self.get_plugin_config(chatter_info.plugin_name) or {}
-        )
-        self._chatter_registry[chatter_name] = chatter_class
-        if not chatter_info.enabled:
-            logger.warning(f"Chatter组件 {chatter_name} 未启用")
-            return True  # 未启用，但是也是注册成功
-        self._enabled_chatter_registry[chatter_name] = chatter_class
-        logger.debug(f"已注册Chatter组件: {chatter_name}")
-        return True
-
-    def _register_interest_calculator_component(
-        self,
-        interest_calculator_info: "InterestCalculatorInfo",
-        interest_calculator_class: type["BaseInterestCalculator"],
-    ) -> bool:
-        """注册InterestCalculator组件到特定注册表"""
-        calculator_name = interest_calculator_info.name
-
-        if not calculator_name:
-            logger.error(f"InterestCalculator组件 {interest_calculator_class.__name__} 必须指定名称")
-            return False
-        if not isinstance(interest_calculator_info, InterestCalculatorInfo) or not issubclass(
-            interest_calculator_class, BaseInterestCalculator
-        ):
-            logger.error(f"注册失败: {calculator_name} 不是有效的InterestCalculator")
-            return False
-
-        _assign_plugin_attrs(
-            interest_calculator_class,
-            interest_calculator_info.plugin_name,
-            self.get_plugin_config(interest_calculator_info.plugin_name) or {},
-        )
-        self._interest_calculator_registry[calculator_name] = interest_calculator_class
-
-        if not interest_calculator_info.enabled:
-            logger.warning(f"InterestCalculator组件 {calculator_name} 未启用")
-            return True  # 未启用，但是也是注册成功
-        self._enabled_interest_calculator_registry[calculator_name] = interest_calculator_class
-
-        logger.debug(f"已注册InterestCalculator组件: {calculator_name}")
-        return True
-
-    def _register_prompt_component(
-        self, prompt_info: PromptInfo, prompt_class: "ComponentClassType"
-    ) -> bool:
-        """注册Prompt组件到Prompt特定注册表"""
-        prompt_name = prompt_info.name
-        if not prompt_name:
-            logger.error(f"Prompt组件 {prompt_class.__name__} 必须指定名称")
-            return False
-
-        _assign_plugin_attrs(
-            prompt_class, prompt_info.plugin_name, self.get_plugin_config(prompt_info.plugin_name) or {}
-        )
-        self._prompt_registry[prompt_name] = prompt_class  # type: ignore
-
-        if prompt_info.enabled:
-            self._enabled_prompt_registry[prompt_name] = prompt_class  # type: ignore
-
-        logger.debug(f"已注册Prompt组件: {prompt_name}")
-        return True
-
-    def _register_router_component(self, router_info: RouterInfo, router_class: type[BaseRouterComponent]) -> bool:
-        """注册Router组件并将其端点挂载到主服务器"""
-        # 1. 检查总开关是否开启
-        if not bot_config.plugin_http_system.enable_plugin_http_endpoints:
-            logger.info("插件HTTP端点功能已禁用，跳过路由注册")
-            return True
-        try:
-            from src.common.server import get_global_server
-
-            router_name = router_info.name
-            plugin_name = router_info.plugin_name
-            plugin_config = self.get_plugin_config(plugin_name) or {}
-            _assign_plugin_attrs(router_class, plugin_name, plugin_config)
-
-            # 2. 实例化组件以触发其 __init__ 和 register_endpoints
-            component_instance = router_class()
-
-            # 3. 获取配置好的 APIRouter
-            plugin_router = component_instance.router
-
-            # 4. 获取全局服务器实例
-            server = get_global_server()
-
-            # 5. 生成唯一的URL前缀
-            prefix = f"/plugins/{plugin_name}"
-
-            # 6. 注册路由，并使用插件名作为API文档的分组标签
-            # 移除了dependencies参数，因为现在由每个端点自行决定是否需要验证
-            server.app.include_router(
-                plugin_router, prefix=prefix, tags=[plugin_name]
-            )
-
-            logger.debug(f"成功将插件 '{plugin_name}' 的路由组件 '{router_name}' 挂载到: {prefix}")
-            return True
-
-        except Exception as e:
-            logger.error(f"注册路由组件 '{router_info.name}' 时出错: {e}")
-            return False
-
-    def _register_adapter_component(self, adapter_info: AdapterInfo, adapter_class: type[BaseAdapter]) -> bool:
-        """将Adapter组件注册到Adapter特定注册表"""
-
-        adapter_name = adapter_info.name
-        if not adapter_name:
-            logger.error(f"Adapter组件 {adapter_class.__name__} 必须指定名称")
-            return False
-        if not isinstance(adapter_info, AdapterInfo) or not issubclass(adapter_class, BaseAdapter):
-            logger.error(f"注册失败: {adapter_name} 不是有效的Adapter")
-            return False
-
-        _assign_plugin_attrs(
-            adapter_class, adapter_info.plugin_name, self.get_plugin_config(adapter_info.plugin_name) or {}
-        )
-        if not hasattr(self, "_adapter_registry"):
-            self._adapter_registry: dict[str, type[BaseAdapter]] = {}
-
-        self._adapter_registry[adapter_name] = adapter_class
-
-        if not adapter_info.enabled:
-            logger.warning(f"Adapter {adapter_name} 未启用")
-        return True
-
-    # === 组件移除相关 ===
-
-    async def remove_component(self, component_name: str, component_type: ComponentType, plugin_name: str) -> bool:
-        target_component_class = self.get_component_class(component_name, component_type)
-        if not target_component_class:
-            logger.warning(f"组件 {component_name} 未注册，无法移除")
-            return False
-        try:
-            # 根据组件类型进行特定的清理操作
-            match component_type:
-                case ComponentType.ACTION:
-                    # 移除Action注册
-                    self._action_registry.pop(component_name, None)
-                    self._default_actions.pop(component_name, None)
-                    logger.debug(f"已移除Action组件: {component_name}")
-
-                case ComponentType.COMMAND:
-                    # 移除Command注册和模式
-                    self._command_registry.pop(component_name, None)
-                    keys_to_remove = [k for k, v in self._command_patterns.items() if v == component_name]
-                    for key in keys_to_remove:
-                        self._command_patterns.pop(key, None)
-                    logger.debug(f"已移除Command组件: {component_name} (清理了 {len(keys_to_remove)} 个模式)")
-
-                case ComponentType.PLUS_COMMAND:
-                    # 移除PlusCommand注册
-                    if hasattr(self, "_plus_command_registry"):
-                        self._plus_command_registry.pop(component_name, None)
-                    logger.debug(f"已移除PlusCommand组件: {component_name}")
-
-                case ComponentType.TOOL:
-                    # 移除Tool注册
-                    self._tool_registry.pop(component_name, None)
-                    self._llm_available_tools.pop(component_name, None)
-                    logger.debug(f"已移除Tool组件: {component_name}")
-
-                case ComponentType.EVENT_HANDLER:
-                    # 移除EventHandler注册和事件订阅
-                    from .event_manager import event_manager  # 延迟导入防止循环导入问题
-
-                    self._event_handler_registry.pop(component_name, None)
-                    self._enabled_event_handlers.pop(component_name, None)
-                    try:
-                        handler = event_manager.get_event_handler(component_name)
-                        # 事件处理器可能未找到或未声明 subscribed_events，需判空
-                        if handler and hasattr(handler, "subscribed_events"):
-                            for event in getattr(handler, "subscribed_events"):
-                                # 假设 unsubscribe_handler_from_event 是协程；若不是则移除 await
-                                result = event_manager.unsubscribe_handler_from_event(event, component_name)
-                                if hasattr(result, "__await__"):
-                                    await result  # type: ignore[func-returns-value]
-                        logger.debug(f"已移除EventHandler组件: {component_name}")
-                        logger.debug(f"已移除EventHandler组件: {component_name}")
-                    except Exception as e:
-                        logger.warning(f"移除EventHandler事件订阅时出错: {e}")
-
-                case ComponentType.CHATTER:
-                    # 移除Chatter注册
-                    if hasattr(self, "_chatter_registry"):
-                        self._chatter_registry.pop(component_name, None)
-                    logger.debug(f"已移除Chatter组件: {component_name}")
-
-                case _:
-                    logger.warning(f"未知的组件类型: {component_type}")
-                    return False
-
-            # 移除通用注册信息
-            namespaced_name = f"{component_type.value}.{component_name}"
-            self._components.pop(namespaced_name, None)
-            self._components_by_type[component_type].pop(component_name, None)
-            self._components_classes.pop(namespaced_name, None)
-            return True
-
-        except Exception as e:
-            logger.error(f"移除组件 {component_name} 时发生错误: {e}")
-            return False
-
-    # === 组件全局启用/禁用方法 ===
-
-    def enable_component(self, component_name: str, component_type: ComponentType) -> bool:
-        """全局的启用某个组件
-        Parameters:
-            component_name: 组件名称
-            component_type: 组件类型
-        Returns:
-            bool: 启用成功返回True，失败返回False
-        """
-        target_component_class = self.get_component_class(component_name, component_type)
-        target_component_info = self.get_component_info(component_name, component_type)
-        if not target_component_class or not target_component_info:
-            logger.warning(f"组件 {component_name} 未注册，无法启用")
-            return False
-        target_component_info.enabled = True
-        match component_type:
-            case ComponentType.ACTION:
-                assert isinstance(target_component_info, ActionInfo)
-                self._default_actions[component_name] = target_component_info
-            case ComponentType.COMMAND:
-                assert isinstance(target_component_info, CommandInfo)
-                pattern = target_component_info.command_pattern
-                self._command_patterns[re.compile(pattern)] = component_name
-            case ComponentType.TOOL:
-                assert isinstance(target_component_info, ToolInfo)
-                assert issubclass(target_component_class, BaseTool)
-                self._llm_available_tools[component_name] = target_component_class
-            case ComponentType.EVENT_HANDLER:
-                assert isinstance(target_component_info, EventHandlerInfo)
-                assert issubclass(target_component_class, BaseEventHandler)
-                self._enabled_event_handlers[component_name] = target_component_class
-                from .event_manager import event_manager  # 延迟导入防止循环导入问题
-
-                # 重新注册事件处理器（启用）使用类而不是名称
-                cfg = self.get_plugin_config(target_component_info.plugin_name) or {}
-                event_manager.register_event_handler(target_component_class, cfg)  # type: ignore[arg-type]
-        namespaced_name = f"{component_type.value}.{component_name}"
-        self._components[namespaced_name].enabled = True
-        self._components_by_type[component_type][component_name].enabled = True
-        logger.info(f"组件 {component_name} 已启用")
-        return True
-
-    async def disable_component(self, component_name: str, component_type: ComponentType) -> bool:
-        """全局的禁用某个组件
-        Parameters:
-            component_name: 组件名称
-            component_type: 组件类型
-        Returns:
-            bool: 禁用成功返回True，失败返回False
-        """
-        target_component_class = self.get_component_class(component_name, component_type)
-        target_component_info = self.get_component_info(component_name, component_type)
-        if not target_component_class or not target_component_info:
-            logger.warning(f"组件 {component_name} 未注册，无法禁用")
-            return False
-        target_component_info.enabled = False
-        try:
-            match component_type:
-                case ComponentType.ACTION:
-                    self._default_actions.pop(component_name)
-                case ComponentType.COMMAND:
-                    self._command_patterns = {k: v for k, v in self._command_patterns.items() if v != component_name}
-                case ComponentType.TOOL:
-                    self._llm_available_tools.pop(component_name)
-                case ComponentType.EVENT_HANDLER:
-                    self._enabled_event_handlers.pop(component_name)
-                    from .event_manager import event_manager  # 延迟导入防止循环导入问题
-
-                    handler = event_manager.get_event_handler(component_name)
-                    if handler and hasattr(handler, "subscribed_events"):
-                        for event in getattr(handler, "subscribed_events"):
-                            result = event_manager.unsubscribe_handler_from_event(event, component_name)
-                            if hasattr(result, "__await__"):
-                                await result  # type: ignore[func-returns-value]
-
-            # 组件主注册表使用命名空间 key
-            namespaced_name = f"{component_type.value}.{component_name}"
-            if namespaced_name in self._components:
-                self._components[namespaced_name].enabled = False
-            self._components_by_type[component_type][component_name].enabled = False
-            logger.info(f"组件 {component_name} 已禁用")
-            return True
-        except KeyError as e:
-            logger.warning(f"禁用组件时未找到组件或已禁用: {component_name}, 发生错误: {e}")
-            return False
-        except Exception as e:
-            logger.error(f"禁用组件 {component_name} 时发生错误: {e}")
-            return False
-
-    # === 组件查询方法 ===
-    def get_component_info(
-        self, component_name: str, component_type: ComponentType | None = None
-    ) -> ComponentInfo | None:
-        # sourcery skip: class-extract-method
-        """获取组件信息，支持自动命名空间解析
-
-        Args:
-            component_name: 组件名称，可以是原始名称或命名空间化的名称
-            component_type: 组件类型，如果提供则优先在该类型中查找
-
-        Returns:
-            Optional[ComponentInfo]: 组件信息或None
-        """
-        # 1. 如果已经是命名空间化的名称，直接查找
-        if "." in component_name:
-            return self._components.get(component_name)
-
-        # 2. 如果指定了组件类型，构造命名空间化的名称查找
-        if component_type:
-            namespaced_name = f"{component_type.value}.{component_name}"
-            return self._components.get(namespaced_name)
-
-        # 3. 如果没有指定类型，尝试在所有命名空间中查找
-        candidates = []
-        for namespace_prefix in [types.value for types in ComponentType]:
-            namespaced_name = f"{namespace_prefix}.{component_name}"
-            if component_info := self._components.get(namespaced_name):
-                candidates.append((namespace_prefix, namespaced_name, component_info))
-
-        if len(candidates) == 1:
-            # 只有一个匹配，直接返回
-            return candidates[0][2]
-        elif len(candidates) > 1:
-            # 多个匹配，记录警告并返回第一个
-            namespaces = [ns for ns, _, _ in candidates]
-            logger.warning(
-                f"组件名称 '{component_name}' 在多个命名空间中存在: {namespaces}，使用第一个匹配项: {candidates[0][1]}"
-            )
-            return candidates[0][2]
-
-        # 4. 都没找到
-        return None
-
-    def get_component_class(
-        self,
-        component_name: str,
-        component_type: ComponentType | None = None,
-    ) -> (
-        type[
-            BaseCommand
-            | BaseAction
-            | BaseEventHandler
-            | BaseTool
-            | PlusCommand
-            | BaseChatter
-            | BaseInterestCalculator
-            | BasePrompt
-            | BaseRouterComponent
-            | BaseAdapter
-        ]
-        | None
-    ):
-        """获取组件类，支持自动命名空间解析
-
-        Args:
-            component_name: 组件名称，可以是原始名称或命名空间化的名称
-            component_type: 组件类型，如果提供则优先在该类型中查找
-
-        Returns:
-            Optional[Union[BaseCommand, BaseAction]]: 组件类或None
-        """
-        # 1. 如果已经是命名空间化的名称，直接查找
-        if "." in component_name:
-            return self._components_classes.get(component_name)
-
-        # 2. 如果指定了组件类型，构造命名空间化的名称查找
-        if component_type:
-            namespaced_name = f"{component_type.value}.{component_name}"
-            return cast(
-                type[BaseCommand]
-                | type[BaseAction]
-                | type[BaseEventHandler]
-                | type[BaseTool]
-                | type[PlusCommand]
-                | type[BaseChatter]
-                | type[BaseInterestCalculator]
-                | type[BasePrompt]
-                | type[BaseRouterComponent]
-                | type[BaseAdapter]
-                | None,
-                self._components_classes.get(namespaced_name),
-            )
-
-        # 3. 如果没有指定类型，尝试在所有命名空间中查找
-        candidates = []
-        for namespace_prefix in [types.value for types in ComponentType]:
-            namespaced_name = f"{namespace_prefix}.{component_name}"
-            if component_class := self._components_classes.get(namespaced_name):
-                candidates.append((namespace_prefix, namespaced_name, component_class))
-
-        if len(candidates) == 1:
-            # 只有一个匹配，直接返回
-            _, full_name, cls = candidates[0]
-            logger.debug(f"自动解析组件: '{component_name}' -> '{full_name}'")
-            return cls
-        elif len(candidates) > 1:
-            # 多个匹配，记录警告并返回第一个
-            namespaces = [ns for ns, _, _ in candidates]
-            logger.warning(
-                f"组件名称 '{component_name}' 在多个命名空间中存在: {namespaces}，使用第一个匹配项: {candidates[0][1]}"
-            )
-            return candidates[0][2]
-
-        # 4. 都没找到
-        return None
-
-    def get_components_by_type(self, component_type: ComponentType) -> dict[str, ComponentInfo]:
-        """获取指定类型的所有组件"""
-        return self._components_by_type.get(component_type, {}).copy()
-
-    def get_enabled_components_by_type(self, component_type: ComponentType) -> dict[str, ComponentInfo]:
-        """获取指定类型的所有启用组件"""
-        components = self.get_components_by_type(component_type)
-        return {name: info for name, info in components.items() if info.enabled}
-
-    # === Action特定查询方法 ===
-
-    def get_action_registry(self) -> dict[str, type[BaseAction]]:
-        """获取Action注册表"""
-        return self._action_registry.copy()
-
-    def get_registered_action_info(self, action_name: str) -> ActionInfo | None:
-        """获取Action信息"""
-        info = self.get_component_info(action_name, ComponentType.ACTION)
-        return info if isinstance(info, ActionInfo) else None
-
-    def get_default_actions(self) -> dict[str, ActionInfo]:
-        """获取默认动作集"""
-        return self._default_actions.copy()
-
-    # === Command特定查询方法 ===
-
-    def get_command_registry(self) -> dict[str, type[BaseCommand]]:
-        """获取Command注册表"""
-        return self._command_registry.copy()
-
-    def get_registered_command_info(self, command_name: str) -> CommandInfo | None:
-        """获取Command信息"""
-        info = self.get_component_info(command_name, ComponentType.COMMAND)
-        return info if isinstance(info, CommandInfo) else None
-
-    def get_command_patterns(self) -> dict[Pattern, str]:
-        """获取Command模式注册表"""
-        return self._command_patterns.copy()
-
-    def find_command_by_text(self, text: str) -> tuple[type[BaseCommand], dict, CommandInfo] | None:
-        # sourcery skip: use-named-expression, use-next
-        """根据文本查找匹配的命令
-
-        Args:
-            text: 输入文本
-
-        Returns:
-            Tuple: (命令类, 匹配的命名组, 命令信息) 或 None
-        """
-
-        # 只查找传统的BaseCommand
-        candidates = [pattern for pattern in self._command_patterns if pattern.match(text)]
-        if candidates:
-            if len(candidates) > 1:
-                logger.warning(f"文本 '{text}' 匹配到多个命令模式: {candidates}，使用第一个匹配")
-            command_name = self._command_patterns[candidates[0]]
-            command_info: CommandInfo = self.get_registered_command_info(command_name)  # type: ignore
-            return (
-                self._command_registry[command_name],
-                candidates[0].match(text).groupdict(),  # type: ignore
-                command_info,
-            )
-
-        return None
-
-    # === Tool 特定查询方法 ===
-    def get_tool_registry(self) -> dict[str, type[BaseTool]]:
-        """获取Tool注册表"""
-        return self._tool_registry.copy()
-
-    def get_llm_available_tools(self) -> dict[str, type[BaseTool]]:
-        """获取LLM可用的Tool列表"""
-        return self._llm_available_tools.copy()
-
-    def get_registered_tool_info(self, tool_name: str) -> ToolInfo | None:
-        """获取Tool信息
-
-        Args:
-            tool_name: 工具名称
-
-        Returns:
-            ToolInfo: 工具信息对象，如果工具不存在则返回 None
-        """
-        info = self.get_component_info(tool_name, ComponentType.TOOL)
-        return info if isinstance(info, ToolInfo) else None
-
-    # === PlusCommand 特定查询方法 ===
-    def get_plus_command_registry(self) -> dict[str, type[PlusCommand]]:
-        """获取PlusCommand注册表"""
-        if not hasattr(self, "_plus_command_registry"):
-            self._plus_command_registry: dict[str, type[PlusCommand]] = {}
-        return self._plus_command_registry.copy()
-
-    def get_registered_plus_command_info(self, command_name: str) -> PlusCommandInfo | None:
-        """获取PlusCommand信息
-
-        Args:
-            command_name: 命令名称
-
-        Returns:
-            PlusCommandInfo: 命令信息对象，如果命令不存在则返回 None
-        """
-        info = self.get_component_info(command_name, ComponentType.PLUS_COMMAND)
-        return info if isinstance(info, PlusCommandInfo) else None
-
-    # === EventHandler 特定查询方法 ===
-
-    def get_event_handler_registry(self) -> dict[str, type[BaseEventHandler]]:
-        """获取事件处理器注册表"""
-        return self._event_handler_registry.copy()
-
-    def get_registered_event_handler_info(self, handler_name: str) -> EventHandlerInfo | None:
-        """获取事件处理器信息"""
-        info = self.get_component_info(handler_name, ComponentType.EVENT_HANDLER)
-        return info if isinstance(info, EventHandlerInfo) else None
-
-    def get_enabled_event_handlers(self) -> dict[str, type[BaseEventHandler]]:
-        """获取启用的事件处理器"""
-        return self._enabled_event_handlers.copy()
-
-    # === Chatter 特定查询方法 ===
-    def get_chatter_registry(self) -> dict[str, type[BaseChatter]]:
-        """获取Chatter注册表"""
-        if not hasattr(self, "_chatter_registry"):
-            self._chatter_registry: dict[str, type[BaseChatter]] = {}
-        return self._chatter_registry.copy()
-
-    def get_enabled_chatter_registry(self) -> dict[str, type[BaseChatter]]:
-        """获取启用的Chatter注册表"""
-        if not hasattr(self, "_enabled_chatter_registry"):
-            self._enabled_chatter_registry: dict[str, type[BaseChatter]] = {}
-        return self._enabled_chatter_registry.copy()
-
-    def get_registered_chatter_info(self, chatter_name: str) -> ChatterInfo | None:
-        """获取Chatter信息"""
-        info = self.get_component_info(chatter_name, ComponentType.CHATTER)
-        return info if isinstance(info, ChatterInfo) else None
-
-    # === 插件查询方法 ===
-
-    def get_plugin_info(self, plugin_name: str) -> PluginInfo | None:
-        """获取插件信息"""
-        return self._plugins.get(plugin_name)
-
-    def get_all_plugins(self) -> dict[str, PluginInfo]:
-        """获取所有插件"""
-        return self._plugins.copy()
-
-    # def get_enabled_plugins(self) -> Dict[str, PluginInfo]:
-    #     """获取所有启用的插件"""
-    #     return {name: info for name, info in self._plugins.items() if info.enabled}
-
-    def get_plugin_components(self, plugin_name: str) -> list["ComponentInfo"]:
-        """获取插件的所有组件"""
-        plugin_info = self.get_plugin_info(plugin_name)
-        logger.info(plugin_info.components)
-        return plugin_info.components if plugin_info else []
-
-    def get_plugin_config(self, plugin_name: str) -> dict:
-        """获取插件配置
-
-        Args:
-            plugin_name: 插件名称
-
-        Returns:
-            dict: 插件配置字典，如果插件实例不存在或配置为空，返回空字典
-        """
-        # 从插件管理器获取插件实例的配置
-        from src.plugin_system.core.plugin_manager import plugin_manager
-
-        plugin_instance = plugin_manager.get_plugin_instance(plugin_name)
-        if plugin_instance and plugin_instance.config:
-            return plugin_instance.config
-
-        # 如果插件实例不存在，尝试从配置文件读取
-        try:
-            import toml
-
-            config_path = Path("config") / "plugins" / plugin_name / "config.toml"
-            if config_path.exists():
-                with open(config_path, encoding="utf-8") as f:
-                    config_data = toml.load(f)
-                    logger.debug(f"从配置文件读取插件 {plugin_name} 的配置")
-                    return config_data
-        except Exception as e:
-            logger.debug(f"读取插件 {plugin_name} 配置文件失败: {e}")
-
-        return {}
-
-    def get_registry_stats(self) -> dict[str, Any]:
-        """获取注册中心统计信息"""
-        action_components: int = 0
-        command_components: int = 0
-        tool_components: int = 0
-        events_handlers: int = 0
-        plus_command_components: int = 0
-        chatter_components: int = 0
-        prompt_components: int = 0
-        router_components: int = 0
-        adapter_components: int = 0
-        for component in self._components.values():
-            if component.component_type == ComponentType.ACTION:
-                action_components += 1
-            elif component.component_type == ComponentType.COMMAND:
-                command_components += 1
-            elif component.component_type == ComponentType.TOOL:
-                tool_components += 1
-            elif component.component_type == ComponentType.EVENT_HANDLER:
-                events_handlers += 1
-            elif component.component_type == ComponentType.PLUS_COMMAND:
-                plus_command_components += 1
-            elif component.component_type == ComponentType.CHATTER:
-                chatter_components += 1
-            elif component.component_type == ComponentType.PROMPT:
-                prompt_components += 1
-            elif component.component_type == ComponentType.ROUTER:
-                router_components += 1
-            elif component.component_type == ComponentType.ADAPTER:
-                adapter_components += 1
-        return {
-            "action_components": action_components,
-            "command_components": command_components,
-            "tool_components": tool_components,
-            "mcp_tools": len(self._mcp_tools),
-            "event_handlers": events_handlers,
-            "plus_command_components": plus_command_components,
-            "chatter_components": chatter_components,
-            "prompt_components": prompt_components,
-            "router_components": router_components,
-            "adapter_components": adapter_components,
-            "total_components": len(self._components),
-            "total_plugins": len(self._plugins),
-            "components_by_type": {
-                component_type.value: len(components) for component_type, components in self._components_by_type.items()
-            },
-            "enabled_components": len([c for c in self._components.values() if c.enabled]),
-            "enabled_plugins": len([p for p in self._plugins.values() if p.enabled]),
+        handlers = {
+            ComponentType.ACTION: self._register_action,
+            ComponentType.COMMAND: self._register_command,
+            ComponentType.PLUS_COMMAND: self._register_plus_command,
+            ComponentType.TOOL: self._register_tool,
+            ComponentType.EVENT_HANDLER: self._register_event_handler,
+            ComponentType.CHATTER: self._register_chatter,
+            ComponentType.INTEREST_CALCULATOR: self._register_interest_calculator,
+            ComponentType.PROMPT: self._register_prompt,
+            ComponentType.ROUTER: self._register_router,
+            ComponentType.ADAPTER: self._register_adapter,
         }
 
-    # === MCP 工具相关方法 ===
-
-    async def load_mcp_tools(self) -> None:
-        """加载 MCP 工具（异步方法）"""
-        if self._mcp_tools_loaded:
-            logger.debug("MCP 工具已加载，跳过")
-            return
-
-        try:
-            from .mcp_tool_adapter import load_mcp_tools_as_adapters
-
-            logger.info("开始加载 MCP 工具...")
-            self._mcp_tools = await load_mcp_tools_as_adapters()
-            self._mcp_tools_loaded = True
-            logger.info(f"MCP 工具加载完成，共 {len(self._mcp_tools)} 个工具")
-        except Exception as e:
-            logger.error(f"加载 MCP 工具失败: {e}")
-            self._mcp_tools = []
-            self._mcp_tools_loaded = True  # 标记为已尝试加载，避免重复尝试
-
-    def get_mcp_tools(self) -> list["BaseTool"]:
-        """获取所有 MCP 工具适配器实例"""
-        return self._mcp_tools.copy()
-
-    def is_mcp_tool(self, tool_name: str) -> bool:
-        """检查工具名是否为 MCP 工具"""
-        return tool_name.startswith("mcp_")
-
-    # === 组件移除相关 ===
-
-    async def unregister_plugin(self, plugin_name: str) -> bool:
-        """
-        卸载一个插件及其所有关联的组件。
-
-        这是一个高级操作，会依次移除插件的所有组件，然后移除插件本身的注册信息。
-
-        Args:
-            plugin_name (str): 要卸载的插件的名称。
-
-        Returns:
-            bool: 如果所有组件和插件本身都成功卸载，则返回 True；否则返回 False。
-        """
-        plugin_info = self.get_plugin_info(plugin_name)
-        if not plugin_info:
-            logger.warning(f"插件 {plugin_name} 未注册，无法卸载")
+        handler = handlers.get(component_type)
+        if not handler:
+            logger.warning(f"未知组件类型: {component_type}")
             return False
 
-        logger.info(f"开始卸载插件: {plugin_name}")
-
-        failed_components = []
-        # 逐个移除插件的所有组件
-        for component_info in plugin_info.components:
-            try:
-                success = await self.remove_component(
-                    component_info.name,
-                    component_info.component_type,
-                    plugin_name,
-                )
-                if not success:
-                    failed_components.append(f"{component_info.component_type}.{component_info.name}")
-            except Exception as e:
-                logger.error(f"移除组件 {component_info.name} 时发生异常: {e}")
-                failed_components.append(f"{component_info.component_type}.{component_info.name}")
-
-        # 移除插件的注册信息
-        plugin_removed = self._remove_plugin_registry(plugin_name)
-
-        if failed_components:
-            logger.warning(f"插件 {plugin_name} 部分组件卸载失败: {failed_components}")
-            return False
-        if not plugin_removed:
-            logger.error(f"插件 {plugin_name} 注册信息移除失败")
+        if not handler(component_info, component_class):
             return False
 
-        logger.info(f"插件 {plugin_name} 卸载成功")
+        logger.debug(f"已注册{component_type}组件: '{component_name}' [插件: {plugin_name}]")
         return True
 
-    async def remove_component(self, component_name: str, component_type: ComponentType, plugin_name: str) -> bool:
+    async def remove_component(
+        self, component_name: str, component_type: ComponentType, plugin_name: str
+    ) -> bool:
         """
         从注册中心移除一个指定的组件。
 
         Args:
-            component_name (str): 要移除的组件的名称。
-            component_type (ComponentType): 组件的类型。
-            plugin_name (str): 组件所属的插件名称 (用于日志和验证)。
+            component_name: 要移除的组件的名称
+            component_type: 组件的类型
+            plugin_name: 组件所属的插件名称 (用于日志记录)
 
         Returns:
-            bool: 移除成功返回 True，否则返回 False。
+            移除成功返回 True，否则返回 False
         """
-        target_component_class = self.get_component_class(component_name, component_type)
-        if not target_component_class:
-            logger.warning(f"组件 {component_name} ({component_type.value}) 未注册，无法移除")
+        if not self.get_component_class(component_name, component_type):
+            logger.warning(f"组件 {component_name} ({component_type.value}) 未注册")
             return False
 
         try:
@@ -1126,16 +326,20 @@ class ComponentRegistry:
                     self._default_actions.pop(component_name, None)
                 case ComponentType.COMMAND:
                     self._command_registry.pop(component_name, None)
-                    keys_to_remove = [k for k, v in self._command_patterns.items() if v == component_name]
-                    for key in keys_to_remove:
-                        self._command_patterns.pop(key, None)
+                    # 移除所有关联的命令模式
+                    self._command_patterns = {
+                        k: v for k, v in self._command_patterns.items() if v != component_name
+                    }
                 case ComponentType.PLUS_COMMAND:
                     self._plus_command_registry.pop(component_name, None)
                 case ComponentType.TOOL:
                     self._tool_registry.pop(component_name, None)
                     self._llm_available_tools.pop(component_name, None)
                 case ComponentType.EVENT_HANDLER:
-                    from .event_manager import event_manager  # 延迟导入
+                    self._event_handler_registry.pop(component_name, None)
+                    self._enabled_event_handlers.pop(component_name, None)
+                    # 从事件管理器中移除
+                    from .event_manager import event_manager
                     event_manager.remove_event_handler(component_name)
                 case ComponentType.CHATTER:
                     self._chatter_registry.pop(component_name, None)
@@ -1146,186 +350,248 @@ class ComponentRegistry:
                 case ComponentType.PROMPT:
                     self._prompt_registry.pop(component_name, None)
                     self._enabled_prompt_registry.pop(component_name, None)
+                case ComponentType.ADAPTER:
+                    self._adapter_registry.pop(component_name, None)
+                    self._enabled_adapter_registry.pop(component_name, None)
                 case ComponentType.ROUTER:
-                    logger.warning(f"Router组件 '{component_name}' 的HTTP端点无法在运行时动态移除，将在下次重启后生效。")
-                case _:
-                    logger.warning(f"未知的组件类型: {component_type}，无法进行特定的清理操作")
-                    return False
+                    # Router 的 HTTP 端点无法在运行时动态移除
+                    logger.warning("Router组件无法在运行时动态移除，将在下次重启后生效")
 
-            # --- 通用注册信息的清理 ---
+            # --- 通用注册信息清理 ---
             namespaced_name = f"{component_type.value}.{component_name}"
             self._components.pop(namespaced_name, None)
             self._components_by_type[component_type].pop(component_name, None)
             self._components_classes.pop(namespaced_name, None)
 
-            logger.info(f"组件 {component_name} ({component_type.value}) 已从插件 '{plugin_name}' 中完全移除")
+            logger.info(f"组件 {component_name} ({component_type.value}) 已移除")
             return True
-
         except Exception as e:
-            logger.error(f"移除组件 {component_name} ({component_type.value}) 时发生错误: {e}", exc_info=True)
+            logger.error(f"移除组件时发生错误: {e}", exc_info=True)
             return False
 
     # =================================================================
-    # == 内部注册辅助方法 (_register_* Methods)
+    # == 内部注册方法 (Internal Registration Methods)
     # =================================================================
 
-    def _register_action_component(self, action_info: ActionInfo, action_class: type[BaseAction]) -> bool:
-        """注册Action组件到Action特定注册表。"""
-        action_name = action_info.name
-        _assign_plugin_attrs(action_class, action_info.plugin_name, self.get_plugin_config(action_info.plugin_name) or {})
-        self._action_registry[action_name] = action_class
+    def _register_action(self, info: ComponentInfo, cls: ComponentClassType) -> bool:
+        """
+        注册 Action 组件到 Action 特定注册表。
+
+        Args:
+            info: Action 组件的元数据信息
+            cls: Action 组件的类定义
+
+        Returns:
+            注册成功返回 True
+        """
+        action_info = cast(ActionInfo, info)
+        action_class = cast(type[BaseAction], cls)
+        _assign_plugin_attrs(action_class, info.plugin_name, self.get_plugin_config(info.plugin_name) or {})
+        self._action_registry[info.name] = action_class
+        # 如果组件默认启用，则添加到默认动作集
         if action_info.enabled:
-            self._default_actions[action_name] = action_info
+            self._default_actions[info.name] = action_info
         return True
 
-    def _register_command_component(self, command_info: CommandInfo, command_class: type[BaseCommand]) -> bool:
-        """通过适配器将旧版Command注册为PlusCommand。"""
+    def _register_command(self, info: ComponentInfo, cls: ComponentClassType) -> bool:
+        """
+        通过适配器将旧版 Command 注册为 PlusCommand。
+
+        旧版 Command 会自动转换为 PlusCommand 以保持向后兼容性。
+
+        Args:
+            info: Command 组件的元数据信息
+            cls: Command 组件的类定义
+
+        Returns:
+            注册成功返回 True
+        """
+        command_class = cast(type[BaseCommand], cls)
         logger.warning(
-            f"检测到旧版Command组件 '{command_info.name}' (来自插件: {command_info.plugin_name})。"
-            "它将通过兼容层运行，但建议尽快迁移到PlusCommand以获得更好的性能和功能。"
+            f"检测到旧版Command组件 '{info.name}'，建议迁移到PlusCommand"
         )
-        # 使用适配器将其转换为PlusCommand
+        # 使用适配器将其转换为 PlusCommand
         adapted_class = create_legacy_command_adapter(command_class)
-        plus_command_info = adapted_class.get_plus_command_info()
-        plus_command_info.plugin_name = command_info.plugin_name  # 继承插件名
+        plus_info = adapted_class.get_plus_command_info()
+        plus_info.plugin_name = info.plugin_name  # 继承插件名
+        return self._register_plus_command(plus_info, adapted_class)
 
-        return self._register_plus_command_component(plus_command_info, adapted_class)
+    def _register_plus_command(self, info: ComponentInfo, cls: ComponentClassType) -> bool:
+        """
+        注册 PlusCommand 组件到特定注册表。
 
-    def _register_plus_command_component(
-        self, plus_command_info: PlusCommandInfo, plus_command_class: type[PlusCommand]
-    ) -> bool:
-        """注册PlusCommand组件到特定注册表。"""
-        plus_command_name = plus_command_info.name
-        _assign_plugin_attrs(
-            plus_command_class,
-            plus_command_info.plugin_name,
-            self.get_plugin_config(plus_command_info.plugin_name) or {},
-        )
-        self._plus_command_registry[plus_command_name] = plus_command_class
-        logger.debug(f"已注册PlusCommand组件: {plus_command_name}")
+        Args:
+            info: PlusCommand 组件的元数据信息
+            cls: PlusCommand 组件的类定义
+
+        Returns:
+            注册成功返回 True
+        """
+        plus_class = cast(type[PlusCommand], cls)
+        _assign_plugin_attrs(plus_class, info.plugin_name, self.get_plugin_config(info.plugin_name) or {})
+        self._plus_command_registry[info.name] = plus_class
         return True
 
-    def _register_tool_component(self, tool_info: ToolInfo, tool_class: type[BaseTool]) -> bool:
-        """注册Tool组件到Tool特定注册表。"""
-        tool_name = tool_info.name
-        _assign_plugin_attrs(tool_class, tool_info.plugin_name, self.get_plugin_config(tool_info.plugin_name) or {})
-        self._tool_registry[tool_name] = tool_class
+    def _register_tool(self, info: ComponentInfo, cls: ComponentClassType) -> bool:
+        """
+        注册 Tool 组件到 Tool 特定注册表。
+
+        Args:
+            info: Tool 组件的元数据信息
+            cls: Tool 组件的类定义
+
+        Returns:
+            注册成功返回 True
+        """
+        tool_info = cast(ToolInfo, info)
+        tool_class = cast(type[BaseTool], cls)
+        _assign_plugin_attrs(tool_class, info.plugin_name, self.get_plugin_config(info.plugin_name) or {})
+        self._tool_registry[info.name] = tool_class
+        # 如果组件默认启用，则添加到 LLM 可用工具集
         if tool_info.enabled:
-            self._llm_available_tools[tool_name] = tool_class
+            self._llm_available_tools[info.name] = tool_class
         return True
 
-    def _register_event_handler_component(
-        self, handler_info: EventHandlerInfo, handler_class: type[BaseEventHandler]
-    ) -> bool:
-        """注册EventHandler组件并订阅事件。"""
-        handler_name = handler_info.name
-        _assign_plugin_attrs(
-            handler_class, handler_info.plugin_name, self.get_plugin_config(handler_info.plugin_name) or {}
-        )
-        self._event_handler_registry[handler_name] = handler_class
+    def _register_event_handler(self, info: ComponentInfo, cls: ComponentClassType) -> bool:
+        """
+        注册 EventHandler 组件并订阅事件。
+
+        Args:
+            info: EventHandler 组件的元数据信息
+            cls: EventHandler 组件的类定义
+
+        Returns:
+            注册成功返回 True，注册到事件管理器失败返回 False
+        """
+        handler_info = cast(EventHandlerInfo, info)
+        handler_class = cast(type[BaseEventHandler], cls)
+        plugin_config = self.get_plugin_config(info.plugin_name) or {}
+        _assign_plugin_attrs(handler_class, info.plugin_name, plugin_config)
+        self._event_handler_registry[info.name] = handler_class
+
+        # 如果组件未启用，仅注册信息，不订阅事件
         if not handler_info.enabled:
-            logger.warning(f"EventHandler组件 {handler_name} 未启用，仅注册信息，不订阅事件")
-            return True  # 未启用但注册成功
+            logger.warning(f"EventHandler组件 {info.name} 未启用")
+            return True
 
         # 延迟导入以避免循环依赖
         from src.plugin_system.core.event_manager import event_manager
-        return event_manager.register_event_handler(
-            handler_class, self.get_plugin_config(handler_info.plugin_name) or {}
-        )
+        return event_manager.register_event_handler(handler_class, plugin_config)
 
-    def _register_chatter_component(self, chatter_info: ChatterInfo, chatter_class: type[BaseChatter]) -> bool:
-        """注册Chatter组件到Chatter特定注册表。"""
-        chatter_name = chatter_info.name
-        _assign_plugin_attrs(
-            chatter_class, chatter_info.plugin_name, self.get_plugin_config(chatter_info.plugin_name) or {}
-        )
-        self._chatter_registry[chatter_name] = chatter_class
+    def _register_chatter(self, info: ComponentInfo, cls: ComponentClassType) -> bool:
+        """
+        注册 Chatter 组件到 Chatter 特定注册表。
+
+        Args:
+            info: Chatter 组件的元数据信息
+            cls: Chatter 组件的类定义
+
+        Returns:
+            注册成功返回 True
+        """
+        chatter_info = cast(ChatterInfo, info)
+        chatter_class = cast(type[BaseChatter], cls)
+        _assign_plugin_attrs(chatter_class, info.plugin_name, self.get_plugin_config(info.plugin_name) or {})
+        self._chatter_registry[info.name] = chatter_class
         if chatter_info.enabled:
-            self._enabled_chatter_registry[chatter_name] = chatter_class
-        logger.debug(f"已注册Chatter组件: {chatter_name}")
+            self._enabled_chatter_registry[info.name] = chatter_class
         return True
 
-    def _register_interest_calculator_component(
-        self,
-        interest_calculator_info: "InterestCalculatorInfo",
-        interest_calculator_class: type["BaseInterestCalculator"],
-    ) -> bool:
-        """注册InterestCalculator组件到特定注册表。"""
-        calculator_name = interest_calculator_info.name
-        _assign_plugin_attrs(
-            interest_calculator_class,
-            interest_calculator_info.plugin_name,
-            self.get_plugin_config(interest_calculator_info.plugin_name) or {},
-        )
-        self._interest_calculator_registry[calculator_name] = interest_calculator_class
-        if interest_calculator_info.enabled:
-            self._enabled_interest_calculator_registry[calculator_name] = interest_calculator_class
-        logger.debug(f"已注册InterestCalculator组件: {calculator_name}")
+    def _register_interest_calculator(self, info: ComponentInfo, cls: ComponentClassType) -> bool:
+        """
+        注册 InterestCalculator 组件到特定注册表。
+
+        Args:
+            info: InterestCalculator 组件的元数据信息
+            cls: InterestCalculator 组件的类定义
+
+        Returns:
+            注册成功返回 True
+        """
+        calc_info = cast(InterestCalculatorInfo, info)
+        calc_class = cast(type[BaseInterestCalculator], cls)
+        _assign_plugin_attrs(calc_class, info.plugin_name, self.get_plugin_config(info.plugin_name) or {})
+        self._interest_calculator_registry[info.name] = calc_class
+        if calc_info.enabled:
+            self._enabled_interest_calculator_registry[info.name] = calc_class
         return True
 
-    def _register_prompt_component(self, prompt_info: PromptInfo, prompt_class: type[BasePrompt]) -> bool:
-        """注册Prompt组件到Prompt特定注册表。"""
-        prompt_name = prompt_info.name
-        _assign_plugin_attrs(
-            prompt_class, prompt_info.plugin_name, self.get_plugin_config(prompt_info.plugin_name) or {}
-        )
-        self._prompt_registry[prompt_name] = prompt_class
+    def _register_prompt(self, info: ComponentInfo, cls: ComponentClassType) -> bool:
+        """
+        注册 Prompt 组件到 Prompt 特定注册表。
+
+        Args:
+            info: Prompt 组件的元数据信息
+            cls: Prompt 组件的类定义
+
+        Returns:
+            注册成功返回 True
+        """
+        prompt_info = cast(PromptInfo, info)
+        prompt_class = cast(type[BasePrompt], cls)
+        _assign_plugin_attrs(prompt_class, info.plugin_name, self.get_plugin_config(info.plugin_name) or {})
+        self._prompt_registry[info.name] = prompt_class
         if prompt_info.enabled:
-            self._enabled_prompt_registry[prompt_name] = prompt_class
-        logger.debug(f"已注册Prompt组件: {prompt_name}")
+            self._enabled_prompt_registry[info.name] = prompt_class
         return True
 
-    def _register_router_component(self, router_info: RouterInfo, router_class: type[BaseRouterComponent]) -> bool:
-        """注册Router组件并将其HTTP端点挂载到主FastAPI应用。"""
+    def _register_router(self, info: ComponentInfo, cls: ComponentClassType) -> bool:
+        """
+        注册 Router 组件并将其 HTTP 端点挂载到主 FastAPI 应用。
+
+        Args:
+            info: Router 组件的元数据信息
+            cls: Router 组件的类定义
+
+        Returns:
+            注册成功返回 True，出错返回 False
+        """
+        # 检查总开关是否开启
         if not bot_config.plugin_http_system.enable_plugin_http_endpoints:
             logger.info("插件HTTP端点功能已禁用，跳过路由注册")
             return True
 
         try:
             from src.common.server import get_global_server
+            router_class = cast(type[BaseRouterComponent], cls)
+            _assign_plugin_attrs(router_class, info.plugin_name, self.get_plugin_config(info.plugin_name) or {})
 
-            router_name = router_info.name
-            plugin_name = router_info.plugin_name
-
-            # 实例化组件以获取其配置好的APIRouter实例
+            # 实例化组件以获取其配置好的 APIRouter 实例
             component_instance = router_class()
-            plugin_router = component_instance.router
-
-            # 获取全局FastAPI应用实例
             server = get_global_server()
-
-            # 生成唯一的URL前缀，格式为 /plugins/{plugin_name}
-            prefix = f"/plugins/{plugin_name}"
-
+            # 生成唯一的 URL 前缀，格式为 /plugins/{plugin_name}
+            prefix = f"/plugins/{info.plugin_name}"
             # 将插件的路由包含到主应用中
-            server.app.include_router(plugin_router, prefix=prefix, tags=[plugin_name])
+            server.app.include_router(component_instance.router, prefix=prefix, tags=[info.plugin_name])
 
-            logger.debug(f"成功将插件 '{plugin_name}' 的路由组件 '{router_name}' 挂载到: {prefix}")
+            logger.debug(f"路由组件 '{info.name}' 已挂载到: {prefix}")
             return True
-
         except Exception as e:
-            logger.error(f"注册路由组件 '{router_info.name}' 时出错: {e}", exc_info=True)
+            logger.error(f"注册路由组件时出错: {e}", exc_info=True)
             return False
 
-    def _remove_plugin_registry(self, plugin_name: str) -> bool:
+    def _register_adapter(self, info: ComponentInfo, cls: ComponentClassType) -> bool:
         """
-        (内部方法) 仅移除插件的注册信息。
+        注册 Adapter 组件到 Adapter 特定注册表。
 
         Args:
-            plugin_name (str): 插件名称。
+            info: Adapter 组件的元数据信息
+            cls: Adapter 组件的类定义
 
         Returns:
-            bool: 是否成功移除。
+            注册成功返回 True
         """
-        if plugin_name not in self._plugins:
-            logger.warning(f"插件 {plugin_name} 未注册，无法移除其注册信息")
-            return False
-        del self._plugins[plugin_name]
-        logger.info(f"插件 {plugin_name} 的注册信息已移除")
+        adapter_info = cast(AdapterInfo, info)
+        adapter_class = cast(type[BaseAdapter], cls)
+        _assign_plugin_attrs(adapter_class, info.plugin_name, self.get_plugin_config(info.plugin_name) or {})
+        self._adapter_registry[info.name] = adapter_class
+        if adapter_info.enabled:
+            self._enabled_adapter_registry[info.name] = adapter_class
         return True
 
     # =================================================================
     # == 组件状态管理 (Component State Management)
+    # == 委托给 ComponentStateManager 处理
     # =================================================================
 
     def enable_component(self, component_name: str, component_type: ComponentType) -> bool:
@@ -1333,337 +599,29 @@ class ComponentRegistry:
         全局启用一个组件。
 
         Args:
-            component_name (str): 组件名称。
-            component_type (ComponentType): 组件类型。
+            component_name: 组件名称
+            component_type: 组件类型
 
         Returns:
-            bool: 启用成功返回 True，失败返回 False。
+            启用成功返回 True，失败返回 False
         """
-        target_component_class = self.get_component_class(component_name, component_type)
-        target_component_info = self.get_component_info(component_name, component_type)
-        if not target_component_class or not target_component_info:
-            logger.warning(f"组件 {component_name} ({component_type.value}) 未注册，无法启用")
-            return False
-
-        target_component_info.enabled = True
-        # 更新通用注册表中的状态
-        namespaced_name = f"{component_type.value}.{component_name}"
-        self._components[namespaced_name].enabled = True
-        self._components_by_type[component_type][component_name].enabled = True
-
-        # 更新特定类型的启用列表
-        match component_type:
-            case ComponentType.ACTION:
-                assert isinstance(target_component_info, ActionInfo)
-                self._default_actions[component_name] = target_component_info
-            case ComponentType.COMMAND:
-                # 旧版Command通过PlusCommand启用，这里无需操作
-                pass
-            case ComponentType.TOOL:
-                assert issubclass(target_component_class, BaseTool)
-                self._llm_available_tools[component_name] = target_component_class
-            case ComponentType.EVENT_HANDLER:
-                assert issubclass(target_component_class, BaseEventHandler)
-                self._enabled_event_handlers[component_name] = target_component_class
-                from .event_manager import event_manager
-                cfg = self.get_plugin_config(target_component_info.plugin_name) or {}
-                event_manager.register_event_handler(target_component_class, cfg)
-            case ComponentType.CHATTER:
-                assert issubclass(target_component_class, BaseChatter)
-                self._enabled_chatter_registry[component_name] = target_component_class
-            case ComponentType.INTEREST_CALCULATOR:
-                assert issubclass(target_component_class, BaseInterestCalculator)
-                self._enabled_interest_calculator_registry[component_name] = target_component_class
-            case ComponentType.PROMPT:
-                assert issubclass(target_component_class, BasePrompt)
-                self._enabled_prompt_registry[component_name] = target_component_class
-
-        logger.info(f"组件 {component_name} ({component_type.value}) 已全局启用")
-        return True
+        return self._state_manager.enable_component(component_name, component_type)
 
     async def disable_component(self, component_name: str, component_type: ComponentType) -> bool:
         """
         全局禁用一个组件。
 
         Args:
-            component_name (str): 组件名称。
-            component_type (ComponentType): 组件类型。
+            component_name: 组件名称
+            component_type: 组件类型
 
         Returns:
-            bool: 禁用成功返回 True，失败返回 False。
+            禁用成功返回 True，失败返回 False
         """
-        target_component_info = self.get_component_info(component_name, component_type)
-        if not target_component_info:
-            logger.warning(f"组件 {component_name} ({component_type.value}) 未注册，无法禁用")
-            return False
-
-        target_component_info.enabled = False
-        # 更新通用注册表中的状态
-        namespaced_name = f"{component_type.value}.{component_name}"
-        if namespaced_name in self._components:
-            self._components[namespaced_name].enabled = False
-        if component_name in self._components_by_type[component_type]:
-            self._components_by_type[component_type][component_name].enabled = False
-
-        try:
-            # 从特定类型的启用列表中移除
-            match component_type:
-                case ComponentType.ACTION:
-                    self._default_actions.pop(component_name, None)
-                case ComponentType.COMMAND:
-                    # 旧版Command通过PlusCommand禁用，这里无需操作
-                    pass
-                case ComponentType.TOOL:
-                    self._llm_available_tools.pop(component_name, None)
-                case ComponentType.EVENT_HANDLER:
-                    self._enabled_event_handlers.pop(component_name, None)
-                    from .event_manager import event_manager
-                    # 从事件管理器中取消订阅
-                    event_manager.remove_event_handler(component_name)
-                case ComponentType.CHATTER:
-                    self._enabled_chatter_registry.pop(component_name, None)
-                case ComponentType.INTEREST_CALCULATOR:
-                    self._enabled_interest_calculator_registry.pop(component_name, None)
-                case ComponentType.PROMPT:
-                    self._enabled_prompt_registry.pop(component_name, None)
-
-            logger.info(f"组件 {component_name} ({component_type.value}) 已全局禁用")
-            return True
-        except Exception as e:
-            logger.error(f"禁用组件 {component_name} ({component_type.value}) 时发生错误: {e}", exc_info=True)
-            # 即使出错，也尝试将状态标记为禁用
-            return False
+        return await self._state_manager.disable_component(component_name, component_type)
 
     # =================================================================
-    # == 查询方法 (Query Methods)
-    # =================================================================
-
-    def get_component_info(
-        self, component_name: str, component_type: ComponentType | None = None
-    ) -> ComponentInfo | None:
-        """
-        获取组件信息，支持自动命名空间解析。
-
-        如果只提供 `component_name`，它会尝试在所有类型中查找。如果找到多个同名但不同类型的
-        组件，会发出警告并返回第一个找到的。
-
-        Args:
-            component_name (str): 组件名称，可以是原始名称或命名空间化的名称 (如 "action.my_action")。
-            component_type (ComponentType, optional): 组件类型。如果提供，将只在该类型中查找。
-
-        Returns:
-            ComponentInfo | None: 找到的组件信息对象，或 None。
-        """
-        # 1. 如果已经是命名空间化的名称，直接查找
-        if "." in component_name:
-            return self._components.get(component_name)
-
-        # 2. 如果指定了组件类型，构造命名空间化的名称查找
-        if component_type:
-            namespaced_name = f"{component_type.value}.{component_name}"
-            return self._components.get(namespaced_name)
-
-        # 3. 如果没有指定类型，遍历所有类型查找
-        candidates = []
-        for c_type in ComponentType:
-            namespaced_name = f"{c_type.value}.{component_name}"
-            if component_info := self._components.get(namespaced_name):
-                candidates.append(component_info)
-
-        if len(candidates) == 1:
-            return candidates[0]
-        if len(candidates) > 1:
-            types_found = [info.component_type.value for info in candidates]
-            logger.warning(
-                f"组件名称 '{component_name}' 在多个类型中存在: {types_found}。"
-                f"返回第一个匹配项 (类型: {candidates[0].component_type.value})。请使用 component_type 参数指定类型以消除歧义。"
-            )
-            return candidates[0]
-
-        # 4. 都没找到
-        return None
-
-    def get_component_class(
-        self, component_name: str, component_type: ComponentType | None = None
-    ) -> ComponentClassType | None:
-        """
-        获取组件的类定义，支持自动命名空间解析。
-
-        逻辑与 `get_component_info` 类似。
-
-        Args:
-            component_name (str): 组件名称。
-            component_type (ComponentType, optional): 组件类型。
-
-        Returns:
-            ComponentClassType | None: 找到的组件类，或 None。
-        """
-        # 1. 如果已经是命名空间化的名称，直接查找
-        if "." in component_name:
-            return self._components_classes.get(component_name)
-
-        # 2. 如果指定了组件类型，构造命名空间化的名称查找
-        if component_type:
-            namespaced_name = f"{component_type.value}.{component_name}"
-            return self._components_classes.get(namespaced_name)
-
-        # 3. 如果没有指定类型，遍历所有类型查找
-        info = self.get_component_info(component_name)  # 复用 get_component_info 的查找和消歧义逻辑
-        if info:
-            namespaced_name = f"{info.component_type.value}.{info.name}"
-            return self._components_classes.get(namespaced_name)
-
-        # 4. 都没找到
-        return None
-
-    def get_components_by_type(self, component_type: ComponentType) -> dict[str, ComponentInfo]:
-        """获取指定类型的所有已注册组件（无论是否启用）。"""
-        return self._components_by_type.get(component_type, {}).copy()
-
-    def get_enabled_components_by_type(
-        self, component_type: ComponentType, stream_id: str | None = None
-    ) -> dict[str, ComponentInfo]:
-        """
-        获取指定类型的所有可用组件。
-
-        这会同时考虑全局启用状态和 `stream_id` 对应的局部状态。
-
-        Args:
-            component_type (ComponentType): 要查询的组件类型。
-            stream_id (str, optional): 会话ID，用于检查局部状态覆盖。
-
-        Returns:
-            dict[str, ComponentInfo]: 一个包含可用组件名称和信息的字典。
-        """
-        all_components = self.get_components_by_type(component_type)
-        return {
-            name: info
-            for name, info in all_components.items()
-            if self.is_component_available(name, component_type, stream_id)
-        }
-
-    # =================================================================
-    # == 特定类型查询方法 (Type-Specific Query Methods)
-    # =================================================================
-
-    # --- Action ---
-    def get_action_registry(self) -> dict[str, type[BaseAction]]:
-        """获取所有已注册的Action类。"""
-        return self._action_registry.copy()
-
-    def get_default_actions(self, stream_id: str | None = None) -> dict[str, ActionInfo]:
-        """获取所有可用的Action信息（考虑全局和局部状态）。"""
-        return cast(
-            dict[str, ActionInfo],
-            self.get_enabled_components_by_type(ComponentType.ACTION, stream_id),
-        )
-
-    # --- PlusCommand ---
-    def get_plus_command_registry(self) -> dict[str, type[PlusCommand]]:
-        """获取所有已注册的PlusCommand类。"""
-        return self._plus_command_registry.copy()
-
-    def get_available_plus_commands_info(self, stream_id: str | None = None) -> dict[str, PlusCommandInfo]:
-        """获取所有可用的PlusCommand信息（考虑全局和局部状态）。"""
-        return cast(
-            dict[str, PlusCommandInfo],
-            self.get_enabled_components_by_type(ComponentType.PLUS_COMMAND, stream_id),
-        )
-
-    # --- Tool ---
-    def get_tool_registry(self) -> dict[str, type[BaseTool]]:
-        """获取所有已注册的Tool类。"""
-        return self._tool_registry.copy()
-
-    def get_llm_available_tools(self, stream_id: str | None = None) -> dict[str, type[BaseTool]]:
-        """获取所有对LLM可用的Tool类（考虑全局和局部状态）。"""
-        all_tools = self.get_tool_registry()
-        available_tools = {}
-        for name, tool_class in all_tools.items():
-            if self.is_component_available(name, ComponentType.TOOL, stream_id):
-                available_tools[name] = tool_class
-        return available_tools
-
-    # --- EventHandler ---
-    def get_event_handler_registry(self) -> dict[str, type[BaseEventHandler]]:
-        """获取所有已注册的EventHandler类。"""
-        return self._event_handler_registry.copy()
-
-    def get_enabled_event_handlers(self) -> dict[str, type[BaseEventHandler]]:
-        """获取所有已启用的EventHandler类。"""
-        return self._enabled_event_handlers.copy()
-
-    # --- Chatter ---
-    def get_chatter_registry(self) -> dict[str, type[BaseChatter]]:
-        """获取所有已注册的Chatter类。"""
-        return self._chatter_registry.copy()
-
-    def get_enabled_chatter_registry(self, stream_id: str | None = None) -> dict[str, type[BaseChatter]]:
-        """获取所有可用的Chatter类（考虑全局和局部状态）。"""
-        all_chatters = self.get_chatter_registry()
-        available_chatters = {}
-        for name, chatter_class in all_chatters.items():
-            if self.is_component_available(name, ComponentType.CHATTER, stream_id):
-                available_chatters[name] = chatter_class
-        return available_chatters
-
-    # --- Prompt ---
-    def get_prompt_registry(self) -> dict[str, type[BasePrompt]]:
-        """获取所有已注册的Prompt类。"""
-        return self._prompt_registry.copy()
-
-    def get_enabled_prompt_registry(self) -> dict[str, type[BasePrompt]]:
-        """获取所有已启用的Prompt类。"""
-        return self._enabled_prompt_registry.copy()
-
-    # --- 插件 ---
-    def get_plugin_info(self, plugin_name: str) -> PluginInfo | None:
-        """获取指定插件的信息。"""
-        return self._plugins.get(plugin_name)
-
-    def get_all_plugins(self) -> dict[str, PluginInfo]:
-        """获取所有已注册的插件。"""
-        return self._plugins.copy()
-
-    def get_plugin_components(self, plugin_name: str) -> list["ComponentInfo"]:
-        """获取指定插件下的所有组件信息。"""
-        plugin_info = self.get_plugin_info(plugin_name)
-        return plugin_info.components if plugin_info else []
-
-    def get_plugin_config(self, plugin_name: str) -> dict | None:
-        """
-        获取插件的配置信息。
-
-        它会首先尝试从已加载的插件实例中获取，如果失败，则尝试从文件系统读取。
-
-        Args:
-            plugin_name (str): 插件名称。
-
-        Returns:
-            dict | None: 插件的配置字典，如果找不到则返回 None。
-        """
-        # 延迟导入以避免循环依赖
-        from src.plugin_system.core.plugin_manager import plugin_manager
-
-        plugin_instance = plugin_manager.get_plugin_instance(plugin_name)
-        if plugin_instance and plugin_instance.config:
-            return plugin_instance.config
-
-        # 如果插件实例不存在，尝试从配置文件读取
-        try:
-            config_path = Path("config") / "plugins" / plugin_name / "config.toml"
-            if config_path.exists():
-                with open(config_path, encoding="utf-8") as f:
-                    config_data = toml.load(f)
-                logger.debug(f"从配置文件延迟加载了插件 {plugin_name} 的配置")
-                return config_data
-        except Exception as e:
-            logger.debug(f"读取插件 {plugin_name} 配置文件失败: {e}")
-
-        return None
-
-    # =================================================================
-    # == 局部状态管理 (Local State Management)
+    # == 局部状态管理 (Local State Management) - 委托给 ComponentStateManager
     # =================================================================
 
     def set_local_component_state(
@@ -1675,30 +633,26 @@ class ComponentRegistry:
         这允许在单个对话流中动态启用或禁用组件，而不影响全局设置。
 
         Args:
-            stream_id (str): 唯一的会话ID。
-            component_name (str): 组件名称。
-            component_type (ComponentType): 组件类型。
-            enabled (bool): True 表示启用，False 表示禁用。
+            stream_id: 唯一的会话ID
+            component_name: 组件名称
+            component_type: 组件类型
+            enabled: True 表示启用，False 表示禁用
 
         Returns:
-            bool: 设置成功返回 True，如果组件类型不支持局部状态则返回 False。
+            设置成功返回 True，如果组件类型不支持局部状态则返回 False
         """
-        if component_type in self._no_local_state_types:
-            logger.warning(
-                f"组件类型 {component_type.value} 不支持局部状态管理。"
-                f"尝试为 '{component_name}' 设置局部状态的操作将被忽略。"
-            )
-            return False
+        return self._state_manager.set_local_component_state(stream_id, component_name, component_type, enabled)
 
-        if stream_id not in self._local_component_states:
-            self._local_component_states[stream_id] = {}
+    def clear_local_component_states(self, stream_id: str) -> None:
+        """
+        清除指定会话的所有局部状态。
 
-        state_key = (component_name, component_type)
-        self._local_component_states[stream_id][state_key] = enabled
-        logger.debug(
-            f"已为 stream '{stream_id}' 设置局部状态: {component_name} ({component_type.value}) -> {'启用' if enabled else '禁用'}"
-        )
-        return True
+        当会话结束时应调用此方法来清理资源。
+
+        Args:
+            stream_id: 要清除状态的会话ID
+        """
+        self._state_manager.clear_local_component_states(stream_id)
 
     def is_component_available(
         self, component_name: str, component_type: ComponentType, stream_id: str | None = None
@@ -1707,40 +661,452 @@ class ComponentRegistry:
         检查一个组件在给定上下文中是否可用。
 
         检查顺序:
-        1. 组件是否存在。
-        2. (如果提供了 stream_id) 是否有局部状态覆盖。
-        3. 全局启用状态。
+            1. 组件是否存在
+            2. (如果提供了 stream_id) 是否有局部状态覆盖
+            3. 全局启用状态
 
         Args:
-            component_name (str): 组件名称。
-            component_type (ComponentType): 组件类型。
-            stream_id (str, optional): 会话ID。
+            component_name: 组件名称
+            component_type: 组件类型
+            stream_id: 会话ID（可选）
 
         Returns:
-            bool: 如果组件可用，则返回 True。
+            如果组件可用则返回 True
         """
-        component_info = self.get_component_info(component_name, component_type)
-
-        # 1. 检查组件是否存在
-        if not component_info:
-            return False
-
-        # 2. 如果组件类型不支持局部状态，直接返回其全局状态
-        if component_type in self._no_local_state_types:
-            return component_info.enabled
-
-        # 3. 如果提供了 stream_id，检查是否存在局部状态覆盖
-        if stream_id and stream_id in self._local_component_states:
-            state_key = (component_name, component_type)
-            local_state = self._local_component_states[stream_id].get(state_key)
-            if local_state is not None:
-                return local_state  # 局部状态存在，直接返回
-
-        # 4. 如果没有局部状态覆盖，返回全局状态
-        return component_info.enabled
+        return self._state_manager.is_component_available(component_name, component_type, stream_id)
 
     # =================================================================
-    # == MCP 工具相关方法 (MCP Tool Methods)
+    # == 组件查询方法 (Component Query Methods)
+    # =================================================================
+
+    def get_component_info(
+        self, component_name: str, component_type: ComponentType | None = None
+    ) -> ComponentInfo | None:
+        """
+        获取组件信息，支持自动命名空间解析。
+
+        如果只提供 component_name，它会尝试在所有类型中查找。如果找到多个同名但
+        不同类型的组件，会发出警告并返回第一个找到的。
+
+        Args:
+            component_name: 组件名称，可以是原始名称或命名空间化的名称 (如 "action.my_action")
+            component_type: 组件类型（可选）。如果提供，将只在该类型中查找
+
+        Returns:
+            找到的组件信息对象，或 None
+        """
+        # 1. 如果已经是命名空间化的名称，直接查找
+        if "." in component_name:
+            return self._components.get(component_name)
+
+        # 2. 如果指定了组件类型，构造命名空间化的名称查找
+        if component_type:
+            return self._components.get(f"{component_type.value}.{component_name}")
+
+        # 3. 如果没有指定类型，遍历所有类型查找
+        candidates = [
+            info
+            for c_type in ComponentType
+            if (info := self._components.get(f"{c_type.value}.{component_name}"))
+        ]
+
+        if len(candidates) == 1:
+            return candidates[0]
+        if len(candidates) > 1:
+            logger.warning(f"组件名称 '{component_name}' 在多个类型中存在，返回第一个匹配项")
+            return candidates[0]
+        return None
+
+    def get_component_class(
+        self, component_name: str, component_type: ComponentType | None = None
+    ) -> ComponentClassType | None:
+        """
+        获取组件的类定义，支持自动命名空间解析。
+
+        逻辑与 get_component_info 类似。
+
+        Args:
+            component_name: 组件名称
+            component_type: 组件类型（可选）
+
+        Returns:
+            找到的组件类，或 None
+        """
+        # 1. 如果已经是命名空间化的名称，直接查找
+        if "." in component_name:
+            return self._components_classes.get(component_name)
+
+        # 2. 如果指定了组件类型，构造命名空间化的名称查找
+        if component_type:
+            return self._components_classes.get(f"{component_type.value}.{component_name}")
+
+        # 3. 复用 get_component_info 的查找逻辑
+        info = self.get_component_info(component_name)
+        if info:
+            return self._components_classes.get(f"{info.component_type.value}.{info.name}")
+        return None
+
+    def get_components_by_type(self, component_type: ComponentType) -> dict[str, ComponentInfo]:
+        """
+        获取指定类型的所有已注册组件（无论是否启用）。
+
+        Args:
+            component_type: 要查询的组件类型
+
+        Returns:
+            组件名称到组件信息的字典（副本）
+        """
+        return self._components_by_type.get(component_type, {}).copy()
+
+    def get_enabled_components_by_type(
+        self, component_type: ComponentType, stream_id: str | None = None
+    ) -> dict[str, ComponentInfo]:
+        """
+        获取指定类型的所有可用组件。
+
+        这会同时考虑全局启用状态和 stream_id 对应的局部状态。
+
+        Args:
+            component_type: 要查询的组件类型
+            stream_id: 会话ID，用于检查局部状态覆盖（可选）
+
+        Returns:
+            一个包含可用组件名称和信息的字典
+        """
+        return {
+            name: info
+            for name, info in self.get_components_by_type(component_type).items()
+            if self.is_component_available(name, component_type, stream_id)
+        }
+
+    # =================================================================
+    # == 特定类型查询方法 (Type-Specific Query Methods)
+    # =================================================================
+
+    # --- Action ---
+    def get_action_registry(self) -> dict[str, type[BaseAction]]:
+        """获取所有已注册的 Action 类。"""
+        return self._action_registry.copy()
+
+    def get_default_actions(self, stream_id: str | None = None) -> dict[str, ActionInfo]:
+        """
+        获取所有可用的 Action 信息（考虑全局和局部状态）。
+
+        Args:
+            stream_id: 会话ID，用于检查局部状态覆盖（可选）
+
+        Returns:
+            可用的 Action 名称到信息的字典
+        """
+        return cast(
+            dict[str, ActionInfo],
+            self.get_enabled_components_by_type(ComponentType.ACTION, stream_id),
+        )
+
+    def get_registered_action_info(self, action_name: str) -> ActionInfo | None:
+        """
+        获取指定 Action 的信息。
+
+        Args:
+            action_name: Action 名称
+
+        Returns:
+            ActionInfo 对象，如果不存在则返回 None
+        """
+        info = self.get_component_info(action_name, ComponentType.ACTION)
+        return info if isinstance(info, ActionInfo) else None
+
+    # --- PlusCommand ---
+    def get_plus_command_registry(self) -> dict[str, type[PlusCommand]]:
+        """获取所有已注册的 PlusCommand 类。"""
+        return self._plus_command_registry.copy()
+
+    def get_available_plus_commands_info(self, stream_id: str | None = None) -> dict[str, PlusCommandInfo]:
+        """
+        获取所有可用的 PlusCommand 信息（考虑全局和局部状态）。
+
+        Args:
+            stream_id: 会话ID，用于检查局部状态覆盖（可选）
+
+        Returns:
+            可用的 PlusCommand 名称到信息的字典
+        """
+        return cast(
+            dict[str, PlusCommandInfo],
+            self.get_enabled_components_by_type(ComponentType.PLUS_COMMAND, stream_id),
+        )
+
+    def get_registered_plus_command_info(self, command_name: str) -> PlusCommandInfo | None:
+        """
+        获取指定 PlusCommand 的信息。
+
+        Args:
+            command_name: 命令名称
+
+        Returns:
+            PlusCommandInfo 对象，如果不存在则返回 None
+        """
+        info = self.get_component_info(command_name, ComponentType.PLUS_COMMAND)
+        return info if isinstance(info, PlusCommandInfo) else None
+
+    # --- Tool ---
+    def get_tool_registry(self) -> dict[str, type[BaseTool]]:
+        """获取所有已注册的 Tool 类。"""
+        return self._tool_registry.copy()
+
+    def get_llm_available_tools(self, stream_id: str | None = None) -> dict[str, type[BaseTool]]:
+        """
+        获取所有对 LLM 可用的 Tool 类（考虑全局和局部状态）。
+
+        Args:
+            stream_id: 会话ID，用于检查局部状态覆盖（可选）
+
+        Returns:
+            可用的 Tool 名称到类的字典
+        """
+        return {
+            name: cls
+            for name, cls in self._tool_registry.items()
+            if self.is_component_available(name, ComponentType.TOOL, stream_id)
+        }
+
+    def get_registered_tool_info(self, tool_name: str) -> ToolInfo | None:
+        """
+        获取指定 Tool 的信息。
+
+        Args:
+            tool_name: 工具名称
+
+        Returns:
+            ToolInfo 对象，如果不存在则返回 None
+        """
+        info = self.get_component_info(tool_name, ComponentType.TOOL)
+        return info if isinstance(info, ToolInfo) else None
+
+    # --- EventHandler ---
+    def get_event_handler_registry(self) -> dict[str, type[BaseEventHandler]]:
+        """获取所有已注册的 EventHandler 类。"""
+        return self._event_handler_registry.copy()
+
+    def get_enabled_event_handlers(self) -> dict[str, type[BaseEventHandler]]:
+        """
+        获取所有已启用的 EventHandler 类。
+
+        会检查组件的全局启用状态。
+
+        Returns:
+            可用的 EventHandler 名称到类的字典
+        """
+        return {
+            name: cls
+            for name, cls in self._event_handler_registry.items()
+            if self.is_component_available(name, ComponentType.EVENT_HANDLER)
+        }
+
+    def get_registered_event_handler_info(self, handler_name: str) -> EventHandlerInfo | None:
+        """
+        获取指定 EventHandler 的信息。
+
+        Args:
+            handler_name: 事件处理器名称
+
+        Returns:
+            EventHandlerInfo 对象，如果不存在则返回 None
+        """
+        info = self.get_component_info(handler_name, ComponentType.EVENT_HANDLER)
+        return info if isinstance(info, EventHandlerInfo) else None
+
+    # --- Chatter ---
+    def get_chatter_registry(self) -> dict[str, type[BaseChatter]]:
+        """获取所有已注册的 Chatter 类。"""
+        return self._chatter_registry.copy()
+
+    def get_enabled_chatter_registry(self, stream_id: str | None = None) -> dict[str, type[BaseChatter]]:
+        """
+        获取所有可用的 Chatter 类（考虑全局和局部状态）。
+
+        Args:
+            stream_id: 会话ID，用于检查局部状态覆盖（可选）
+
+        Returns:
+            可用的 Chatter 名称到类的字典
+        """
+        return {
+            name: cls
+            for name, cls in self._chatter_registry.items()
+            if self.is_component_available(name, ComponentType.CHATTER, stream_id)
+        }
+
+    def get_registered_chatter_info(self, chatter_name: str) -> ChatterInfo | None:
+        """
+        获取指定 Chatter 的信息。
+
+        Args:
+            chatter_name: Chatter 名称
+
+        Returns:
+            ChatterInfo 对象，如果不存在则返回 None
+        """
+        info = self.get_component_info(chatter_name, ComponentType.CHATTER)
+        return info if isinstance(info, ChatterInfo) else None
+
+    # --- InterestCalculator ---
+    def get_interest_calculator_registry(self) -> dict[str, type[BaseInterestCalculator]]:
+        """获取所有已注册的 InterestCalculator 类。"""
+        return self._interest_calculator_registry.copy()
+
+    def get_enabled_interest_calculator_registry(self) -> dict[str, type[BaseInterestCalculator]]:
+        """
+        获取所有已启用的 InterestCalculator 类。
+
+        会检查组件的全局启用状态。
+
+        Returns:
+            可用的 InterestCalculator 名称到类的字典
+        """
+        return {
+            name: cls
+            for name, cls in self._interest_calculator_registry.items()
+            if self.is_component_available(name, ComponentType.INTEREST_CALCULATOR)
+        }
+
+    # --- Prompt ---
+    def get_prompt_registry(self) -> dict[str, type[BasePrompt]]:
+        """获取所有已注册的 Prompt 类。"""
+        return self._prompt_registry.copy()
+
+    def get_enabled_prompt_registry(self) -> dict[str, type[BasePrompt]]:
+        """
+        获取所有已启用的 Prompt 类。
+
+        会检查组件的全局启用状态。
+
+        Returns:
+            可用的 Prompt 名称到类的字典
+        """
+        return {
+            name: cls
+            for name, cls in self._prompt_registry.items()
+            if self.is_component_available(name, ComponentType.PROMPT)
+        }
+
+    # --- Adapter ---
+    def get_adapter_registry(self) -> dict[str, type[BaseAdapter]]:
+        """获取所有已注册的 Adapter 类。"""
+        return self._adapter_registry.copy()
+
+    def get_enabled_adapter_registry(self) -> dict[str, type[BaseAdapter]]:
+        """获取所有已启用的 Adapter 类。"""
+        return self._enabled_adapter_registry.copy()
+
+    # --- Command (旧版兼容) ---
+    def get_command_registry(self) -> dict[str, type[BaseCommand]]:
+        """获取 Command 注册表（旧版兼容）。"""
+        return self._command_registry.copy()
+
+    def get_command_patterns(self) -> dict[Pattern, str]:
+        """获取 Command 模式注册表（旧版兼容）。"""
+        return self._command_patterns.copy()
+
+    def get_registered_command_info(self, command_name: str) -> CommandInfo | None:
+        """
+        获取 Command 信息（旧版兼容）。
+
+        Args:
+            command_name: 命令名称
+
+        Returns:
+            CommandInfo 对象，如果不存在则返回 None
+        """
+        info = self.get_component_info(command_name, ComponentType.COMMAND)
+        return info if isinstance(info, CommandInfo) else None
+
+    def find_command_by_text(self, text: str) -> tuple[type[BaseCommand], dict, CommandInfo] | None:
+        """
+        根据文本查找匹配的命令（旧版兼容）。
+
+        Args:
+            text: 输入文本
+
+        Returns:
+            元组 (命令类, 匹配的命名组, 命令信息) 或 None
+        """
+        for pattern, command_name in self._command_patterns.items():
+            if match := pattern.match(text):
+                command_info = self.get_registered_command_info(command_name)
+                if command_info:
+                    return (
+                        self._command_registry[command_name],
+                        match.groupdict(),
+                        command_info,
+                    )
+        return None
+
+    # =================================================================
+    # == 插件查询方法 (Plugin Query Methods)
+    # =================================================================
+
+    def get_plugin_info(self, plugin_name: str) -> PluginInfo | None:
+        """
+        获取指定插件的信息。
+
+        Args:
+            plugin_name: 插件名称
+
+        Returns:
+            PluginInfo 对象，如果不存在则返回 None
+        """
+        return self._plugins.get(plugin_name)
+
+    def get_all_plugins(self) -> dict[str, PluginInfo]:
+        """获取所有已注册的插件。"""
+        return self._plugins.copy()
+
+    def get_plugin_components(self, plugin_name: str) -> list[ComponentInfo]:
+        """
+        获取指定插件下的所有组件信息。
+
+        Args:
+            plugin_name: 插件名称
+
+        Returns:
+            该插件的组件信息列表，如果插件不存在则返回空列表
+        """
+        plugin_info = self.get_plugin_info(plugin_name)
+        return plugin_info.components if plugin_info else []
+
+    def get_plugin_config(self, plugin_name: str) -> dict | None:
+        """
+        获取插件的配置信息。
+
+        它会首先尝试从已加载的插件实例中获取，如果失败，则尝试从文件系统读取。
+
+        Args:
+            plugin_name: 插件名称
+
+        Returns:
+            插件的配置字典，如果找不到则返回 None
+        """
+        # 延迟导入以避免循环依赖
+        from src.plugin_system.core.plugin_manager import plugin_manager
+
+        # 首先尝试从已加载的插件实例获取配置
+        plugin_instance = plugin_manager.get_plugin_instance(plugin_name)
+        if plugin_instance and plugin_instance.config:
+            return plugin_instance.config
+
+        # 如果插件实例不存在，尝试从配置文件读取
+        try:
+            config_path = Path("config") / "plugins" / plugin_name / "config.toml"
+            if config_path.exists():
+                with open(config_path, encoding="utf-8") as f:
+                    return toml.load(f)
+        except Exception as e:
+            logger.debug(f"读取插件 {plugin_name} 配置文件失败: {e}")
+        return None
+
+    # =================================================================
+    # == MCP 工具方法 (MCP Tool Methods)
     # =================================================================
 
     async def load_mcp_tools(self) -> None:
@@ -1750,12 +1116,10 @@ class ComponentRegistry:
         此方法会动态导入并实例化 MCP 工具适配器。为避免重复加载，它会检查一个标志位。
         """
         if self._mcp_tools_loaded:
-            logger.debug("MCP 工具已加载，跳过")
             return
 
         try:
             from .mcp_tool_adapter import load_mcp_tools_as_adapters
-
             logger.info("开始加载 MCP 工具...")
             self._mcp_tools = await load_mcp_tools_as_adapters()
             self._mcp_tools_loaded = True
@@ -1765,28 +1129,42 @@ class ComponentRegistry:
             self._mcp_tools = []
             self._mcp_tools_loaded = True  # 标记为已尝试加载，避免重复失败
 
-    def get_mcp_tools(self) -> list["BaseTool"]:
+    def get_mcp_tools(self) -> list[Any]:
         """获取所有已加载的 MCP 工具适配器实例。"""
         return self._mcp_tools.copy()
 
     def is_mcp_tool(self, tool_name: str) -> bool:
-        """检查一个工具名称是否代表一个 MCP 工具（基于命名约定）。"""
+        """
+        检查一个工具名称是否代表一个 MCP 工具（基于命名约定）。
+
+        Args:
+            tool_name: 工具名称
+
+        Returns:
+            如果工具名以 "mcp_" 开头则返回 True
+        """
         return tool_name.startswith("mcp_")
 
     # =================================================================
-    # == 统计与辅助方法 (Statistics and Helper Methods)
+    # == 统计方法 (Statistics Methods)
     # =================================================================
 
     def get_registry_stats(self) -> dict[str, Any]:
-        """获取注册中心的统计信息，用于调试和监控。"""
-        stats = {component_type.value: 0 for component_type in ComponentType}
+        """
+        获取注册中心的统计信息，用于调试和监控。
+
+        Returns:
+            包含各种统计数据的字典
+        """
+        # 按类型统计组件数量
+        stats = {ct.value: 0 for ct in ComponentType}
         for component in self._components.values():
             stats[component.component_type.value] += 1
 
         return {
             "total_plugins": len(self._plugins),
             "total_components": len(self._components),
-            "enabled_components": len([c for c in self._components.values() if c.enabled]),
+            "enabled_components": sum(1 for c in self._components.values() if c.enabled),
             "mcp_tools_loaded": len(self._mcp_tools),
             "components_by_type": stats,
         }
@@ -1795,3 +1173,4 @@ class ComponentRegistry:
 # --- 全局实例 ---
 # 创建全局唯一的组件注册中心实例，供项目各处使用
 component_registry = ComponentRegistry()
+
diff --git a/src/plugin_system/core/component_state_manager.py b/src/plugin_system/core/component_state_manager.py
new file mode 100644
index 000000000..300764d79
--- /dev/null
+++ b/src/plugin_system/core/component_state_manager.py
@@ -0,0 +1,341 @@
+"""
+组件状态管理器模块。
+
+该模块负责管理组件的全局启用/禁用状态以及会话级别的局部（临时）状态。
+将状态管理逻辑从 ComponentRegistry 分离出来，实现职责分离。
+
+主要功能:
+    - 全局启用/禁用组件
+    - 会话级别的局部状态管理
+    - 组件可用性检查（综合全局和局部状态）
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, cast
+
+from src.common.logger import get_logger
+from src.plugin_system.base.component_types import (
+    ActionInfo,
+    ComponentInfo,
+    ComponentType,
+)
+
+if TYPE_CHECKING:
+    from src.plugin_system.base.base_chatter import BaseChatter
+    from src.plugin_system.base.base_events_handler import BaseEventHandler
+    from src.plugin_system.base.base_interest_calculator import BaseInterestCalculator
+    from src.plugin_system.base.base_prompt import BasePrompt
+    from src.plugin_system.base.base_tool import BaseTool
+    from src.plugin_system.core.component_registry import ComponentRegistry
+
+logger = get_logger("component_state_manager")
+
+
+class ComponentStateManager:
+    """
+    组件状态管理器。
+
+    该类负责管理所有组件的启用/禁用状态，包括:
+        - 全局状态: 影响所有会话的组件启用状态
+        - 局部状态: 仅影响特定会话（stream_id）的临时状态覆盖
+
+    Attributes:
+        _registry: 组件注册中心的引用
+        _local_component_states: 局部组件状态管理器
+        _no_local_state_types: 不支持局部状态管理的组件类型集合
+    """
+
+    def __init__(self, registry: ComponentRegistry):
+        """
+        初始化组件状态管理器。
+
+        Args:
+            registry: 组件注册中心实例的引用
+        """
+        self._registry = registry
+
+        # 局部组件状态管理器
+        # 结构: {stream_id: {(component_name, component_type): enabled}}
+        self._local_component_states: dict[str, dict[tuple[str, ComponentType], bool]] = {}
+
+        # 定义不支持局部状态管理的组件类型集合
+        # 这些组件类型需要保持全局一致性
+        self._no_local_state_types: set[ComponentType] = {
+            ComponentType.ROUTER,  # 路由组件需要全局一致性
+            ComponentType.EVENT_HANDLER,  # 事件处理器需要全局一致性
+            ComponentType.PROMPT,  # 提示词组件需要全局一致性
+            ComponentType.ADAPTER, # ADAPTER组件需要全局一致性
+        }
+
+        logger.debug("组件状态管理器初始化完成")
+
+    # =================================================================
+    # == 全局状态管理 (Global State Management)
+    # =================================================================
+
+    def enable_component(self, component_name: str, component_type: ComponentType) -> bool:
+        """
+        全局启用一个组件。
+
+        Args:
+            component_name: 组件名称
+            component_type: 组件类型
+
+        Returns:
+            启用成功返回 True，失败返回 False
+        """
+        if component_type is ComponentType.ADAPTER:
+            logger.error(f"组件 {component_name} 类型是适配器，无法启用或者禁用")
+            return False
+        target_class = self._registry.get_component_class(component_name, component_type)
+        target_info = self._registry.get_component_info(component_name, component_type)
+        if not target_class or not target_info:
+            logger.warning(f"组件 {component_name} 未注册，无法启用")
+            return False
+
+        # 更新通用注册表中的状态
+        target_info.enabled = True
+        namespaced_name = f"{component_type.value}.{component_name}"
+        self._registry._components[namespaced_name].enabled = True
+        self._registry._components_by_type[component_type][component_name].enabled = True
+
+        # 更新特定类型的启用列表
+        match component_type:
+            case ComponentType.ACTION:
+                self._registry._default_actions[component_name] = cast(ActionInfo, target_info)
+            case ComponentType.TOOL:
+                self._registry._llm_available_tools[component_name] = cast(type[BaseTool], target_class)
+            case ComponentType.EVENT_HANDLER:
+                self._registry._enabled_event_handlers[component_name] = cast(type[BaseEventHandler], target_class)
+                # 重新注册事件处理器
+                from .event_manager import event_manager
+                event_manager.register_event_handler(
+                    cast(type[BaseEventHandler], target_class),
+                    self._registry.get_plugin_config(target_info.plugin_name) or {}
+                )
+            case ComponentType.CHATTER:
+                self._registry._enabled_chatter_registry[component_name] = cast(type[BaseChatter], target_class)
+            case ComponentType.INTEREST_CALCULATOR:
+                self._registry._enabled_interest_calculator_registry[component_name] = cast(
+                    type[BaseInterestCalculator], target_class
+                )
+            case ComponentType.PROMPT:
+                self._registry._enabled_prompt_registry[component_name] = cast(type[BasePrompt], target_class)
+            case ComponentType.ADAPTER:
+                self._registry._enabled_adapter_registry[component_name] = cast(Any, target_class)
+
+        logger.info(f"组件 {component_name} ({component_type.value}) 已全局启用")
+        return True
+
+    async def disable_component(self, component_name: str, component_type: ComponentType) -> bool:
+        """
+        全局禁用一个组件。
+
+        Args:
+            component_name: 组件名称
+            component_type: 组件类型
+
+        Returns:
+            禁用成功返回 True，失败返回 False
+        """
+        if component_type is ComponentType.ADAPTER:
+            logger.error(f"组件 {component_name} 类型是适配器，无法启用或者禁用")
+            return False
+        target_info = self._registry.get_component_info(component_name, component_type)
+        if not target_info:
+            logger.warning(f"组件 {component_name} 未注册，无法禁用")
+            return False
+
+        # 更新通用注册表中的状态
+        target_info.enabled = False
+        namespaced_name = f"{component_type.value}.{component_name}"
+        if namespaced_name in self._registry._components:
+            self._registry._components[namespaced_name].enabled = False
+        if component_name in self._registry._components_by_type[component_type]:
+            self._registry._components_by_type[component_type][component_name].enabled = False
+
+        try:
+            # 从特定类型的启用列表中移除
+            match component_type:
+                case ComponentType.ACTION:
+                    self._registry._default_actions.pop(component_name, None)
+                case ComponentType.TOOL:
+                    self._registry._llm_available_tools.pop(component_name, None)
+                case ComponentType.EVENT_HANDLER:
+                    self._registry._enabled_event_handlers.pop(component_name, None)
+                    # 从事件管理器中取消订阅
+                    from .event_manager import event_manager
+                    event_manager.remove_event_handler(component_name)
+                case ComponentType.CHATTER:
+                    self._registry._enabled_chatter_registry.pop(component_name, None)
+                case ComponentType.INTEREST_CALCULATOR:
+                    self._registry._enabled_interest_calculator_registry.pop(component_name, None)
+                case ComponentType.PROMPT:
+                    self._registry._enabled_prompt_registry.pop(component_name, None)
+                case ComponentType.ADAPTER:
+                    self._registry._enabled_adapter_registry.pop(component_name, None)
+
+            logger.info(f"组件 {component_name} ({component_type.value}) 已全局禁用")
+            return True
+        except Exception as e:
+            logger.error(f"禁用组件时发生错误: {e}", exc_info=True)
+            return False
+
+    # =================================================================
+    # == 局部状态管理 (Local State Management) - 用于会话级别控制
+    # =================================================================
+
+    def set_local_component_state(
+        self, stream_id: str, component_name: str, component_type: ComponentType, enabled: bool
+    ) -> bool:
+        """
+        为指定的会话（stream_id）设置组件的局部（临时）状态。
+
+        这允许在单个对话流中动态启用或禁用组件，而不影响全局设置。
+
+        Args:
+            stream_id: 唯一的会话ID
+            component_name: 组件名称
+            component_type: 组件类型
+            enabled: True 表示启用，False 表示禁用
+
+        Returns:
+            设置成功返回 True，如果组件类型不支持局部状态则返回 False
+        """
+        # 检查组件类型是否支持局部状态
+        if component_type in self._no_local_state_types:
+            logger.warning(f"组件类型 {component_type.value} 不支持局部状态管理")
+            return False
+
+        # 初始化该会话的状态字典（如果不存在）
+        if stream_id not in self._local_component_states:
+            self._local_component_states[stream_id] = {}
+
+        # 设置局部状态
+        self._local_component_states[stream_id][(component_name, component_type)] = enabled
+        logger.debug(
+            f"已为 stream '{stream_id}' 设置局部状态: "
+            f"{component_name} ({component_type.value}) -> {'启用' if enabled else '禁用'}"
+        )
+        return True
+
+    def clear_local_component_states(self, stream_id: str) -> None:
+        """
+        清除指定会话的所有局部状态。
+
+        当会话结束时应调用此方法来清理资源。
+
+        Args:
+            stream_id: 要清除状态的会话ID
+        """
+        self._local_component_states.pop(stream_id, None)
+
+    def get_local_state(
+        self, stream_id: str, component_name: str, component_type: ComponentType
+    ) -> bool | None:
+        """
+        获取指定会话中组件的局部状态。
+
+        Args:
+            stream_id: 会话ID
+            component_name: 组件名称
+            component_type: 组件类型
+
+        Returns:
+            局部状态值（True/False），如果没有设置则返回 None
+        """
+        if stream_id not in self._local_component_states:
+            return None
+        return self._local_component_states[stream_id].get((component_name, component_type))
+
+    # =================================================================
+    # == 组件可用性检查 (Component Availability Check)
+    # =================================================================
+
+    def is_component_available(
+        self, component_name: str, component_type: ComponentType, stream_id: str | None = None
+    ) -> bool:
+        """
+        检查一个组件在给定上下文中是否可用。
+
+        检查顺序:
+            1. 组件是否存在
+            2. (如果提供了 stream_id 且组件类型支持局部状态) 是否有局部状态覆盖
+            3. 全局启用状态
+
+        Args:
+            component_name: 组件名称
+            component_type: 组件类型
+            stream_id: 会话ID（可选）
+
+        Returns:
+            如果组件可用则返回 True
+        """
+        component_info = self._registry.get_component_info(component_name, component_type)
+
+        # 1. 检查组件是否存在
+        if not component_info:
+            return False
+
+        # 2. 不支持局部状态的类型，直接返回全局状态
+        if component_type in self._no_local_state_types:
+            return component_info.enabled
+
+        # 3. 如果提供了 stream_id，检查是否存在局部状态覆盖
+        if stream_id:
+            local_state = self.get_local_state(stream_id, component_name, component_type)
+            if local_state is not None:
+                return local_state  # 局部状态存在，直接返回
+
+        # 4. 如果没有局部状态覆盖，返回全局状态
+        return component_info.enabled
+
+    def get_enabled_components_by_type(
+        self, component_type: ComponentType, stream_id: str | None = None
+    ) -> dict[str, ComponentInfo]:
+        """
+        获取指定类型的所有可用组件。
+
+        这会同时考虑全局启用状态和 stream_id 对应的局部状态。
+
+        Args:
+            component_type: 要查询的组件类型
+            stream_id: 会话ID，用于检查局部状态覆盖（可选）
+
+        Returns:
+            一个包含可用组件名称和信息的字典
+        """
+        return {
+            name: info
+            for name, info in self._registry.get_components_by_type(component_type).items()
+            if self.is_component_available(name, component_type, stream_id)
+        }
+
+    # =================================================================
+    # == 辅助方法 (Helper Methods)
+    # =================================================================
+
+    def supports_local_state(self, component_type: ComponentType) -> bool:
+        """
+        检查指定的组件类型是否支持局部状态管理。
+
+        Args:
+            component_type: 组件类型
+
+        Returns:
+            如果支持局部状态则返回 True
+        """
+        return component_type not in self._no_local_state_types
+
+    def get_all_local_states(self) -> dict[str, dict[tuple[str, ComponentType], bool]]:
+        """
+        获取所有会话的局部状态（用于调试）。
+
+        Returns:
+            所有局部状态的字典（副本）
+        """
+        return {
+            stream_id: states.copy()
+            for stream_id, states in self._local_component_states.items()
+        }
diff --git a/src/plugins/built_in/affinity_flow_chatter/planner/planner.py b/src/plugins/built_in/affinity_flow_chatter/planner/planner.py
index 703265624..8a364eda7 100644
--- a/src/plugins/built_in/affinity_flow_chatter/planner/planner.py
+++ b/src/plugins/built_in/affinity_flow_chatter/planner/planner.py
@@ -13,7 +13,7 @@ from src.chat.message_receive.storage import MessageStorage
 from src.common.logger import get_logger
 from src.config.config import global_config
 from src.mood.mood_manager import mood_manager
-from src.plugin_system.base.component_types import ChatMode
+from src.plugin_system.base.component_types import ChatMode, ChatType
 from src.plugins.built_in.affinity_flow_chatter.planner.plan_executor import ChatterPlanExecutor
 from src.plugins.built_in.affinity_flow_chatter.planner.plan_filter import ChatterPlanFilter
 from src.plugins.built_in.affinity_flow_chatter.planner.plan_generator import ChatterPlanGenerator
@@ -201,6 +201,10 @@ class ChatterActionPlanner:
             reply_not_available = True
             aggregate_should_act = False
 
+            # 检查私聊必回配置
+            is_private_chat = context and context.chat_type == ChatType.PRIVATE
+            force_reply = is_private_chat and global_config.chat.private_chat_inevitable_reply
+
             if unread_messages:
                 # 直接使用消息中已计算的标志，无需重复计算兴趣值
                 for message in unread_messages:
@@ -219,9 +223,11 @@ class ChatterActionPlanner:
                             f"should_reply={message_should_reply}, should_act={message_should_act}"
                         )
 
-                        if message_should_reply:
+                        if message_should_reply or force_reply:
                             aggregate_should_act = True
                             reply_not_available = False
+                            if force_reply:
+                                logger.info(f"Focus模式 - 私聊必回已启用，强制回复消息 {message.message_id}")
                             break
 
                         if message_should_act:
@@ -394,12 +400,19 @@ class ChatterActionPlanner:
             should_reply = False
             target_message = None
 
+            # 检查私聊必回配置
+            is_private_chat = context and context.chat_type == ChatType.PRIVATE
+            force_reply = is_private_chat and global_config.chat.private_chat_inevitable_reply
+
             for message in unread_messages:
                 message_should_reply = getattr(message, "should_reply", False)
-                if message_should_reply:
+                if message_should_reply or force_reply:
                     should_reply = True
                     target_message = message
-                    logger.info(f"Normal模式 - 消息 {message.message_id} 达到reply阈值，准备回复")
+                    if force_reply:
+                        logger.info(f"Normal模式 - 私聊必回已启用，强制回复消息 {message.message_id}")
+                    else:
+                        logger.info(f"Normal模式 - 消息 {message.message_id} 达到reply阈值，准备回复")
                     break
 
             if should_reply and target_message:
@@ -426,7 +439,6 @@ class ChatterActionPlanner:
 
                 # 4. 构建回复动作（Normal模式使用respond动作）
                 from src.common.data_models.info_data_model import ActionPlannerInfo, Plan
-                from src.plugin_system.base.component_types import ChatType
 
                 # Normal模式使用respond动作，表示统一回应未读消息
                 # respond动作不需要target_message_id和action_message，因为它是统一回应所有未读消息
diff --git a/src/plugins/built_in/stt_whisper_plugin/__init__.py b/src/plugins/built_in/stt_whisper_plugin/__init__.py
index 5cde004ae..c6bd46bd7 100644
--- a/src/plugins/built_in/stt_whisper_plugin/__init__.py
+++ b/src/plugins/built_in/stt_whisper_plugin/__init__.py
@@ -6,4 +6,5 @@ __plugin_meta__ = PluginMetadata(
     usage="在 bot_config.toml 中将 asr_provider 设置为 'local' 即可启用",
     version="0.1.0",
     author="Elysia",
+    python_dependencies=["openai-whisper"],
 )
diff --git a/src/plugins/built_in/stt_whisper_plugin/plugin.py b/src/plugins/built_in/stt_whisper_plugin/plugin.py
index 78ed6d8ad..0baa325d4 100644
--- a/src/plugins/built_in/stt_whisper_plugin/plugin.py
+++ b/src/plugins/built_in/stt_whisper_plugin/plugin.py
@@ -1,8 +1,6 @@
 import asyncio
 from typing import ClassVar
 
-import whisper
-
 from src.common.logger import get_logger
 from src.plugin_system import BasePlugin, ComponentInfo, register_plugin
 from src.plugin_system.base.base_tool import BaseTool
@@ -35,6 +33,8 @@ class LocalASRTool(BaseTool):
         if _whisper_model is None and not _is_loading:
             _is_loading = True
             try:
+                import whisper
+
                 model_size = plugin_config.get("whisper", {}).get("model_size", "tiny")
                 device = plugin_config.get("whisper", {}).get("device", "cpu")
                 logger.info(f"正在预加载 Whisper ASR 模型: {model_size} ({device})")
diff --git a/src/plugins/built_in/system_management/plugin.py b/src/plugins/built_in/system_management/plugin.py
index 72bc826c6..3f14075d2 100644
--- a/src/plugins/built_in/system_management/plugin.py
+++ b/src/plugins/built_in/system_management/plugin.py
@@ -12,6 +12,8 @@ from src.chat.utils.prompt_component_manager import prompt_component_manager
 from src.chat.utils.prompt_params import PromptParameters
 from src.plugin_system.apis import (
     chat_api,
+    component_state_api,
+    plugin_info_api,
     plugin_manage_api,
 )
 from src.plugin_system.apis.logging_api import get_logger
@@ -29,6 +31,7 @@ from src.plugin_system.base.component_types import (
 from src.plugin_system.base.config_types import ConfigField
 from src.plugin_system.base.plus_command import PlusCommand
 from src.plugin_system.utils.permission_decorators import require_permission
+from src.plugin_system.apis.permission_api import permission_api
 
 logger = get_logger("SystemManagement")
 
@@ -46,9 +49,15 @@ class SystemCommand(PlusCommand):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
-    @require_permission("access", deny_message="❌ 你没有权限使用此命令")
     async def execute(self, args: CommandArgs) -> tuple[bool, str | None, bool]:
         """执行系统管理命令"""
+        if not self.chat_stream.user_info:
+            logger.error("chat_stream缺失用户信息,请报告开发者")
+            return False, "chat_stream缺失用户信息,请报告开发者", True
+        has_permission = await permission_api.check_permission(platform=self.chat_stream.platform,user_id=self.chat_stream.user_info.user_id,permission_node="access")
+        if has_permission:
+            logger.warning("没有权限使用此命令")
+            return False, "没有权限使用此命令", True
         if args.is_empty:
             await self._show_help("all")
             return True, "显示帮助信息", True
@@ -79,7 +88,7 @@ class SystemCommand(PlusCommand):
 🔧 主要功能：
 • `/system help` - 显示此帮助
 • `/system permission` - 权限管理
-• `/system plugin` - 插件管理
+• `/system plugin` - 插件与组件管理
 • `/system schedule` - 定时任务管理
 • `/system prompt` - 提示词注入管理
 """
@@ -96,16 +105,18 @@ class SystemCommand(PlusCommand):
 """
         elif target == "plugin":
             help_text = """🔌 插件管理命令帮助
-📋 基本操作：
-• `/system plugin help` - 显示插件管理帮助
-• `/system plugin report` - 查看系统插件报告
-• `/system plugin rescan` - 重新扫描所有插件目录
 
 ⚙️ 插件控制：
+• `/system plugin rescan` - 重新扫描所有插件目录
 • `/system plugin load <插件名>` - 加载指定插件
 • `/system plugin reload <插件名>` - 重新加载指定插件
 • `/system plugin reload_all` - 重新加载所有插件
-🎯 局部控制 (需要 `system.plugin.manage.local` 权限):
+
+🔧 全局组件控制 (需要 `system.plugin.manage` 权限):
+• `/system plugin enable <组件名>` - 全局启用组件
+• `/system plugin disable <组件名>` - 全局禁用组件
+
+🎯 局部组件控制 (需要 `system.plugin.manage.local` 权限):
 • `/system plugin enable_local <名称> [group <群号> | private <QQ号>]` - 在指定会话局部启用组件
 • `/system plugin disable_local <名称> [group <群号> | private <QQ号>]` - 在指定会话局部禁用组件
 """
@@ -154,6 +165,15 @@ class SystemCommand(PlusCommand):
             await self._show_help("plugin")
         elif action in ["report", "报告"]:
             await self._show_system_report()
+        elif action in ["info", "详情"] and remaining_args:
+            await self._show_plugin_info(remaining_args[0])
+        elif action in ["list", "列表"]:
+            comp_type = remaining_args[0] if remaining_args else None
+            await self._list_components(comp_type)
+        elif action in ["search", "搜索"] and remaining_args:
+            await self._search_components(remaining_args[0])
+        elif action in ["disabled", "禁用列表"]:
+            await self._list_disabled_components()
         elif action in ["rescan", "重扫"]:
             await self._rescan_plugin_dirs()
         elif action in ["load", "加载"] and len(remaining_args) > 0:
@@ -162,6 +182,10 @@ class SystemCommand(PlusCommand):
             await self._reload_plugin(remaining_args[0])
         elif action in ["reload_all", "重载全部"]:
             await self._reload_all_plugins()
+        elif action in ["enable", "启用"] and len(remaining_args) >= 1:
+            await self._set_global_component_state(remaining_args[0], enabled=True)
+        elif action in ["disable", "禁用"] and len(remaining_args) >= 1:
+            await self._set_global_component_state(remaining_args[0], enabled=False)
         elif action in ["enable_local", "局部启用"] and len(remaining_args) >= 1:
             await self._set_local_component_state(remaining_args, enabled=True)
         elif action in ["disable_local", "局部禁用"] and len(remaining_args) >= 1:
@@ -428,13 +452,198 @@ class SystemCommand(PlusCommand):
         await self.send_text("\n".join(response_parts))
 
     # =================================================================
-    # Permission Management Section
+    # Permission Management Section (Plugin Stats & Info)
     # =================================================================
+    @require_permission("plugin.manage", deny_message="❌ 你没有权限查看插件详情")
+    async def _show_plugin_info(self, plugin_name: str):
+        """显示单个插件的详细信息"""
+        details = plugin_info_api.get_plugin_details(plugin_name)
+
+        if not details:
+            # 尝试模糊匹配
+            all_plugins = plugin_info_api.list_plugins("loaded")
+            suggestions = [p for p in all_plugins if plugin_name.lower() in p.lower()]
+            if suggestions:
+                await self.send_text(
+                    f"❌ 未找到插件 `{plugin_name}`\n"
+                    f"你可能想找的是: {', '.join([f'`{s}`' for s in suggestions[:5]])}"
+                )
+            else:
+                await self.send_text(f"❌ 未找到插件 `{plugin_name}`")
+            return
+
+        response_parts = [
+            f"🔌 **插件详情: {details['display_name']}**",
+            f"  • 内部名称: `{details['name']}`",
+            f"  • 版本: {details['version']}",
+            f"  • 作者: {details['author']}",
+            f"  • 状态: {'✅ 已启用' if details['enabled'] else '❌ 已禁用'}",
+            f"  • 加载状态: {details['status']}",
+        ]
+
+        if details.get('description'):
+            response_parts.append(f"  • 描述: {details['description']}")
+
+        if details.get('license'):
+            response_parts.append(f"  • 许可证: {details['license']}")
+
+        # 组件信息
+        if details['components']:
+            response_parts.append(f"\n🧩 **组件列表** (共 {len(details['components'])} 个):")
+            for comp in details['components']:
+                status = "✅" if comp['enabled'] else "❌"
+                response_parts.append(f"  {status} `{comp['name']}` ({comp['component_type']})")
+                if comp.get('description'):
+                    response_parts.append(f"      {comp['description'][:50]}...")
+
+        await self._send_long_message("\n".join(response_parts))
+
+    @require_permission("plugin.manage", deny_message="❌ 你没有权限查看组件列表")
+    async def _list_components(self, comp_type_str: str | None):
+        """列出指定类型的组件"""
+        # 显示可用类型帮助
+        available_types = [t.value for t in ComponentType]
+
+        if comp_type_str:
+            # 尝试匹配组件类型
+            comp_type = None
+            for t in ComponentType:
+                if t.value.lower() == comp_type_str.lower() or t.name.lower() == comp_type_str.lower():
+                    comp_type = t
+                    break
+
+            if not comp_type:
+                await self.send_text(
+                    f"❌ 未知的组件类型: `{comp_type_str}`\n"
+                    f"可用类型: {', '.join([f'`{t}`' for t in available_types])}"
+                )
+                return
+
+            components = plugin_info_api.list_components(comp_type, enabled_only=False)
+            title = f"🧩 **{comp_type.value} 组件列表** (共 {len(components)} 个)"
+        else:
+            # 列出所有类型的统计
+            response_parts = ["🧩 **组件类型概览**", ""]
+            for t in ComponentType:
+                comps = plugin_info_api.list_components(t, enabled_only=False)
+                enabled = sum(1 for c in comps if c['enabled'])
+                if comps:
+                    response_parts.append(f"• **{t.value}**: {enabled}/{len(comps)} 启用")
+
+            response_parts.append(f"\n💡 使用 `/system plugin list <类型>` 查看详情")
+            response_parts.append(f"可用类型: {', '.join([f'`{t}`' for t in available_types])}")
+            await self.send_text("\n".join(response_parts))
+            return
+
+        if not components:
+            await self.send_text(f"📭 没有找到 {comp_type.value} 类型的组件")
+            return
+
+        response_parts = [title, ""]
+        for comp in components:
+            status = "✅" if comp['enabled'] else "❌"
+            response_parts.append(f"{status} `{comp['name']}` (来自: `{comp['plugin_name']}`)")
+
+        await self._send_long_message("\n".join(response_parts))
+
+    @require_permission("plugin.manage", deny_message="❌ 你没有权限搜索组件")
+    async def _search_components(self, keyword: str):
+        """搜索组件"""
+        results = plugin_info_api.search_components_by_name(keyword, case_sensitive=False)
+
+        if not results:
+            await self.send_text(f"🔍 未找到包含 `{keyword}` 的组件")
+            return
+
+        response_parts = [f"🔍 **搜索结果** (关键词: `{keyword}`, 共 {len(results)} 个)", ""]
+
+        for comp in results:
+            status = "✅" if comp['enabled'] else "❌"
+            response_parts.append(
+                f"{status} `{comp['name']}` ({comp['component_type']})\n"
+                f"   来自: `{comp['plugin_name']}`"
+            )
+
+        await self._send_long_message("\n".join(response_parts))
+
+    @require_permission("plugin.manage", deny_message="❌ 你没有权限查看禁用组件")
+    async def _list_disabled_components(self):
+        """列出所有禁用的组件"""
+        disabled = component_state_api.get_disabled_components()
+
+        if not disabled:
+            await self.send_text("✅ 当前没有被禁用的组件")
+            return
+
+        response_parts = [f"🚫 **禁用组件列表** (共 {len(disabled)} 个)", ""]
+
+        # 按插件分组
+        by_plugin: dict[str, list] = {}
+        for comp in disabled:
+            plugin_name = comp.plugin_name
+            if plugin_name not in by_plugin:
+                by_plugin[plugin_name] = []
+            by_plugin[plugin_name].append(comp)
+
+        for plugin_name, comps in by_plugin.items():
+            response_parts.append(f"🔌 **{plugin_name}**:")
+            for comp in comps:
+                response_parts.append(f"  ❌ `{comp.name}` ({comp.component_type.value})")
+
+        await self._send_long_message("\n".join(response_parts))
+
+    @require_permission("plugin.manage", deny_message="❌ 你没有权限管理组件状态")
+    async def _set_global_component_state(self, comp_name: str, enabled: bool):
+        """全局启用或禁用组件"""
+        # 搜索组件
+        found_components = plugin_info_api.search_components_by_name(comp_name, exact_match=True)
+
+        if not found_components:
+            # 尝试模糊搜索给出建议
+            fuzzy_results = plugin_info_api.search_components_by_name(comp_name, exact_match=False)
+            if fuzzy_results:
+                suggestions = ", ".join([f"`{c['name']}`" for c in fuzzy_results[:5]])
+                await self.send_text(f"❌ 未找到名为 `{comp_name}` 的组件\n你可能想找的是: {suggestions}")
+            else:
+                await self.send_text(f"❌ 未找到名为 `{comp_name}` 的组件")
+            return
+
+        if len(found_components) > 1:
+            suggestions = "\n".join([f"- `{c['name']}` (类型: {c['component_type']})" for c in found_components])
+            await self.send_text(f"❌ 发现多个名为 `{comp_name}` 的组件，操作已取消。\n找到的组件:\n{suggestions}")
+            return
+
+        component_info = found_components[0]
+        comp_type_str = component_info["component_type"]
+        component_type = ComponentType(comp_type_str)
+
+        # 禁用保护
+        if not enabled:
+            protected_types = [
+                ComponentType.INTEREST_CALCULATOR,
+                ComponentType.PROMPT,
+                ComponentType.ROUTER,
+            ]
+            if component_type in protected_types:
+                await self.send_text(f"❌ 无法禁用核心组件 `{comp_name}` ({comp_type_str})")
+                return
+
+        # 执行操作
+        success = await component_state_api.set_component_enabled(comp_name, component_type, enabled)
+
+        action_text = "启用" if enabled else "禁用"
+        if success:
+            await self.send_text(f"✅ 已全局{action_text}组件 `{comp_name}` ({comp_type_str})")
+        else:
+            if component_type == ComponentType.CHATTER and not enabled:
+                await self.send_text(f"❌ 无法禁用最后一个 Chatter 组件 `{comp_name}`")
+            else:
+                await self.send_text(f"❌ {action_text}组件 `{comp_name}` 失败，请检查日志")
 
     @require_permission("plugin.manage", deny_message="❌ 你没有权限查看插件报告")
     async def _show_system_report(self):
         """显示系统插件报告"""
-        report = plugin_manage_api.get_system_report()
+        report = plugin_info_api.get_system_report()
         
         response_parts = [
             "📊 **系统插件报告**",
@@ -509,7 +718,7 @@ class SystemCommand(PlusCommand):
         stream_id = self.message.chat_info.stream_id  # 默认作用于当前会话
 
         # 1. 搜索组件
-        found_components = plugin_manage_api.search_components_by_name(comp_name, exact_match=True)
+        found_components = plugin_info_api.search_components_by_name(comp_name, exact_match=True)
 
         if not found_components:
             await self.send_text(f"❌ 未找到名为 '{comp_name}' 的组件。")
@@ -563,7 +772,7 @@ class SystemCommand(PlusCommand):
             stream_id = target_stream.stream_id
 
         # 4. 执行操作
-        success = plugin_manage_api.set_component_enabled_local(
+        success = component_state_api.set_component_enabled_local(
             stream_id=stream_id,
             name=comp_name,
             component_type=component_type,
@@ -782,13 +991,13 @@ class SystemCommand(PlusCommand):
 @register_plugin
 class SystemManagementPlugin(BasePlugin):
     plugin_name: str = "system_management"
-    enable_plugin: bool = True
+    enable_plugin: bool = False
     dependencies: ClassVar[list[str]] = []  # 插件依赖列表
     python_dependencies: ClassVar[list[str]] = []  # Python包依赖列表，现在使用内置API
     config_file_name: str = "config.toml"  # 配置文件名
     config_schema: ClassVar[dict] = {
         "plugin": {
-            "enabled": ConfigField(bool, default=True, description="是否启用插件"),
+            "enabled": ConfigField(bool, default=False, description="是否启用插件"),
         }
     }
 
diff --git a/template/bot_config_template.toml b/template/bot_config_template.toml
index 61a5775f8..13699c9fd 100644
--- a/template/bot_config_template.toml
+++ b/template/bot_config_template.toml
@@ -171,6 +171,7 @@ learning_strength = 0.5
 
 [chat] #MoFox-Bot的聊天通用设置
 allow_reply_self = false # 是否允许回复自己说的话
+private_chat_inevitable_reply = false # 私聊必然回复
 
 max_context_size = 25 # 上下文长度
 thinking_timeout = 40 # MoFox-Bot一次回复最长思考规划时间，超过这个时间的思考会放弃（往往是api反应太慢）
@@ -391,7 +392,7 @@ reaction = "请按照以下模板造句：[n]是这样的，xx只要xx就可以
 # 可以自定义部分提示词
 [custom_prompt]
 image_prompt = "请用中文描述这张图片的内容。如果有文字，请把文字描述概括出来，请留意其主题，直观感受，输出为一段平文本，最多30字，请注意不要分点，就输出一段文本"
-planner_custom_prompt_content = "" # 决策器自定义提示词内容，如果这里没有内容则不生效
+planner_custom_prompt_content = "" # AFC的决策器自定义提示词内容，如果这里没有内容则不生效
 
 [response_post_process]
 enable_response_post_process = true # 是否启用回复后处理，包括错别字生成器，回复分割器
@@ -536,23 +537,6 @@ s4u_whitelist_chats = []
 # 黑名单列表，格式同上
 s4u_blacklist_chats = []
 
-# --- Normal模式: 共享组配置 ---
-# 现在这些是预留plugin使用的上下文互通组配置
-# 您可以根据需要添加多个互通组
-# 在回复过程中只会遵循上面的--S4U模式: 用户中心上下文检索--
-
-# --- QQ空间专用互通组 (示例) ---
-# Maizone插件会根据组名 "Maizone默认互通组" 来获取上下文
-# 您可以修改下面的chat_ids来定义哪些聊天内容可以被Maizone插件参考
-[[cross_context.groups]]
-name = "Maizone默认互通组"
-mode = "whitelist"
-default_limit = 10
-chat_ids = [
-    ["group", "111111"],     # 示例群聊1
-    ["private", "222222"]  # 示例私聊2
-]
-
 [affinity_flow]
 enable_normal_mode = true # 是否启用 Normal 聊天模式。启用后，在专注模式回复后会自动切换，并根据兴趣度决定是否回复，以实现更快速的回复。
 # 兴趣评分系统参数
diff --git a/template/model_config_template.toml b/template/model_config_template.toml
index 059cce89d..fc0fea76b 100644
--- a/template/model_config_template.toml
+++ b/template/model_config_template.toml
@@ -1,5 +1,5 @@
 [inner]
-version = "1.4.0"
+version = "1.4.1"
 
 # 配置文件版本号迭代规则同bot_config.toml
 
@@ -21,9 +21,9 @@ max_retry = 2
 timeout = 30
 retry_interval = 10
 
-[[api_providers]] # 特殊：Google的Gimini使用特殊API，与OpenAI格式不兼容，需要配置client为"aiohttp_gemini"
+[[api_providers]] # 特殊：Google的Gemini使用特殊API，与OpenAI格式不兼容，需要配置client为"aiohttp_gemini"
 name = "Google"
-base_url = "https://api.google.com/v1"
+base_url = "https://generativelanguage.googleapis.com/v1beta"
 api_key = ["your-google-api-key-1", "your-google-api-key-2"]
 client_type = "aiohttp_gemini" # 官方的gemini客户端现在已经死了
 max_retry = 2
@@ -112,6 +112,17 @@ api_provider = "SiliconFlow"
 price_in = 4.0
 price_out = 16.0
 
+[[models]] # Gemini 模型配置示例
+model_identifier = "gemini-2.5-pro"  # 或使用 "gemini-2.5-pro", "gemini-3-pro-preview" 等
+name = "gemini-2.5-pro"
+api_provider = "Google"
+price_in = 0.0
+price_out = 0.0
+[models.extra_params]
+# 思考配置（二选一，不能同时使用，否则会返回 400 错误）：
+#thinking_level = "medium"     # Gemini3新版参数，可选值: "low", "medium", "high"
+thinking_budget = 256       # Gemini2.5系列旧版参数，不同模型范围不同（如 gemini-2.5-flash: 1-24576, gemini-2.5-pro: 128-32768）
+
 [model_task_config.utils] # 在麦麦的一些组件中使用的模型，例如表情包模块，取名模块，关系模块，是麦麦必须的模型
 model_list = ["siliconflow-deepseek-ai/DeepSeek-V3.2-Exp"] # 使用的模型列表，每个子项对应上面的模型名称(name)
 temperature = 0.2                        # 模型温度，新V3建议0.1-0.3