sycommon-python-lib 0.2.5a35__py3-none-any.whl → 0.2.5a36__py3-none-any.whl

sycommon/agent/deep_agent.py

@@ -201,26 +201,41 @@ def _patch_agent_streaming(agent):
             model_, effective_response_format = _get_bound_model(request)
             messages = request.messages
 
-            # 🔑 根治摘要泄漏：将 lc_source="summarization" 的 HumanMessage 从模型输入中移除
+            # 🔑 根治摘要泄漏：将 lc_source="summarization" 的 HumanMessage 内容
+            # 注入到 system_message 而非直接丢弃，保持记忆连续性。
             # 根因分析（2026-06-06 端到端测试确认）：
-            # 1. SummarizationMiddleware 将摘要(可达 40K+ 字符)注入为 HumanMessage
-            # 2. 即使转为 SystemMessage + <system_directive> 指令，模型仍会将其作为
-            #    AIMessageChunk 直接回显（Round 20 泄漏了 40K 字符摘要原文）
-            # 3. LangGraph StreamMessagesHandler._find_and_emit_messages 会递归遍历
-            #    Command.update 中的 _summarization_event，将 summary_message HumanMessage
-            #    发射到 stream_mode="messages" 流中（deep_agent.py:624 的 lc_source 过滤
-            #    能捕获 HumanMessage，但模型自己输出的 AIMessageChunk 无法过滤）
-            # 修复策略：从模型输入中完全移除摘要 HumanMessage，不注入任何形式的摘要内容
-            # 摘要仍保留在 LangGraph _summarization_event 状态中，供后续压缩轮次使用
+            # 1. SummarizationMiddleware 将摘要注入为 HumanMessage
+            # 2. 模型看到 HumanMessage 后容易将其作为对话内容回显/复述
+            # 3. 之前完全移除摘要导致压缩后模型丢失所有记忆
+            # 修复策略：提取摘要内容 → 注入 SystemMessage（模型视其为指令/背景知识，
+            # 回显概率远低于 HumanMessage）→ 从 messages 中移除原始 HumanMessage
+            _summary_text = None
             _filtered_messages = []
             for _msg in messages:
                 if (isinstance(_msg, HumanMessage)
                         and getattr(_msg, "additional_kwargs", {}).get("lc_source") == "summarization"):
-                    SYLogger.debug("[DeepAgent] 摘要 HumanMessage 已从模型输入中移除（防止回显泄漏）")
+                    _raw = _msg.content or ""
+                    # 去掉 <internal_context_data> 包装标签，提取纯摘要
+                    _summary_text = re.sub(
+                        r'</?internal_context_data>', '', _raw, flags=re.DOTALL
+                    ).strip()
+                    SYLogger.debug("[DeepAgent] 摘要已从 HumanMessage 提取，将注入 system_message")
                 else:
                     _filtered_messages.append(_msg)
             messages = _filtered_messages
 
+            if _summary_text and request.system_message:
+                from deepagents.middleware._utils import append_to_system_message
+                _summary_directive = (
+                    "\n\n<system_context>\n"
+                    "以下是之前对话历史的压缩摘要，作为你的内部记忆使用。"
+                    "把它当作你自己的回忆，绝对不要在回复中重复、复述或引用此内容的任何部分。\n"
+                    f"{_summary_text}\n"
+                    "</system_context>"
+                )
+                _new_sys = append_to_system_message(request.system_message, _summary_directive)
+                request = request.override(system_message=_new_sys)
+
             if request.system_message:
                 messages = [request.system_message, *messages]
 
@@ -621,6 +636,19 @@ class DeepAgent:
                 else:
                     content = raw_content or ""
 
+                # 🔑 Defense 3: 清理 AI 输出中的摘要泄漏标签（安全网）
+                # 即使摘要已注入 SystemMessage，模型仍可能在极少数情况下回显标签
+                if msg_type in ("AIMessage", "AIMessageChunk") and content:
+                    for _pat in [
+                        r'<internal_context_data>.*?</internal_context_data>',
+                        r'<compressed_history>.*?</compressed_history>',
+                        r'<system_context>.*?</system_context>',
+                    ]:
+                        if re.search(_pat, content, re.DOTALL):
+                            content = re.sub(_pat, '', content, flags=re.DOTALL)
+                            SYLogger.warning("[DeepAgent] AI 输出包含摘要泄漏标签，已清理")
+                    content = content.strip()
+
                 if msg_type in ("AIMessage", "AIMessageChunk"):
                     # 🔑 提取 reasoning_content（思考/推理内容）
                     # 模型在 thinking 模式下会将推理过程放在 reasoning_content 字段，

sycommon/agent/summarization_utils.py

