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

astrbot/core/pipeline/scheduler.py

@@ -1,9 +1,11 @@
+from collections.abc import AsyncGenerator
+
+from astrbot.core import logger
+from astrbot.core.platform import AstrMessageEvent
+
 from . import STAGES_ORDER
-from .stage import registered_stages
 from .context import PipelineContext
-from typing import AsyncGenerator
-from astrbot.core.platform import AstrMessageEvent
-from astrbot.core import logger
+from .stage import registered_stages
 
 
 class PipelineScheduler:
@@ -11,16 +13,17 @@ class PipelineScheduler:
 
     def __init__(self, context: PipelineContext):
         registered_stages.sort(
-            key=lambda x: STAGES_ORDER.index(x.__class__.__name__)
+            key=lambda x: STAGES_ORDER.index(x.__name__),
         )  # 按照顺序排序
         self.ctx = context  # 上下文对象
+        self.stages = []  # 存储阶段实例
 
     async def initialize(self):
         """初始化管道调度器时, 初始化所有阶段"""
-        for stage in registered_stages:
-            # logger.debug(f"初始化阶段 {stage.__class__ .__name__}")
-
-            await stage.initialize(self.ctx)
+        for stage_cls in registered_stages:
+            stage_instance = stage_cls()  # 创建实例
+            await stage_instance.initialize(self.ctx)
+            self.stages.append(stage_instance)
 
     async def _process_stages(self, event: AstrMessageEvent, from_stage=0):
         """依次执行各个阶段
@@ -28,12 +31,13 @@ class PipelineScheduler:
         Args:
             event (AstrMessageEvent): 事件对象
             from_stage (int): 从第几个阶段开始执行, 默认从0开始
+
         """
-        for i in range(from_stage, len(registered_stages)):
-            stage = registered_stages[i]  # 获取当前要执行的阶段
-            # logger.debug(f"执行阶段 {stage.__class__ .__name__}")
+        for i in range(from_stage, len(self.stages)):
+            stage = self.stages[i]  # 获取当前要执行的阶段
+            # logger.debug(f"执行阶段 {stage.__class__.__name__}")
             coroutine = stage.process(
-                event
+                event,
             )  # 调用阶段的process方法, 返回协程或者异步生成器
 
             if isinstance(coroutine, AsyncGenerator):
@@ -42,7 +46,7 @@ class PipelineScheduler:
                     # 此处是前置处理完成后的暂停点(yield), 下面开始执行后续阶段
                     if event.is_stopped():
                         logger.debug(
-                            f"阶段 {stage.__class__.__name__} 已终止事件传播。"
+                            f"阶段 {stage.__class__.__name__} 已终止事件传播。",
                         )
                         break
 
@@ -52,7 +56,7 @@ class PipelineScheduler:
                     # 此处是后续所有阶段处理完毕后返回的点, 执行后置处理
                     if event.is_stopped():
                         logger.debug(
-                            f"阶段 {stage.__class__.__name__} 已终止事件传播。"
+                            f"阶段 {stage.__class__.__name__} 已终止事件传播。",
                         )
                         break
             else:
@@ -69,11 +73,12 @@ class PipelineScheduler:
 
         Args:
             event (AstrMessageEvent): 事件对象
