sycommon-python-lib 0.2.7a31__tar.gz → 0.2.7a33__tar.gz

{sycommon_python_lib-0.2.7a31 → sycommon_python_lib-0.2.7a33}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.2.7a31
+Version: 0.2.7a33
 Summary: Add your description here
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
-Requires-Dist: aio-pika==9.6.2
+Requires-Dist: aio-pika==10.0.1
 Requires-Dist: aiohttp==3.14.1
 Requires-Dist: aiomysql==0.3.2
 Requires-Dist: anyio==4.14.1
@@ -13,12 +13,12 @@ Requires-Dist: deepagents==0.6.12
 Requires-Dist: elasticsearch==9.4.1
 Requires-Dist: fastapi==0.139.0
 Requires-Dist: jinja2==3.1.6
-Requires-Dist: kafka-python==3.0.7
-Requires-Dist: langchain==1.3.12
+Requires-Dist: kafka-python==3.0.8
+Requires-Dist: langchain==1.3.13
 Requires-Dist: langchain-core==1.4.9
-Requires-Dist: langchain-openai==1.3.4
-Requires-Dist: langfuse==4.13.2
-Requires-Dist: langgraph==1.2.8
+Requires-Dist: langchain-openai==1.3.5
+Requires-Dist: langfuse==4.14.0
+Requires-Dist: langgraph==1.2.9
 Requires-Dist: langgraph-checkpoint-postgres==3.1.0
 Requires-Dist: langgraph-checkpoint-redis==0.5.0
 Requires-Dist: ldap3==2.9.1

{sycommon_python_lib-0.2.7a31 → sycommon_python_lib-0.2.7a33}/pyproject.toml

@@ -1,11 +1,11 @@
 [project]
 name = "sycommon-python-lib"