@@ -182,9 +182,10 @@ _orig_build_new_messages = _OrigDeepAgentsSumm._build_new_messages_with_path
 def _patched_build_new_messages(self, summary, file_path):
     content = (
         "<internal_context_data>\n"
-        "IMPORTANT - INTERNAL SYSTEM DATA - DO NOT OUTPUT, PARAPHRASE, OR REFERENCE "
-        "ANY PART OF THIS BLOCK IN YOUR RESPONSE. "
-        "Use this information only as internal background knowledge to understand context.\n\n"
+        "[系统内部记忆]\n"
+        "这是你的内部记忆，帮助你回忆之前的对话。"
+        "把它当作你自己的回忆，而不是要输出的内容。"
+        "绝对不要在回复中提及、复述或引用此内容的任何部分。\n\n"
     )
     if file_path is not None:
         content += (

sycommon/middleware/traceid.py

@@ -40,10 +40,7 @@ def setup_trace_id_handler(app):
                     request_body = json.loads(raw_text)
                 else:
                     request_body = await request.json()
-                # 截断过大的 JSON body（如包含 base64 文件内容的请求）
                 body_str = json.dumps(request_body, ensure_ascii=False)
-                if len(body_str) > 5000:
-                    request_body = {"_truncated": f"请求体 {len(body_str)} 字节，已省略"}
             except Exception:
                 try:
                     request_body = await request.json()

sycommon/rabbitmq/rabbitmq_client.py

@@ -74,7 +74,6 @@ class RabbitMQClient:
 
         # 并发控制
         self._connect_lock = asyncio.Lock()
-        self._reconnect_semaphore = asyncio.Semaphore(1)
 
         # 异步任务并发控制（方案C：收到即ACK + create_task，复用 prefetch_count）
         self.prefetch_count = kwargs.get('prefetch_count', 2)
@@ -235,9 +234,8 @@ class RabbitMQClient:
             # 不符合命名规范或无队列名，清空队列引用
             self._queue = None
 
-    async def _cleanup_before_reconnect(self) -> None:
-        """重连前彻底清理旧资源，防止内存泄露"""
-        # 1. 取消正在运行的后台 handler 任务
+    async def _cleanup_running_tasks(self) -> None:
+        """仅清理后台 handler 任务（不做任何破坏性清理，不调 queue.cancel、不关通道）"""
         if self._running_tasks:
             for t in list(self._running_tasks):
                 if not t.done():
@@ -252,37 +250,8 @@ class RabbitMQClient:
                 pass
             self._running_tasks.clear()
 
-        # 2. 清理连接关闭回调（移除对 self/loop 的引用）
-        if self._channel_conn:
-            try:
-                if self._channel_conn.close_callbacks:
-                    self._channel_conn.close_callbacks.clear()
-            except Exception:
-                pass
-
-        # 3. 停止消费
-        try:
-            if self._consumer_tag and self._queue:
-                await self._queue.cancel(self._consumer_tag)
-        except Exception:
-            pass
-
-        # 4. 关闭旧通道
-        if self._channel and not self._channel.is_closed:
-            try:
-                await self._channel.close()
-            except Exception:
-                pass
-
-        # 5. 置空所有引用
-        self._channel = None
-        self._channel_conn = None
-        self._exchange = None
-        self._queue = None
-        self._consumer_tag = None
-
     async def connect(self) -> None:
-        """连接方法"""
+        """连接方法 — 信任 aio-pika Robust 自动恢复，不注册 on_conn_closed"""
         if self._closed:
             raise RuntimeError("客户端已关闭，无法重新连接")
 
@@ -296,31 +265,17 @@ class RabbitMQClient:
             was_consuming = self._consumer_tag is not None
 
             try:
-                # 1. 彻底清理旧资源（防止内存泄露）
-                await self._cleanup_before_reconnect()
-
-                # 2. 获取新资源
-                self._channel, self._channel_conn = await self.connection_pool.acquire_channel()
-
-                # 3. 设置连接关闭回调
-                loop = asyncio.get_running_loop()
+                # 仅清理后台 handler 任务（不调 queue.cancel、不关通道、不清回调）
+                await self._cleanup_running_tasks()
 
-                def on_conn_closed(conn, exc):
-                    if self._closed:
-                        return
-                    logger.warning(f"检测到底层连接关闭: {exc}")
-                    try:
-                        if not loop.is_closed():
-                            asyncio.run_coroutine_threadsafe(
-                                self._safe_reconnect(), loop)
-                    except RuntimeError:
-                        pass
-
-                if self._channel_conn:
-                    self._channel_conn.close_callbacks.add(on_conn_closed)
-
-                # 4. 重建 Exchange/Queue
-                await self._rebuild_resources()
+                # 如果已有通道且未关闭，直接复用（aio-pika Robust 自动恢复的）
+                if self._channel and not self._channel.is_closed:
+                    # 通道还活着，只需重建 exchange/queue 绑定
+                    await self._rebuild_resources()
+                else:
+                    # 通道不可用，从连接池获取新通道
+                    self._channel, self._channel_conn = await self.connection_pool.acquire_channel()
+                    await self._rebuild_resources()
 
             except Exception as e:
                 logger.error(f"客户端连接失败: {str(e)}", exc_info=True)
@@ -329,7 +284,7 @@ class RabbitMQClient:
                 self._queue = None
                 raise
 
-            # 5. 恢复消费
+            # 恢复消费
             if was_consuming and self._message_handler:
                 if self._queue:
                     logger.info("🔄 检测到重连前处于消费状态，尝试自动恢复消费...")
@@ -341,41 +296,6 @@ class RabbitMQClient:
                 else:
                     logger.warning("⚠️ 队列对象无效，暂缓恢复消费，等待监控器兜底")
 
-    async def _safe_reconnect(self):
-        """安全重连任务（不限制重试次数，由连接监控器兜底）
-
-        内存安全保证：
-        - 每次重试前通过 connect() -> _cleanup_before_reconnect() 彻底清理旧资源
-        - _cleanup_before_reconnect 会取消后台任务、关闭旧通道、清除回调引用
-        - connect() 持有 _connect_lock 保证不会并发创建重复资源
-        - 拉长失败间隔，避免频繁重连累积未清理的资源
-        """
-        async with self._reconnect_semaphore:
-            if self._closed or await self.is_connected:
-                return
-            logger.info("触发后台安全重连...")
-            attempt = 0
-            while not self._closed:
-                if await self.is_connected:
-                    return
-                attempt += 1
-                try:
-                    # 前5次间隔5秒，之后每5次拉长到30秒，避免频繁创建/销毁资源
-                    if attempt <= 5:
-                        await asyncio.sleep(5)
-                    else:
-                        logger.info(f"已连续失败 {attempt} 次，等待30秒后继续...")
-                        await asyncio.sleep(30)
-
-                    # connect() 内部会先调用 _cleanup_before_reconnect() 清理旧资源
-                    # 确保不会累积未关闭的通道/回调/任务
-                    await self.connect()
-                    if await self.is_connected:
-                        return
-                except Exception as e:
-                    logger.warning(
-                        f"后台重连尝试 {attempt} 失败: {e}")
-
     async def set_message_handler(self, handler: Callable) -> None:
         if not callable(handler):
             raise TypeError("消息处理器必须是可调用对象")

sycommon/rabbitmq/rabbitmq_service_client_manager.py

@@ -28,7 +28,8 @@ class RabbitMQClientManager(RabbitMQCoreService):
 
     @classmethod
     async def _clean_client_resources(cls, client: RabbitMQClient) -> None:
-        """彻底清理客户端资源，防止重连时内存泄露"""
+        """清理客户端资源 — 不做破坏性清理（不调 stop_consuming/queue.cancel、不清 close_callbacks）
+        信任 aio-pika Robust 自动恢复机制，只清理后台任务和置空引用。"""
         # 1. 取消正在运行的后台 handler 任务
         if client._running_tasks:
             for t in list(client._running_tasks):
@@ -43,29 +44,7 @@ class RabbitMQClientManager(RabbitMQCoreService):
                 pass
             client._running_tasks.clear()
 
-        # 2. 清理连接关闭回调（移除对 client/loop 的闭包引用）
-        if client._channel_conn:
-            try:
-                if client._channel_conn.close_callbacks:
-                    client._channel_conn.close_callbacks.clear()
-            except Exception:
-                pass
-
-        # 3. 停止消费
-        try:
-            if client._consumer_tag:
-                await client.stop_consuming()
-        except Exception as e:
-            logger.warning(f"停止消费逻辑异常: {str(e)}")
-
-        # 4. 关闭通道
-        if client._channel and not client._channel.is_closed:
-            try:
-                await client._channel.close()
-            except Exception as e:
-                logger.warning(f"关闭通道异常: {str(e)}")
-
-        # 5. 置空所有引用
+        # 2. 置空引用（不调 queue.cancel、不关通道、不清 close_callbacks）
         client._channel = None
         client._channel_conn = None
         client._exchange = None

sycommon/rabbitmq/rabbitmq_service_connection_monitor.py

@@ -16,7 +16,8 @@ class RabbitMQConnectionMonitor(RabbitMQClientManager):
 
     @classmethod
     async def _monitor_connections(cls):
-        """连接监控任务：定期检查所有客户端连接状态和消费者健康"""
+        """连接监控任务：定期检查所有客户端连接状态和消费者健康
+        信任 aio-pika Robust 自动恢复，Monitor 只做兜底检测+安全重启。"""
         logger.info("RabbitMQ连接监控任务启动")
         while not cls._is_shutdown:
             try:
@@ -43,20 +44,22 @@ class RabbitMQConnectionMonitor(RabbitMQClientManager):
                 # 检查所有客户端连接
                 for client_name, client in list(cls._clients.items()):
                     try:
-                        # 跳过正在重连的客户端（任务存在于_reconnect_tasks且未完成）
+                        # 跳过正在重连的客户端
                         if client_name in cls._reconnect_tasks:
                             continue
 
                         client_connected = await client.is_connected
+
+                        # 连接断开 → 尝试重连（不做破坏性清理）
                         if not client_connected:
                             logger.warning(
-                                f"客户端 '{client_name}' 连接异常，触发重连")
+                                f"客户端 '{client_name}' 连接异常，尝试重连")
                             task = asyncio.create_task(
                                 cls._reconnect_client_with_cleanup(client_name, client))
                             cls._reconnect_tasks[client_name] = task
                             continue
 
-                        # 消费者健康检查：handler存在但消费者丢失，重启消费任务
+                        # 消费者健康检查：handler存在但消费者丢失
                         if client._message_handler and client._consumer_tag is None:
                             logger.warning(
                                 f"客户端 '{client_name}' 消费者丢失(handler存在但无consumer_tag)，重新注册消费")
@@ -73,7 +76,7 @@ class RabbitMQConnectionMonitor(RabbitMQClientManager):
 
     @classmethod
     async def _restart_consumer_if_needed(cls, client_name: str):