+
         """
         await self._process_stages(event)
 
         # 如果没有发送操作, 则发送一个空消息, 以便于后续的处理
-        if not event._has_send_oper and event.get_platform_name() == "webchat":
+        if event.get_platform_name() in ["webchat", "wecom_ai_bot"]:
             await event.send(None)
 
         logger.debug("pipeline 执行完毕。")

astrbot/core/pipeline/session_status_check/stage.py

@@ -0,0 +1,37 @@
+from collections.abc import AsyncGenerator
+
+from astrbot.core import logger
+from astrbot.core.platform.astr_message_event import AstrMessageEvent
+from astrbot.core.star.session_llm_manager import SessionServiceManager
+
+from ..context import PipelineContext
+from ..stage import Stage, register_stage
+
+
+@register_stage
+class SessionStatusCheckStage(Stage):
+    """检查会话是否整体启用"""
+
+    async def initialize(self, ctx: PipelineContext) -> None:
+        self.ctx = ctx
+        self.conv_mgr = ctx.plugin_manager.context.conversation_manager
+
+    async def process(
+        self,
+        event: AstrMessageEvent,
+    ) -> None | AsyncGenerator[None, None]:
+        # 检查会话是否整体启用
+        if not SessionServiceManager.is_session_enabled(event.unified_msg_origin):
+            logger.debug(f"会话 {event.unified_msg_origin} 已被关闭，已终止事件传播。")
+
+            # workaround for #2309
+            conv_id = await self.conv_mgr.get_curr_conversation_id(
+                event.unified_msg_origin,
+            )
+            if not conv_id:
+                await self.conv_mgr.new_conversation(
+                    event.unified_msg_origin,
+                    platform_id=event.get_platform_id(),
+                )
+
+            event.stop_event()

astrbot/core/pipeline/stage.py

@@ -1,19 +1,18 @@
 from __future__ import annotations
+
 import abc
-import inspect
-import traceback
-from astrbot.api import logger
-from typing import List, AsyncGenerator, Union, Awaitable
+from collections.abc import AsyncGenerator
+
 from astrbot.core.platform.astr_message_event import AstrMessageEvent
+
 from .context import PipelineContext
-from astrbot.core.message.message_event_result import MessageEventResult, CommandResult
 
-registered_stages: List[Stage] = []  # 维护了所有已注册的 Stage 实现类
+registered_stages: list[type[Stage]] = []  # 维护了所有已注册的 Stage 实现类类型
 
 
 def register_stage(cls):
     """一个简单的装饰器，用于注册 pipeline 包下的 Stage 实现类"""
-    registered_stages.append(cls())
+    registered_stages.append(cls)
     return cls
 
 
@@ -26,85 +25,21 @@ class Stage(abc.ABC):
 
         Args:
             ctx (PipelineContext): 消息管道上下文对象, 包括配置和插件管理器
+
         """
         raise NotImplementedError
 
     @abc.abstractmethod
     async def process(
-        self, event: AstrMessageEvent
-    ) -> Union[None, AsyncGenerator[None, None]]:
+        self,
+        event: AstrMessageEvent,
+    ) -> None | AsyncGenerator[None, None]:
         """处理事件
 
         Args:
             event (AstrMessageEvent): 事件对象，包含事件的相关信息
         Returns:
             Union[None, AsyncGenerator[None, None]]: 处理结果，可能是 None 或者异步生成器, 如果为 None 则表示不需要继续处理, 如果为异步生成器则表示需要继续处理(进入下一个阶段)
-        """
-        raise NotImplementedError
 
-    async def _call_handler(
-        self,
-        ctx: PipelineContext,
-        event: AstrMessageEvent,
-        handler: Awaitable,
-        *args,
-        **kwargs,
-    ) -> AsyncGenerator[None, None]:
-        """执行事件处理函数并处理其返回结果
-
-        该方法负责调用处理函数并处理不同类型的返回值。它支持两种类型的处理函数:
-        1. 异步生成器: 实现洋葱模型，每次yield都会将控制权交回上层
-        2. 协程: 执行一次并处理返回值
-
-        Args:
-            ctx (PipelineContext): 消息管道上下文对象
-            event (AstrMessageEvent): 待处理的事件对象
-            handler (Awaitable): 事件处理函数
-            *args: 传递给handler的位置参数
-            **kwargs: 传递给handler的关键字参数
-
-        Returns:
-            AsyncGenerator[None, None]: 异步生成器，用于在管道中传递控制流
         """
-        ready_to_call = None  # 一个协程或者异步生成器(async def)
-
-        trace_ = None
-
-        try:
-            ready_to_call = handler(event, *args, **kwargs)
-        except TypeError as _:
-            # 向下兼容
-            trace_ = traceback.format_exc()
-            # 以前的handler会额外传入一个参数, 但是context对象实际上在插件实例中有一份
-            ready_to_call = handler(event, ctx.plugin_manager.context, *args, **kwargs)
-
-        if isinstance(ready_to_call, AsyncGenerator):
-            # 如果是一个异步生成器, 进入洋葱模型
-            _has_yielded = False  # 是否返回过值
-            try:
-                async for ret in ready_to_call:
-                    # 这里逐步执行异步生成器, 对于每个yield返回的ret, 执行下面的代码
-                    # 返回值只能是 MessageEventResult 或者 None（无返回值）
-                    _has_yielded = True
-                    if isinstance(ret, (MessageEventResult, CommandResult)):
-                        # 如果返回值是 MessageEventResult, 设置结果并继续
-                        event.set_result(ret)
-                        yield  # 传递控制权给上一层的process函数
-                    else:
-                        # 如果返回值是 None, 则不设置结果并继续
-                        # 继续执行后续阶段
-                        yield ret  # 传递控制权给上一层的process函数
-                if not _has_yielded:
-                    # 如果这个异步生成器没有执行到yield分支
-                    yield
-            except Exception as e:
-                logger.error(f"Previous Error: {trace_}")
-                raise e
-        elif inspect.iscoroutine(ready_to_call):
-            # 如果只是一个协程, 直接执行
-            ret = await ready_to_call
-            if isinstance(ret, (MessageEventResult, CommandResult)):
-                event.set_result(ret)
-                yield  # 传递控制权给上一层的process函数
-            else:
-                yield ret  # 传递控制权给上一层的process函数
+        raise NotImplementedError

