fix: 优化 Embedding Provider 初始化逻辑，添加缺失提供者警告，确保 Milvus 连接任务按需启动 (#103)

* fix: 优化 Embedding Provider 初始化逻辑，添加缺失提供者警告，确保 Milvus 连接任务按需启动

* fix: 优化异常处理和后台任务创建逻辑，确保在无事件循环时安全启动任务

Author: piexian

main.py

@@ -71,6 +71,9 @@ def __init__(self, context: Context, config: AstrBotConfig):
         self._initialized_components = []
         self._embedding_provider_ready = False
         self._migrated_sessions: set[str] = set()  # 用于记录已迁移的会话
+        self._warned_missing_provider_ids: set[str] = set()
+        self._post_load_tasks_started = False
+        self._ensure_milvus_connection_task: asyncio.Task | None = None
 
         logger.info("开始初始化 Mnemosyne 插件...")
         # 启动后台异步初始化，但不包括 Embedding Provider 的初始化
@@ -97,7 +100,29 @@ def _initialize_embedding_provider(
             # 优先级 1: 从配置指定的 Provider ID 获取
             emb_id = self.config.get("embedding_provider_id")
             if emb_id:
-                provider = self.context.get_provider_by_id(emb_id)
+                # 避免在 AstrBot 尚未完成启动时调用 context.get_provider_by_id 产生多余的 WARN 日志。
+                provider = None
+                try:
+                    provider_manager = getattr(self.context, "provider_manager", None)
+                    inst_map = getattr(provider_manager, "inst_map", None)
+                    if isinstance(inst_map, dict):
+                        provider = inst_map.get(emb_id)
+                except (AttributeError, TypeError) as exc:
+                    # 仅在访问 provider_manager / inst_map 出现属性或类型问题时处理，避免掩盖真实错误。
+                    if silent:
+                        logger.debug(
+                            f"无法从 context 读取 Embedding Provider '{emb_id}'（provider_manager/inst_map 不可用）: {exc}"
+                        )
+                    else:
+                        logger.warning(
+                            f"无法从 context 读取 Embedding Provider '{emb_id}'（provider_manager/inst_map 不可用）: {exc}"
+                        )
+                    provider = None
+
+                # 兼容旧版本：如果无法访问 provider_manager，再回退到官方 API
+                if provider is None and not hasattr(self.context, "provider_manager"):
+                    provider = self.context.get_provider_by_id(emb_id)
+
                 # 安全地检查 provider 是否为 EmbeddingProvider 类型
                 if provider:
                     # 检查 provider 是否具有 EmbeddingProvider 的关键方法
@@ -113,6 +138,16 @@ def _initialize_embedding_provider(
                             logger.warning(
                                 f"获取的 Provider {emb_id} 不是有效的 EmbeddingProvider 类型"
                             )
+                else:
+                    if (
+                        not silent
+                        and emb_id not in self._warned_missing_provider_ids
+                        and self._are_providers_initialized()
+                    ):
+                        logger.warning(
+                            f"未找到配置的 Embedding Provider: {emb_id}，请检查 AstrBot 提供商配置是否已加载/启用。"
+                        )
+                        self._warned_missing_provider_ids.add(emb_id)
 
             # 优先级 2: 使用框架默认的第一个 Embedding Provider
             # 使用 context 提供的方法获取所有 embedding providers
@@ -196,6 +231,83 @@ async def _initialize_embedding_provider_async(
         )
         return False
 
+    def _are_providers_initialized(self) -> bool:
+        """
+        判断 AstrBot 的 ProviderManager 是否已完成 Provider 加载。
+
+        说明：不要依赖 context.get_provider_by_id 的 WARN 日志来判断是否加载完成。
+        """
+        provider_manager = getattr(self.context, "provider_manager", None)
+        inst_map = getattr(provider_manager, "inst_map", None)
+        if isinstance(inst_map, dict) and len(inst_map) > 0:
+            return True
+
+        # 兜底：部分版本可能不暴露 inst_map（或初始化时机不同）
+        try:
+            if self.context.get_all_providers():
+                return True
+        except (AttributeError, TypeError) as exc:
+            logger.warning(f"检查 Providers 初始化状态失败（get_all_providers 不可用）: {exc}")
+        return False
+
+    def _create_background_task(self, coro: Any, name: str) -> asyncio.Task | None:
+        """
+        安全创建后台任务：确保存在运行中的事件循环，避免在同步/无 loop 场景下直接抛异常。
+        """
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError as exc:
+            logger.warning(f"无法启动后台任务 '{name}': 当前没有运行中的事件循环: {exc}")
+            return None
+
+        # 额外提示：如果不是在 Task 上下文中创建，未来改动更容易定位。
+        try:
+            if asyncio.current_task() is None:
+                logger.debug(f"启动后台任务 '{name}'：当前不在 asyncio.Task 上下文中")
+        except RuntimeError:
+            # 极少数情况下 current_task() 也可能因 loop 上下文问题抛错，忽略即可。
+            pass
+
+        try:
+            return loop.create_task(coro, name=name)  # type: ignore[arg-type]
+        except TypeError:
+            # 兼容：部分运行环境可能不支持 name 参数
+            return loop.create_task(coro)  # type: ignore[arg-type]
+
+    def _start_post_load_tasks(self):
+        """在 AstrBot 启动完成/Providers 可用后启动需要依赖 Providers 的后台任务。"""
+        if (
+            self._post_load_tasks_started
+            and self._embedding_provider_task
+            and not self._embedding_provider_task.done()
+            and self._ensure_milvus_connection_task
+            and not self._ensure_milvus_connection_task.done()
+        ):
+            return
+
+        self._post_load_tasks_started = True
+
+        # 启动 Embedding Provider 后台加载任务（静默模式）
+        if not self._embedding_provider_task or self._embedding_provider_task.done():
+            task = self._create_background_task(
+                self._initialize_embedding_provider_async(max_wait=10.0),
+                name="mnemosyne.embedding_provider_init",
+            )
+            if task:
+                self._embedding_provider_task = task
+
+        # 启动 Milvus 连接后台任务（在 Embedding Provider 加载后执行）
+        if (
+            not self._ensure_milvus_connection_task
+            or self._ensure_milvus_connection_task.done()
+        ):
+            task = self._create_background_task(
+                self._ensure_milvus_connection_async(),
+                name="mnemosyne.ensure_milvus_connection",
+            )
+            if task:
+                self._ensure_milvus_connection_task = task
+
     async def _ensure_milvus_connection_async(self):
         """
         在 Embedding Provider 加载完成后，确保 Milvus 连接已建立
@@ -207,10 +319,15 @@ async def _ensure_milvus_connection_async(self):
                 logger.debug("等待 Embedding Provider 加载完成后再连接 Milvus...")
                 await self._embedding_provider_task
 
-            # 检查 Milvus Manager 是否已初始化
+            # 等待 Milvus Manager 初始化完成（插件初始化可能仍在进行）
             if not self.milvus_manager:
-                logger.warning("Milvus Manager 未初始化，跳过自动连接")
-                return
+                wait_start = time.time()
+                while not self.milvus_manager and time.time() - wait_start < 10.0:
+                    await asyncio.sleep(0.5)
+
+                if not self.milvus_manager:
+                    logger.warning("Milvus Manager 未初始化，跳过自动连接")
+                    return
 
             # 检查是否已连接
             if self.milvus_manager.is_connected():
@@ -260,14 +377,11 @@ async def _initialize_plugin_async(self):
             # 1. Embedding Provider 采用延迟初始化策略
             # 在后台静默尝试加载，但不阻塞插件启动
             logger.info("Embedding Provider 采用延迟初始化策略")
-
-            # 启动 Embedding Provider 后台加载任务（静默模式）
-            self._embedding_provider_task = asyncio.create_task(
-                self._initialize_embedding_provider_async(max_wait=10.0)
-            )
-
-            # 启动 Milvus 连接后台任务（在 Embedding Provider 加载后执行）
-            asyncio.create_task(self._ensure_milvus_connection_async())
+            if self._are_providers_initialized():
+                # 兼容：插件被热重载/晚加载时，Providers 可能已经就绪
+                self._start_post_load_tasks()
+            else:
+                logger.info("等待 AstrBot 启动完成后再加载 Embedding Provider")
 
             # 2. 继续初始化其他组件
             try:
@@ -410,6 +524,16 @@ async def _initialize_plugin_async(self):
             raise
 
     # --- 事件处理钩子 (调用 memory_operations.py 中的实现) ---
+    @filter.on_astrbot_loaded()
+    async def on_astrbot_loaded(self):
+        """[事件钩子] AstrBot 初始化完成后再加载依赖 Providers 的组件。"""
+        try:
+            logger.info("AstrBot 初始化完成，开始加载 Embedding Provider...")
+            self._start_post_load_tasks()
+        except Exception as e:
+            logger.error(f"处理 on_astrbot_loaded 钩子时发生捕获异常: {e}", exc_info=True)
+        return
+
     @filter.on_llm_request()
     async def query_memory(self, event: AstrMessageEvent, req: ProviderRequest):
         """[事件钩子] 在 LLM 请求前，查询并注入长期记忆。"""