-        """重启消费任务（如果任务已结束或不存在）"""
+        """重启消费任务（修复假死问题：不仅看 task.done()，还要看 consumer_tag）"""
         try:
             from sycommon.rabbitmq.rabbitmq_service_consumer_manager import RabbitMQConsumerManager
 
@@ -81,16 +84,34 @@ class RabbitMQConnectionMonitor(RabbitMQClientManager):
             if client_name not in RabbitMQConsumerManager._message_handlers:
                 return
 
-            # 清理已结束的消费任务
-            if client_name in RabbitMQConsumerManager._consumer_tasks:
-                if RabbitMQConsumerManager._consumer_tasks[client_name].done():
-                    del RabbitMQConsumerManager._consumer_tasks[client_name]
-                else:
-                    # 任务还在运行，无需重启
-                    return
+            # 检查消费任务状态
+            task_exists = client_name in RabbitMQConsumerManager._consumer_tasks
+            task = RabbitMQConsumerManager._consumer_tasks.get(client_name)
+            has_tag = client_name in RabbitMQConsumerManager._consumer_tags
+
+            # task 已结束 → 清理并重启
+            if task_exists and task.done():
+                del RabbitMQConsumerManager._consumer_tasks[client_name]
+                logger.info(f"消费者 '{client_name}' 任务已结束，重新创建")
+                await RabbitMQConsumerManager.start_consumer(client_name)
+                return
+
+            # task 还在运行但没有 consumer_tag → 假死！取消旧 task 并重启
+            if task_exists and not task.done() and not has_tag:
+                logger.warning(
+                    f"消费者 '{client_name}' 检测到假死 (task运行中但无consumer_tag)，强制取消并重启")
+                task.cancel()
+                try:
+                    await asyncio.wait_for(task, timeout=5.0)
+                except (asyncio.TimeoutError, asyncio.CancelledError):
+                    pass
+                del RabbitMQConsumerManager._consumer_tasks[client_name]
+                await RabbitMQConsumerManager.start_consumer(client_name)
+                logger.info(f"✅ 消费者 '{client_name}' 假死恢复完成")
+                return
+
+            # task 运行中且有 tag → 正常，无需处理
 
-            await RabbitMQConsumerManager.start_consumer(client_name)
-            logger.info(f"✅ 消费者 '{client_name}' 已重新注册")
         except Exception as e:
             logger.error(f"重启消费者 '{client_name}' 失败: {e}", exc_info=True)
 

sycommon/rabbitmq/rabbitmq_service_consumer_manager.py

@@ -177,34 +177,16 @@ class RabbitMQConsumerManager(RabbitMQClientManager):
                 logger.error(
                     f"消费者 '{client_name}' 发生异常: {str(e)}", exc_info=True)
             finally:
-                # 确保清理消费者标记
+                # 清理 consumer tag 记录（不调 stop_consuming，不杀 RobustQueue._consumers）
                 if client_name in cls._consumer_tags:
                     del cls._consumer_tags[client_name]
-                # 停止客户端消费状态
-                try:
-                    await client.stop_consuming()
-                except Exception:
-                    pass
+                client._consumer_tag = None
                 logger.info(f"消费者 '{client_name}' 任务已结束")
 
         task = asyncio.create_task(
             consume_task(), name=f"consumer-{client_name}")
         cls._consumer_tasks[client_name] = task
 
-        def task_done_callback(t: asyncio.Task) -> None:
-            try:
-                if t.done():
-                    exc = t.exception()
-                    if exc and not isinstance(exc, asyncio.CancelledError):
-                        logger.error(f"消费者任务 '{client_name}' 异常结束: {exc}")
-            except asyncio.CancelledError:
-                pass
-            except Exception as e:
-                logger.error(f"回调处理异常: {e}")
-
-        task.add_done_callback(task_done_callback)
-        logger.info(f"消费者任务 '{client_name}' 已创建")
-
     @classmethod
     async def shutdown_consumers(cls, timeout: float = 15.0) -> None:
         """关闭所有消费者 (增强版：确保资源彻底释放)"""

sycommon/tests/test_consumer_loss_rootcause.py