astrbot/core/pipeline/waking_check/stage.py

@@ -1,13 +1,17 @@
-from ..stage import Stage, register_stage
-from ..context import PipelineContext
+from collections.abc import AsyncGenerator
+
 from astrbot import logger
-from typing import Union, AsyncGenerator
+from astrbot.core.message.components import At, AtAll, Reply
+from astrbot.core.message.message_event_result import MessageChain, MessageEventResult
 from astrbot.core.platform.astr_message_event import AstrMessageEvent
-from astrbot.core.message.message_event_result import MessageEventResult, MessageChain
-from astrbot.core.message.components import At
-from astrbot.core.star.star_handler import star_handlers_registry, EventType
-from astrbot.core.star.star import star_map
+from astrbot.core.star.filter.command_group import CommandGroupFilter
 from astrbot.core.star.filter.permission import PermissionTypeFilter
+from astrbot.core.star.session_plugin_manager import SessionPluginManager
+from astrbot.core.star.star import star_map
+from astrbot.core.star.star_handler import EventType, star_handlers_registry
+
+from ..context import PipelineContext
+from ..stage import Stage, register_stage
 
 
 @register_stage
@@ -26,10 +30,12 @@ class WakingCheckStage(Stage):
 
         Args:
             ctx (PipelineContext): 消息管道上下文对象, 包括配置和插件管理器
