AstrBot/astrbot/core/core_lifecycle.py

"""Astrbot 核心生命周期管理类, 负责管理 AstrBot 的启动､停止､重启等操作.

该类负责初始化各个组件, 包括 ProviderManager､PlatformManager､ConversationManager､PluginManager､PipelineScheduler､EventBus等｡
该类还负责加载和执行插件, 以及处理事件总线的分发｡

工作流程:
1. 初始化所有组件
2. 启动事件总线和任务, 所有任务都在这里运行
3. 执行启动完成事件钩子
"""

import asyncio
import inspect
import os
import threading
import time
import traceback
from asyncio import Queue
from enum import Enum
from typing import Any

from astrbot.api import logger, sp
from astrbot.core import LogBroker, LogManager
from astrbot.core.astrbot_config_mgr import AstrBotConfigManager
from astrbot.core.config.default import VERSION
from astrbot.core.conversation_mgr import ConversationManager
from astrbot.core.cron import CronJobManager
from astrbot.core.db import BaseDatabase
from astrbot.core.knowledge_base.kb_mgr import KnowledgeBaseManager
from astrbot.core.persona_mgr import PersonaManager
from astrbot.core.pipeline.scheduler import PipelineContext, PipelineScheduler
from astrbot.core.platform.manager import PlatformManager
from astrbot.core.platform_message_history_mgr import PlatformMessageHistoryManager
from astrbot.core.provider.manager import ProviderManager
from astrbot.core.star.context import Context
from astrbot.core.star.star_handler import EventType, star_handlers_registry, star_map
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.llm_metadata import update_llm_metadata
from astrbot.core.utils.migra_helper import migra
from astrbot.core.utils.temp_dir_cleaner import TempDirCleaner

from . import astrbot_config, html_renderer
from .event_bus import EventBus


class LifecycleState(str, Enum):
    """Minimal lifecycle contract for split initialization."""

    CREATED = "created"
    CORE_READY = "core_ready"
    RUNTIME_FAILED = "runtime_failed"
    RUNTIME_READY = "runtime_ready"


