AstrBot 3.5.6__py3-none-any.whl → 4.7.0__py3-none-any.whl

astrbot/core/star/session_llm_manager.py

@@ -0,0 +1,280 @@
+"""会话服务管理器 - 负责管理每个会话的LLM、TTS等服务的启停状态"""
+
+from astrbot.core import logger, sp
+from astrbot.core.platform.astr_message_event import AstrMessageEvent
+
+
+class SessionServiceManager:
+    """管理会话级别的服务启停状态，包括LLM和TTS"""
+
+    # =============================================================================
+    # LLM 相关方法
+    # =============================================================================
+
+    @staticmethod
+    def is_llm_enabled_for_session(session_id: str) -> bool:
+        """检查LLM是否在指定会话中启用
+
+        Args:
+            session_id: 会话ID (unified_msg_origin)
+
+        Returns:
+            bool: True表示启用，False表示禁用
+
+        """
+        # 获取会话服务配置
+        session_services = sp.get(
+            "session_service_config",
+            {},
+            scope="umo",
+            scope_id=session_id,
+        )
+
+        # 如果配置了该会话的LLM状态，返回该状态
+        llm_enabled = session_services.get("llm_enabled")
+        if llm_enabled is not None:
+            return llm_enabled
+
+        # 如果没有配置，默认为启用（兼容性考虑）
+        return True
+
+    @staticmethod
+    def set_llm_status_for_session(session_id: str, enabled: bool) -> None:
+        """设置LLM在指定会话中的启停状态
+
+        Args:
+            session_id: 会话ID (unified_msg_origin)
+            enabled: True表示启用，False表示禁用
+
+        """
+        session_config = (
+            sp.get("session_service_config", {}, scope="umo", scope_id=session_id) or {}
+        )
+        session_config["llm_enabled"] = enabled
+        sp.put(
+            "session_service_config",
+            session_config,
+            scope="umo",
+            scope_id=session_id,
+        )
+
+    @staticmethod
+    def should_process_llm_request(event: AstrMessageEvent) -> bool:
+        """检查是否应该处理LLM请求
+
+        Args:
+            event: 消息事件
+
+        Returns:
+            bool: True表示应该处理，False表示跳过
+
+        """
+        session_id = event.unified_msg_origin
+        return SessionServiceManager.is_llm_enabled_for_session(session_id)
+
+    # =============================================================================
+    # TTS 相关方法
+    # =============================================================================
+
+    @staticmethod
+    def is_tts_enabled_for_session(session_id: str) -> bool:
+        """检查TTS是否在指定会话中启用
+
+        Args:
+            session_id: 会话ID (unified_msg_origin)
+
+        Returns:
+            bool: True表示启用，False表示禁用
+
+        """
+        # 获取会话服务配置
+        session_services = sp.get(
+            "session_service_config",
+            {},
+            scope="umo",
+            scope_id=session_id,
+        )
+
+        # 如果配置了该会话的TTS状态，返回该状态
+        tts_enabled = session_services.get("tts_enabled")
+        if tts_enabled is not None:
+            return tts_enabled
+
+        # 如果没有配置，默认为启用（兼容性考虑）
+        return True
+
+    @staticmethod
+    def set_tts_status_for_session(session_id: str, enabled: bool) -> None:
+        """设置TTS在指定会话中的启停状态
+
+        Args:
+            session_id: 会话ID (unified_msg_origin)
+            enabled: True表示启用，False表示禁用
+
+        """
+        session_config = (
+            sp.get("session_service_config", {}, scope="umo", scope_id=session_id) or {}
+        )
+        session_config["tts_enabled"] = enabled
+        sp.put(
+            "session_service_config",
+            session_config,
+            scope="umo",
+            scope_id=session_id,
+        )
+
+        logger.info(
+            f"会话 {session_id} 的TTS状态已更新为: {'启用' if enabled else '禁用'}",
+        )
+
+    @staticmethod
+    def should_process_tts_request(event: AstrMessageEvent) -> bool:
+        """检查是否应该处理TTS请求
+
+        Args:
+            event: 消息事件
+
+        Returns:
+            bool: True表示应该处理，False表示跳过
+
+        """
+        session_id = event.unified_msg_origin
+        return SessionServiceManager.is_tts_enabled_for_session(session_id)
+
+    # =============================================================================
+    # 会话整体启停相关方法
+    # =============================================================================
+
+    @staticmethod
+    def is_session_enabled(session_id: str) -> bool:
+        """检查会话是否整体启用
+
+        Args:
+            session_id: 会话ID (unified_msg_origin)
+
+        Returns:
+            bool: True表示启用，False表示禁用
+
+        """
+        # 获取会话服务配置
+        session_services = sp.get(
+            "session_service_config",
+            {},
+            scope="umo",
+            scope_id=session_id,
+        )
+
+        # 如果配置了该会话的整体状态，返回该状态
+        session_enabled = session_services.get("session_enabled")
+        if session_enabled is not None:
+            return session_enabled
+
+        # 如果没有配置，默认为启用（兼容性考虑）
+        return True
+
+    @staticmethod
+    def set_session_status(session_id: str, enabled: bool) -> None:
+        """设置会话的整体启停状态
+
+        Args:
+            session_id: 会话ID (unified_msg_origin)
+            enabled: True表示启用，False表示禁用
+
+        """
+        session_config = (
+            sp.get("session_service_config", {}, scope="umo", scope_id=session_id) or {}
+        )
+        session_config["session_enabled"] = enabled
+        sp.put(
+            "session_service_config",
+            session_config,
+            scope="umo",
+            scope_id=session_id,
+        )
+
+        logger.info(
+            f"会话 {session_id} 的整体状态已更新为: {'启用' if enabled else '禁用'}",
+        )
+
+    @staticmethod
+    def should_process_session_request(event: AstrMessageEvent) -> bool:
+        """检查是否应该处理会话请求（会话整体启停检查）
+
+        Args:
+            event: 消息事件
+
+        Returns:
+            bool: True表示应该处理，False表示跳过
+
+        """
+        session_id = event.unified_msg_origin
+        return SessionServiceManager.is_session_enabled(session_id)
+
+    # =============================================================================
+    # 会话命名相关方法
+    # =============================================================================
+
+    @staticmethod
+    def get_session_custom_name(session_id: str) -> str | None:
+        """获取会话的自定义名称
+
+        Args:
+            session_id: 会话ID (unified_msg_origin)
+
+        Returns:
+            str: 自定义名称，如果没有设置则返回None
+
+        """
+        session_services = sp.get(
+            "session_service_config",
+            {},
+            scope="umo",
+            scope_id=session_id,
+        )
+        return session_services.get("custom_name")
+
+    @staticmethod
+    def set_session_custom_name(session_id: str, custom_name: str) -> None:
+        """设置会话的自定义名称
+
+        Args:
+            session_id: 会话ID (unified_msg_origin)
+            custom_name: 自定义名称，可以为空字符串来清除名称
+
+        """
+        session_config = (
+            sp.get("session_service_config", {}, scope="umo", scope_id=session_id) or {}
+        )
+        if custom_name and custom_name.strip():
+            session_config["custom_name"] = custom_name.strip()
+        else:
+            # 如果传入空名称，则删除自定义名称
+            session_config.pop("custom_name", None)
+        sp.put(
+            "session_service_config",
+            session_config,
+            scope="umo",
+            scope_id=session_id,
+        )
+
+        logger.info(
+            f"会话 {session_id} 的自定义名称已更新为: {custom_name.strip() if custom_name and custom_name.strip() else '已清除'}",
+        )
+
+    @staticmethod
+    def get_session_display_name(session_id: str) -> str:
+        """获取会话的显示名称（优先显示自定义名称，否则显示原始session_id的最后一段）
+
+        Args:
+            session_id: 会话ID (unified_msg_origin)
+
+        Returns:
+            str: 显示名称
+
+        """
+        custom_name = SessionServiceManager.get_session_custom_name(session_id)
+        if custom_name:
+            return custom_name
+
+        # 如果没有自定义名称，返回session_id的最后一段
+        return session_id.split(":")[2] if session_id.count(":") >= 2 else session_id

