sycommon-python-lib 0.2.5a35__tar.gz → 0.2.5a36__tar.gz

{sycommon_python_lib-0.2.5a35 → sycommon_python_lib-0.2.5a36}/PKG-INFO

@@ -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 → sycommon_python_lib-0.2.5a36}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sycommon-python-lib"
-version = "0.2.5a35"
+version = "0.2.5a36"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.11"

{sycommon_python_lib-0.2.5a35 → sycommon_python_lib-0.2.5a36}/src/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_python_lib-0.2.5a35 → sycommon_python_lib-0.2.5a36}/src/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_python_lib-0.2.5a35 → sycommon_python_lib-0.2.5a36}/src/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_python_lib-0.2.5a35 → sycommon_python_lib-0.2.5a36}/src/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_python_lib-0.2.5a35 → sycommon_python_lib-0.2.5a36}/src/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_python_lib-0.2.5a35 → sycommon_python_lib-0.2.5a36}/src/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_python_lib-0.2.5a35 → sycommon_python_lib-0.2.5a36}/src/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:
         """关闭所有消费者 (增强版：确保资源彻底释放)"""