-version = "0.2.7a31"
+version = "0.2.7a33"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.11"
 dependencies = [
-    "aio-pika==9.6.2",
+    "aio-pika==10.0.1",
     "aiohttp==3.14.1",
     "aiomysql==0.3.2",
     "anyio==4.14.1",
@@ -14,12 +14,12 @@ dependencies = [
     "elasticsearch==9.4.1",
     "fastapi==0.139.0",
     "jinja2==3.1.6",
-    "kafka-python==3.0.7",
-    "langchain==1.3.12",
+    "kafka-python==3.0.8",
+    "langchain==1.3.13",
     "langchain-core==1.4.9",
-    "langchain-openai==1.3.4",
-    "langfuse==4.13.2",
-    "langgraph==1.2.8",
+    "langchain-openai==1.3.5",
+    "langfuse==4.14.0",
+    "langgraph==1.2.9",
     "langgraph-checkpoint-postgres==3.1.0",
     "langgraph-checkpoint-redis==0.5.0",
     "ldap3==2.9.1",

{sycommon_python_lib-0.2.7a31 → sycommon_python_lib-0.2.7a33}/src/sycommon/agent/deep_agent.py

@@ -98,12 +98,13 @@ def _patch_agent_streaming(agent):
     删除此函数及调用即可。
     """
     # 已验证兼容的版本范围(超出仅警告, 不阻断 —— 闭包强校验是真正的安全网)
-    # 1.3.10/1.3.11/1.3.12 + langchain_core 1.4.8/1.4.9 经实测确认闭包结构兼容
-    # (factory.py 在 1.3.11→1.3.12 字节级无变化: amodel_node freevars 含
-    # _execute_model_async, 内层 freevars 含 _get_bound_model/_handle_model_output),
-    # patch 正常生效。1.3.12 的 _execute_model_async 仍为 ainvoke + 不传 config,
-    # 官方未修复, 补丁仍需保留。
-    _VERIFIED = {"langchain": "1.3.12", "langchain_core": "1.4.9"}
+    # 1.3.10/1.3.11/1.3.12/1.3.13 + langchain_core 1.4.8/1.4.9 确认闭包结构兼容
+    # (factory.py 在 1.3.12→1.3.13 逐字节无变化 —— PyPI sdist diff 实证;
+    #  amodel_node freevars 含 _execute_model_async, 内层 freevars 含
+    #  _get_bound_model/_handle_model_output), patch 正常生效。
+    # 1.3.13 的 _execute_model_async 仍为 ainvoke + 不传 config (factory.py:1467),
+    # 官方仍未修复, 补丁仍需保留。
+    _VERIFIED = {"langchain": "1.3.13", "langchain_core": "1.4.9"}
     try:
         import langchain as _lc
         import langchain_core as _lcc
@@ -377,7 +378,8 @@ class AgentConfig(BaseModel):
     internal_model_name: Optional[str] = None
     # 敏感检测提示词（应用层可覆盖）；未传(None)用基础库 DEFAULT_DETECT_PROMPT
     sensitive_detect_prompt: Optional[str] = None
-    # 命中敏感后的动作："allow"=不检测放行；"downgrade"=降级内部模型继续；"block"=直接阻断不执行
+    # 命中敏感后的动作："allow"=不检测放行；"downgrade"=降级内部模型继续；
+    # "block"=直接阻断不执行(检测整段上下文)；"block_user_input"=阻断(仅检测最后一条 HumanMessage)。
     sensitive_action: str = "allow"
 
     # 系统提示词

{sycommon_python_lib-0.2.7a31 → sycommon_python_lib-0.2.7a33}/src/sycommon/agent/middleware/sensitive_guard.py

@@ -72,6 +72,19 @@ class DowngradeState:
             self.last_source = source
             return True
 
+    async def reset(self, source: str = "user_input") -> None:
+        """清除降级标记（带锁，CAS 契约一致）。
+
+        应用层在「命中敏感后想放行下一轮重检」场景（如 block 模式阻断后，
+        用户切走/换 thread 重建 agent）应调本方法，而不是直接写
+        `state.downgraded = False`（无锁、绕过 CAS）。单 agent 下两者等价，
+        但 multi-agent 共享状态或未来跨 task 重置时，无锁直写会与
+        mark_downgraded 的 CAS 真竞态——本方法是唯一安全的重置入口。
+        """
+        async with self._lock:
+            self.downgraded = False
+            self.last_source = source
+
 
 DEFAULT_DETECT_PROMPT = """你是数据脱敏分类器。判断以下「即将发送给外部云模型」的对话上下文是否包含不宜外流的敏感数据，只回答结构化字段（is_sensitive + reason + source）。
 
@@ -237,13 +250,19 @@ class SensitiveGuardMiddleware(AgentMiddleware):
         state: Optional[DowngradeState] = None,
         # 应用层可覆盖检测提示词；未传(None)用 DEFAULT_DETECT_PROMPT
         detect_prompt: Optional[str] = None,
-        # 命中敏感后的动作："allow"=不检测放行；"downgrade"=降级内部模型继续；"block"=直接阻断(不调任何模型)
+        # 命中敏感后的动作："allow"=不检测放行；"downgrade"=降级内部模型继续；
+        # "block"=直接阻断(不调任何模型)，检测整段上下文；
+        # "block_user_input"=直接阻断，但只检测最后一条 HumanMessage(用户本轮输入)。
         action: str = "allow",
         # 阻断模式下的异步提示回调（与 on_downgrade 区分文案）；downgrade 模式不用
         on_block: Optional[Callable[[], Awaitable[None]]] = None,
         # 测试注入：绕过懒加载的真实 get_llm
         _detector: Any = None,
         _internal_raw: Any = None,
+        # 是否执行检测。多 agent 子 agent 传 False：它看到的「最后一条 HumanMessage」
+        # 多是协调者委派指令而非用户原文，重复判易误命中；改由协调者检测、子 agent 只靠
+        # 共享 DowngradeState 短路阻断。单 agent 始终 True（默认）。
+        detect: bool = True,
     ):
         self._model_tier = model_tier
         # None 时检测器/降级目标都用 get_llm() 读 nacos default 模型，不写死模型名
@@ -251,7 +270,13 @@ class SensitiveGuardMiddleware(AgentMiddleware):
         self._on_downgrade = on_downgrade
         self._on_block = on_block
         # 默认 allow（不检测）：应用层未显式指定时按"放行"处理，避免误伤。
-        self._action = action if action in ("downgrade", "block", "allow") else "allow"
+        self._action = action if action in ("downgrade", "block", "block_user_input", "allow") else "allow"
+        self._detect_enabled = detect
+        # 单轮「有附件降 block」标志：仅 block_user_input 模式下，应用层每轮 chat 前按
+        # has_file 刷新。True → 本轮按 block 行为检测（整段上下文，含工具结果/附件正文）；
+        # False → 按 block_user_input（仅最后一条 HumanMessage）。绝不改 _action，避免
+        # 与用户配的真 block 混淆（set_file_turn_degrade 在非 block_user_input 上为 no-op）。
+        self._file_turn_degrade = False
         self._enabled = enabled
         self._state = state or DowngradeState()
         self._detect_prompt = detect_prompt or DEFAULT_DETECT_PROMPT
@@ -263,15 +288,50 @@ class SensitiveGuardMiddleware(AgentMiddleware):
     def is_downgraded(self) -> bool:
         return self._state.is_downgraded
 
+    @property
+    def _is_block_turn(self) -> bool:
+        """本轮是否走阻断路径（命中即返空响应、不调任何模型）。
+
+        block 和 block_user_input 都是阻断型 action；降级标志只改「检测范围」
+        （effective_detect_messages: last_human vs all），不改「是否阻断」。
+        is_blocked 与 awrap_model_call 的 (b)(d) 共用本判定。
+        """
+        return self._action in ("block", "block_user_input")
+
     @property
     def is_blocked(self) -> bool:
-        """本会话是否已阻断（命中过敏感且 action=block）。"""
-        return self._state.is_downgraded and self._action == "block"
+        """本会话是否已阻断（命中过敏感且本轮 action 是阻断型）。
+        action ∈ {block, block_user_input} 时为 True（两者都是阻断型 action）。
+        降级标志只改检测范围（effective_detect_messages），不改是否阻断。"""
+        return self._state.is_downgraded and self._is_block_turn
 
     @property
     def action(self) -> str:
         return self._action
 
+    def set_file_turn_degrade(self, on: bool) -> None:
+        """单轮「有附件降 block」标志开关（仅对 base=block_user_input 生效）。
+
+        应用层每轮 agent.chat 开始前按本轮 has_file 调用：
+          - has_file=True  → on=True  本轮按 block 行为检测（整段上下文）
+          - has_file=False → on=False 本轮按 block_user_input 行为检测（仅用户输入）
+        只在 self._action == "block_user_input" 时生效；其它 base（allow/downgrade/block）
+        调本方法为 no-op（且强制清标志防残留），绝不改 _action。
+        """
+        if self._action == "block_user_input":
+            self._file_turn_degrade = bool(on)
+        else:
+            self._file_turn_degrade = False
+
+    @property
+    def effective_detect_messages(self) -> str:
+        """本轮检测范围标识：'all'（整段上下文）/ 'last_human'（仅最后一条 HumanMessage）。
+        block_user_input + 降级标志 → 'all'；block_user_input 无标志 → 'last_human'；
+        block/downgrade → 'all'；allow 由 (a) 短路不检测。"""
+        if self._action == "block_user_input" and not self._file_turn_degrade:
+            return "last_human"
+        return "all"
+
     @property
     def last_notice_source(self) -> str:
         """首次命中时的敏感来源(user_input/tool_result/history)，供应用层选文案。"""
@@ -281,6 +341,18 @@ class SensitiveGuardMiddleware(AgentMiddleware):
     def state(self) -> DowngradeState:
         return self._state
 
+    @staticmethod
+    def _last_human(messages: List[BaseMessage]) -> Optional[List[BaseMessage]]:
+        """取最后一条 HumanMessage，包装成单元素列表供 _detect 使用。
+
+        block_user_input 模式只检测用户本轮输入（含附件正文），工具结果/历史不进检测。
+        无 HumanMessage 返回 None（调用方放行）。
+        """
+        for m in reversed(messages):
+            if isinstance(m, HumanMessage):
+                return [m]
+        return None
+
     async def _get_detector(self):
         if self._detector is None:
             async with self._init_lock:
@@ -364,27 +436,42 @@ class SensitiveGuardMiddleware(AgentMiddleware):
         if not self._enabled or self._model_tier == "internal" or self._action == "allow":
             return await handler(request)
 
-        # (b) 本会话已命中敏感
+        # (b) 本会话已命中敏感（共享 state 已 downgraded）
         if self._state.is_downgraded:
-            # 阻断模式：直接返回空响应，不再调任何模型；应用层发完提示后会 break stream。
-            # 这里构造一个 content 空的 AIMessage，让 langgraph 把本轮当作模型已回完，
-            # 不进工具循环（无 tool_calls），干净结束。
-            if self._action == "block":
+            # 阻断路径（真 block 或 block_user_input+降级标志）：返回空响应，不再调模型。
+            if self._is_block_turn:
                 return ModelResponse(result=[AIMessage(content="")])
-            # 降级模式：路由内部模型继续；本次输入若非敏感(来自历史记忆)刷新 source=history
+            # 降级模式（downgrade，或 block_user_input 非降级轮——后者理论不会到这因 (c) 只判用户输入）：
+            # 路由内部模型继续；本次输入若非敏感(来自历史记忆)刷新 source=history
             await self._refresh_source_if_history(request.messages)
             return await handler(request.override(model=await self._get_internal_raw()))
 
-        # (c) 检测
-        check = await self._detect(request.messages)
+        # (b') detect=False 且尚未命中：放行（多 agent 子 agent 不主动检测，
+        #      等协调者命中后由共享 state 在 (b) 短路阻断）。
+        if not self._detect_enabled:
+            return await handler(request)
+
+        # (c) 检测：按 effective_detect_messages 选喂给 detector 的消息范围
+        #     block_user_input 无降级标志 → 仅最后一条 HumanMessage；其余（block/downgrade/
+        #     block_user_input+降级；allow 已在 (a) 短路不会到这）→ 整段上下文
+        if self.effective_detect_messages == "last_human":
+            detect_messages = self._last_human(request.messages)
+            if detect_messages is None:
+                # 无用户输入（理论上不会发生）→ 无从检测，放行
+                return await handler(request)
+        else:
+            # block / downgrade / block_user_input+降级：整段上下文
+            detect_messages = request.messages
+
+        check = await self._detect(detect_messages)
         if not check.is_sensitive:
             return await handler(request)
 
-        # (d) 命中 → CAS 抢占；按 action 分流
+        # (d) 命中 → CAS 抢占；按本轮是否阻断路径分流
         is_first = await self._state.mark_downgraded(check.source)
-        if self._action == "block":
+        if self._is_block_turn:
             SYLogger.info(
-                f"[SensitiveGuard] 命中敏感信息，阻断执行: {check.reason} (source={check.source})")
+                f"[SensitiveGuard] 命中敏感信息，阻断执行: {check.reason} (source={check.source}, action={self._action})")
             if is_first and self._on_block:
                 try:
                     await self._on_block()