astrbot/core/star/session_plugin_manager.py

@@ -0,0 +1,170 @@
+"""会话插件管理器 - 负责管理每个会话的插件启停状态"""
+
+from astrbot.core import logger, sp
+from astrbot.core.platform.astr_message_event import AstrMessageEvent
+
+
+class SessionPluginManager:
+    """管理会话级别的插件启停状态"""
+
+    @staticmethod
+    def is_plugin_enabled_for_session(session_id: str, plugin_name: str) -> bool:
+        """检查插件是否在指定会话中启用
+
+        Args:
+            session_id: 会话ID (unified_msg_origin)
+            plugin_name: 插件名称
+
+        Returns:
+            bool: True表示启用，False表示禁用
+
+        """
+        # 获取会话插件配置
+        session_plugin_config = sp.get(
+            "session_plugin_config",
+            {},
+            scope="umo",
+            scope_id=session_id,
+        )
+        session_config = session_plugin_config.get(session_id, {})
+
+        enabled_plugins = session_config.get("enabled_plugins", [])
+        disabled_plugins = session_config.get("disabled_plugins", [])
+
+        # 如果插件在禁用列表中，返回False
+        if plugin_name in disabled_plugins:
+            return False
+
+        # 如果插件在启用列表中，返回True
+        if plugin_name in enabled_plugins:
+            return True
+
+        # 如果都没有配置，默认为启用（兼容性考虑）
+        return True
+
+    @staticmethod
+    def set_plugin_status_for_session(
+        session_id: str,
+        plugin_name: str,
+        enabled: bool,
+    ) -> None:
+        """设置插件在指定会话中的启停状态
+
+        Args:
+            session_id: 会话ID (unified_msg_origin)
+            plugin_name: 插件名称
+            enabled: True表示启用，False表示禁用
+
+        """
+        # 获取当前配置
+        session_plugin_config = sp.get(
+            "session_plugin_config",
+            {},
+            scope="umo",
+            scope_id=session_id,
+        )
+        if session_id not in session_plugin_config:
+            session_plugin_config[session_id] = {
+                "enabled_plugins": [],
+                "disabled_plugins": [],
+            }
+
+        session_config = session_plugin_config[session_id]
+        enabled_plugins = session_config.get("enabled_plugins", [])
+        disabled_plugins = session_config.get("disabled_plugins", [])
+
+        if enabled:
+            # 启用插件
+            if plugin_name in disabled_plugins:
+                disabled_plugins.remove(plugin_name)
+            if plugin_name not in enabled_plugins:
+                enabled_plugins.append(plugin_name)
+        else:
+            # 禁用插件
+            if plugin_name in enabled_plugins:
+                enabled_plugins.remove(plugin_name)
+            if plugin_name not in disabled_plugins:
+                disabled_plugins.append(plugin_name)
+
+        # 保存配置
+        session_config["enabled_plugins"] = enabled_plugins
+        session_config["disabled_plugins"] = disabled_plugins
+        session_plugin_config[session_id] = session_config
+        sp.put(
+            "session_plugin_config",
+            session_plugin_config,
+            scope="umo",
+            scope_id=session_id,
+        )
+
+        logger.info(
+            f"会话 {session_id} 的插件 {plugin_name} 状态已更新为: {'启用' if enabled else '禁用'}",
+        )
+
+    @staticmethod
+    def get_session_plugin_config(session_id: str) -> dict[str, list[str]]:
+        """获取指定会话的插件配置
+
+        Args:
+            session_id: 会话ID (unified_msg_origin)
+
+        Returns:
+            Dict[str, List[str]]: 包含enabled_plugins和disabled_plugins的字典
+
+        """
+        session_plugin_config = sp.get(
+            "session_plugin_config",
+            {},
+            scope="umo",
+            scope_id=session_id,
+        )
+        return session_plugin_config.get(
+            session_id,
+            {"enabled_plugins": [], "disabled_plugins": []},
+        )
+
+    @staticmethod
+    def filter_handlers_by_session(event: AstrMessageEvent, handlers: list) -> list:
+        """根据会话配置过滤处理器列表
+
+        Args:
+            event: 消息事件
+            handlers: 原始处理器列表
+
+        Returns:
+            List: 过滤后的处理器列表
+
+        """
+        from astrbot.core.star.star import star_map
+
+        session_id = event.unified_msg_origin
+        filtered_handlers = []
+
+        for handler in handlers:
+            # 获取处理器对应的插件
+            plugin = star_map.get(handler.handler_module_path)
+            if not plugin:
+                # 如果找不到插件元数据，允许执行（可能是系统插件）
+                filtered_handlers.append(handler)
+                continue
+
+            # 跳过保留插件（系统插件）
+            if plugin.reserved:
+                filtered_handlers.append(handler)
+                continue
+
+            if plugin.name is None:
+                continue
+
+            # 检查插件是否在当前会话中启用
+            if SessionPluginManager.is_plugin_enabled_for_session(
+                session_id,
+                plugin.name,
+            ):
+                filtered_handlers.append(handler)
+            else:
+                logger.debug(
+                    f"插件 {plugin.name} 在会话 {session_id} 中被禁用，跳过处理器 {handler.handler_name}",
+                )
+
+        return filtered_handlers

