sycommon-python-lib 0.2.6a11__tar.gz → 0.2.6a13__tar.gz

{sycommon_python_lib-0.2.6a11 → sycommon_python_lib-0.2.6a13}/PKG-INFO

@@ -1,23 +1,23 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.2.6a11
+Version: 0.2.6a13
 Summary: Add your description here
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 Requires-Dist: aio-pika==9.6.2
 Requires-Dist: aiohttp==3.14.1
 Requires-Dist: aiomysql==0.3.2
-Requires-Dist: anyio==4.13.0
+Requires-Dist: anyio==4.14.0
 Requires-Dist: decorator==5.3.1
 Requires-Dist: deepagents==0.6.10
 Requires-Dist: elasticsearch==9.4.1
-Requires-Dist: fastapi==0.136.3
+Requires-Dist: fastapi==0.137.1
 Requires-Dist: jinja2==3.1.6
 Requires-Dist: kafka-python==3.0.0
 Requires-Dist: langchain==1.3.9
 Requires-Dist: langchain-core==1.4.7
 Requires-Dist: langchain-openai==1.3.2
-Requires-Dist: langfuse==4.7.1
+Requires-Dist: langfuse==4.8.1
 Requires-Dist: langgraph==1.2.5
 Requires-Dist: langgraph-checkpoint-postgres==3.1.0
 Requires-Dist: langgraph-checkpoint-redis==0.4.1
@@ -33,7 +33,7 @@ Requires-Dist: python-multipart==0.0.32
 Requires-Dist: pyyaml==6.0.3
 Requires-Dist: redis==7.4.0
 Requires-Dist: sentry-sdk[fastapi]==2.62.0
-Requires-Dist: sqlalchemy[asyncio]==2.0.50
+Requires-Dist: sqlalchemy[asyncio]==2.0.51
 Requires-Dist: starlette[full]==1.3.1
 Requires-Dist: tiktoken==0.13.0
 Requires-Dist: uvicorn==0.49.0