{sycommon_python_lib-0.2.7a31 → sycommon_python_lib-0.2.7a33}/src/sycommon/agent/multi_agent_team.py

@@ -134,7 +134,7 @@ class TeamConfig(BaseModel):
     sensitive_guard: bool = True        # 是否启用敏感信息检测守卫
     internal_model_name: Optional[str] = None   # 敏感降级目标内部模型名（应用层透传）
     sensitive_detect_prompt: Optional[str] = None  # 敏感检测提示词（应用层覆盖）
-    sensitive_action: str = "allow"  # "allow"=不检测放行；"downgrade"=降级继续；"block"=阻断
+    sensitive_action: str = "allow"  # "allow"=不检测放行；"downgrade"=降级继续；"block"=阻断(整段上下文)；"block_user_input"=阻断(仅检测用户输入)
 
     coordinator_prompt: str = ""
     coordinator_name: str = "项目经理"
@@ -200,6 +200,7 @@ class MultiAgentTeam:
         coordinator_name: str = "项目经理",
         recovery_manager: Optional[SandboxRecoveryManager] = None,
         downgrade_state: Optional[DowngradeState] = None,
+        sensitive_guard: Optional["SensitiveGuardMiddleware"] = None,
     ):
         self.user_id = user_id
         self.agent = agent