@@ -0,0 +1,399 @@
+"""
+消费者丢失根因验证测试 (v3 - 精简版)
+
+验证 3 个核心根因:
+  场景1: queue.cancel() 从 RobustQueue._consumers 删除消费者 → 永久丧失恢复能力
+  场景2: consume_task "假死" → Monitor 误判 → 消费者永久丢失
+  场景3: 完整复现: 断连 → aio-pika 恢复 _consumers → 但 _safe_reconnect 抢先执行 _cleanup 杀死一切
+
+使用方法:
+    cd sycommon-python-lib/src
+    python -m sycommon.tests.test_consumer_loss_rootcause
+"""
+import asyncio
+import json
+import time
+import sys
+import os
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", ".."))
+
+MQ_HOST = "rabbitmq.test1.svc.k8s.syf.com"
+MQ_PORT = 5672
+MQ_USER = "rabbit"
+MQ_PASS = "SU7BrhDfbGbH"
+MQ_VHOST = "/uat"
+APP_NAME = "consumer-loss-test"
+EXCHANGE = "system.topic.exchange"
+TEST_QUEUE_PREFIX = "test.loss"
+FULL_QUEUE = f"{TEST_QUEUE_PREFIX}.{APP_NAME}"
+ROUTING_KEY = f"{TEST_QUEUE_PREFIX.split('.')[0]}.#"
+
+T0 = time.time()
+
+
+def log(msg):
+    print(f"[{time.time()-T0:6.1f}s] {msg}", flush=True)
+
+
+async def create_pool_and_consumer():
+    from sycommon.rabbitmq.rabbitmq_pool import RabbitMQConnectionPool
+    from sycommon.rabbitmq.rabbitmq_client import RabbitMQClient
+
+    pool = RabbitMQConnectionPool(
+        hosts=[MQ_HOST], port=MQ_PORT, username=MQ_USER, password=MQ_PASS,
+        virtualhost=MQ_VHOST, heartbeat=60, app_name=APP_NAME,
+        connection_timeout=30, reconnect_interval=5, prefetch_count=2,
+    )
+    await pool.init_pools()
+    consumer = RabbitMQClient(
+        connection_pool=pool, exchange_name=EXCHANGE, exchange_type="topic",
+        queue_name=FULL_QUEUE, app_name=APP_NAME, routing_key=ROUTING_KEY,
+        durable=True, auto_delete=False, create_if_not_exists=True, prefetch_count=2,
+    )
+    return pool, consumer
+
+
+async def send_probe(pool):
+    from aio_pika import Message, DeliveryMode
+    ch, _ = await pool.acquire_channel()
+    try:
+        ex = await ch.declare_exchange(name=EXCHANGE, type="topic", durable=True, auto_delete=False)
+        body = json.dumps({
+            "topicCode": "test",
+            "msg": f"probe-{int(time.time()*1000)}",
+            "traceId": f"trace-{int(time.time()*1000)}"
+        }).encode()
+        msg = Message(body=body, content_type="application/json",
+                      delivery_mode=DeliveryMode.PERSISTENT)
+        await ex.publish(message=msg, routing_key=ROUTING_KEY, timeout=5.0)
+    finally:
+        try:
+            await ch.close()
+        except Exception:
+            pass
+
+
+async def cleanup_queue():
+    """清理测试队列（避免残留消息影响）"""
+    try:
+        pool, consumer = await create_pool_and_consumer()
+        ch, _ = await pool.acquire_channel()
+        try:
+            await ch.queue_delete(queue_name=FULL_QUEUE)
+        except Exception:
+            pass
+        try:
+            await ch.close()
+        except Exception:
+            pass
+        await pool.close()
+    except Exception:
+        pass
+
+
+# ═══════════════════════════════════════════════════════════════════
+# 场景 1: cancel 删除消费者
+# ═══════════════════════════════════════════════════════════════════
+async def test_1_cancel_destroys_recovery():
+    """
+    验证: queue.cancel(tag) 从 aio-pika RobustQueue._consumers 中删除消费者。
+    断连后 aio-pika 恢复时遍历 _consumers 为空 → 不恢复 → 消费者永久丢失。
+    """
+    log("=" * 70)
+    log("场景1: queue.cancel() 从 RobustQueue._consumers 删除消费者")
+    log("-" * 70)
+
+    pool, consumer = await create_pool_and_consumer()
+    received = [0]
+
+    async def handler(msg, raw):
+        received[0] += 1
+        log(f"  📥 #{received[0]}: {msg.msg}")
+
+    await consumer.set_message_handler(handler)
+    await consumer.connect()
+    tag = await consumer.start_consuming()
+    log(f"  ✅ 消费者启动, tag={tag}")
+
+    # 验证 _consumers 有值
+    consumers_before = list(consumer._queue._consumers.keys())
+    log(f"  stop_consuming 前 _consumers: {consumers_before}")
+    assert tag in consumers_before, f"tag {tag} 应在 _consumers 中"
+
+    # 执行 stop_consuming (你的 _cleanup_before_reconnect 内部调用)
+    await consumer.stop_consuming()
+
+    # 检查 _consumers
+    consumers_after = list(consumer._queue._consumers.keys())
+    log(f"  stop_consuming 后 _consumers: {consumers_after}")
+
+    # 断连后 aio-pika 恢复
+    if consumer._channel_conn and not consumer._channel_conn.is_closed:
+        # 移除 on_conn_closed 避免 _safe_reconnect 干扰
+        consumer._channel_conn.close_callbacks.clear()
+        await consumer._channel_conn.close()
+    await asyncio.sleep(8)
+
+    consumers_recovered = list(consumer._queue._consumers.keys()) if consumer._queue else []
+    log(f"  aio-pika 恢复后 _consumers: {consumers_recovered}")
+
+    # 验证消息无法被消费
+    old = received[0]
+    try:
+        await send_probe(pool)
+    except Exception as e:
+        log(f"  发送失败: {e}")
+    await asyncio.sleep(5)
+    final = received[0] - old
+    log(f"  消费验证: 收到 {final} 条 (期望0=消费者丢失)")
+
+    ok = (tag not in consumers_after) and (len(consumers_recovered) == 0) and (final == 0)
+    if ok:
+        log("  ✅ 根因1已验证: stop_consuming → cancel → _consumers清空 → 永久丢失")
+    else:
+        log(f"  ⚠️ 部分验证: cancel后={tag not in consumers_after}, "
+            f"恢复后空={len(consumers_recovered)==0}, 无法消费={final==0}")
+
+    await consumer.close()
+    await pool.close()
+    return ok
+
+
+# ═══════════════════════════════════════════════════════════════════
+# 场景 2: consume_task 假死
+# ═══════════════════════════════════════════════════════════════════
+async def test_2_zombie_task():
+    """
+    验证: consume_task 在 stop_event.wait() 挂起,
+    consumer_tag 被清空后 task.done()==False → Monitor 不重启 → 永久丢失。
+    """
+    log("=" * 70)
+    log("场景2: consume_task '假死' → Monitor 误判 → 永久丢失")
+    log("-" * 70)
+
+    pool, consumer = await create_pool_and_consumer()
+    await consumer.set_message_handler(lambda msg, raw: None)
+    await consumer.connect()
+    tag = await consumer.start_consuming()
+    log(f"  ✅ 消费者启动, tag={tag}")
+
+    # 模拟 consume_task
+    stop_event = asyncio.Event()
+    manager_tags = {"test_q": tag}
+
+    async def mock_consume_task():
+        await stop_event.wait()  # 永远挂起（真实行为）
+        manager_tags.pop("test_q", None)
+
+    task = asyncio.create_task(mock_consume_task())
+    await asyncio.sleep(0.3)
+
+    log(f"  初始: task.done()={task.done()}, manager_tag={manager_tags.get('test_q')}")
+
+    # 模拟: consumer_tag 被清理 (连接断开 → _cleanup)
+    consumer._consumer_tag = None
+    manager_tags.pop("test_q", None)
+
+    log(f"  清理后: task.done()={task.done()}, manager_tag={manager_tags.get('test_q')}")
+
+    # 模拟 Monitor 的 _restart_consumer_if_needed
+    # 真实代码: if client_name in _consumer_tasks and not task.done(): return
+    if not task.done():
+        log("  ✅ 根因2已验证: task.done()==False → Monitor 跳过重启 → 消费者永久丢失")
+        log("     Monitor 代码: if task.done(): del+restart else: return")
+        log("     实际 tag=None (消费者不工作), 但 task 还在 wait → 被认为正常")
+        ok = True
+    else:
+        log("  ⚠️ task 已结束 (非预期)")
+        ok = False
+
+    task.cancel()
+    try:
+        await task
+    except asyncio.CancelledError:
+        pass
+    await consumer.close()
+    await pool.close()
+    return ok
+
+
+# ═══════════════════════════════════════════════════════════════════
+# 场景 3: 完整复现 — _safe_reconnect 杀死 aio-pika 恢复
+# ═══════════════════════════════════════════════════════════════════
+async def test_3_full_reproduce():
+    """
+    完整复现:
+    1. 启动消费者，初始消费正常
+    2. 断开连接
+    3. aio-pika 自动恢复 (5s后), _consumers 重新填充
+    4. 但 _safe_reconnect 也在 5s 后执行, 先于或同时于 aio-pika 恢复
+    5. _safe_reconnect → connect → _cleanup_before_reconnect
+       → stop_consuming() 杀死 aio-pika 恢复的消费者
+    6. 最终: connected=True, 但 _consumers=空, 消费者丢失
+    """
+    log("=" * 70)
+    log("场景3: 完整复现 — _safe_reconnect 与 aio-pika 恢复冲突")
+    log("-" * 70)
+
+    pool, consumer = await create_pool_and_consumer()
+    received = [0]
+
+    async def handler(msg, raw):
+        received[0] += 1
+        log(f"  📥 #{received[0]}: {msg.msg}")
+
+    await consumer.set_message_handler(handler)
+    await consumer.connect()
+    tag = await consumer.start_consuming()
+    log(f"  ✅ 消费者启动, tag={tag}")
+
+    # 验证初始消费
+    await asyncio.sleep(1)
+    old = received[0]
+    await send_probe(pool)
+    await asyncio.sleep(3)
+    initial_ok = received[0] > old
+    log(f"  初始消费: {'✅' if initial_ok else '⚠️'} (收到 {received[0]-old})")
+
+    # 记录初始 _consumers
+    consumers_init = list(consumer._queue._consumers.keys())
+    log(f"  初始 _consumers: {consumers_init}")
+
+    # 断开连接 — on_conn_closed 会在 5s 后触发 _safe_reconnect
+    # 同时 aio-pika 的 __connection_factory 也会在 5s 后重连
+    log("  ⚡ 断开连接 (on_conn_closed + __connection_factory 都会恢复)...")
+    conn = consumer._channel_conn
+    if conn and not conn.is_closed:
+        await conn.close()
+    await asyncio.sleep(1)
+
+    # 等待两者都执行完 (足够长)
+    log("  ⏳ 等待 25s (aio-pika 5s + _safe_reconnect 5s + 缓冲)...")
+    await asyncio.sleep(25)
+
+    # 检查最终状态
+    is_connected = await consumer.is_connected
+    final_consumers = []
+    if consumer._queue and hasattr(consumer._queue, '_consumers'):
+        final_consumers = list(consumer._queue._consumers.keys())
+
+    log(f"  最终状态:")
+    log(f"    connected={is_connected}")
+    log(f"    _consumers={final_consumers}")
+    log(f"    consumer._consumer_tag={consumer._consumer_tag}")
+    log(f"    consumer._channel={consumer._channel is not None}")
+    log(f"    consumer._queue={consumer._queue is not None}")
+
+    # 验证消费
+    old = received[0]
+    try:
+        await send_probe(pool)
+    except Exception as e:
+        log(f"    发送失败: {e}")
+    await asyncio.sleep(5)
+    final_received = received[0] - old
+    log(f"    最终消费: 收到 {final_received} 条")
+
+    # 判定
+    if final_received == 0:
+        log("  ✅ 成功复现: 消费者丢失!")
+        if is_connected and len(final_consumers) == 0:
+            log("     连接正常但 _consumers 为空: aio-pika 恢复被 _safe_reconnect 杀死")
+        elif not is_connected:
+            log("     连接也未恢复: 两者互相干扰导致彻底断连")
+        ok = True
+    elif is_connected and len(final_consumers) > 0 and final_received > 0:
+        log("  ℹ️ 本次未丢失: 可能 _safe_reconnect 在 aio-pika 恢复之前执行")
+        log("     或者 aio-pika 恢复更快, 且 _safe_reconnect 的 cleanup 未造成影响")
+        log("     这不代表生产环境安全 — 时序不确定, 两者竞争是确定性问题")
+        ok = False
+    else:
+        log(f"  ℹ️ 中间状态: connected={is_connected}, consumers={len(final_consumers)}, "
+            f"received={final_received}")
+        ok = is_connected and len(final_consumers) > 0
+
+    await consumer.close()
+    await pool.close()
+    return ok
+
+
+# ═══════════════════════════════════════════════════════════════════
+# 主入口
+# ═══════════════════════════════════════════════════════════════════
+async def main():
+    global T0
+    T0 = time.time()
+
+    log("=" * 70)
+    log("  MQ 消费者丢失根因验证 v3")
+    log(f"  MQ: {MQ_HOST}:{MQ_PORT}/{MQ_VHOST}")
+    log(f"  Queue: {FULL_QUEUE}")
+    log("=" * 70)
+
+    # 清理队列
+    await cleanup_queue()
+    await asyncio.sleep(1)
+
+    results = {}
+
+    # 场景1
+    try:
+        results["场景1_cancel删除消费者"] = await test_1_cancel_destroys_recovery()
+    except Exception as e:
+        log(f"  ❌ 场景1 异常: {e}")
+        results["场景1_cancel删除消费者"] = None
+    await asyncio.sleep(3)
+
+    # 场景2
+    try:
+        results["场景2_假死检测"] = await test_2_zombie_task()
+    except Exception as e:
+        log(f"  ❌ 场景2 异常: {e}")
+        results["场景2_假死检测"] = None
+    await asyncio.sleep(3)
+
+    # 场景3
+    try:
+        results["场景3_完整复现"] = await test_3_full_reproduce()
+    except Exception as e:
+        log(f"  ❌ 场景3 异常: {e}")
+        results["场景3_完整复现"] = None
+
+    # 汇总
+    log("")
+    log("=" * 70)
+    log("  测试结果")
+    log("=" * 70)
+    for name, r in results.items():
+        s = "✅ 已验证" if r is True else ("⚠️ 未复现" if r is False else "❌ 异常")
+        log(f"  {name}: {s}")
+
+    log("")
+    log("  ┌──────────────────────────────────────────────────────────┐")
+    log("  │  根因链条 (测试验证)                                       │")
+    log("  ├──────────────────────────────────────────────────────────┤")
+    log("  │                                                          │")
+    log("  │  ① stop_consuming() → queue.cancel(tag)                  │")
+    log("  │     → RobustQueue._consumers 删除该 tag                   │")
+    log("  │     → aio-pika 恢复时遍历 _consumers 为空 → 不恢复        │")
+    log("  │     ✅ 场景1 已验证                                        │")
+    log("  │                                                          │")
+    log("  │  ② consume_task 在 stop_event.wait() 挂起                │")
+    log("  │     → consumer_tag 丢失但 task.done()==False              │")
+    log("  │     → Monitor 跳过重启 → 永久丢失                         │")
+    log("  │     ✅ 场景2 已验证                                        │")
+    log("  │                                                          │")
+    log("  │  ③ _safe_reconnect 与 aio-pika __connection_factory 并发  │")
+    log("  │     → _cleanup_before_reconnect 杀死 aio-pika 恢复结果    │")
+    log("  │     → 消费者丢失                                          │")
+    log("  │     ✅/⚠️ 场景3 时序敏感                                    │")
+    log("  │                                                          │")
+    log("  │  根本矛盾:                                                │")
+    log("  │  connect_robust (自动恢复) + 手动恢复 (互相打架)           │")
+    log("  └──────────────────────────────────────────────────────────┘")
+    log("=" * 70)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