{sycommon_python_lib-0.2.6a11 → sycommon_python_lib-0.2.6a13}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sycommon-python-lib"
-version = "0.2.6a11"
+version = "0.2.6a13"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -8,17 +8,17 @@ dependencies = [
     "aio-pika==9.6.2",
     "aiohttp==3.14.1",
     "aiomysql==0.3.2",
-    "anyio==4.13.0",
+    "anyio==4.14.0",
     "decorator==5.3.1",
     "deepagents==0.6.10",
     "elasticsearch==9.4.1",
-    "fastapi==0.136.3",
+    "fastapi==0.137.1",
     "jinja2==3.1.6",
     "kafka-python==3.0.0",
     "langchain==1.3.9",
     "langchain-core==1.4.7",
     "langchain-openai==1.3.2",
-    "langfuse==4.7.1",
+    "langfuse==4.8.1",
     "langgraph==1.2.5",
     "langgraph-checkpoint-postgres==3.1.0",
     "langgraph-checkpoint-redis==0.4.1",
@@ -34,7 +34,7 @@ dependencies = [
     "pyyaml==6.0.3",
     "redis==7.4.0",
     "sentry-sdk[fastapi]==2.62.0",
-    "sqlalchemy[asyncio]==2.0.50",
+    "sqlalchemy[asyncio]==2.0.51",
     "starlette[full]==1.3.1",
     "tiktoken==0.13.0",
     "uvicorn==0.49.0",

{sycommon_python_lib-0.2.6a11 → sycommon_python_lib-0.2.6a13}/src/sycommon/agent/deep_agent.py

@@ -1260,72 +1260,20 @@ def _parse_skill_version(content: str) -> str:
     return ""
 
 
-async def _sync_skill_to_minio(
-    minio_service,
-    local_skill_dir: str,
-    skill_name: str,
-) -> int:
-    """将单个技能目录上传到 MinIO（skills/{skill_name}/...）
-
-    Returns:
-        成功上传的文件数量
-    """
-    count = 0
-    for root, _dirs, files in os.walk(local_skill_dir):
-        for fname in files:
-            fpath = os.path.join(root, fname)
-            rel = os.path.relpath(fpath, local_skill_dir)
-            # 统一使用 / 作为分隔符
-            object_key = f"skills/{skill_name}/{rel.replace(os.sep, '/')}"
-            try:
-                content = await asyncio.to_thread(
-                    lambda p: open(p, "rb").read(), fpath)
-                await minio_service.aupload_bytes(object_key, content)
-                count += 1
-            except Exception as e:
-                SYLogger.warning(
-                    f"[MinIO] 技能文件上传失败: {object_key}, {e}")
-    SYLogger.info(f"[MinIO] 技能 {skill_name} 同步完成: {count} 个文件")
-    return count
-
-
-async def _get_minio_skill_version(minio_service, skill_name: str) -> str:
-    """从 MinIO 全局 skills/ 路径下读取技能版本"""
-    try:
-        content = await asyncio.to_thread(
-            minio_service._client.get_object,
-            minio_service._bucket,
-            f"skills/{skill_name}/SKILL.md",
-        )
-        data = content.read()
-        content.close()
-        return _parse_skill_version(data.decode("utf-8"))
-    except Exception:
-        return ""
-
-
 async def _sync_skills_to_sandbox(
     skills_dir: str,
     backend: HTTPSandboxBackend,
 ) -> None:
-    """同步技能目录到沙箱和 MinIO（按版本检查，版本不一致则全量覆盖）
+    """同步技能目录到沙箱（按版本检查，版本不一致则全量覆盖）
 
-    版本检查优先级：
-    1. 沙箱 /skills/{name}/SKILL.md — 最快，无需额外 IO
-    2. MinIO skills/{name}/SKILL.md — 沙箱为空时（新 Pod / 新沙箱）的兜底
-    版本一致则跳过，不一致或无版本则全量上传到沙箱和 MinIO。
+    技能来源是仓库内的 skills/ 目录（随部署持久，不随 Pod 重启丢失），
+    版本比较只看沙箱 /skills/{name}/SKILL.md，无需 MinIO 锚点：
+    - 沙箱有该技能且 version 一致 → 跳过
+    - 沙箱没有 / version 不一致 → 从本地 skills/ 全量上传到沙箱
     """
     if not os.path.isdir(skills_dir):
         return
 
-    try:
-        from sycommon.agent.sandbox.minio_sync import MinioSyncService
-        minio_available = MinioSyncService.is_available()
-        minio_service = MinioSyncService() if minio_available else None
-    except Exception:
-        minio_available = False
-        minio_service = None
-
     try:
         # 获取沙箱 /skills 下已有的目录列表
         existing_dirs = set()
@@ -1352,7 +1300,7 @@ async def _sync_skills_to_sandbox(
                 except Exception:
                     pass
 
-            # 比较版本：优先从沙箱读，沙箱无则从 MinIO 读
+            # 比较版本：只从沙箱 /skills/{name}/SKILL.md 读取
             remote_version = ""
             if skill_name in existing_dirs:
                 try:
@@ -1363,22 +1311,11 @@ async def _sync_skills_to_sandbox(
                 except Exception:
                     pass
 
-            # 沙箱无版本，尝试从 MinIO 全局 skills/ 读取
-            if not remote_version and minio_service:
-                remote_version = await _get_minio_skill_version(
-                    minio_service, skill_name)
-
             if remote_version and remote_version == local_version:
                 SYLogger.debug(
                     f"[DeepAgent] 技能版本一致，跳过: {skill_name} v{local_version}")
                 backend._synced_skills.add(skill_name)
                 skip_count += 1
-                # 沙箱为空但 MinIO 有（版本一致）：只恢复到沙箱，不再上传 MinIO
-                if skill_name not in existing_dirs:
-                    await backend.async_sync_dirs(
-                        [(src, f"/skills/{skill_name}")])
-                    SYLogger.info(
-                        f"[DeepAgent] 从本地恢复技能到沙箱: {skill_name} v{local_version}")
                 continue
 
             # 版本不一致或无版本，删除旧目录后全量覆盖
@@ -1399,10 +1336,6 @@ async def _sync_skills_to_sandbox(
             SYLogger.info(
                 f"[DeepAgent] 全量同步技能到沙箱: {skill_name} v{local_version}")
 
-            # 同步到 MinIO
-            if minio_service:
-                await _sync_skill_to_minio(minio_service, src, skill_name)
-
         SYLogger.info(
             f"[DeepAgent] 技能同步完成: 同步 {skill_count} 个, 跳过 {skip_count} 个")
     except Exception as e:

{sycommon_python_lib-0.2.6a11 → sycommon_python_lib-0.2.6a13}/src/sycommon/agent/sandbox/minio_sync.py

@@ -63,10 +63,23 @@ class MinioSyncService(metaclass=SingletonMeta):
             instance._initialized = True
             SYLogger.info(
                 f"[MinIO] Client initialized: {cfg['endpoint']}, bucket={instance._bucket}")
+
+            # 订阅配置热更新（幂等）
+            from sycommon.config.config_change_notifier import notifier
+            notifier.register("minio_sync", sync_cb=cls.reload)
         except Exception as e:
             SYLogger.error(f"[MinIO] Client initialization failed: {e}")
             instance._initialized = False
 
+    @classmethod
+    def reload(cls) -> None:
+        """配置热更新：清空旧 client 并按最新配置重建（setup 幂等 guard 需先置 None）。"""
+        instance = cls()
+        instance._initialized = None
+        instance._client = None
+        instance._bucket = None
+        cls.setup()
+
     def _load_config(self, config: dict = None) -> dict:
         """从 Nacos 配置或环境变量加载 MinIO 配置"""
         if config:

{sycommon_python_lib-0.2.6a11 → sycommon_python_lib-0.2.6a13}/src/sycommon/auth/wecom_ldap_service.py

@@ -211,6 +211,10 @@ class WeComLDAPService(metaclass=SingletonMeta):
         # 企微部门 ID -> 名称 缓存
         self._dept_map: Dict[int, str] = {}
 
+        # 订阅配置热更新（幂等）
+        from sycommon.config.config_change_notifier import notifier
+        notifier.register("wecom_ldap", sync_cb=self.reload)
+
     def _ensure_configs(self):
         """延迟加载配置"""
         if self._wecom_config is None:
@@ -220,6 +224,15 @@ class WeComLDAPService(metaclass=SingletonMeta):
 
             self._ldap_config = LDAPConfig.from_config()
 
+    def reload(self) -> None:
+        """配置热更新：清空缓存的 WeCom/LDAP 配置及派生缓存，下次使用重新读取。"""
+        self._wecom_config = None
+        self._ldap_config = None
+        # 派生缓存（token/index/dept）按 TTL 自然过期即可，无需立即清；
+        # access_token 直接作废，避免用旧 secret 换来的 token 继续生效。
+        self._access_token = None
+        self._token_expires_at = 0
+
     # ─── 企微 API ───
 
     async def _get_access_token(self) -> str:

sycommon_python_lib-0.2.6a13/src/sycommon/config/config_change_notifier.py

@@ -0,0 +1,171 @@
+# -*- coding: utf-8 -*-
+"""配置变更通知器（事件总线）
+
+当 Nacos 共享配置发生变更时，NacosConfigManager._sync_to_global_config() 会先
+把最新配置合并进全局 Config 单例，然后调用 notifier.fire() 通知所有订阅者。
+
+设计要点：
+    - 解耦：nacos_config_manager 不直接 import 各业务单例，各单例在自己
+      init/setup 成功后调 register() 订阅自己的 reload()。
+    - 去抖：Nacos watcher 按 dataId 独立触发，短时间内多个 dataId 连续变更
+      （或同一 dataId 抖动）会被合并成一次 fan-out，避免重复 rebuild。
+      去抖窗口默认 500ms，用 threading.Timer 实现（watcher 回调跑在 Nacos
+      SDK 线程，不在 asyncio loop 里，不能用 asyncio 定时器）。
+    - sync / async 混合回调：
+        * sync_cb 直接 inline 执行。
+        * async_cb 通过 asyncio.run_coroutine_threadsafe 投递到 Services
+          捕获的主事件循环（见 Services._init_event_loop 调用 set_loop）。
+          无可用 loop 时跳过并告警（本地 dev 模式不会触发 fire，仅兜底）。
+    - 错误隔离：任一回调抛异常只记录日志，不影响其他回调，也不会冒泡
+      到 Nacos SDK 线程导致后续 watcher 失效。
+
+典型用法（业务单例内部）：
+
+    from sycommon.config.config_change_notifier import notifier
+
+    class RedisService:
+        @classmethod
+        async def reload(cls):
+            ...
+
+        @classmethod
+        def init(cls, ...):
+            ...
+            notifier.register("redis", async_cb=cls.reload)
+"""
+import asyncio
+import threading
+from typing import Awaitable, Callable, Dict, Optional, Tuple
+
+from sycommon.logging.kafka_log import SYLogger
+
+# 默认去抖窗口（秒）：Nacos 多个 dataId 连续变更时合并为一次 reload
+_DEFAULT_DEBOUNCE_SECONDS = 0.5
+
+# 同步/异步回调签名
+SyncCB = Callable[[], None]
+AsyncCB = Callable[[], Awaitable[None]]
+
+
+class ConfigChangeNotifier:
+    """配置变更事件总线（模块级单例 ``notifier``）"""
+
+    def __init__(self, debounce_seconds: float = _DEFAULT_DEBOUNCE_SECONDS):
+        self._debounce_seconds = debounce_seconds
+        # name -> (sync_cb, async_cb)
+        self._callbacks: Dict[str, Tuple[Optional[SyncCB], Optional[AsyncCB]]] = {}
+        self._lock = threading.Lock()
+        # 待触发的去抖定时器
+        self._timer: Optional[threading.Timer] = None
+        # 业务主事件循环（由 Services._init_event_loop 注入），
+        # 用于把 async reload 投递回业务线程。
+        self._loop: Optional[asyncio.AbstractEventLoop] = None
+
+    # ------------------------------------------------------------------ 注册
+    def register(
+        self,
+        name: str,
+        sync_cb: Optional[SyncCB] = None,
+        async_cb: Optional[AsyncCB] = None,
+    ) -> None:
+        """注册一个 reload 回调（幂等：同名重复注册覆盖上一次）。
+
+        Args:
+            name: 订阅者唯一标识，建议用单例类名/服务名。
+            sync_cb: 同步 reload 函数，在 fan-out 时 inline 执行。
+            async_cb: 异步 reload 函数，通过 run_coroutine_threadsafe 投递。
+            两者至少传一个。
+        """
+        if sync_cb is None and async_cb is None:
+            return
+        with self._lock:
+            self._callbacks[name] = (sync_cb, async_cb)
+
+    def unregister(self, name: str) -> None:
+        """取消订阅。"""
+        with self._lock:
+            self._callbacks.pop(name, None)
+
+    def set_loop(self, loop: Optional[asyncio.AbstractEventLoop]) -> None:
+        """注入业务主事件循环，供 async 回调投递。"""
+        self._loop = loop
+
+    # ------------------------------------------------------------------ 触发
+    def fire(self) -> None:
+        """通知一次配置变更（去抖：窗口内多次调用合并为一次 fan-out）。"""
+        with self._lock:
+            if self._timer is not None:
+                # 已有待触发的定时器：取消并重置，相当于「滑动窗口续期」
+                self._timer.cancel()
+                self._timer = None
+            timer = threading.Timer(self._debounce_seconds, self._fan_out)
+            timer.daemon = True
+            timer.start()
+            self._timer = timer
+
+    def reload_now(self) -> None:
+        """立即触发一次 fan-out（取消挂起的去抖定时器）。供测试/手动触发。"""
+        with self._lock:
+            if self._timer is not None:
+                self._timer.cancel()
+                self._timer = None
+        self._fan_out()
+
+    def _fan_out(self) -> None:
+        """执行所有已注册回调。每个回调独立 try/except，互不影响。"""
+        # 快照一份，执行期间新的 register 不影响本轮
+        items = list(self._callbacks.items())
+        loop = self._loop
+
+        for name, (sync_cb, async_cb) in items:
+            if sync_cb is not None:
+                try:
+                    sync_cb()
+                except Exception as e:  # noqa: BLE001 - 通知器不能让单点故障扩散
+                    SYLogger.error(
+                        f"config_change_notifier: 同步 reload 失败 [{name}]: {e}",
+                        exc_info=True,
+                    )
+            if async_cb is not None:
+                self._schedule_async(name, async_cb, loop)
+
+    def _schedule_async(
+        self,
+        name: str,
+        async_cb: AsyncCB,
+        loop: Optional[asyncio.AbstractEventLoop],
+    ) -> None:
+        """把 async 回调投递到业务事件循环。无 loop 则告警跳过。"""
+        if loop is None:
+            # 兜底：尝试取当前线程的 loop（极少命中，watcher 在 SDK 线程）
+            try:
+                loop = asyncio.get_event_loop()
+            except RuntimeError:
+                loop = None
+        if loop is None or loop.is_closed():
+            SYLogger.warning(
+                f"config_change_notifier: 无可用事件循环，跳过异步 reload [{name}]"
+            )
+            return
+        try:
+            future = asyncio.run_coroutine_threadsafe(async_cb(), loop)
+
+            def _on_done(fut):
+                try:
+                    fut.result()
+                except Exception as e:  # noqa: BLE001
+                    SYLogger.error(
+                        f"config_change_notifier: 异步 reload 失败 [{name}]: {e}",
+                        exc_info=True,
+                    )
+
+            future.add_done_callback(_on_done)
+        except Exception as e:  # noqa: BLE001
+            SYLogger.error(
+                f"config_change_notifier: 投递异步 reload 失败 [{name}]: {e}",
+                exc_info=True,
+            )
+
+
+# 模块级单例
+notifier = ConfigChangeNotifier()

{sycommon_python_lib-0.2.6a11 → sycommon_python_lib-0.2.6a13}/src/sycommon/database/async_database_service.py

@@ -10,6 +10,8 @@ from sycommon.synacos.nacos_service import NacosService
 
 class AsyncDatabaseService(metaclass=SingletonMeta):
     _engine = None
+    # setup 时记录入参，供 reload() 重建使用
+    _setup_args = None
 
     @staticmethod
     async def setup_database(config: dict, shareConfigKey: str):
@@ -29,10 +31,49 @@ class AsyncDatabaseService(metaclass=SingletonMeta):
             if not await connector.test_connection():
                 raise Exception("Database connection test failed")
 
+            # 记录入参，供热更新 reload 使用
+            AsyncDatabaseService._setup_args = (config, shareConfigKey)
+            # 订阅配置热更新（幂等）
+            from sycommon.config.config_change_notifier import notifier
+            notifier.register("async_database", async_cb=AsyncDatabaseService.reload)
+
     @staticmethod
     def engine():
         return AsyncDatabaseService._engine
 
+    @staticmethod
+    async def dispose() -> None:
+        """释放异步引擎连接池资源"""
+        if AsyncDatabaseService._engine is not None:
+            try:
+                await AsyncDatabaseService._engine.dispose()
+            except Exception as e:
+                SYLogger.error(f"AsyncDatabase engine dispose error: {e}")
+            finally:
+                AsyncDatabaseService._engine = None
+
+    @classmethod
+    async def reload(cls) -> None:
+        """配置热更新：dispose 旧引擎并按最新配置重建，失败回退。"""
+        if not cls._setup_args:
+            return
+        old_engine = cls._engine
+        # 清掉 AsyncDatabaseConnector 单例缓存，使其按新配置重建
+        from sycommon.config.Config import SingletonMeta
+        SingletonMeta._instances.pop(AsyncDatabaseConnector, None)
+        try:
+            await cls.setup_database(*cls._setup_args)
+        except Exception as e:
+            SYLogger.error(f"AsyncDatabaseService reload 重建失败: {e}", exc_info=True)
+            cls._engine = old_engine
+            return
+        # 新 engine 建好，释放旧的
+        if old_engine is not None:
+            try:
+                await old_engine.dispose()
+            except Exception as e:
+                SYLogger.error(f"AsyncDatabaseService reload 释放旧 engine 失败: {e}")
+
 
 class AsyncDatabaseConnector(metaclass=SingletonMeta):
     def __init__(self, db_config: DatabaseConfig):

{sycommon_python_lib-0.2.6a11 → sycommon_python_lib-0.2.6a13}/src/sycommon/database/database_service.py

@@ -9,6 +9,8 @@ from sycommon.synacos.nacos_service import NacosService
 
 class DatabaseService(metaclass=SingletonMeta):
     _engine = None
+    # setup 时记录入参，供 reload() 重建使用（config + shareConfigKey）
+    _setup_args = None
 
     @staticmethod
     def setup_database(config: dict, shareConfigKey: str):
@@ -18,6 +20,11 @@ class DatabaseService(metaclass=SingletonMeta):
             converted_dict = convert_dict_keys(databaseConfig)
             db_config = DatabaseConfig.model_validate(converted_dict)
             DatabaseService._engine = DatabaseConnector(db_config).engine
+            # 记录入参，供热更新 reload 使用
+            DatabaseService._setup_args = (config, shareConfigKey)
+            # 订阅配置热更新（幂等）
+            from sycommon.config.config_change_notifier import notifier
+            notifier.register("database", sync_cb=DatabaseService.reload)
 
     @staticmethod
     def engine():
@@ -35,6 +42,35 @@ class DatabaseService(metaclass=SingletonMeta):
             finally:
                 DatabaseService._engine = None
 
+    @staticmethod
+    def reload() -> None:
+        """配置热更新：用最新 datasource 重建 engine，失败回退旧 engine。
+
+        注意：已存在的 BaseDBService 子类实例在 __init__ 缓存了旧 engine 的
+        sessionmaker，热切换后长期持有的实例需重新构造；通常业务侧每次请求
+        new 出来，影响有限。
+        """
+        if not DatabaseService._setup_args:
+            return
+        old_engine = DatabaseService._engine
+        DatabaseService._engine = None
+        # 清掉 DatabaseConnector 单例缓存，使其按新配置重建
+        from sycommon.config.Config import SingletonMeta
+        from sycommon.database.database_service import DatabaseConnector
+        SingletonMeta._instances.pop(DatabaseConnector, None)
+        try:
+            DatabaseService.setup_database(*DatabaseService._setup_args)
+        except Exception as e:
+            SYLogger.error(f"DatabaseService reload 重建失败: {e}", exc_info=True)
+            DatabaseService._engine = old_engine
+            return
+        # 新 engine 建好，释放旧的
+        if old_engine is not None:
+            try:
+                old_engine.dispose()
+            except Exception as e:
+                SYLogger.error(f"DatabaseService reload 释放旧 engine 失败: {e}")
+
 
 class DatabaseConnector(metaclass=SingletonMeta):
     def __init__(self, db_config: DatabaseConfig):

{sycommon_python_lib-0.2.6a11 → sycommon_python_lib-0.2.6a13}/src/sycommon/database/elasticsearch_service.py

@@ -72,6 +72,10 @@ class ElasticsearchService(metaclass=SingletonMeta):
             cls._initialized = True
             logging.info(f"ElasticsearchService 初始化成功，ES 地址: {es_config.uris}")
 
+            # 订阅配置热更新（幂等）
+            from sycommon.config.config_change_notifier import notifier
+            notifier.register("elasticsearch", async_cb=cls.reload)
+
         except Exception as e:
             logging.error(f"ElasticsearchService 初始化失败: {e}", exc_info=True)
 
@@ -102,3 +106,26 @@ class ElasticsearchService(metaclass=SingletonMeta):
             finally:
                 cls._client = None
                 cls._initialized = False
+
+    @classmethod
+    async def reload(cls) -> None:
+        """配置热更新：用最新 ElasticsearchConfig 重建 client，失败回退旧 client。"""
+        old_client = cls._client
+        cls._client = None
+        cls._initialized = False
+        try:
+            cls.init()
+        except Exception as e:
+            logging.error(f"ElasticsearchService reload 重建失败: {e}", exc_info=True)
+        if cls._initialized:
+            # 新 client 已就绪，关闭旧的
+            if old_client is not None:
+                try:
+                    await old_client.close()
+                except Exception as e:
+                    logging.debug(f"reload 关闭旧 ES 连接失败: {e}")
+        else:
+            # 重建未成功（如配置缺失），回退到旧 client
+            logging.warning("ElasticsearchService reload 未成功，保留旧 ES 连接")
+            cls._client = old_client
+            cls._initialized = old_client is not None

{sycommon_python_lib-0.2.6a11 → sycommon_python_lib-0.2.6a13}/src/sycommon/database/pg_checkpoint_service.py

@@ -103,6 +103,10 @@ class PgCheckpointService(metaclass=SingletonMeta):
                 f"PgCheckpointService 初始化成功，地址: {cls._config.host}:{cls._config.port}/{cls._config.dbname}"
             )
 
+            # 订阅配置热更新（幂等）
+            from sycommon.config.config_change_notifier import notifier
+            notifier.register("pg_checkpoint", async_cb=cls.reload)
+
         except Exception as e:
             logging.error(f"PgCheckpointService 初始化失败: {e}", exc_info=True)
             # 清理可能已创建的连接池
@@ -150,3 +154,24 @@ class PgCheckpointService(metaclass=SingletonMeta):
                 cls._pool = None
                 cls._checkpointer = None
                 cls._initialized = False
+
+    @classmethod
+    async def reload(cls) -> None:
+        """配置热更新：关闭旧连接池并按最新 llm.PostgreSQL 重建。
+
+        关键：close() 不重置 _setup_attempts，而 setup() 在达到 _max_setup_attempts
+        时会拒绝重建，所以这里必须手动重置计数器。
+        """
+        if not cls._initialized:
+            return
+        try:
+            await cls.close()
+        except Exception as e:
+            logging.error(f"PgCheckpointService reload close 失败: {e}", exc_info=True)
+        # 重置重试计数器，允许重新 setup
+        cls._setup_attempts = 0
+        cls._initialized = False
+        try:
+            await cls.setup()
+        except Exception as e:
+            logging.error(f"PgCheckpointService reload 重建失败: {e}", exc_info=True)

{sycommon_python_lib-0.2.6a11 → sycommon_python_lib-0.2.6a13}/src/sycommon/database/redis_service.py

@@ -85,6 +85,10 @@ class RedisService(metaclass=SingletonMeta):
 
             cls._initialized = True
 
+            # 订阅配置热更新（幂等）：redis.yml 变更后重建连接
+            from sycommon.config.config_change_notifier import notifier
+            notifier.register("redis", async_cb=cls.reload)
+
         except Exception as e:
             logging.error(f"RedisService 初始化失败: {e}", exc_info=True)
 
@@ -765,3 +769,20 @@ class RedisService(metaclass=SingletonMeta):
     def is_initialized(cls) -> bool:
         """检查是否已初始化"""
         return cls._initialized
+
+    @classmethod
+    async def reload(cls) -> None:
+        """配置热更新：关闭旧连接并按最新 redis.yml 重建。
+
+        重建失败（如新配置缺失/错误）时，旧连接已关闭无法回退，
+        会落入未初始化状态并记录日志。Redis 配置通常稳定，可接受。
+        """
+        if not cls._initialized:
+            # 尚未初始化：无需 reload，等首次 init 读最新配置即可
+            return
+        try:
+            await cls.close()
+        except Exception as e:
+            logging.error(f"RedisService reload 关闭旧连接失败: {e}", exc_info=True)
+        # close() 已将 _initialized 置 False；init() 不传 config 会自动读最新 redis.yml
+        cls.init()