@@ -210,6 +211,10 @@ class MultiAgentTeam:
         self.sandbox_backend = sandbox_backend
         self.recovery_manager = recovery_manager
         self.downgrade_state = downgrade_state
+        # 协调者的敏感检测 guard 实例（build 时传入）。暴露给应用层读 guard 状态
+        # （is_downgraded / last_notice_source / set_file_turn_degrade 等），
+        # 让单 agent 与 multi-agent 的应用层代码统一走 `getattr(agent, "sensitive_guard", None)`。
+        self.sensitive_guard = sensitive_guard
 
     @property
     def is_downgraded(self) -> bool:
@@ -628,7 +633,9 @@ async def create_multi_agent_team(
     # 任一命中 → 全员降级（敏感数据会经委派链流动，独立 state 会漏）。
     shared_downgrade_state = DowngradeState()
 
-    def _make_guard():
+    def _make_guard(detect: bool = True):
+        """协调者 detect=True（检测用户输入）；子 agent detect=False
+        （只靠共享 state 短路阻断，不把委派指令当用户输入重复判）。"""
         return SensitiveGuardMiddleware(
             model_tier=config.model_tier,
             enabled=config.sensitive_guard,
@@ -636,10 +643,11 @@ async def create_multi_agent_team(
             internal_model_name=config.internal_model_name,
             detect_prompt=config.sensitive_detect_prompt,
             action=config.sensitive_action,
+            detect=detect,
         )
 
     middleware = [
-        _make_guard(),
+        _make_guard(detect=False),
         ToolResultTruncationMiddleware(),
         TokenTrackingMiddleware(model_name=config.model_name, user_id=user_id),
         summarization_mw,
@@ -686,6 +694,10 @@ async def create_multi_agent_team(
     # 创建协调者 Agent
     coord_name = config.coordinator_name
     coord_summarization_mw = build_summarization_middleware(model, config.model_name, sandbox_backend)
+    # 协调者 guard 实例：单独构造，传给 MultiAgentTeam.sensitive_guard 供应用层读取
+    # （与单 agent 的 agent.sensitive_guard 对齐）。
+    coord_guard = _make_guard(detect=True)
+
     coordinator_agent = create_deep_agent(
         model=model,
         tools=config.shared_tools or [get_current_date],
@@ -698,7 +710,7 @@ async def create_multi_agent_team(
         debug=config.debug,
         name=coord_name,
         middleware=[
-            _make_guard(),
+            coord_guard,
             ToolResultTruncationMiddleware(),
             TokenTrackingMiddleware(model_name=config.model_name, user_id=user_id),
             coord_summarization_mw,
@@ -718,6 +730,7 @@ async def create_multi_agent_team(
         coordinator_name=coord_name,
         recovery_manager=recovery_manager,
         downgrade_state=shared_downgrade_state,
+        sensitive_guard=coord_guard,
     )
 
 

{sycommon_python_lib-0.2.7a31 → sycommon_python_lib-0.2.7a33}/src/sycommon/agent/sandbox/minio_sync.py

@@ -27,11 +27,11 @@ _SNAPSHOT_ENABLED = False
 # restore_from_minio 的 MinIO 下载并发度。
 # 两层信号量：
 #   - 单用户层 _RESTORE_PER_USER：每个用户恢复时最多 5 路并发下载（单用户恢复够快）；
-#   - 全局层   _RESTORE_GLOBAL_CAP：全进程最多 15 路下载，防 N 个用户同时恢复时
-#     N×5 路把默认线程池(≈min(32,cpu+4)=12)打满、挤占主请求路径的沙箱操作。
-# 单用户独享 5 槽 + 全局封顶 15，兼顾「单用户快」与「多用户不互相压垮」。
+#   - 全局层   _RESTORE_GLOBAL_CAP：全进程最多 100 路下载，多用户同时恢复时全局封顶，
+#     避免无限放大压垮 MinIO/网络，又留足并发让多用户恢复不互相拖慢。
+# 单用户独享 5 槽 + 全局封顶 100。
 _RESTORE_PER_USER = 5
-_RESTORE_GLOBAL_CAP = 15
+_RESTORE_GLOBAL_CAP = 100
 # 全局信号量惰性创建（绑定到首次调用时的 event loop；单 loop 部署下不变）。
 _RESTORE_DOWNLOAD_SEM: "asyncio.Semaphore | None" = None
 

{sycommon_python_lib-0.2.7a31 → sycommon_python_lib-0.2.7a33}/src/sycommon/agent/summarization_utils.py

@@ -42,6 +42,13 @@ try:
     from langchain_core.exceptions import ContextOverflowError
 
     _orig_handle_bad_request = _lc_oai_base._handle_openai_bad_request
+    _orig_handle_api_error = _lc_oai_base._handle_openai_api_error
+
+    # langchain_openai 原生识别的上下文溢出模式(1.3.5 起 bad_request/api_error 各有):
+    #   bad_request: "context_length_exceeded" / "Input tokens exceed the configured
+    #                limit" / "prompt is too long"
+    #   api_error  : "exceeds the context window"   ← 1.3.5 新增
+    # 这些都不覆盖 MiniMax/vLLM 的 "maximum context length is ..." 句式, 下方扩展补上。
 
     def _patched_handle_openai_bad_request(e: openai.BadRequestError) -> None:
         """扩展版 _handle_openai_bad_request，识别更多上下文溢出错误格式。"""
@@ -58,14 +65,11 @@ try:
                 message=e.message, response=e.response, body=e.body
             ) from e
 
-        # 回退到原始处理逻辑
+        # 回退到原始处理逻辑（含官方的 context_length_exceeded 等识别）
         _orig_handle_bad_request(e)
 
     _lc_oai_base._handle_openai_bad_request = _patched_handle_openai_bad_request
 
-    # 同步 patch _handle_openai_api_error
-    _orig_handle_api_error = _lc_oai_base._handle_openai_api_error
-
     def _patched_handle_openai_api_error(e: openai.APIError) -> None:
         """扩展版 _handle_openai_api_error，识别更多上下文溢出错误格式。"""
         error_str = str(e)
@@ -73,6 +77,7 @@ try:
             raise _lc_oai_base.OpenAIAPIContextOverflowError(
                 message=e.message, request=e.request, body=e.body
             ) from e
+        # 回退到原始处理逻辑（含官方 1.3.5 新增的 "exceeds the context window" 识别）
         _orig_handle_api_error(e)
 
     _lc_oai_base._handle_openai_api_error = _patched_handle_openai_api_error

{sycommon_python_lib-0.2.7a31 → sycommon_python_lib-0.2.7a33}/src/sycommon/config/Config.py

@@ -186,7 +186,8 @@ class Config(metaclass=SingletonMeta):
         # 但消费方按顶层 key 读取（LLMConfig 等）——提升到顶层，免得每个调用方都得知道嵌套路径。
         override_keys = ['LLMConfig', 'EmbeddingConfig', 'RerankerConfig',
                          'ACPAgentConfig',
-                         'SkillApiWhitelist']
+                         'SkillApiWhitelist',
+                         'SensitiveConfig']
         for k in override_keys:
             if k in project_cfg:
                 self.config[k] = project_cfg[k]

sycommon_python_lib-0.2.7a33/src/sycommon/tests/test_upgrade_aio_pika.py

@@ -0,0 +1,153 @@
+"""aio-pika 10 升级端到端验证（真实 RabbitMQ）。
+
+验证 aio-pika 9.6.2 → 10.0.1（aiormq 6→7）升级的核心风险点：
+1. 普通连接 connect() 的 connect+channel+publish+consume 全链路
+2. connect_robust() + RobustConnection（robust 模块在 v10 仍保留）
+3. Connection.Close 帧解析能力（用于诊断 vhost 权限等问题）
+
+连接配置取自 shengye-platform-digital-work 的 nacos-data 快照（mq.yml）。
+rabbit 用户对 /uat 无权限（broker ACL），对 / 有权限；本测试用 / 验证连通性，
+/uat 的权限问题与本次升级无关，仅在 e2e 验证时记录为已知差异。
+
+运行方式（pytest 或直接 python）：
+    uv run python -m pytest src/sycommon/tests/test_upgrade_aio_pika.py -v -s
+    python src/sycommon/tests/test_upgrade_aio_pika.py
+"""
+import asyncio
+import os
+import sys
+
+import pytest
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+import aio_pika
+from importlib.metadata import version
+
+# nacos mq.yml 配置
+MQ_HOST = "rabbitmq.test1.svc.k8s.syf.com"
+MQ_PORT = 5672
+MQ_USER = "rabbit"
+MQ_PASS = "SU7BrhDfbGbH"
+# rabbit 用户对 / 有权限；mq.yml 里的 /uat 是另一套授权用户才能访问的 vhost
+MQ_VHOST_OK = "/"
+MQ_VHOST_UAT = "uat"
+
+TEST_QUEUE = "sycommon_upgrade_test"
+TEST_MSG = b"upgrade-test"
+
+
+def _url(vhost: str) -> str:
+    return f"amqp://{MQ_USER}:{MQ_PASS}@{MQ_HOST}:{MQ_PORT}/{vhost}"
+
+
+def test_aio_pika_versions_pinned():
+    """v10 依赖链：aio-pika 10 / aiormq 7 / pamqp 4。"""
+    assert aio_pika.__version__ == "10.0.1", (
+        f"aio-pika 应为 10.0.1, 实际 {aio_pika.__version__}")
+    assert version("aiormq").split(".")[0] == "7", (
+        f"aiormq 主版本应为 7, 实际 {version('aiormq')}")
+    assert version("pamqp").split(".")[0] == "4", (
+        f"pamqp 主版本应为 4, 实际 {version('pamqp')}")
+    print(f"  [OK] aio-pika={aio_pika.__version__} "
+          f"aiormq={version('aiormq')} pamqp={version('pamqp')}")
+
+
+def test_roundtrip_plain_connection():
+    """普通连接：connect + channel + declare_queue + publish + get 全链路。"""
+    async def go():
+        conn = await aio_pika.connect(_url(MQ_VHOST_OK), timeout=10)
+        async with conn:
+            ch = await conn.channel()
+            q = await ch.declare_queue(TEST_QUEUE, auto_delete=True)
+            await ch.default_exchange.publish(
+                aio_pika.Message(body=TEST_MSG), routing_key=TEST_QUEUE)
+            msg = await q.get(timeout=5, no_ack=True)
+            return msg.body
+
+    body = asyncio.run(go())
+    assert body == TEST_MSG, f"收发不一致: {body!r}"
+    print(f"  [OK] 普通连接 roundtrip: body={body!r}")
+
+
+def test_robust_connection_roundtrip():
+    """connect_robust 返回 RobustConnection，robust 模块在 v10 仍存在且工作。"""
+    async def go():
+        conn: aio_pika.RobustConnection = await aio_pika.connect_robust(
+            _url(MQ_VHOST_OK), timeout=10)
+        info = {
+            "type": type(conn).__name__,
+            "is_robust": issubclass(type(conn), aio_pika.RobustConnection),
+            "reconnect_interval": conn.reconnect_interval,
+        }
+        async with conn:
+            ch = await conn.channel()
+            info["channel_type"] = type(ch).__name__
+            q = await ch.declare_queue(TEST_QUEUE, auto_delete=True)
+            got = asyncio.Event()
+            received = []
+
+            async def consumer(message: aio_pika.IncomingMessage):
+                received.append(message.body)
+                got.set()
+
+            await q.consume(consumer, no_ack=True)
+            await ch.default_exchange.publish(
+                aio_pika.Message(body=TEST_MSG), routing_key=TEST_QUEUE)
+            await asyncio.wait_for(got.wait(), timeout=5)
+            info["body"] = received[0]
+        return info
+
+    info = asyncio.run(go())
+    assert info["is_robust"], "connect_robust 未返回 RobustConnection 子类"
+    assert info["type"] == "RobustConnection", f"连接类型异常: {info['type']}"
+    assert info["channel_type"] == "RobustChannel", (
+        f"channel 非鲁棒类型: {info['channel_type']}")
+    assert info["body"] == TEST_MSG, f"robust 收发不一致: {info['body']!r}"
+    print(f"  [OK] RobustConnection roundtrip: "
+          f"type={info['type']} channel={info['channel_type']} "
+          f"reconnect_interval={info['reconnect_interval']} body={info['body']!r}")
+
+
+def test_uat_vhost_permission_known_issue():
+    """记录已知差异：rabbit 用户对 /uat 无权限（broker ACL，与升级无关）。
+
+    断言它确实被 broker 拒绝（reply_text 含 NOT_ALLOWED），以便未来
+    broker 授权变更时本测试会主动失败提醒复核。
+    """
+    async def go():
+        conn = await aio_pika.connect(_url(MQ_VHOST_UAT), timeout=10)
+        async with conn:
+            pass
+
+    try:
+        asyncio.run(go())
+        # 如果将来 /uat 对 rabbit 开放了权限，连接会成功 —— 提示复核
+        pytest.fail(
+            "/uat 现在可连了：broker 可能已给 rabbit 授权，请复核 mq.yml 配置")
+    except Exception as e:  # noqa: BLE001
+        cl = e.args[1] if len(getattr(e, "args", ())) > 1 else None
+        detail = ""
+        if cl is not None and hasattr(cl, "marshal"):
+            detail = cl.marshal().decode("latin1", "replace")
+        assert "NOT_ALLOWED" in detail, (
+            f"/uat 被拒但原因非权限问题，请复核: {detail!r}")
+        print(f"  [OK] /uat 确实因权限被拒（已知差异，与升级无关）: "
+              f"{detail[:60]!r}")
+
+
+if __name__ == "__main__":
+    # 直接运行模式（与 test_consumer_recovery.py 一致的 __main__ 风格）
+    async def main():
+        print("=" * 70)
+        print("  aio-pika 10 升级端到端验证")
+        print("=" * 70)
+        test_aio_pika_versions_pinned()
+        test_roundtrip_plain_connection()
+        test_robust_connection_roundtrip()
+        test_uat_vhost_permission_known_issue()
+        print("=" * 70)
+        print("  全部通过")
+        print("=" * 70)
+
+    asyncio.run(main())