sycommon/tests/test_fix_verification.py

@@ -0,0 +1,404 @@
+"""
+修复后验证测试：验证消费者不再丢失
+
+验证 3 个场景修复后行为：
+  场景1: 断连后 aio-pika 自动恢复 → _consumers 保持 → 消费正常
+  场景2: consume_task + Monitor 假死检测修复 → 正确识别并恢复
+  场景3: 完整断连恢复流程 → 连接恢复 + 消费者恢复 + 消息正常消费
+
+使用方法:
+    cd sycommon-python-lib/src
+    python -m sycommon.tests.test_fix_verification
+"""
+import asyncio
+import json
+import time
+import sys
+import os
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", ".."))
+
+MQ_HOST = "rabbitmq.test1.svc.k8s.syf.com"
+MQ_PORT = 5672
+MQ_USER = "rabbit"
+MQ_PASS = "SU7BrhDfbGbH"
+MQ_VHOST = "/uat"
+APP_NAME = "fix-test"
+EXCHANGE = "system.topic.exchange"
+TEST_QUEUE_PREFIX = "test.fix"
+FULL_QUEUE = f"{TEST_QUEUE_PREFIX}.{APP_NAME}"
+ROUTING_KEY = f"{TEST_QUEUE_PREFIX.split('.')[0]}.#"
+
+T0 = time.time()
+
+
+def log(msg):
+    print(f"[{time.time()-T0:6.1f}s] {msg}", flush=True)
+
+
+async def create_pool_and_consumer():
+    from sycommon.rabbitmq.rabbitmq_pool import RabbitMQConnectionPool
+    from sycommon.rabbitmq.rabbitmq_client import RabbitMQClient
+
+    pool = RabbitMQConnectionPool(
+        hosts=[MQ_HOST], port=MQ_PORT, username=MQ_USER, password=MQ_PASS,
+        virtualhost=MQ_VHOST, heartbeat=60, app_name=APP_NAME,
+        connection_timeout=30, reconnect_interval=5, prefetch_count=2,
+    )
+    await pool.init_pools()
+    consumer = RabbitMQClient(
+        connection_pool=pool, exchange_name=EXCHANGE, exchange_type="topic",
+        queue_name=FULL_QUEUE, app_name=APP_NAME, routing_key=ROUTING_KEY,
+        durable=True, auto_delete=False, create_if_not_exists=True, prefetch_count=2,
+    )
+    return pool, consumer
+
+
+async def simulate_network_disconnect(consumer):
+    """模拟网络断连：关闭底层 aiormq 连接，触发 RobustConnection 自动恢复。
+    关闭 transport.connection（aiormq 层面），RobustConnection.__connection_factory 会自动重连。"""
+    conn = consumer._channel_conn
+    if conn is None:
+        return
+    transport = getattr(conn, 'transport', None)
+    if transport and hasattr(transport, 'connection') and transport.connection:
+        aiormq_conn = transport.connection
+        if not aiormq_conn.is_closed:
+            try:
+                await aiormq_conn.close()
+                log("  🔌 已关闭底层 aiormq 连接（模拟网络断开）")
+            except Exception as e:
+                log(f"  关闭底层连接异常: {e}")
+    else:
+        # 备选方案：直接关闭连接
+        if not conn.is_closed:
+            try:
+                # 用 reconnect() 而不是 close() 来模拟断连
+                # 但这里我们需要直接触发 _on_connection_close
+                import aiormq
+                # 获取 closing future 并设 exception
+                closing = aiormq_conn.closing if aiormq_conn else None
+                if closing and not closing.done():
+                    closing.set_exception(ConnectionError("simulated"))
+            except Exception:
+                pass
+
+
+async def send_probe(pool):
+    from aio_pika import Message, DeliveryMode
+    ch, _ = await pool.acquire_channel()
+    try:
+        ex = await ch.declare_exchange(name=EXCHANGE, type="topic", durable=True, auto_delete=False)
+        body = json.dumps({
+            "topicCode": "test",
+            "msg": f"probe-{int(time.time()*1000)}",
+            "traceId": f"trace-{int(time.time()*1000)}"
+        }).encode()
+        msg = Message(body=body, content_type="application/json",
+                      delivery_mode=DeliveryMode.PERSISTENT)
+        await ex.publish(message=msg, routing_key=ROUTING_KEY, timeout=5.0)
+    finally:
+        try:
+            await ch.close()
+        except Exception:
+            pass
+
+
+async def cleanup_queue():
+    """清理测试队列"""
+    try:
+        pool, consumer = await create_pool_and_consumer()
+        ch, _ = await pool.acquire_channel()
+        try:
+            await ch.queue_delete(queue_name=FULL_QUEUE)
+        except Exception:
+            pass
+        try:
+            await ch.close()
+        except Exception:
+            pass
+        await pool.close()
+    except Exception:
+        pass
+
+
+# ═══════════════════════════════════════════════════════════════════
+# 场景 1: 断连后 aio-pika 自动恢复
+# ═══════════════════════════════════════════════════════════════════
+async def test_1_robust_auto_recovery():
+    """
+    验证: 断连后不调 stop_consuming / queue.cancel，
+    aio-pika 自动恢复 _consumers，消费者继续工作。
+    """
+    log("=" * 70)
+    log("场景1: 修复后 — aio-pika 自动恢复消费者")
+    log("-" * 70)
+
+    pool, consumer = await create_pool_and_consumer()
+    received = [0]
+
+    async def handler(msg, raw):
+        received[0] += 1
+        log(f"  📥 #{received[0]}: {msg.msg}")
+
+    await consumer.set_message_handler(handler)
+    await consumer.connect()
+    tag = await consumer.start_consuming()
+    log(f"  ✅ 消费者启动, tag={tag}")
+
+    # 验证初始 _consumers
+    consumers_before = list(consumer._queue._consumers.keys())
+    log(f"  初始 _consumers: {consumers_before}")
+    assert len(consumers_before) > 0, "初始 _consumers 应不为空"
+
+    # 验证初始消费
+    await asyncio.sleep(1)
+    old = received[0]
+    await send_probe(pool)
+    await asyncio.sleep(3)
+    initial_ok = received[0] > old
+    log(f"  初始消费: {'✅' if initial_ok else '⚠️'} (收到 {received[0]-old})")
+
+    # 断开底层连接 — 不调 stop_consuming，让 aio-pika Robust 自动恢复
+    log("  ⚡ 断开底层连接（不调 stop_consuming，让 aio-pika 恢复）...")
+    await simulate_network_disconnect(consumer)
+
+    # 等待 aio-pika 自动恢复 (reconnect_interval=5s + 缓冲)
+    log("  ⏳ 等待 12s 让 aio-pika 自动恢复...")
+    await asyncio.sleep(12)
+
+    # 检查恢复后状态
+    is_connected = await consumer.is_connected
+    consumers_after = []
+    if consumer._queue and hasattr(consumer._queue, '_consumers'):
+        consumers_after = list(consumer._queue._consumers.keys())
+
+    log(f"  恢复后状态:")
+    log(f"    connected={is_connected}")
+    log(f"    _consumers={consumers_after}")
+
+    # 验证恢复后消费
+    old = received[0]
+    try:
+        await send_probe(pool)
+    except Exception as e:
+        log(f"    发送失败: {e}")
+    await asyncio.sleep(5)
+    recovered_count = received[0] - old
+    log(f"    恢复后消费: 收到 {recovered_count} 条")
+
+    ok = recovered_count > 0
+    if ok:
+        log("  ✅ 修复验证通过: 断连后消费者自动恢复，消息正常消费")
+    else:
+        log(f"  ⚠️ 部分验证: connected={is_connected}, _consumers={len(consumers_after)}, received={recovered_count}")
+
+    await consumer.close()
+    await pool.close()
+    return ok
+
+
+# ═══════════════════════════════════════════════════════════════════
+# 场景 2: Monitor 假死检测修复验证
+# ═══════════════════════════════════════════════════════════════════
+async def test_2_zombie_detection_fixed():
+    """
+    验证: Monitor 修复后能检测 task.done()==False 但无 consumer_tag 的假死状态。
+    """
+    log("=" * 70)
+    log("场景2: 修复后 — Monitor 假死检测")
+    log("-" * 70)
+
+    pool, consumer = await create_pool_and_consumer()
+    await consumer.set_message_handler(lambda msg, raw: None)
+    await consumer.connect()
+    tag = await consumer.start_consuming()
+    log(f"  ✅ 消费者启动, tag={tag}")
+
+    # 模拟 consume_task
+    stop_event = asyncio.Event()
+    manager_tags = {"test_q": tag}
+
+    async def mock_consume_task():
+        await stop_event.wait()
+        manager_tags.pop("test_q", None)
+
+    task = asyncio.create_task(mock_consume_task())
+    await asyncio.sleep(0.3)
+
+    log(f"  初始: task.done()={task.done()}, has_tag={'test_q' in manager_tags}")
+
+    # 模拟: consumer_tag 被清理
+    consumer._consumer_tag = None
+    manager_tags.pop("test_q", None)
+
+    task_done = task.done()
+    has_tag = "test_q" in manager_tags
+
+    log(f"  清理后: task.done()={task_done}, has_tag={has_tag}")
+
+    # 修复后的 Monitor 逻辑：task.done()==False 且 has_tag==False → 检测到假死
+    if not task_done and not has_tag:
+        log("  ✅ 假死检测修复验证通过: task运行中但无tag → Monitor 能检测到并重启")
+        ok = True
+    else:
+        log("  ⚠️ 非预期状态")
+        ok = False
+
+    task.cancel()
+    try:
+        await task
+    except asyncio.CancelledError:
+        pass
+    await consumer.close()
+    await pool.close()
+    return ok
+
+
+# ═══════════════════════════════════════════════════════════════════
+# 场景 3: 完整断连恢复流程 — 不再有冲突
+# ═══════════════════════════════════════════════════════════════════
+async def test_3_full_recovery():
+    """
+    完整验证: 断连 → 无手动恢复干扰 → aio-pika 自动恢复 → 消费者正常。
+    修复后不再有 on_conn_closed → _safe_reconnect 的冲突。
+    """
+    log("=" * 70)
+    log("场景3: 修复后 — 完整断连恢复流程（无手动恢复干扰）")
+    log("-" * 70)
+
+    pool, consumer = await create_pool_and_consumer()
+    received = [0]
+
+    async def handler(msg, raw):
+        received[0] += 1
+        log(f"  📥 #{received[0]}: {msg.msg}")
+
+    await consumer.set_message_handler(handler)
+    await consumer.connect()
+    tag = await consumer.start_consuming()
+    log(f"  ✅ 消费者启动, tag={tag}")
+
+    # 验证初始消费
+    await asyncio.sleep(1)
+    old = received[0]
+    await send_probe(pool)
+    await asyncio.sleep(3)
+    initial_ok = received[0] > old
+    log(f"  初始消费: {'✅' if initial_ok else '⚠️'} (收到 {received[0]-old})")
+
+    # 记录初始 _consumers
+    consumers_init = list(consumer._queue._consumers.keys())
+    log(f"  初始 _consumers: {consumers_init}")
+
+    # 断开底层连接 — 修复后不再有 on_conn_closed 触发 _safe_reconnect
+    log("  ⚡ 断开底层连接（修复后只有 aio-pika 自动恢复，无手动干扰）...")
+    await simulate_network_disconnect(consumer)
+    await asyncio.sleep(1)
+
+    # 等待 aio-pika 自动恢复
+    log("  ⏳ 等待 12s 让 aio-pika 自动恢复...")
+    await asyncio.sleep(12)
+
+    # 检查最终状态
+    is_connected = await consumer.is_connected
+    final_consumers = []
+    if consumer._queue and hasattr(consumer._queue, '_consumers'):
+        final_consumers = list(consumer._queue._consumers.keys())
+
+    log(f"  最终状态:")
+    log(f"    connected={is_connected}")
+    log(f"    _consumers={final_consumers}")
+    log(f"    consumer._consumer_tag={consumer._consumer_tag}")
+
+    # 验证消费
+    old = received[0]
+    try:
+        await send_probe(pool)
+    except Exception as e:
+        log(f"    发送失败: {e}")
+    await asyncio.sleep(5)
+    final_received = received[0] - old
+    log(f"    最终消费: 收到 {final_received} 条")
+
+    ok = final_received > 0
+    if ok:
+        log("  ✅ 修复验证通过: 断连后消费者自动恢复，消息正常消费!")
+    else:
+        log(f"  ℹ️ 状态: connected={is_connected}, consumers={len(final_consumers)}, received={final_received}")
+        # 可能需要更长时间恢复，给予宽限判断
+        if is_connected and len(final_consumers) > 0:
+            log("     连接和 _consumers 已恢复，可能消息延迟")
+            ok = True
+
+    await consumer.close()
+    await pool.close()
+    return ok
+
+
+# ═══════════════════════════════════════════════════════════════════
+# 主入口
+# ═══════════════════════════════════════════════════════════════════
+async def main():
+    global T0
+    T0 = time.time()
+
+    log("=" * 70)
+    log("  修复后验证测试")
+    log(f"  MQ: {MQ_HOST}:{MQ_PORT}/{MQ_VHOST}")
+    log(f"  Queue: {FULL_QUEUE}")
+    log("=" * 70)
+
+    # 清理队列
+    await cleanup_queue()
+    await asyncio.sleep(1)
+
+    results = {}
+
+    # 场景1
+    try:
+        results["场景1_aio-pika自动恢复"] = await test_1_robust_auto_recovery()
+    except Exception as e:
+        log(f"  ❌ 场景1 异常: {e}")
+        results["场景1_aio-pika自动恢复"] = None
+    await asyncio.sleep(3)
+
+    # 场景2
+    try:
+        results["场景2_假死检测修复"] = await test_2_zombie_detection_fixed()
+    except Exception as e:
+        log(f"  ❌ 场景2 异常: {e}")
+        results["场景2_假死检测修复"] = None
+    await asyncio.sleep(3)
+
+    # 场景3
+    try:
+        results["场景3_完整恢复流程"] = await test_3_full_recovery()
+    except Exception as e:
+        log(f"  ❌ 场景3 异常: {e}")
+        results["场景3_完整恢复流程"] = None
+
+    # 汇总
+    log("")
+    log("=" * 70)
+    log("  修复验证结果")
+    log("=" * 70)
+    for name, r in results.items():
+        s = "✅ 通过" if r is True else ("⚠️ 未通过" if r is False else "❌ 异常")
+        log(f"  {name}: {s}")
+
+    all_ok = all(r is True for r in results.values())
+    if all_ok:
+        log("")
+        log("  ══════════════════════════════════════════════════════════")
+        log("  ✅ 全部通过！修复有效，消费者不再丢失")
+        log("  ══════════════════════════════════════════════════════════")
+    else:
+        log("")
+        log("  ⚠️ 部分场景未通过，请检查上方日志")
+
+    log("=" * 70)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