class AstrBotCoreLifecycle:
    """AstrBot 核心生命周期管理类, 负责管理 AstrBot 的启动､停止､重启等操作.

    该类负责初始化各个组件, 包括 ProviderManager､PlatformManager､ConversationManager､PluginManager､PipelineScheduler､
    EventBus 等｡
    该类还负责加载和执行插件, 以及处理事件总线的分发｡
    """

    def __init__(self, log_broker: LogBroker, db: BaseDatabase) -> None:
        self.log_broker = log_broker  # 初始化日志代理
        self.astrbot_config = astrbot_config  # 初始化配置
        self.db = db  # 初始化数据库

        self.umop_config_router: UmopConfigRouter | None = None
        self.astrbot_config_mgr: AstrBotConfigManager | None = None
        self.event_queue: Queue | None = None
        self.persona_mgr: PersonaManager | None = None
        self.provider_manager: ProviderManager | None = None
        self.platform_manager: PlatformManager | None = None
        self.conversation_manager: ConversationManager | None = None
        self.platform_message_history_manager: PlatformMessageHistoryManager | None = (
            None
        )
        self.kb_manager: KnowledgeBaseManager | None = None
        self.subagent_orchestrator: SubAgentOrchestrator | None = None
        self.cron_manager: CronJobManager | None = None
        self.temp_dir_cleaner: TempDirCleaner | None = None
        self.star_context: Context | None = None
        self.plugin_manager: PluginManager | None = None
        self.pipeline_scheduler_mapping: dict[str, PipelineScheduler] = {}
        self.astrbot_updator: AstrBotUpdator | None = None
        self.event_bus: EventBus | None = None
        self.dashboard_shutdown_event: asyncio.Event | None = None
        self.curr_tasks: list[asyncio.Task] = []
        self.start_time = 0
        self.runtime_bootstrap_task: asyncio.Task[None] | None = None
        self.runtime_bootstrap_error: BaseException | None = None
        self.runtime_ready_event = asyncio.Event()
        self.runtime_failed_event = asyncio.Event()
        self._runtime_wait_interrupted = False
        self._set_lifecycle_state(LifecycleState.CREATED)

        # 设置代理
        proxy_config = self.astrbot_config.get("http_proxy", "")
        if proxy_config != "":
            os.environ["https_proxy"] = proxy_config
            os.environ["http_proxy"] = proxy_config
            logger.debug(f"Using proxy: {proxy_config}")
            # 设置 no_proxy
            no_proxy_list = self.astrbot_config.get("no_proxy", [])
            os.environ["no_proxy"] = ",".join(no_proxy_list)
        else:
            # 清空代理环境变量
            if "https_proxy" in os.environ:
                del os.environ["https_proxy"]
            if "http_proxy" in os.environ:
                del os.environ["http_proxy"]
            if "no_proxy" in os.environ:
                del os.environ["no_proxy"]
            logger.debug("HTTP proxy cleared")

    async def _init_or_reload_subagent_orchestrator(self) -> None:
        """Create (if needed) and reload the subagent orchestrator from config.

        This keeps lifecycle wiring in one place while allowing the orchestrator
        to manage enable/disable and tool registration details.
        """
        try:
            if self.provider_manager is None or self.persona_mgr is None:
                raise RuntimeError("core dependencies are not initialized")
            provider_manager = self.provider_manager
            persona_mgr = self.persona_mgr
            if self.subagent_orchestrator is None:
                self.subagent_orchestrator = SubAgentOrchestrator(
                    provider_manager.llm_tools,
                    persona_mgr,
                )
            await self.subagent_orchestrator.reload_from_config(
                self.astrbot_config.get("subagent_orchestrator", {}),
            )
        except Exception as e:
            logger.error(f"Subagent orchestrator init failed: {e}", exc_info=True)

    def _set_lifecycle_state(self, state: LifecycleState) -> None:
        """Update the lifecycle state and compatibility flags together."""
        self.lifecycle_state = state
        self.core_initialized = state is not LifecycleState.CREATED
        self.runtime_failed = state is LifecycleState.RUNTIME_FAILED
        self.runtime_ready = state is LifecycleState.RUNTIME_READY

    def _clear_runtime_failure_for_retry(self) -> None:
        if self.lifecycle_state is LifecycleState.RUNTIME_FAILED:
            self._set_lifecycle_state(LifecycleState.CORE_READY)

    async def _cleanup_partial_runtime_bootstrap(self) -> None:
        if self.star_context is not None and hasattr(
            self.star_context,
            "reset_runtime_registrations",
        ):
            self.star_context.reset_runtime_registrations()
        for manager in (self.platform_manager, self.kb_manager, self.provider_manager):
            if manager is None:
                continue
            try:
                terminate = getattr(manager, "terminate", None)
                if not callable(terminate):
                    continue
                result = terminate()
                if inspect.isawaitable(result):
                    await result
            except Exception as exc:
                logger.warning(
                    f"Failed to clean up partial runtime bootstrap state: {exc}",
                    exc_info=True,
                )
        self._clear_runtime_artifacts()

    def _reset_runtime_bootstrap_state(self) -> None:
        self.runtime_bootstrap_task = None
        self.runtime_bootstrap_error = None
        self.runtime_ready_event.clear()
        self.runtime_failed_event.clear()

    def _interrupt_runtime_bootstrap_waiters(self) -> None:
        self._runtime_wait_interrupted = True
        self.runtime_bootstrap_error = None
        self.runtime_failed_event.set()

    async def _consume_runtime_bootstrap_task(
        self,
        task: asyncio.Task[None] | None = None,
    ) -> None:
        task = task or self.runtime_bootstrap_task
        if task is None or not task.done():
            return
        try:
            await task
        except asyncio.CancelledError:
            pass
        except Exception:
            pass

    async def _wait_for_runtime_ready(self) -> bool:
        if self.runtime_ready or self.runtime_ready_event.is_set():
            return True
        if self._runtime_wait_interrupted:
            self.runtime_failed_event.clear()
            return False
        if self.runtime_failed or self.runtime_bootstrap_error is not None:
            if self.runtime_bootstrap_task is not None:
                await self._consume_runtime_bootstrap_task(self.runtime_bootstrap_task)
            return False
        runtime_bootstrap_task = self.runtime_bootstrap_task
        if runtime_bootstrap_task is None:
            raise RuntimeError(
                "runtime bootstrap task was not scheduled before start",
            )
        if self.runtime_failed_event.is_set():
            await self._consume_runtime_bootstrap_task(runtime_bootstrap_task)
            if self._runtime_wait_interrupted:
                self.runtime_failed_event.clear()
            return False

        ready_wait = asyncio.create_task(self.runtime_ready_event.wait())
        failed_wait = asyncio.create_task(self.runtime_failed_event.wait())
        done: set[asyncio.Task[Any]] = set()
        pending: set[asyncio.Task[Any]] = set()
        try:
            done, pending = await asyncio.wait(
                {runtime_bootstrap_task, ready_wait, failed_wait},
                return_when=asyncio.FIRST_COMPLETED,
            )
        finally:
            for task in pending:
                if task is runtime_bootstrap_task:
                    continue
                task.cancel()
            pending_waiters = [
                task for task in pending if task is not runtime_bootstrap_task
            ]
            if pending_waiters:
                await asyncio.gather(*pending_waiters, return_exceptions=True)

        for task in done:
            if task is runtime_bootstrap_task:
                continue
            task.result()

        if runtime_bootstrap_task in done:
            await self._consume_runtime_bootstrap_task(runtime_bootstrap_task)

        if self.runtime_ready or self.runtime_ready_event.is_set():
            return True

        if self._runtime_wait_interrupted:
            self.runtime_failed_event.clear()
            return False

        if self.runtime_bootstrap_task is None and self.runtime_bootstrap_error is None:
            self.runtime_failed_event.clear()
            return False

        await self._consume_runtime_bootstrap_task(runtime_bootstrap_task)
        return False

    def _collect_runtime_bootstrap_task(self) -> list[asyncio.Task]:
        task = self.runtime_bootstrap_task
        self.runtime_bootstrap_task = None
        if task is None:
            return []
        if not task.done():
            task.cancel()
        return [task]

    def _require_runtime_bootstrap_components(
        self,
    ) -> tuple[PluginManager, ProviderManager, KnowledgeBaseManager, PlatformManager]:
        if (
            self.plugin_manager is None
            or self.provider_manager is None
            or self.kb_manager is None
            or self.platform_manager is None
        ):
            raise RuntimeError("initialize_core must complete before runtime bootstrap")
        return (
            self.plugin_manager,
            self.provider_manager,
            self.kb_manager,
            self.platform_manager,
        )

    def _require_runtime_started_components(self) -> tuple[EventBus, Context]:
        if self.lifecycle_state is not LifecycleState.RUNTIME_READY:
            raise RuntimeError("LifecycleState.RUNTIME_READY required before start")
        if self.event_bus is None or self.star_context is None:
            raise RuntimeError("runtime bootstrap must complete before start")
        return self.event_bus, self.star_context

    def _cancel_current_tasks(self) -> list[asyncio.Task]:
        tasks_to_wait: list[asyncio.Task] = []
        for task in self.curr_tasks:
            task.cancel()
            if isinstance(task, asyncio.Task):
                tasks_to_wait.append(task)
        self.curr_tasks = []
        return tasks_to_wait

    def _clear_runtime_artifacts(self) -> None:
        self.event_bus = None
        self.pipeline_scheduler_mapping = {}
        self.curr_tasks = []
        self.start_time = 0

    def _require_scheduler_dependencies(
        self,
    ) -> tuple[AstrBotConfigManager, PluginManager]:
        if self.astrbot_config_mgr is None or self.plugin_manager is None:
            raise RuntimeError("initialize_core must complete before scheduler setup")
        return self.astrbot_config_mgr, self.plugin_manager

    def _require_config_manager(self) -> AstrBotConfigManager:
        if self.astrbot_config_mgr is None:
            raise RuntimeError("initialize_core must complete before scheduler setup")
        return self.astrbot_config_mgr

    def _require_plugin_manager(self) -> PluginManager:
        if self.plugin_manager is None:
            raise RuntimeError("initialize_core must complete before scheduler setup")
        return self.plugin_manager

    def _require_platform_manager(self) -> PlatformManager:
        if self.platform_manager is None:
            raise RuntimeError("platform manager is not initialized")
        return self.platform_manager

    async def initialize_core(self) -> None:
        """Initialize the fast core phase without runtime bootstrap."""
        if self.core_initialized:
            return

        self._runtime_wait_interrupted = False
        self._reset_runtime_bootstrap_state()

        # 初始化日志代理
        logger.info("AstrBot v" + VERSION)
        if os.environ.get("TESTING", ""):
            LogManager.configure_logger(
                logger, self.astrbot_config, override_level="DEBUG"
            )
            LogManager.configure_trace_logger(self.astrbot_config)
        else:
            LogManager.configure_logger(logger, self.astrbot_config)
            LogManager.configure_trace_logger(self.astrbot_config)

        await self.db.initialize()

        await html_renderer.initialize()

        # 初始化 UMOP 配置路由器
        self.umop_config_router = UmopConfigRouter(sp=sp)
        await self.umop_config_router.initialize()

        # 初始化 AstrBot 配置管理器
        self.astrbot_config_mgr = AstrBotConfigManager(
            default_config=self.astrbot_config,
            ucr=self.umop_config_router,
            sp=sp,
        )
        if self.astrbot_config_mgr is None:
            raise RuntimeError("config manager initialization failed")
        astrbot_config_mgr = self.astrbot_config_mgr
        self.temp_dir_cleaner = TempDirCleaner(
            max_size_getter=lambda: astrbot_config_mgr.default_conf.get(
                TempDirCleaner.CONFIG_KEY,
                TempDirCleaner.DEFAULT_MAX_SIZE,
            ),
        )

        # apply migration
        try:
            await migra(
                self.db,
                self.astrbot_config_mgr,
                self.umop_config_router,
                self.astrbot_config_mgr,
            )
        except Exception as e:
            logger.error(f"AstrBot migration failed: {e!s}")
            logger.error(traceback.format_exc())

        # 初始化事件队列
        self.event_queue = Queue()

        # 初始化人格管理器
        self.persona_mgr = PersonaManager(self.db, self.astrbot_config_mgr)
        await self.persona_mgr.initialize()

        # 初始化供应商管理器
        self.provider_manager = ProviderManager(
            self.astrbot_config_mgr,
            self.db,
            self.persona_mgr,
        )

        # 初始化平台管理器
        self.platform_manager = PlatformManager(self.astrbot_config, self.event_queue)

        # 初始化对话管理器
        self.conversation_manager = ConversationManager(self.db)

        # 初始化平台消息历史管理器
        self.platform_message_history_manager = PlatformMessageHistoryManager(self.db)

        # 初始化知识库管理器
        self.kb_manager = KnowledgeBaseManager(self.provider_manager)

        # 初始化 CronJob 管理器
        self.cron_manager = CronJobManager(self.db)

        # Dynamic subagents (handoff tools) from config.
        await self._init_or_reload_subagent_orchestrator()

        # 初始化提供给插件的上下文
        self.star_context = Context(
            self.event_queue,
            self.astrbot_config,
            self.db,
            self.provider_manager,
            self.platform_manager,
            self.conversation_manager,
            self.platform_message_history_manager,
            self.persona_mgr,
            self.astrbot_config_mgr,
            self.kb_manager,
            self.cron_manager,
            self.subagent_orchestrator,
        )

        # 初始化插件管理器
        self.plugin_manager = PluginManager(self.star_context, self.astrbot_config)

        # 为提前启动 Dashboard 准备核心依赖
        self.astrbot_updator = AstrBotUpdator()
        self.dashboard_shutdown_event = asyncio.Event()

        self._set_lifecycle_state(LifecycleState.CORE_READY)

    async def bootstrap_runtime(self) -> None:
        """Complete deferred runtime bootstrap after core initialization."""
        if not self.core_initialized:
            raise RuntimeError(
                "initialize_core must be called before bootstrap_runtime",
            )
        if self.runtime_ready:
            return

        self._clear_runtime_failure_for_retry()
        self.runtime_bootstrap_error = None
        self.runtime_ready_event.clear()
        self.runtime_failed_event.clear()

        try:
            plugin_manager, provider_manager, kb_manager, platform_manager = (
                self._require_runtime_bootstrap_components()
            )

            # 扫描、注册插件、实例化插件类
            await plugin_manager.reload()

            # 根据配置实例化各个 Provider
            await provider_manager.initialize()

            await kb_manager.initialize()

            # 初始化消息事件流水线调度器
            self.pipeline_scheduler_mapping = await self.load_pipeline_scheduler()

            if self.event_queue is None or self.astrbot_config_mgr is None:
                raise RuntimeError(
                    "initialize_core must complete before runtime bootstrap",
                )

            # 初始化事件总线
            self.event_bus = EventBus(
                self.event_queue,
                self.pipeline_scheduler_mapping,
                self.astrbot_config_mgr,
            )

            # 记录启动时间
            self.start_time = int(time.time())

            # 初始化当前任务列表
            self.curr_tasks = []

            # 根据配置实例化各个平台适配器
            await platform_manager.initialize()

            asyncio.create_task(update_llm_metadata())

            self._set_lifecycle_state(LifecycleState.RUNTIME_READY)
            self.runtime_ready_event.set()
        except asyncio.CancelledError:
            await self._cleanup_partial_runtime_bootstrap()
            self._set_lifecycle_state(LifecycleState.CORE_READY)
            self.runtime_bootstrap_error = None
            self.runtime_failed_event.clear()
            raise
        except BaseException as exc:
            await self._cleanup_partial_runtime_bootstrap()
            self._set_lifecycle_state(LifecycleState.RUNTIME_FAILED)
            self.runtime_bootstrap_error = exc
            self.runtime_failed_event.set()
            raise

    async def initialize(self) -> None:
        """初始化 AstrBot 核心生命周期管理类.

        负责初始化各个组件, 包括 ProviderManager、PlatformManager、ConversationManager、PluginManager、PipelineScheduler、EventBus、AstrBotUpdator等。
        """
        await self.initialize_core()
        await self.bootstrap_runtime()

    def _load(self) -> None:
        """加载事件总线和任务并初始化."""
        event_bus, star_context = self._require_runtime_started_components()

        # 创建一个异步任务来执行事件总线的 dispatch() 方法
        # dispatch是一个无限循环的协程, 从事件队列中获取事件并处理
        event_bus_task = asyncio.create_task(
            event_bus.dispatch(),
            name="event_bus",
        )
        cron_task = None
        if self.cron_manager:
            cron_task = asyncio.create_task(
                self.cron_manager.start(star_context),
                name="cron_manager",
            )
        temp_dir_cleaner_task = None
        if self.temp_dir_cleaner:
            temp_dir_cleaner_task = asyncio.create_task(
                self.temp_dir_cleaner.run(),
                name="temp_dir_cleaner",
            )

        # 把插件中注册的所有协程函数注册到事件总线中并执行
        extra_tasks: list[asyncio.Task[Any]] = []
        if star_context._register_tasks is not None:
            for task in star_context._register_tasks:
                task_name = getattr(task, "__name__", task.__class__.__name__)
                extra_tasks.append(asyncio.create_task(task, name=task_name))

        tasks_ = [event_bus_task, *(extra_tasks if extra_tasks else [])]
        if cron_task:
            tasks_.append(cron_task)
        if temp_dir_cleaner_task:
            tasks_.append(temp_dir_cleaner_task)
        for task in tasks_:
            self.curr_tasks.append(
                asyncio.create_task(self._task_wrapper(task), name=task.get_name()),
            )

        self.start_time = int(time.time())

    async def _task_wrapper(self, task: asyncio.Task) -> None:
        """异步任务包装器, 用于处理异步任务执行中出现的各种异常.

        Args:
            task (asyncio.Task): 要执行的异步任务

        """
        try:
            await task
        except asyncio.CancelledError:
            pass  # 任务被取消, 静默处理
        except Exception as e:
            # 获取完整的异常堆栈信息, 按行分割并记录到日志中
            logger.error(f"------- 任务 {task.get_name()} 发生错误: {e}")
            for line in traceback.format_exc().split("\n"):
                logger.error(f"|    {line}")
            logger.error("-------")

    async def start(self) -> None:
        """启动 AstrBot 核心生命周期管理类.

        用load加载事件总线和任务并初始化, 执行启动完成事件钩子
        """
        if not await self._wait_for_runtime_ready():
            if self._runtime_wait_interrupted:
                return
            error = self.runtime_bootstrap_error
            if error is None:
                logger.error("AstrBot runtime bootstrap failed before start completed.")
            else:
                logger.error(
                    f"AstrBot runtime bootstrap failed before start completed: {error}",
                )
            return

        self._load()
        logger.info("AstrBot 启动完成｡")

        # 执行启动完成事件钩子
        handlers = star_handlers_registry.get_handlers_by_event_type(
            EventType.OnAstrBotLoadedEvent,
        )
        for handler in handlers:
            try:
                logger.info(
                    f"hook(on_astrbot_loaded) -> {star_map[handler.handler_module_path].name} - {handler.handler_name}",
                )
                await handler.handler()
            except BaseException:
                logger.error(traceback.format_exc())

        # 同时运行curr_tasks中的所有任务
        await asyncio.gather(*self.curr_tasks, return_exceptions=True)

    async def stop(self) -> None:
        """停止 AstrBot 核心生命周期管理类, 取消所有当前任务并终止各个管理器."""
        if self.temp_dir_cleaner:
            await self.temp_dir_cleaner.stop()

        # 请求停止所有正在运行的异步任务
        self._interrupt_runtime_bootstrap_waiters()
        tasks_to_wait = self._cancel_current_tasks()
        tasks_to_wait.extend(self._collect_runtime_bootstrap_task())

        if self.cron_manager:
            await self.cron_manager.shutdown()

        if self.plugin_manager and self.plugin_manager.context:
            for plugin in self.plugin_manager.context.get_all_stars():
                try:
                    await self.plugin_manager._terminate_plugin(plugin)
                except Exception as e:
                    logger.warning(traceback.format_exc())
                    logger.warning(
                        f"插件 {plugin.name} 未被正常终止 {e!s}, 可能会导致资源泄露等问题。",
                    )

        if self.provider_manager:
            await self.provider_manager.terminate()
        if self.platform_manager:
            await self.platform_manager.terminate()
        if self.kb_manager:
            await self.kb_manager.terminate()
        if self.dashboard_shutdown_event:
            self.dashboard_shutdown_event.set()
        self._clear_runtime_artifacts()
        self._set_lifecycle_state(LifecycleState.CREATED)
        self._reset_runtime_bootstrap_state()

        # 再次遍历curr_tasks等待每个任务真正结束
        for task in tasks_to_wait:
            try:
                await task
            except asyncio.CancelledError:
                pass
            except Exception as e:
                logger.error(f"任务 {task.get_name()} 发生错误: {e}")

    async def restart(self) -> None:
        """重启 AstrBot 核心生命周期管理类, 终止各个管理器并重新加载平台实例"""
        self._interrupt_runtime_bootstrap_waiters()
        tasks_to_wait = self._cancel_current_tasks()
        tasks_to_wait.extend(self._collect_runtime_bootstrap_task())
        if self.provider_manager:
            await self.provider_manager.terminate()
        if self.platform_manager:
            await self.platform_manager.terminate()
        if self.kb_manager:
            await self.kb_manager.terminate()
        if self.dashboard_shutdown_event:
            self.dashboard_shutdown_event.set()
        for task in tasks_to_wait:
            try:
                await task
            except asyncio.CancelledError:
                pass
            except Exception as e:
                logger.error(f"任务 {task.get_name()} 发生错误: {e}")
        self._clear_runtime_artifacts()
        self._set_lifecycle_state(LifecycleState.CREATED)
        self._reset_runtime_bootstrap_state()
        if self.astrbot_updator is None:
            return
        threading.Thread(
            target=self.astrbot_updator._reboot,
            name="restart",
            daemon=True,
        ).start()

    def load_platform(self) -> list[asyncio.Task]:
        """加载平台实例并返回所有平台实例的异步任务列表"""
        tasks = []
        platform_insts = self._require_platform_manager().get_insts()
        for platform_inst in platform_insts:
            tasks.append(
                asyncio.create_task(
                    platform_inst.run(),
                    name=f"{platform_inst.meta().id}({platform_inst.meta().name})",
                ),
            )
        return tasks

    async def load_pipeline_scheduler(self) -> dict[str, PipelineScheduler]:
        """加载消息事件流水线调度器.

        Returns:
            dict[str, PipelineScheduler]: 平台 ID 到流水线调度器的映射

        """
        mapping = {}
        astrbot_config_mgr, plugin_manager = self._require_scheduler_dependencies()
        for conf_id, ab_config in astrbot_config_mgr.confs.items():
            scheduler = PipelineScheduler(
                PipelineContext(ab_config, plugin_manager, conf_id),
            )
            await scheduler.initialize()
            mapping[conf_id] = scheduler
        return mapping

    async def reload_pipeline_scheduler(self, conf_id: str) -> None:
        """重新加载消息事件流水线调度器.

        Returns:
            dict[str, PipelineScheduler]: 平台 ID 到流水线调度器的映射

        """
        astrbot_config_mgr = self._require_config_manager()
        ab_config = astrbot_config_mgr.confs.get(conf_id)
        if not ab_config:
            raise ValueError(f"配置文件 {conf_id} 不存在")
        plugin_manager = self._require_plugin_manager()
        scheduler = PipelineScheduler(
            PipelineContext(ab_config, plugin_manager, conf_id),
        )
        await scheduler.initialize()
        self.pipeline_scheduler_mapping[conf_id] = scheduler