+
         """
         self.ctx = ctx
         self.no_permission_reply = self.ctx.astrbot_config["platform_settings"].get(
-            "no_permission_reply", True
+            "no_permission_reply",
+            True,
         )
         # 私聊是否需要 wake_prefix 才能唤醒机器人
         self.friend_message_needs_wake_prefix = self.ctx.astrbot_config[
@@ -37,12 +43,18 @@ class WakingCheckStage(Stage):
         ].get("friend_message_needs_wake_prefix", False)
         # 是否忽略机器人自己发送的消息
         self.ignore_bot_self_message = self.ctx.astrbot_config["platform_settings"].get(
-            "ignore_bot_self_message", False
+            "ignore_bot_self_message",
+            False,
+        )
+        self.ignore_at_all = self.ctx.astrbot_config["platform_settings"].get(
+            "ignore_at_all",
+            False,
         )
 
     async def process(
-        self, event: AstrMessageEvent
-    ) -> Union[None, AsyncGenerator[None, None]]:
+        self,
+        event: AstrMessageEvent,
+    ) -> None | AsyncGenerator[None, None]:
         if (
             self.ignore_bot_self_message
             and event.get_self_id() == event.get_sender_id()
@@ -77,11 +89,18 @@ class WakingCheckStage(Stage):
                 event.message_str = event.message_str[len(wake_prefix) :].strip()
                 break
         if not is_wake:
-            # 检查是否有 at 消息
+            # 检查是否有at消息 / at全体成员消息 / 引用了bot的消息
             for message in messages:
-                if isinstance(message, At) and (
-                    str(message.qq) == str(event.get_self_id())
-                    or str(message.qq) == "all"
+                if (
+                    (
+                        isinstance(message, At)
+                        and (str(message.qq) == str(event.get_self_id()))
+                    )
+                    or (isinstance(message, AtAll) and not self.ignore_at_all)
+                    or (
+                        isinstance(message, Reply)
+                        and str(message.sender_id) == str(event.get_self_id())
+                    )
                 ):
                     is_wake = True
                     event.is_wake = True
@@ -99,8 +118,18 @@ class WakingCheckStage(Stage):
         activated_handlers = []
         handlers_parsed_params = {}  # 注册了指令的 handler
 
+        # 将 plugins_name 设置到 event 中
+        enabled_plugins_name = self.ctx.astrbot_config.get("plugin_set", ["*"])
+        if enabled_plugins_name == ["*"]:
+            # 如果是 *，则表示所有插件都启用
+            event.plugins_name = None
+        else:
+            event.plugins_name = enabled_plugins_name
+        logger.debug(f"enabled_plugins_name: {enabled_plugins_name}")
+
         for handler in star_handlers_registry.get_handlers_by_event_type(
-            EventType.AdapterMessageEvent
+            EventType.AdapterMessageEvent,
+            plugins_name=event.plugins_name,
         ):
             # filter 需满足 AND 逻辑关系
             passed = True
@@ -115,17 +144,15 @@ class WakingCheckStage(Stage):
                         if not filter.filter(event, self.ctx.astrbot_config):
                             permission_not_pass = True
                             permission_filter_raise_error = filter.raise_error
-                    else:
-                        if not filter.filter(event, self.ctx.astrbot_config):
-                            passed = False
-                            break
+                    elif not filter.filter(event, self.ctx.astrbot_config):
+                        passed = False
+                        break
                 except Exception as e:
                     await event.send(
                         MessageEventResult().message(
-                            f"插件 {star_map[handler.handler_module_path].name}: {e}"
-                        )
+                            f"插件 {star_map[handler.handler_module_path].name}: {e}",
+                        ),
                     )
-                    await event._post_send()
                     event.stop_event()
                     passed = False
                     break
@@ -137,12 +164,11 @@ class WakingCheckStage(Stage):
                     if self.no_permission_reply:
                         await event.send(
                             MessageChain().message(
-                                f"ID {event.get_sender_id()} 权限不足。通过 /sid 获取 ID 并请管理员添加。"
-                            )
+                                f"您(ID: {event.get_sender_id()})的权限不足以使用此指令。通过 /sid 获取 ID 并请管理员添加。",
+                            ),
                         )
-                        await event._post_send()
                     logger.info(
-                        f"触发 {star_map[handler.handler_module_path].name} 时, 用户(ID={event.get_sender_id()}) 权限不足。"
+                        f"触发 {star_map[handler.handler_module_path].name} 时, 用户(ID={event.get_sender_id()}) 权限不足。",
                     )
                     event.stop_event()
                     return
@@ -150,13 +176,23 @@ class WakingCheckStage(Stage):
                 is_wake = True
                 event.is_wake = True
 
-                activated_handlers.append(handler)
-                if "parsed_params" in event.get_extra():
-                    handlers_parsed_params[handler.handler_full_name] = event.get_extra(
-                        "parsed_params"
-                    )
+                is_group_cmd_handler = any(
+                    isinstance(f, CommandGroupFilter) for f in handler.event_filters
+                )
+                if not is_group_cmd_handler:
+                    activated_handlers.append(handler)
+                    if "parsed_params" in event.get_extra(default={}):
+                        handlers_parsed_params[handler.handler_full_name] = (
+                            event.get_extra("parsed_params")
+                        )
 
-            event.clear_extra()
+            event._extras.pop("parsed_params", None)
+
+        # 根据会话配置过滤插件处理器
+        activated_handlers = SessionPluginManager.filter_handlers_by_session(
+            event,
+            activated_handlers,
+        )
 
         event.set_extra("activated_handlers", activated_handlers)
         event.set_extra("handlers_parsed_params", handlers_parsed_params)

astrbot/core/pipeline/whitelist_check/stage.py

@@ -1,9 +1,11 @@
-from ..stage import Stage, register_stage
-from ..context import PipelineContext
-from typing import AsyncGenerator, Union
+from collections.abc import AsyncGenerator
+
+from astrbot.core import logger
 from astrbot.core.platform.astr_message_event import AstrMessageEvent
 from astrbot.core.platform.message_type import MessageType
-from astrbot.core import logger
+
+from ..context import PipelineContext
+from ..stage import Stage, register_stage
 
 
 @register_stage
@@ -27,8 +29,9 @@ class WhitelistCheckStage(Stage):
         self.wl_log = ctx.astrbot_config["platform_settings"]["id_whitelist_log"]
 
     async def process(
-        self, event: AstrMessageEvent
-    ) -> Union[None, AsyncGenerator[None, None]]:
+        self,
+        event: AstrMessageEvent,
+    ) -> None | AsyncGenerator[None, None]:
         if not self.enable_whitelist_check:
             # 白名单检查未启用
             return
@@ -60,6 +63,6 @@ class WhitelistCheckStage(Stage):
         ):
             if self.wl_log:
                 logger.info(
-                    f"会话 ID {event.unified_msg_origin} 不在会话白名单中，已终止事件传播。请在配置文件中添加该会话 ID 到白名单。"
+                    f"会话 ID {event.unified_msg_origin} 不在会话白名单中，已终止事件传播。请在配置文件中添加该会话 ID 到白名单。",
                 )
             event.stop_event()

astrbot/core/platform/__init__.py

@@ -1,14 +1,14 @@
-from .platform import Platform
 from .astr_message_event import AstrMessageEvent
+from .astrbot_message import AstrBotMessage, Group, MessageMember, MessageType
+from .platform import Platform
 from .platform_metadata import PlatformMetadata
-from .astrbot_message import AstrBotMessage, MessageMember, MessageType, Group
 
 __all__ = [
-    "Platform",
-    "AstrMessageEvent",
-    "PlatformMetadata",
     "AstrBotMessage",
+    "AstrMessageEvent",
+    "Group",
     "MessageMember",
     "MessageType",
-    "Group",
+    "Platform",
+    "PlatformMetadata",
 ]