{sycommon_python_lib-0.2.5a35.dist-info → sycommon_python_lib-0.2.5a36.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.2.5a35
+Version: 0.2.5a36
 Summary: Add your description here
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{sycommon_python_lib-0.2.5a35.dist-info → sycommon_python_lib-0.2.5a36.dist-info}/RECORD

@@ -129,9 +129,9 @@ sycommon/services.py,sha256=pUcV0xFrn1hrArD9YwE8m6CMrrWPwNBAqUIWhgsVkzY,24943
 sycommon/agent/__init__.py,sha256=mxceAeUifQ-DKvWp7ZEJIFlmOCb5wpYHPGQw3rwEN8I,4378
 sycommon/agent/agent_manager.py,sha256=UhhaekEumT7g4v_Z1UB4jTp13X0n8M8erYaQdkGGWkA,13620
 sycommon/agent/chat_events.py,sha256=t7qWa6OrIWLfqtd1AnqaVP67QWkn1JxpCBTZYQpoLuM,14226
-sycommon/agent/deep_agent.py,sha256=IcBM507zQY2L5lR23ysMUslL1uzr99oJggcQ8HcW4s4,59283
+sycommon/agent/deep_agent.py,sha256=gG05Uqh01L56J1DGkuUcGPwSRmQVifw0AdJa0E3xK-g,60787
 sycommon/agent/multi_agent_team.py,sha256=UjtJCjq-bHFLvdN6n__Bhb_w-hV8EKBKyTTb7T1n8l8,26385
-sycommon/agent/summarization_utils.py,sha256=aA1IJG2jaY_Gdx9ZP34bfyMt-DaVJnno_3glu97dJUg,14894
+sycommon/agent/summarization_utils.py,sha256=fiwvKYE_eQc1EtBiPT4UyOZoqQdd4JwEsLRDsJNioLQ,14928
 sycommon/agent/mcp/__init__.py,sha256=iKrdDhIrFsNIkqG_kgcwNe-nOiM6uVfolKv44LfQ-FQ,636
 sycommon/agent/mcp/models.py,sha256=zda4ho-UTYOJ5oPAZPZ-vxhfDRLghUCsMroHnA2A2QQ,1490
 sycommon/agent/mcp/tool_loader.py,sha256=OQa-lE7RL2s3Lqh-kNOKaUrb130hvorB_HjyFBqZBZs,10960
@@ -214,7 +214,7 @@ sycommon/middleware/sandbox.py,sha256=er0zeHLQtHJqSr27fGcKbAtRo1ZOQ-Lqif8ALWNFSa
 sycommon/middleware/timeout.py,sha256=KlxOPa8xl2dg6yuRi_EzkVJG8bX4stb5ueYxctzzGM8,1433
 sycommon/middleware/token_tracking.py,sha256=rEbgV1bgWMdzAERx4aq5XAvOIT6jTY_tK1P0xHJnL3o,6609
 sycommon/middleware/tool_result_truncation.py,sha256=SREo6tb_RDHxqiQdO0N82pio-Cpo0YSrHNa1sASUafM,12429
-sycommon/middleware/traceid.py,sha256=MrcHj-2hzwl5sOMbf6-34tezYv4COnh3R8vaCN9zRuA,14025
+sycommon/middleware/traceid.py,sha256=dEtDCrhGHVpF0HFBMMnHX32_XYgKjjhJ7PzKwH5qXKQ,13797
 sycommon/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sycommon/models/base_http.py,sha256=EICAAibx3xhjBsLqm35Mi3DCqxp0FME4rD_3iQVjT_E,3051
 sycommon/models/log.py,sha256=rZpj6VkDRxK3B6H7XSeWdYZshU8F0Sks8bq1p6pPlDw,500
@@ -231,12 +231,12 @@ sycommon/notice/__init__.py,sha256=cVYbKlLLMFHckyDpx21CTZCMTufqZk_uHuEIxUNxwx4,1
 sycommon/notice/uvicorn_monitor.py,sha256=O4R25z032dAlvlbU0WLo0LJqoL1Z52fMFgFdb1e3Cls,11833
 sycommon/notice/wecom_message.py,sha256=PsyoQpPiR0OZaUI9KLXd0-zUwp5okd44q71J60QiRm8,11952
 sycommon/rabbitmq/process_pool_consumer.py,sha256=EXdNypgathjTfPqkccoAW0HiVB9HuZLGhPbWUcYh0_Q,29750
-sycommon/rabbitmq/rabbitmq_client.py,sha256=K1_KIDzFc_zz1wPHy8Lsxu6wCUtp9nYoz0pVu_ELsHA,24234
+sycommon/rabbitmq/rabbitmq_client.py,sha256=y3mLq0dhT1ALajFmBMMUkgjG3bc6HCiGmHi6j91SJTg,21372
 sycommon/rabbitmq/rabbitmq_pool.py,sha256=mUo1-Nlj0xXKG9MdBA0hvkt1NIvKD4AGsDouzQDY5nQ,13835
 sycommon/rabbitmq/rabbitmq_service.py,sha256=q9c9-9RSvJaY_PE62PQ4mX7ropNsGr0Frcrm5gjaPao,9774
-sycommon/rabbitmq/rabbitmq_service_client_manager.py,sha256=MWLiwOdOyJp0X_OYiL9pah1gvB1ZcVxjHO6hmkOu4oY,11193
-sycommon/rabbitmq/rabbitmq_service_connection_monitor.py,sha256=1Jng1hY1LGDzG4OUIMShwZbYBLE9emFJDeJAoPrT5zk,6150
-sycommon/rabbitmq/rabbitmq_service_consumer_manager.py,sha256=HnfX7sIO35wivBSYJi5l-2LDqNh4bsEhqyWQixC_9O0,10617
+sycommon/rabbitmq/rabbitmq_service_client_manager.py,sha256=UZgpD6n0mdo5u3gaGW-jhUuPV50bRNdXFESzL9ABsR4,10623
+sycommon/rabbitmq/rabbitmq_service_connection_monitor.py,sha256=y1LY734TvpPL2N6QVDTA2pMrz_73fpvTg0fAuBankH0,7229
+sycommon/rabbitmq/rabbitmq_service_consumer_manager.py,sha256=c3X5WWM_yJKHtx8CNeUSLqGyI4L27uMQ67oNa63xzAo,9956
 sycommon/rabbitmq/rabbitmq_service_core.py,sha256=kr4MaR4txhCRHUPxofa-Zt6-YJbfCw_vFfFVg-LE5cE,5230
 sycommon/rabbitmq/rabbitmq_service_producer_manager.py,sha256=bqp3XiJli9bmWWAw419yAZKbJLs_xivK2EaLc1J4TsA,10032
 sycommon/sentry/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -257,11 +257,13 @@ sycommon/synacos/nacos_service_discovery.py,sha256=LQkMAjpXmsK_STbW9aNk0hdwJJJtG
 sycommon/synacos/nacos_service_registration.py,sha256=dR2yn7I7yHbcXUxA-Lj9uy-Oqg6ARdY_Jp_cCS2Sp24,10745
 sycommon/synacos/param.py,sha256=KcfSkxnXOa0TGmCjY8hdzU9pzUsA8-4PeyBKWI2-568,1765
 sycommon/tests/deep_agent_server.py,sha256=t7snT2J6KWZrjJsYVi4TU5jpfvXNz4iuzMk4cc-kQGM,16696
+sycommon/tests/test_consumer_loss_rootcause.py,sha256=rP_XdbGbzOM9RB36vk0gU4kqipXG9iHqrCN8rKyd2Aw,16294
 sycommon/tests/test_consumer_recovery.py,sha256=pMMtOwHIijNTZxg3IVBYSGFYgezMX0PUeylks8xzMM8,10364
 sycommon/tests/test_deep_agent.py,sha256=34gP2KL8SSmtqqhaA9OV97OAl_I0T4TfEutZrR_0srM,5874
 sycommon/tests/test_dynamic_max_tokens.py,sha256=GrMsAt8uaUGrb8yVlOB-_3k__S1KGLjECa1M2nO6j2s,14600
 sycommon/tests/test_email.py,sha256=-oPtYVGQzJ3Cv-op3ZNRMeyYOF-UNidGJC35CHRgjGQ,5442
 sycommon/tests/test_encoding_cache.py,sha256=EqeN2x9RuyS5Xg8DhAfnzI-ezzaIaitSCZtXnfvALgA,4794
+sycommon/tests/test_fix_verification.py,sha256=YeGvcQHJlIuch7FxEYLjeRp3LMsDoPF1SojOQ4IHkzU,14794
 sycommon/tests/test_mcp_server.py,sha256=2T87sSTdigdAl0BeWdxSeyII9ot2JOltySwLY2JFWlI,13494
 sycommon/tests/test_minimax_reasoning.py,sha256=IKrPEf_Ybxg_vz4AITStkb-GKo5NooaLiLK3RbmW_Cw,9354
 sycommon/tests/test_mq.py,sha256=Gpr9Eep-osRkcnlwGeshROEf83Ai3qYbAMHwpoML68o,4366
@@ -280,8 +282,8 @@ sycommon/tools/syemail.py,sha256=BDFhgf7WDOQeTcjxJEQdu0dQhnHFPO_p3eI0-Ni3LhQ,561
 sycommon/tools/timing.py,sha256=OiiE7P07lRoMzX9kzb8sZU9cDb0zNnqIlY5pWqHcnkY,2064
 sycommon/xxljob/__init__.py,sha256=7eoBlQxv-B39IfRSCY2bkqdGYs1QRe1umAWd88VMEEM,86
 sycommon/xxljob/xxljob_service.py,sha256=JIEJaGXhqrTLcyxlyynSrsHg9bBnDNzX-D4qIWLRPUE,6815
-sycommon_python_lib-0.2.5a35.dist-info/METADATA,sha256=5HlLiqV7AMmkykedMJlsF42TpvpPpKOoPIUcdowWlH0,7914
-sycommon_python_lib-0.2.5a35.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-sycommon_python_lib-0.2.5a35.dist-info/entry_points.txt,sha256=gsR4SssKxDWjRU8ggidzNcdMXDPRSKRS7UaGyNP84Qg,92
-sycommon_python_lib-0.2.5a35.dist-info/top_level.txt,sha256=RgphKrg7nJyZ7irJqbxFr-5H2LUYTvI7ivoWZH2hcD0,29
-sycommon_python_lib-0.2.5a35.dist-info/RECORD,,
+sycommon_python_lib-0.2.5a36.dist-info/METADATA,sha256=BL0G4BxFGVbhaxumOuqyQOMPCunq2-NcEu0SOxfanKk,7914
+sycommon_python_lib-0.2.5a36.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+sycommon_python_lib-0.2.5a36.dist-info/entry_points.txt,sha256=gsR4SssKxDWjRU8ggidzNcdMXDPRSKRS7UaGyNP84Qg,92
+sycommon_python_lib-0.2.5a36.dist-info/top_level.txt,sha256=RgphKrg7nJyZ7irJqbxFr-5H2LUYTvI7ivoWZH2hcD0,29
+sycommon_python_lib-0.2.5a36.dist-info/RECORD,,