fix: keep model metadata separate from providers

astrbot/core/core_lifecycle.py

@@ -35,9 +35,6 @@ from astrbot.core.star.star_manager import PluginManager
 from astrbot.core.subagent_orchestrator import SubAgentOrchestrator
 from astrbot.core.umop_config_router import UmopConfigRouter
 from astrbot.core.updator import AstrBotUpdator
-from astrbot.core.utils.event_loop_diagnostics import (
-    create_event_loop_diagnostic_tasks,
-)
 from astrbot.core.utils.llm_metadata import update_llm_metadata
 from astrbot.core.utils.migra_helper import migra
 from astrbot.core.utils.temp_dir_cleaner import TempDirCleaner
@@ -299,18 +296,13 @@ class AstrBotCoreLifecycle:
                 self.temp_dir_cleaner.run(),
                 name="temp_dir_cleaner",
             )
-        diagnostic_tasks = create_event_loop_diagnostic_tasks()
 
         # 把插件中注册的所有协程函数注册到事件总线中并执行
         extra_tasks = []
         for task in self.star_context._register_tasks:
             extra_tasks.append(asyncio.create_task(task, name=task.__name__))  # type: ignore
 
-        tasks_ = [
-            event_bus_task,
-            *diagnostic_tasks,
-            *(extra_tasks if extra_tasks else []),
-        ]
+        tasks_ = [event_bus_task, *(extra_tasks if extra_tasks else [])]
         if cron_task:
             tasks_.append(cron_task)
         if temp_dir_cleaner_task:

astrbot/core/platform/sources/qqofficial/qqofficial_platform_adapter.py

@@ -17,7 +17,7 @@ from botpy.gateway import BotWebSocket
 
 from astrbot import logger
 from astrbot.api.event import MessageChain