astrbot/core/star/star.py

@@ -1,39 +1,47 @@
 from __future__ import annotations
 
-from types import ModuleType
-from typing import List, Dict
 from dataclasses import dataclass, field
+from types import ModuleType
+from typing import TYPE_CHECKING
+
 from astrbot.core.config import AstrBotConfig
 
-star_registry: List[StarMetadata] = []
-star_map: Dict[str, StarMetadata] = {}
+star_registry: list[StarMetadata] = []
+star_map: dict[str, StarMetadata] = {}
 """key 是模块路径，__module__"""
 
+if TYPE_CHECKING:
+    from . import Star
+
 
 @dataclass
 class StarMetadata:
-    """
-    插件的元数据。
+    """插件的元数据。
 
     当 activated 为 False 时，star_cls 可能为 None，请不要在插件未激活时调用 star_cls 的方法。
     """
 
-    name: str
-    author: str  # 插件作者
-    desc: str  # 插件简介
-    version: str  # 插件版本
-    repo: str = None  # 插件仓库地址
-
-    star_cls_type: type = None
+    name: str | None = None
+    """插件名"""
+    author: str | None = None
+    """插件作者"""
+    desc: str | None = None
+    """插件简介"""
+    version: str | None = None
+    """插件版本"""
+    repo: str | None = None
+    """插件仓库地址"""
+
+    star_cls_type: type[Star] | None = None
     """插件的类对象的类型"""
-    module_path: str = None
+    module_path: str | None = None
     """插件的模块路径"""
 
-    star_cls: object = None
+    star_cls: Star | None = None
     """插件的类对象"""
-    module: ModuleType = None
+    module: ModuleType | None = None
     """插件的模块对象"""
-    root_dir_name: str = None
+    root_dir_name: str | None = None
     """插件的目录名称"""
     reserved: bool = False
     """是否是 AstrBot 的保留插件"""
@@ -41,35 +49,20 @@ class StarMetadata:
     activated: bool = True
     """是否被激活"""
 
-    config: AstrBotConfig = None
+    config: AstrBotConfig | None = None
     """插件配置"""
 
-    star_handler_full_names: List[str] = field(default_factory=list)
+    star_handler_full_names: list[str] = field(default_factory=list)
     """注册的 Handler 的全名列表"""
 
-    supported_platforms: Dict[str, bool] = field(default_factory=dict)
-    """插件支持的平台ID字典，key为平台ID，value为是否支持"""
+    display_name: str | None = None
+    """用于展示的插件名称"""
+
+    logo_path: str | None = None
+    """插件 Logo 的路径"""
 
     def __str__(self) -> str:
-        return f"StarMetadata({self.name}, {self.desc}, {self.version}, {self.repo})"
-
-    def update_platform_compatibility(self, plugin_enable_config: dict) -> None:
-        """更新插件支持的平台列表
-
-        Args:
-            plugin_enable_config: 平台插件启用配置，即platform_settings.plugin_enable配置项
-        """
-        if not plugin_enable_config:
-            return
-
-        # 清空之前的配置
-        self.supported_platforms.clear()
-
-        # 遍历所有平台配置
-        for platform_id, plugins in plugin_enable_config.items():
-            # 检查该插件在当前平台的配置
-            if self.name in plugins:
-                self.supported_platforms[platform_id] = plugins[self.name]
-            else:
-                # 如果没有明确配置，默认为启用
-                self.supported_platforms[platform_id] = True
+        return f"Plugin {self.name} ({self.version}) by {self.author}: {self.desc}"
+
+    def __repr__(self) -> str:
+        return f"Plugin {self.name} ({self.version}) by {self.author}: {self.desc}"