-from astrbot.api.message_components import At, File, Image, Plain, Record, Reply, Video
+from astrbot.api.message_components import At, File, Image, Plain, Record, Video
 from astrbot.api.platform import (
     AstrBotMessage,
     MessageMember,
@@ -37,75 +37,7 @@ for handler in logging.root.handlers[:]:
     logging.root.removeHandler(handler)
 
 
-def _set_raw_message_fields(message: Any, data: dict[str, Any]) -> None:
-    """Preserve QQ message fields that qq-botpy does not expose.
-
-    Args:
-        message: Patched qq-botpy message object.
-        data: Raw message payload from QQ.
-
-    Returns:
-        None.
-    """
-    if not isinstance(data, dict):
-        data = {}
-    message.raw_data = data
-    message.message_type = data.get("message_type")
-    msg_elements = data.get("msg_elements")
-    message.msg_elements = msg_elements if isinstance(msg_elements, list) else []
-
-
-class PatchedMessage(botpy.message.Message):
-    __slots__ = ("raw_data", "message_type", "msg_elements")
-
-    def __init__(
-        self,
-        api: Any,
-        event_id: str | None,
-        data: dict[str, Any],
-    ) -> None:
-        super().__init__(api, event_id, data)  # type: ignore
-        _set_raw_message_fields(self, data)
-
-
-class PatchedDirectMessage(botpy.message.DirectMessage):
-    __slots__ = ("raw_data", "message_type", "msg_elements")
-
-    def __init__(
-        self,
-        api: Any,
-        event_id: str | None,
-        data: dict[str, Any],
-    ) -> None:
-        super().__init__(api, event_id, data)  # type: ignore
-        _set_raw_message_fields(self, data)
-
-
-class PatchedC2CMessage(botpy.message.C2CMessage):
-    __slots__ = ("raw_data", "message_type", "msg_elements")
-
-    def __init__(
-        self,
-        api: Any,
-        event_id: str | None,
-        data: dict[str, Any],
-    ) -> None:
-        super().__init__(api, event_id, data)  # type: ignore
-        _set_raw_message_fields(self, data)
-
-
 class PatchedGroupMessage(botpy.message.GroupMessage):
-    __slots__ = ("raw_data", "message_type", "msg_elements")
-
-    def __init__(
-        self,
-        api: Any,
-        event_id: str | None,
-        data: dict[str, Any],
-    ) -> None:
-        super().__init__(api, event_id, data)  # type: ignore
-        _set_raw_message_fields(self, data)
-
     class _User:
         def __init__(self, data: dict[str, Any]) -> None:
             self.id = data.get("id", None)
@@ -121,43 +53,21 @@ class PatchedGroupMessage(botpy.message.GroupMessage):
 
 
 def _ensure_group_message_create_parser() -> None:
-    """Register qq-botpy message parsers with QQ quote payload preservation."""
+    """Register the missing qq-botpy parser for GROUP_MESSAGE_CREATE."""
 
-    def build_parser(event_name: str, message_cls: type) -> Any:
-        """Build a ConnectionState parser for one QQ message event.
+    if hasattr(ConnectionState, "parse_group_message_create"):
+        return
 
-        Args:
-            event_name: botpy dispatch event name.
-            message_cls: Patched message class used to retain raw fields.
-
-        Returns:
-            Parser function bound by qq-botpy's ConnectionState.
-        """
-
-        def parse_message(self, payload: dict[str, Any]) -> None:
-            qq_message = message_cls(
-                self.api,
-                payload.get("id", None),
-                payload.get("d", {}),
-            )
-            self._dispatch(event_name, qq_message)
-
-        return parse_message
-
-    parser_specs = {
-        "message_create": ("message_create", PatchedMessage),
-        "at_message_create": ("at_message_create", PatchedMessage),
-        "direct_message_create": ("direct_message_create", PatchedDirectMessage),
-        "group_at_message_create": ("group_at_message_create", PatchedGroupMessage),
-        "c2c_message_create": ("c2c_message_create", PatchedC2CMessage),
-        "group_message_create": ("group_message_create", PatchedGroupMessage),
-    }
-    for parser_name, (event_name, message_cls) in parser_specs.items():
-        setattr(
-            ConnectionState,
-            f"parse_{parser_name}",
-            build_parser(event_name, message_cls),
+    def parse_group_message_create(self, payload: dict[str, Any]) -> None:
+        group_message = PatchedGroupMessage(
+            self.api,
+            payload.get("id", None),
+            payload.get("d", {}),
         )
+        logger.debug("[QQOfficial] Received group message: %s", group_message)
+        self._dispatch("group_message_create", group_message)
+
+    setattr(ConnectionState, "parse_group_message_create", parse_group_message_create)
 
 
 class ManagedBotWebSocket(BotWebSocket):
@@ -581,41 +491,25 @@ class QQOfficialPlatformAdapter(Platform):
             return
 
         for attachment in attachments:
-            if isinstance(attachment, dict):
-                content_type = str(
-                    attachment.get("content_type")
-                    or attachment.get("contentType")
-                    or "",
-                ).lower()
-                url = QQOfficialPlatformAdapter._normalize_attachment_url(
-                    cast(str | None, attachment.get("url"))
-                )
-                filename = cast(
-                    str,
-                    attachment.get("filename")
-                    or attachment.get("name")
-                    or "attachment",
-                )
-            else:
-                content_type = cast(
-                    str,
-                    getattr(attachment, "content_type", "") or "",
-                ).lower()
-                url = QQOfficialPlatformAdapter._normalize_attachment_url(
-                    cast(str | None, getattr(attachment, "url", None))
-                )
-                filename = cast(
-                    str,
-                    getattr(attachment, "filename", None)
-                    or getattr(attachment, "name", None)
-                    or "attachment",
-                )
+            content_type = cast(
+                str,
+                getattr(attachment, "content_type", "") or "",
+            ).lower()
+            url = QQOfficialPlatformAdapter._normalize_attachment_url(
+                cast(str | None, getattr(attachment, "url", None))
+            )
             if not url:
                 continue
 
             if content_type.startswith("image"):
                 msg.append(Image.fromURL(url))
             else:
+                filename = cast(
+                    str,
+                    getattr(attachment, "filename", None)
+                    or getattr(attachment, "name", None)
+                    or "attachment",
+                )
                 ext = Path(filename).suffix.lower()
                 image_exts = {".jpg", ".jpeg", ".png", ".gif", ".webp", ".bmp"}
                 audio_exts = {
@@ -713,53 +607,6 @@ class QQOfficialPlatformAdapter(Platform):
         abm.message_id = message.id
         # abm.tag = "qq_official"
         msg: list[BaseMessageComponent] = []
-        message_reference = getattr(message, "message_reference", None)
-        quoted_message_id = getattr(message_reference, "message_id", None)
-        raw_message_type = getattr(message, "message_type", None)
-        try:
-            is_quoted_message = int(raw_message_type or 0) == 103
-        except (TypeError, ValueError):
-            is_quoted_message = False
-        msg_elements = getattr(message, "msg_elements", None)
-        quoted_message_str = ""
-        quoted_element_message_id = ""
-        quoted_chain: list[BaseMessageComponent] = []
-        if is_quoted_message and isinstance(msg_elements, list) and msg_elements:
-            quoted_element = msg_elements[0]
-            if isinstance(quoted_element, dict):
-                quoted_content = quoted_element.get("content")
-                quoted_attachments = quoted_element.get("attachments")
-                quoted_element_message_id = str(
-                    quoted_element.get("id") or quoted_element.get("message_id") or "",
-                )
-            else:
-                quoted_content = getattr(quoted_element, "content", None)
-                quoted_attachments = getattr(quoted_element, "attachments", None)
-                quoted_element_message_id = str(
-                    getattr(quoted_element, "id", None)
-                    or getattr(quoted_element, "message_id", None)
-                    or "",
-                )
-
-            quoted_message_str = QQOfficialPlatformAdapter._parse_face_message(
-                str(quoted_content or "").strip()
-            )
-            if quoted_message_str:
-                quoted_chain.append(Plain(quoted_message_str))
-            if isinstance(quoted_attachments, list):
-                await QQOfficialPlatformAdapter._append_attachments(
-                    quoted_chain,
-                    quoted_attachments,
-                )
-        if quoted_message_id or quoted_element_message_id or quoted_chain:
-            msg.append(
-                Reply(
-                    id=str(quoted_message_id or quoted_element_message_id or ""),
-                    chain=quoted_chain,
-                    message_str=quoted_message_str,
-                    text=quoted_message_str,
-                )
-            )
 
         if isinstance(message, botpy.message.GroupMessage) or isinstance(
             message,

astrbot/core/star/star_manager.py

@@ -1295,7 +1295,8 @@ class PluginManager:
                     star_registry.append(metadata)
 
                 # 禁用/启用插件
-                metadata.activated = metadata.module_path not in inactivated_plugins
+                if metadata.module_path in inactivated_plugins:
+                    metadata.activated = False
 
                 # Plugin logo path
                 if os.path.exists(logo_path):
@@ -1933,12 +1934,7 @@ class PluginManager:
         for func_tool in self._iter_plugin_llm_tools(plugin.module_path):
             func_tool.active = func_tool.name not in inactivated_llm_tools
 
-        success, error = await self.reload(plugin_name)
-        if not success:
-            raise Exception(error or f"插件 {plugin_name} 启用失败。")
-        current_plugin = self.context.get_registered_star(plugin_name)
-        if current_plugin:
-            current_plugin.activated = True
+        await self.reload(plugin_name)
 
     async def install_plugin_from_file(
         self, zip_file_path: str, ignore_version_check: bool = False

astrbot/core/utils/event_loop_diagnostics.py

@@ -1,216 +0,0 @@
-import asyncio
-import faulthandler
-from dataclasses import dataclass
-from pathlib import Path
-from typing import TextIO
-
-from astrbot import logger
-from astrbot.core.utils.astrbot_path import get_astrbot_data_path
-
-DEFAULT_LAG_MONITOR_ENABLED = True
-DEFAULT_LAG_MONITOR_INTERVAL = 5.0
-DEFAULT_LAG_MONITOR_THRESHOLD = 15.0
-DEFAULT_WATCHDOG_ENABLED = True
-DEFAULT_WATCHDOG_INTERVAL = 5.0
-DEFAULT_WATCHDOG_TIMEOUT = 30.0
-DEFAULT_WATCHDOG_LOG_RELATIVE_PATH = Path("logs") / "event_loop_watchdog.log"
-DEFAULT_WATCHDOG_LOG_MAX_BYTES = 1024 * 1024
-
-
-@dataclass(frozen=True)
-class EventLoopDiagnosticSettings:
-    """Settings for event loop lag and blockage diagnostics.
-
-    Args:
-        lag_monitor_enabled: Whether to log event loop scheduling lag.
-        lag_monitor_interval: Seconds between lag monitor wakeups.
-        lag_monitor_threshold: Minimum lag seconds before logging a warning.
-        watchdog_enabled: Whether to arm the faulthandler watchdog.
-        watchdog_interval: Seconds between faulthandler watchdog refreshes.
-        watchdog_timeout: Seconds without event loop progress before dumping stacks.
-        watchdog_log_path: File that receives faulthandler watchdog output.
-        watchdog_log_max_bytes: Maximum watchdog log bytes before rotation.
-    """
-
-    lag_monitor_enabled: bool
-    lag_monitor_interval: float
-    lag_monitor_threshold: float
-    watchdog_enabled: bool
-    watchdog_interval: float
-    watchdog_timeout: float
-    watchdog_log_path: Path
-    watchdog_log_max_bytes: int
-
-
-def _watchdog_log_path() -> Path:
-    """Resolve the watchdog stack dump log path.
-
-    Returns:
-        Absolute path for watchdog stack dump output.
-    """
-    return Path(get_astrbot_data_path()) / DEFAULT_WATCHDOG_LOG_RELATIVE_PATH
-
-
-def load_event_loop_diagnostic_settings() -> EventLoopDiagnosticSettings:
-    """Load fixed event loop diagnostic settings.
-
-    Returns:
-        Event loop diagnostic settings.
-    """
-    return EventLoopDiagnosticSettings(
-        lag_monitor_enabled=DEFAULT_LAG_MONITOR_ENABLED,
-        lag_monitor_interval=DEFAULT_LAG_MONITOR_INTERVAL,
-        lag_monitor_threshold=DEFAULT_LAG_MONITOR_THRESHOLD,
-        watchdog_enabled=DEFAULT_WATCHDOG_ENABLED,
-        watchdog_interval=DEFAULT_WATCHDOG_INTERVAL,
-        watchdog_timeout=DEFAULT_WATCHDOG_TIMEOUT,
-        watchdog_log_path=_watchdog_log_path(),
-        watchdog_log_max_bytes=DEFAULT_WATCHDOG_LOG_MAX_BYTES,
-    )
-
-
-async def monitor_event_loop_lag(
-    *,
-    interval: float = DEFAULT_LAG_MONITOR_INTERVAL,
-    warn_after: float = DEFAULT_LAG_MONITOR_THRESHOLD,
-) -> None:
-    """Log a warning when the event loop wakes significantly later than expected.
-
-    Args:
-        interval: Seconds between monitor wakeups.
-        warn_after: Minimum lag seconds before logging a warning.
-    """
-    loop = asyncio.get_running_loop()
-    expected = loop.time() + interval
-    while True:
-        await asyncio.sleep(interval)
-        now = loop.time()
-        lag = now - expected
-        if lag > warn_after:
-            logger.warning(
-                "Event loop lag detected: %.3fs (threshold %.3fs).",
-                lag,
-                warn_after,
-            )
-        expected = now + interval
-
-
-def _rotate_watchdog_log_file(log_path: Path, max_bytes: int) -> None:
-    """Rotate the watchdog log when it reaches the configured size limit.
-
-    Args:
-        log_path: Current watchdog log path.
-        max_bytes: Maximum current log size before rotation.
-    """
-    try:
-        if not log_path.exists() or log_path.stat().st_size < max_bytes:
-            return
-        rotated_path = log_path.with_name(f"{log_path.name}.1")
-        if rotated_path.exists():
-            rotated_path.unlink()
-        log_path.replace(rotated_path)
-    except OSError as e:
-        logger.warning("Failed to rotate event loop watchdog log %s: %s", log_path, e)
-
-
-def _open_watchdog_log_file(log_path: Path, max_bytes: int) -> TextIO:
-    """Open the watchdog log file after applying size-based rotation.
-
-    Args:
-        log_path: Current watchdog log path.
-        max_bytes: Maximum current log size before rotation.
-
-    Returns:
-        Writable text file object for faulthandler output.
-    """
-    log_path.parent.mkdir(parents=True, exist_ok=True)
-    _rotate_watchdog_log_file(log_path, max_bytes)
-    return log_path.open("a", encoding="utf-8")
-
-
-async def faulthandler_event_loop_watchdog(
-    *,
-    timeout: float = DEFAULT_WATCHDOG_TIMEOUT,
-    interval: float = DEFAULT_WATCHDOG_INTERVAL,
-    dump_file: TextIO | None = None,
-    dump_path: Path | None = None,
-    max_bytes: int = DEFAULT_WATCHDOG_LOG_MAX_BYTES,
-) -> None:
-    """Dump all thread stacks if the event loop is blocked for too long.
-
-    Args:
-        timeout: Seconds without watchdog refresh before faulthandler dumps stacks.
-        interval: Seconds between watchdog refreshes while the event loop is healthy.
-        dump_file: File object that receives faulthandler output.
-        dump_path: Path that receives faulthandler output when dump_file is unset.
-        max_bytes: Maximum current log size before rotation.
-    """
-    log_path = dump_path or _watchdog_log_path()
-    try:
-        while True:
-            faulthandler.cancel_dump_traceback_later()
-            output: TextIO | None = None
-            should_close = False
-            try:
-                output = dump_file or _open_watchdog_log_file(log_path, max_bytes)
-                should_close = dump_file is None
-                faulthandler.dump_traceback_later(
-                    timeout,
-                    repeat=False,
-                    file=output,
-                )
-                await asyncio.sleep(interval)
-            except Exception as e:
-                logger.warning("Event loop faulthandler watchdog failed: %s", e)
-                await asyncio.sleep(interval)
-            finally:
-                faulthandler.cancel_dump_traceback_later()
-                if should_close and output is not None:
-                    output.close()
-    finally:
-        faulthandler.cancel_dump_traceback_later()
-
-
-def create_event_loop_diagnostic_tasks() -> list[asyncio.Task]:
-    """Create enabled event loop diagnostic tasks for the current loop.
-
-    Returns:
-        A list of created asyncio tasks.
-    """
-    settings = load_event_loop_diagnostic_settings()
-    tasks: list[asyncio.Task] = []
-
-    if settings.lag_monitor_enabled:
-        tasks.append(
-            asyncio.create_task(
-                monitor_event_loop_lag(
-                    interval=settings.lag_monitor_interval,
-                    warn_after=settings.lag_monitor_threshold,
-                ),
-                name="event_loop_lag_monitor",
-            )
-        )
-
-    if settings.watchdog_enabled:
-        logger.info(
-            "Event loop faulthandler watchdog enabled: timeout=%.3fs interval=%.3fs. "
-            "If the loop is blocked, Python thread stacks will be written to %s "
-            "(rotates at %d bytes).",
-            settings.watchdog_timeout,
-            settings.watchdog_interval,
-            settings.watchdog_log_path,
-            settings.watchdog_log_max_bytes,
-        )
-        tasks.append(
-            asyncio.create_task(
-                faulthandler_event_loop_watchdog(
-                    timeout=settings.watchdog_timeout,
-                    interval=settings.watchdog_interval,
-                    dump_path=settings.watchdog_log_path,
-                    max_bytes=settings.watchdog_log_max_bytes,
-                ),
-                name="event_loop_faulthandler_watchdog",
-            )
-        )
-
-    return tasks

astrbot/dashboard/services/chat_service.py

@@ -345,23 +345,6 @@ def serialize_thread(thread) -> dict:
     }
 
 
-def serialize_history_entry(history) -> dict:
-    """Serialize a PlatformMessageHistory record with UTC-aware timestamps.
-
-    Args:
-        history: A PlatformMessageHistory instance. Must not be None.
-
-    Returns:
-        Dict with all model fields plus created_at/updated_at serialized as
-        UTC-aware ISO strings (e.g. ``2026-07-06T04:00:00+00:00``).
-    """
-    return {
-        **history.model_dump(),
-        "created_at": to_utc_isoformat(history.created_at),
-        "updated_at": to_utc_isoformat(history.updated_at),
-    }
-
-
 def find_checkpoint_index(history: list[dict], checkpoint_id: str) -> int | None:
     for index, message in enumerate(history):
         if get_checkpoint_id(message) == checkpoint_id:
@@ -1234,7 +1217,7 @@ class ChatService:
         )
 
         response_data = {
-            "history": [serialize_history_entry(history) for history in history_ls],
+            "history": [history.model_dump() for history in history_ls],
             "threads": [serialize_thread(thread) for thread in threads],
             "is_running": self.running_convs.get(session_id, False),
         }
@@ -1350,7 +1333,7 @@ class ChatService:
         )
         return {
             "thread": serialize_thread(thread),
-            "history": [serialize_history_entry(history) for history in history_ls],
+            "history": [history.model_dump() for history in history_ls],
             "is_running": self.running_convs.get(thread_id, False),
         }
 
@@ -1504,7 +1487,7 @@ class ChatService:
         await self.db.update_platform_session(session_id=session_id)
         updated = await self.db.get_platform_message_history_by_id(message_id)
         return {
-            "message": serialize_history_entry(updated) if updated else None,
+            "message": updated.model_dump() if updated else None,
             "needs_regenerate": True,
             "truncated_after_message": True,
         }

dashboard/src/components/chat/Chat.vue

@@ -357,7 +357,6 @@
             :is-running="
               Boolean(currSessionId && isSessionRunning(currSessionId))
             "
-            :token-usage="tokenUsageIndicator"
             :session-id="currSessionId || null"
             :current-session="currentSession"
             :reply-to="chatInputReplyTarget"
@@ -441,7 +440,6 @@
             :is-running="
               Boolean(currSessionId && isSessionRunning(currSessionId))
             "
-            :token-usage="tokenUsageIndicator"
             :session-id="currSessionId || null"
             :current-session="currentSession"
             :reply-to="chatInputReplyTarget"
@@ -563,7 +561,7 @@ import {
   Sun,
   Trash2,
 } from "@lucide/vue";
-import { chatApi, providerApi } from "@/api/v1";
+import { chatApi } from "@/api/v1";
 import StyledMenu from "@/components/shared/StyledMenu.vue";
 import ProjectDialog, {
   type ProjectFormData,
@@ -599,12 +597,6 @@ import {
 } from "@/i18n/composables";
 import type { Locale } from "@/i18n/types";
 import { askForConfirmation, useConfirmDialog } from "@/utils/confirmDialog";
-import {
-  contextLimit,
-  formatTokenCount,
-  type ProviderModelMetadata,
-  type ProviderMetadataSource,
-} from "@/utils/providerMetadata";
 import { useToast } from "@/utils/toast";
 
 const props = withDefaults(defineProps<{ chatboxMode?: boolean; active?: boolean }>(), {
@@ -660,11 +652,6 @@ const {
 
 type WorkspaceView = "chat" | "providers";
 
-interface TokenProviderConfig extends ProviderMetadataSource {
-  id: string;
-  enable?: boolean;
-}
-
 const activeWorkspace = ref<WorkspaceView>("chat");
 const projectDialogOpen = ref(false);
 const editingProject = ref<Project | null>(null);
@@ -683,9 +670,6 @@ const projectSessionsById = ref<Record<string, Session[]>>({});
 const loadingProjectSessionIds = ref<string[]>([]);
 const loadingSessions = ref(false);
 const draft = ref("");
-const tokenProviderConfigs = ref<TokenProviderConfig[]>([]);
-const tokenModelMetadata = ref<Record<string, ProviderModelMetadata>>({});
-const selectedTokenProviderId = ref("");
 const messagesContainer = ref<HTMLElement | null>(null);
 const inputRef = ref<InstanceType<typeof ChatInput> | null>(null);
 const shouldStickToBottom = ref(true);
@@ -857,58 +841,15 @@ const chatInputReplyTarget = computed(() =>
         selectedText: replyPreview(replyTarget.value.id, ""),
       },
 );
-const currentTokenProvider = computed(() => {
-  const selectedProvider = tokenProviderConfigs.value.find(
-    (provider) => provider.id === selectedTokenProviderId.value,
-  );
-  return selectedProvider || tokenProviderConfigs.value[0] || null;
-});
-const currentTokenMetadata = computed(() => {
-  const model = currentTokenProvider.value?.model;
-  return model ? tokenModelMetadata.value[model] || null : null;
-});
-const latestTokenUsageTotal = computed(() => {
-  for (let index = activeMessages.value.length - 1; index >= 0; index -= 1) {
-    const message = activeMessages.value[index];
-    if (isUserMessage(message)) continue;
-    const usage = message.content?.agentStats?.token_usage;
-    if (!usage) continue;
-    return (
-      readTokenCount(usage.input_other) +
-      readTokenCount(usage.input_cached) +
-      readTokenCount(usage.output)
-    );
-  }
-  return 0;
-});
-const tokenUsageIndicator = computed(() => {
-  const used = latestTokenUsageTotal.value;
-  const limit = contextLimit(currentTokenProvider.value, currentTokenMetadata.value);
-  if (used <= 0 || limit <= 0) return null;
-
-  const percent = (used / limit) * 100;
-  return {
-    used,
-    limit,
-    percent: Math.min(100, Math.max(0, percent)),
-    tooltip: tm("tokenUsage.tooltip", {
-      used: formatTokenCount(used),
-      limit: formatTokenCount(limit),
-      percent: formatUsagePercent(percent),
-    }),
-  };
-});
 
 function getSelectedProviderSelection() {
   const inputSelection = inputRef.value?.getCurrentSelection();
   if (inputSelection?.providerId) {
-    selectedTokenProviderId.value = inputSelection.providerId;
     return inputSelection;
   }
   if (typeof window === "undefined") {
     return { providerId: "", modelName: "" };
   }
-  syncSelectedTokenProvider();
   return {
     providerId: localStorage.getItem("selectedProvider") || "",
     modelName: localStorage.getItem("selectedProviderModel") || "",
@@ -928,7 +869,7 @@ watch(
 onMounted(async () => {
   loadingSessions.value = true;
   try {
-    await Promise.all([getSessions(), getProjects(), loadTokenProviders()]);
+    await Promise.all([getSessions(), getProjects()]);
     const routeSessionId = getRouteSessionId();
     if (routeSessionId === "models") {
       activeWorkspace.value = "providers";
@@ -1013,40 +954,6 @@ function sessionTitle(session: Session) {
   return session.display_name?.trim() || tm("conversation.newConversation");
 }
 
-function syncSelectedTokenProvider() {
-  if (typeof window === "undefined") return;
-  selectedTokenProviderId.value = localStorage.getItem("selectedProvider") || "";
-}
-
-async function loadTokenProviders() {
-  syncSelectedTokenProvider();
-  try {
-    const response = await providerApi.listByProviderType("chat_completion");
-    if (response.data.status === "ok") {
-      tokenModelMetadata.value = (
-        (response.data as any).model_metadata || {}
-      ) as Record<string, ProviderModelMetadata>;
-      tokenProviderConfigs.value = (
-        (response.data.data || []) as unknown as TokenProviderConfig[]
-      ).filter((provider) => provider.enable !== false);
-    }
-  } catch (error) {
-    console.error("Failed to load provider context metadata:", error);
-  }
-}
-
-function readTokenCount(value: unknown) {
-  const count = Number(value || 0);
-  return Number.isFinite(count) && count > 0 ? count : 0;
-}
-
-function formatUsagePercent(value: number) {
-  if (!Number.isFinite(value) || value <= 0) return "0";
-  if (value >= 10) return String(Math.round(value));
-  if (value >= 1) return String(Math.round(value * 10) / 10);
-  return String(Math.round(value * 100) / 100);
-}
-
 async function startNewChat() {
   showChatWorkspace();
   selectedProjectId.value = null;

dashboard/src/components/chat/ChatInput.vue

@@ -242,27 +242,6 @@
             class="mr-1"
             width="1.5"
           />
-          <v-tooltip
-            v-if="tokenUsageVisible"
-            location="top"
-            max-width="320"
-          >
-            <template #activator="{ props: tokenTooltipProps }">
-              <span
-                v-bind="tokenTooltipProps"
-                class="token-usage-indicator"
-                :style="{ '--token-usage-color': tokenUsageColor }"
-              >
-                <v-progress-circular
-                  :model-value="tokenUsagePercent"
-                  size="24"
-                  width="2.5"
-                  class="token-usage-progress"
-                />
-              </span>
-            </template>
-            <span>{{ props.tokenUsage?.tooltip }}</span>
-          </v-tooltip>
           <!-- <v-btn @click="$emit('openLiveMode')"
                         icon
                         variant="text"
@@ -353,13 +332,6 @@ interface ReplyInfo {
   selectedText?: string;
 }
 
-interface TokenUsageInfo {
-  used: number;
-  limit: number;
-  percent: number;
-  tooltip: string;
-}
-
 interface Props {
   prompt: string;
   stagedImagesUrl: string[];
@@ -375,7 +347,6 @@ interface Props {
   replyTo?: ReplyInfo | null;
   sendShortcut?: "enter" | "shift_enter";
   showProviderSelector?: boolean;
-  tokenUsage?: TokenUsageInfo | null;
 }
 
 const props = withDefaults(defineProps<Props>(), {
@@ -386,7 +357,6 @@ const props = withDefaults(defineProps<Props>(), {
   replyTo: null,
   sendShortcut: "shift_enter",
   showProviderSelector: true,
-  tokenUsage: null,
 });
 
 const emit = defineEmits<{
@@ -599,29 +569,6 @@ function handleReplyAfterLeave() {
 
 const { mobile } = useDisplay();
 
-const tokenUsageVisible = computed(() => {
-  const usage = props.tokenUsage;
-  return Boolean(
-    usage &&
-      Number.isFinite(usage.used) &&
-      Number.isFinite(usage.limit) &&
-      usage.used > 0 &&
-      usage.limit > 0,
-  );
-});
-
-const tokenUsagePercent = computed(() => {
-  const percent = props.tokenUsage?.percent || 0;
-  if (!Number.isFinite(percent)) return 0;
-  return Math.min(100, Math.max(0, percent));
-});
-
-const tokenUsageColor = computed(() =>
-  isDark.value
-    ? "rgba(var(--v-theme-on-surface), 0.82)"
-    : "rgba(var(--v-theme-on-surface), 0.72)",
-);
-
 // Auto-resize textarea
 function autoResize() {
   const el = inputField.value;
@@ -1049,31 +996,6 @@ defineExpose({
   background: rgba(var(--v-theme-on-surface), 0.04) !important;
 }
 
-.token-usage-indicator {
-  width: 24px;
-  height: 24px;
-  display: inline-flex;
-  align-items: center;
-  justify-content: center;
-  flex: 0 0 24px;
-  border-radius: 50%;
-  color: var(--token-usage-color);
-}
-
-.token-usage-progress {
-  color: currentColor;
-}
-
-.token-usage-progress :deep(.v-progress-circular__underlay) {
-  color: rgba(var(--v-theme-on-surface), 0.18);
-  stroke: currentColor;
-  opacity: 0.24;
-}
-
-.token-usage-progress :deep(.v-progress-circular__overlay) {
-  stroke: currentColor;
-}
-
 .input-outline-control {
   width: 36px !important;
   height: 36px !important;

dashboard/src/i18n/locales/en-US/features/chat.json

@@ -156,9 +156,6 @@
     "duration": "Duration",
     "ttft": "Time to First Token"
   },
-  "tokenUsage": {
-    "tooltip": "{used} / {limit} tokens ({percent}%)"
-  },
   "refs": {
     "title": "References",
     "sources": "Sources"

dashboard/src/i18n/locales/ru-RU/features/chat.json

@@ -156,9 +156,6 @@
     "duration": "Время",
     "ttft": "Время до первого токена"
   },
-  "tokenUsage": {
-    "tooltip": "{used} / {limit} токенов ({percent}%)"
-  },
   "refs": {
     "title": "Ссылки",
     "sources": "Источники"

dashboard/src/i18n/locales/zh-CN/features/chat.json

@@ -156,9 +156,6 @@
     "duration": "耗时",
     "ttft": "首字时间"
   },
-  "tokenUsage": {
-    "tooltip": "{used} / {limit} tokens（{percent}%）"
-  },
   "refs": {
     "title": "引用",
     "sources": "来源"

dashboard/src/utils/providerMetadata.ts

@@ -19,28 +19,15 @@ export interface ProviderCapabilityBadge {
   tooltip: string
 }
 
-export function contextLimit(
-  provider: ProviderMetadataSource | null | undefined,
-  metadata?: ProviderModelMetadata | null
-): number {
-  const context = Number(metadata?.limit?.context || provider?.max_context_tokens || 0)
-  return Number.isFinite(context) && context > 0 ? context : 0
-}
-
-export function formatTokenCount(value: number): string {
-  if (!Number.isFinite(value)) return ''
-  const absValue = Math.abs(value)
-  if (absValue >= 1_000_000) return `${formatCompactNumber(value / 1_000_000)}M`
-  if (absValue >= 1_000) return `${formatCompactNumber(value / 1_000)}K`
-  return `${Math.round(value)}`
-}
-
 export function formatContextLimit(
   provider: ProviderMetadataSource | null | undefined,
   metadata?: ProviderModelMetadata | null
 ): string {
-  const context = contextLimit(provider, metadata)
-  return context ? formatTokenCount(context) : ''
+  const context = metadata?.limit?.context || provider?.max_context_tokens
+  if (!context || typeof context !== 'number') return ''
+  if (context >= 1_000_000) return `${Math.round(context / 1_000_000)}M`
+  if (context >= 1_000) return `${Math.round(context / 1_000)}K`
+  return `${context}`
 }
 
 export function providerCapabilityBadges(
@@ -94,9 +81,3 @@ export function providerCapabilityBadges(
           : tm('models.metadata.enabled', { capability: item.label })
     }))
 }
-
-function formatCompactNumber(value: number): string {
-  const absValue = Math.abs(value)
-  const rounded = absValue >= 10 ? Math.round(value) : Math.round(value * 10) / 10
-  return String(rounded).replace(/\.0$/, '')
-}

dashboard/src/views/extension/useExtensionPage.js

@@ -1043,12 +1043,9 @@ export const useExtensionPage = () => {
   };
 
   const pluginOn = async (extension) => {
-    const previousActivated = extension.activated;
-    extension.activated = true;
     try {
       const res = await pluginApi.setEnabled(extension.name, true);
       if (res.data.status === "error") {
-        extension.activated = previousActivated;
         toast(res.data.message, "error");
         return;
       }
@@ -1057,25 +1054,20 @@ export const useExtensionPage = () => {
 
       await checkAndPromptConflicts();
     } catch (err) {
-      extension.activated = previousActivated;
       toast(err, "error");
     }
   };
 
   const pluginOff = async (extension) => {
-    const previousActivated = extension.activated;
-    extension.activated = false;
     try {
       const res = await pluginApi.setEnabled(extension.name, false);
       if (res.data.status === "error") {
-        extension.activated = previousActivated;
         toast(res.data.message, "error");
         return;
       }
       toast(res.data.message, "success");
-      await getExtensions();
+      getExtensions();
     } catch (err) {
-      extension.activated = previousActivated;
       toast(err, "error");
     }
   };

pyproject.toml

@@ -42,7 +42,7 @@ dependencies = [
   "qrcode>=8.2",
   "quart>=0.20.0",
   "python-telegram-bot>=22.6",
-  "qq-botpy==1.2.1",
+  "qq-botpy>=1.2.1",
   "silk-python>=0.2.6",
   "slack-sdk>=3.35.0",
   "sqlalchemy[asyncio]>=2.0.41",

requirements.txt

@@ -29,7 +29,7 @@ pydantic>=2.12.5
 pydub>=0.25.1
 pyjwt>=2.10.1
 python-telegram-bot>=22.6
-qq-botpy==1.2.1
+qq-botpy>=1.2.1
 python-socks>=2.8.0
 silk-python>=0.2.6
 slack-sdk>=3.35.0

tests/test_plugin_manager.py

@@ -2,7 +2,6 @@ import asyncio
 import json
 import os
 from pathlib import Path
-from types import ModuleType
 from typing import Any, cast
 
 import pytest
@@ -1982,89 +1981,6 @@ async def test_uninstall_failed_plugin_without_plugin_id_in_record(
 # --- reload + deactivated plugin regression tests ---
 
 
-@pytest.mark.asyncio
-@pytest.mark.parametrize(
-    ("inactivated_plugins", "expected_activated"),
-    [
-        ([], True),
-        (["data.plugins.demo_plugin.main"], False),
-    ],
-)
-async def test_load_syncs_existing_metadata_activation_from_preferences(
-    plugin_manager_pm: PluginManager,
-    monkeypatch,
-    inactivated_plugins: list[str],
-    expected_activated: bool,
-):
-    """Existing plugin metadata activation follows persisted preferences."""
-    _clear_star_runtime_state()
-    plugin_name = "demo_plugin"
-    module_path = f"data.plugins.{plugin_name}.main"
-    metadata = star_manager_module.StarMetadata(
-        name=plugin_name,
-        author="AstrBot Team",
-        desc="Demo plugin",
-        version="1.0.0",
-        root_dir_name=plugin_name,
-        module_path=module_path,
-        activated=False,
-    )
-    star_manager_module.star_map[module_path] = metadata
-    star_manager_module.star_registry.append(metadata)
-    preferences = {
-        "inactivated_plugins": inactivated_plugins,
-        "inactivated_llm_tools": [],
-        "alter_cmd": {},
-    }
-
-    async def mock_global_get(key, default=None):
-        return preferences.get(key, default)
-
-    async def mock_import_plugin_with_dependency_recovery(
-        path,
-        module_str,
-        root_dir_name,
-        requirements_path,
-        *,
-        reserved=False,
-    ):
-        del module_str, root_dir_name, requirements_path, reserved
-        assert path == module_path
-        return ModuleType(module_path)
-
-    async def mock_sync_command_configs():
-        return None
-
-    monkeypatch.setattr(star_manager_module.sp, "global_get", mock_global_get)
-    monkeypatch.setattr(
-        plugin_manager_pm,
-        "_get_plugin_modules",
-        lambda: [{"pname": plugin_name, "module": "main"}],
-    )
-    monkeypatch.setattr(
-        plugin_manager_pm,
-        "_import_plugin_with_dependency_recovery",
-        mock_import_plugin_with_dependency_recovery,
-    )
-    monkeypatch.setattr(plugin_manager_pm, "_load_plugin_metadata", lambda **_: None)
-    monkeypatch.setattr(
-        star_manager_module,
-        "sync_command_configs",
-        mock_sync_command_configs,
-    )
-
-    try:
-        success, error = await plugin_manager_pm.load(
-            specified_module_path=module_path,
-        )
-
-        assert success is True
-        assert error is None
-        assert metadata.activated is expected_activated
-    finally:
-        _clear_star_runtime_state()
-
-
 @pytest.mark.asyncio
 async def test_reload_deactivated_plugin_preserves_tools(
     plugin_manager_pm: PluginManager, monkeypatch
@@ -2240,6 +2156,9 @@ async def test_turn_on_plugin_after_deactivated_reload_reactivates_tools(
 
     async def mock_reload(plugin_name_arg):
         assert plugin_name_arg == plugin_name
+        # Simulate what load() does: re-register with activated=True
+        # since it's no longer in inactivated_plugins
+        plugin.activated = True
         return True, None
 
     monkeypatch.setattr(star_manager_module.sp, "global_get", mock_global_get)

tests/test_qqofficial_group_message_create.py

@@ -10,7 +10,7 @@ import pytest
 from botpy import ConnectionSession
 
 from astrbot.api.event import MessageChain
-from astrbot.api.message_components import At, Image, Plain, Reply
+from astrbot.api.message_components import At, Plain
 from astrbot.core.message.message_event_result import (
     MessageEventResult,
     ResultContentType,
@@ -38,11 +38,8 @@ def _make_group_payload(
     mentions: list[dict] | None = None,
     member_openid: str = "member-1",
     group_openid: str = "group-1",
-    message_type: int | None = None,
-    msg_elements: list[dict] | None = None,
-    message_reference: dict | None = None,
 ) -> dict:
-    data = {
+    return {
         "id": f"event-{message_id}",
         "d": {
             "id": message_id,
@@ -53,13 +50,6 @@ def _make_group_payload(
             "attachments": [],
         },
     }
-    if message_type is not None:
-        data["d"]["message_type"] = message_type
-    if msg_elements is not None:
-        data["d"]["msg_elements"] = msg_elements
-    if message_reference is not None:
-        data["d"]["message_reference"] = message_reference
-    return data
 
 
 def _dispatch_group_message(payload: dict) -> tuple[str, botpy.message.GroupMessage]:
@@ -118,49 +108,6 @@ async def test_parse_group_message_create_plain_message_has_no_at_component():
     ] == ["plain group message"]
 
 
-@pytest.mark.asyncio
-async def test_parse_group_message_create_quoted_context():
-    _, message = _dispatch_group_message(
-        _make_group_payload(
-            content="answer",
-            message_type=103,
-            message_reference={"message_id": "quoted-1"},
-            msg_elements=[
-                {
-                    "content": "quoted text",
-                    "attachments": [
-                        {
-                            "content_type": "image/png",
-                            "filename": "quoted.png",
-                            "url": "img.example.com/quoted.png",
-                        }
-                    ],
-                }
-            ],
-        )
-    )
-
-    abm = await QQOfficialPlatformAdapter._parse_from_qqofficial(
-        message,
-        MessageType.GROUP_MESSAGE,
-    )
-
-    assert getattr(message, "message_type") == 103
-    assert getattr(message, "msg_elements")[0]["content"] == "quoted text"
-    reply = abm.message[0]
-    assert isinstance(reply, Reply)
-    assert reply.id == "quoted-1"
-    assert reply.message_str == "quoted text"
-    assert isinstance(reply.chain[0], Plain)
-    assert reply.chain[0].text == "quoted text"
-    assert isinstance(reply.chain[1], Image)
-    assert reply.chain[1].file == "https://img.example.com/quoted.png"
-    assert abm.message_str == "answer"
-    assert [
-        component.text for component in abm.message if isinstance(component, Plain)
-    ][-1] == "answer"
-
-
 @pytest.mark.asyncio
 async def test_parse_group_message_create_bot_mention_cleans_plain_text():
     _, message = _dispatch_group_message(

tests/unit/test_event_loop_diagnostics.py

@@ -1,134 +0,0 @@
-import asyncio
-
-import pytest
-
-from astrbot.core.utils import event_loop_diagnostics as diagnostics
-
-
-def test_load_event_loop_diagnostic_settings_defaults():
-    """Default settings enable lag monitoring and stack dump watchdog."""
-    settings = diagnostics.load_event_loop_diagnostic_settings()
-
-    assert settings.lag_monitor_enabled is True
-    assert settings.lag_monitor_interval == diagnostics.DEFAULT_LAG_MONITOR_INTERVAL
-    assert settings.lag_monitor_threshold == diagnostics.DEFAULT_LAG_MONITOR_THRESHOLD
-    assert settings.watchdog_enabled is True
-    assert settings.watchdog_interval == diagnostics.DEFAULT_WATCHDOG_INTERVAL
-    assert settings.watchdog_timeout == diagnostics.DEFAULT_WATCHDOG_TIMEOUT
-    assert settings.watchdog_log_max_bytes == diagnostics.DEFAULT_WATCHDOG_LOG_MAX_BYTES
-
-
-@pytest.mark.asyncio
-async def test_create_event_loop_diagnostic_tasks_defaults():
-    """Default diagnostics should create both event loop diagnostic tasks."""
-    tasks = diagnostics.create_event_loop_diagnostic_tasks()
-
-    try:
-        assert [task.get_name() for task in tasks] == [
-            "event_loop_lag_monitor",
-            "event_loop_faulthandler_watchdog",
-        ]
-    finally:
-        for task in tasks:
-            task.cancel()
-        await asyncio.gather(*tasks, return_exceptions=True)
-
-
-@pytest.mark.asyncio
-async def test_faulthandler_watchdog_cancels_pending_dump(monkeypatch):
-    """The faulthandler watchdog should cancel its pending dump on shutdown."""
-    calls = []
-
-    class FakeFaultHandler:
-        def cancel_dump_traceback_later(self):
-            calls.append("cancel")
-
-        def dump_traceback_later(self, timeout, repeat, file):
-            calls.append(("dump", timeout, repeat, file))
-
-    fake_faulthandler = FakeFaultHandler()
-    monkeypatch.setattr(diagnostics, "faulthandler", fake_faulthandler)
-
-    task = asyncio.create_task(
-        diagnostics.faulthandler_event_loop_watchdog(timeout=10, interval=1)
-    )
-    await asyncio.sleep(0)
-    task.cancel()
-    await asyncio.gather(task, return_exceptions=True)
-
-    assert any(isinstance(call, tuple) and call[0] == "dump" for call in calls)
-    assert calls[-1] == "cancel"
-
-
-@pytest.mark.asyncio
-async def test_faulthandler_watchdog_writes_rotating_log(tmp_path, monkeypatch):
-    """The faulthandler watchdog should write to and rotate its log file."""
-    log_path = tmp_path / "logs" / "event_loop_watchdog.log"
-    log_path.parent.mkdir()
-    log_path.write_text("x" * 8, encoding="utf-8")
-    calls = []
-
-    class FakeFaultHandler:
-        def cancel_dump_traceback_later(self):
-            calls.append("cancel")
-
-        def dump_traceback_later(self, timeout, repeat, file):
-            calls.append(("dump", timeout, repeat, file.name))
-            file.write("watchdog dump\n")
-            file.flush()
-
-    fake_faulthandler = FakeFaultHandler()
-    monkeypatch.setattr(diagnostics, "faulthandler", fake_faulthandler)
-
-    task = asyncio.create_task(
-        diagnostics.faulthandler_event_loop_watchdog(
-            timeout=10,
-            interval=1,
-            dump_path=log_path,
-            max_bytes=4,
-        )
-    )
-    await asyncio.sleep(0)
-    task.cancel()
-    await asyncio.gather(task, return_exceptions=True)
-
-    assert log_path.read_text(encoding="utf-8") == "watchdog dump\n"
-    assert log_path.with_name("event_loop_watchdog.log.1").read_text(
-        encoding="utf-8"
-    ) == "x" * 8
-    assert any(isinstance(call, tuple) and call[0] == "dump" for call in calls)
-
-
-@pytest.mark.asyncio
-async def test_faulthandler_watchdog_survives_dump_failure(tmp_path, monkeypatch):
-    """The watchdog should keep running after faulthandler arm failures."""
-    log_path = tmp_path / "event_loop_watchdog.log"
-    armed_again = asyncio.Event()
-    calls = []
-
-    class FakeFaultHandler:
-        def cancel_dump_traceback_later(self):
-            calls.append("cancel")
-
-        def dump_traceback_later(self, timeout, repeat, file):
-            calls.append(("dump", timeout, repeat, file.name))
-            if len([call for call in calls if isinstance(call, tuple)]) == 1:
-                raise RuntimeError("boom")
-            armed_again.set()
-
-    fake_faulthandler = FakeFaultHandler()
-    monkeypatch.setattr(diagnostics, "faulthandler", fake_faulthandler)
-
-    task = asyncio.create_task(
-        diagnostics.faulthandler_event_loop_watchdog(
-            timeout=10,
-            interval=0.01,
-            dump_path=log_path,
-        )
-    )
-    await asyncio.wait_for(armed_again.wait(), timeout=1)
-    task.cancel()
-    await asyncio.gather(task, return_exceptions=True)
-
-    dump_calls = [call for call in calls if isinstance(call, tuple)]
-    assert len(dump_calls) >= 2