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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.2.5a34
+Version: 0.2.5a36
 Summary: Add your description here
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -9,16 +9,16 @@ Requires-Dist: aiohttp==3.13.5
 Requires-Dist: aiomysql==0.3.2
 Requires-Dist: anyio==4.13.0
 Requires-Dist: decorator==5.3.1
-Requires-Dist: deepagents==0.6.7
+Requires-Dist: deepagents==0.6.8
 Requires-Dist: elasticsearch==9.4.1
 Requires-Dist: fastapi==0.136.3
 Requires-Dist: jinja2==3.1.6
 Requires-Dist: kafka-python==2.3.1
-Requires-Dist: langchain==1.3.2
+Requires-Dist: langchain==1.3.4
 Requires-Dist: langchain-core==1.4.0
 Requires-Dist: langchain-openai==1.2.2
 Requires-Dist: langfuse==4.7.1
-Requires-Dist: langgraph==1.2.2
+Requires-Dist: langgraph==1.2.4
 Requires-Dist: langgraph-checkpoint-postgres==3.1.0
 Requires-Dist: langgraph-checkpoint-redis==0.4.1
 Requires-Dist: ldap3==2.9.1

{sycommon_python_lib-0.2.5a34 → sycommon_python_lib-0.2.5a36}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sycommon-python-lib"
-version = "0.2.5a34"
+version = "0.2.5a36"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -10,16 +10,16 @@ dependencies = [
     "aiomysql==0.3.2",
     "anyio==4.13.0",
     "decorator==5.3.1",
-    "deepagents==0.6.7",
+    "deepagents==0.6.8",
     "elasticsearch==9.4.1",
     "fastapi==0.136.3",
     "jinja2==3.1.6",
     "kafka-python==2.3.1",
-    "langchain==1.3.2",
+    "langchain==1.3.4",
     "langchain-core==1.4.0",
     "langchain-openai==1.2.2",
     "langfuse==4.7.1",
-    "langgraph==1.2.2",
+    "langgraph==1.2.4",
     "langgraph-checkpoint-postgres==3.1.0",
     "langgraph-checkpoint-redis==0.4.1",
     "ldap3==2.9.1",

{sycommon_python_lib-0.2.5a34 → sycommon_python_lib-0.2.5a36}/src/sycommon/agent/deep_agent.py

@@ -201,34 +201,42 @@ def _patch_agent_streaming(agent):
             model_, effective_response_format = _get_bound_model(request)
             messages = request.messages
 
-            # 🔑 根治摘要泄漏：将 lc_source="summarization" 的 HumanMessage 转为 SystemMessage
-            # 根因：SummarizationMiddleware 将摘要注入为 HumanMessage，模型有时会将摘要
-            # 当作用户输入来回复（复述摘要内容），导致 "SESSION INTENT" 等泄漏到前端。
-            # 修复：在模型调用前，把摘要 HumanMessage 转换为 SystemMessage，
-            # 这样模型会将其视为系统上下文而非需要回复的用户消息。
-            _summary_parts = []
+            # 🔑 根治摘要泄漏：将 lc_source="summarization" 的 HumanMessage 内容
+            # 注入到 system_message 而非直接丢弃，保持记忆连续性。
+            # 根因分析（2026-06-06 端到端测试确认）：
+            # 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"):
-                    _summary_parts.append(_msg.content)
-                    SYLogger.debug("[DeepAgent] 摘要 HumanMessage → SystemMessage 转换")
+                    _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_parts:
-                from langchain_core.messages import SystemMessage as _SysMsg
-                _summary_system = _SysMsg(
-                    content="[系统注入的对话上下文摘要，仅供你理解历史，不要复述或提及给用户]\n\n"
-                    + "\n\n".join(_summary_parts)
+            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>"
                 )
-                if request.system_message:
-                    messages = [_summary_system, request.system_message, *messages]
-                else:
-                    messages = [_summary_system, *messages]
-                SYLogger.debug(f"[DeepAgent] 已将 {len(_summary_parts)} 条摘要转为 SystemMessage")
-            elif request.system_message:
+                _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]
 
             # 动态调整 max_tokens，防止 input + max_output 超过上下文窗口
@@ -628,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.5a34 → sycommon_python_lib-0.2.5a36}/src/sycommon/agent/mcp/tool_loader.py

@@ -27,6 +27,27 @@ def sanitize_name(name: str) -> str:
     return sanitized
 
 
+def _contains_auth_error(err_msg: str) -> bool:
+    """检查错误信息中是否包含认证相关关键词"""
+    auth_keywords = [
+        "401", "unauthorized", "token expired", "authentication failed",
+        "440", "login timeout", "403", "forbidden",
+        "认证失败", "登录过期", "token无效", "token过期",
+        "syt_token", "SYT_TOKEN",
+    ]
+    msg_lower = err_msg.lower()
+    return any(kw.lower() in msg_lower for kw in auth_keywords)
+
+
+def _auth_error_hint() -> str:
+    """返回认证错误时的 authorize 工具调用提示"""
+    return (
+        "\n\n⚠️ **检测到认证错误**：这可能是 SYT_TOKEN 过期或未设置导致的。"
+        "请立即调用 `authorize` 工具（传入失败原因和待重试的命令），"
+        "让用户重新授权后再自动重试。不要只是告知用户有问题。"
+    )
+
+
 def wrap_tool_with_error_handler(
     tool: BaseTool,
     server_config_id: str,
@@ -97,6 +118,10 @@ def wrap_tool_with_error_handler(
                         f"可能原因: MCP 服务器未启动、网络不可达或连接超时。\n"
                         f"请尝试不使用该工具继续完成任务，或联系管理员检查 MCP 服务 '{server_name}'。"
                     )
+
+                # 检测认证错误，追加 authorize 工具提示
+                if _contains_auth_error(err_msg):
+                    friendly_msg += _auth_error_hint()
                 if is_content_and_artifact:
                     return friendly_msg, None
                 return [friendly_msg]

{sycommon_python_lib-0.2.5a34 → sycommon_python_lib-0.2.5a36}/src/sycommon/agent/multi_agent_team.py

@@ -408,6 +408,10 @@ class MultiAgentTeam:
                         parent_agent_map.pop(tool_call_id, None)
 
                 elif msg_type == "HumanMessage":
+                    # 🔑 跳过上下文压缩产生的摘要消息，不发送给前端
+                    if getattr(msg, "additional_kwargs", {}).get("lc_source") == "summarization":
+                        SYLogger.debug("[MultiAgentTeam] 跳过摘要消息 (lc_source=summarization)")
+                        continue
                     if ai_chunk_buffer:
                         SYLogger.debug(f"[ai_message] {repr(ai_chunk_buffer[:100])}...")
                         ai_chunk_buffer = ""

{sycommon_python_lib-0.2.5a34 → sycommon_python_lib-0.2.5a36}/src/sycommon/agent/sandbox/file_ops.py

@@ -421,13 +421,13 @@ class FileOperationsMixin:
 
     # ============== 搜索 ==============
 
-    def glob(self: "HTTPSandboxBackend", pattern: str, path: str = "/") -> GlobResult:
+    def glob(self: "HTTPSandboxBackend", pattern: str, path: str | None = None) -> GlobResult:
         """glob 搜索文件"""
         try:
             self._ensure_synced_sync()
             result = self._post_sync(f"{SANDBOX_API_PREFIX}/glob", {
                 "pattern": pattern,
-                "path": path,
+                "path": path or "/",
                 "user_id": self.user_id
             })
             matches = [FileInfo(**item) for item in result]
@@ -436,13 +436,13 @@ class FileOperationsMixin:
             SYLogger.error(f"[Sandbox] glob 搜索失败: {e}")
             return GlobResult(error=str(e))
 
-    async def aglob(self: "HTTPSandboxBackend", pattern: str, path: str = "/", *, timeout: int = None) -> GlobResult:
+    async def aglob(self: "HTTPSandboxBackend", pattern: str, path: str | None = None, *, timeout: int = None) -> GlobResult:
         """异步 glob 搜索文件"""
         try:
             await self._ensure_synced_async()
             result = await self._post_async_with_failover(f"{SANDBOX_API_PREFIX}/glob", {
                 "pattern": pattern,
-                "path": path,
+                "path": path or "/",
                 "user_id": self.user_id
             }, timeout=timeout)
             matches = [FileInfo(**item) for item in result]

{sycommon_python_lib-0.2.5a34 → sycommon_python_lib-0.2.5a36}/src/sycommon/agent/summarization_utils.py

@@ -26,7 +26,7 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 # 中文摘要提示词，替代 langchain DEFAULT_SUMMARY_PROMPT
-# 使用自然段落格式，避免 SESSION INTENT / ARTIFACTS / NEXT STEPS 等英文标题泄漏到用户输出
+# 使用纯自然段落格式（无标题/小标题/列表标记），避免结构化标题被模型回显到用户输出
 CUSTOM_SUMMARY_PROMPT = """<role>
 上下文提取助手
 </role>
@@ -44,19 +44,15 @@ CUSTOM_SUMMARY_PROMPT = """<role>
 下面的对话历史将被你在此步骤中提取的上下文替换。
 你需要确保不会重复任何已完成的操作，因此你从对话历史中提取的上下文应集中于对整体目标最重要的信息。
 
-请用以下结构提取上下文，每个部分用中文自然段落描述：
+请用纯自然段落格式提取上下文。不要使用任何标题、小标题、编号列表或【】括号标记。
+用连贯的叙述方式，在段落中自然地包含以下四类信息：
 
-【用户意图】
-简要描述用户的主要目标或请求，确保足够完整以理解整个会话的目的。
+第一段：用户的整体目标、主要请求和意图。
+第二段：对话中做出的关键决策、重要结论、选择的策略及原因，以及被拒绝的选项。
+第三段：涉及的重要文件路径、创建或修改过的资源。
+第四段：仍需完成的待办事项和接下来的步骤。
 
-【关键上下文】
-提取并记录对话历史中所有最重要的上下文信息，包括重要选择、结论或策略，以及关键决策背后的推理。记录被拒绝的选项及其原因。
-
-【相关文件】
-列出在本次对话中创建、修改或访问的文件、资源或工件。对于文件修改，列出具体文件路径并简要描述每个文件的变更。
-
-【待办事项】
-列出为达成用户意图仍需完成的具体任务，以及接下来应该做什么。
+重要：每段直接以内容开始，不要添加「用户意图」「关键上下文」等任何前缀标签。
 </instructions>
 
 用户将向你发送完整的消息历史，你需要从中提取上下文以创建替换内容。请仔细阅读所有内容，并深入思考哪些信息对整体目标最重要且应该被保存：
@@ -184,22 +180,110 @@ _orig_build_new_messages = _OrigDeepAgentsSumm._build_new_messages_with_path
 
 
 def _patched_build_new_messages(self, summary, file_path):
+    content = (
+        "<internal_context_data>\n"
+        "[系统内部记忆]\n"
+        "这是你的内部记忆，帮助你回忆之前的对话。"
+        "把它当作你自己的回忆，而不是要输出的内容。"
+        "绝对不要在回复中提及、复述或引用此内容的任何部分。\n\n"
+    )
     if file_path is not None:
-        content = (
-            "[系统内部消息 - 仅供你理解上下文，绝对禁止将此消息或摘要内容展示、复述或提及给用户]\n\n"
-            "你正在一个已经被压缩的对话中继续回复用户。\n\n"
-            f"完整的对话历史已保存到 {file_path}，如需查阅细节可以读取该文件。\n\n"
-            "以下是压缩后的对话摘要（直接基于此摘要理解上下文并正常回复用户，不要提及摘要的存在）：\n\n"
-            f"<summary>\n{summary}\n</summary>"
+        content += (
+            f"Previous conversation history archived at: {file_path}\n\n"
         )
-    else:
-        content = f"以下是到目前为止的对话摘要：\n\n{summary}"
+    content += (
+        f"<compressed_history>\n{summary}\n</compressed_history>\n"
+        "</internal_context_data>"
+    )
     from langchain_core.messages import HumanMessage
     return [HumanMessage(content=content, additional_kwargs={"lc_source": "summarization"})]
 
 
 _OrigDeepAgentsSumm._build_new_messages_with_path = _patched_build_new_messages
 
+# monkey-patch：覆盖 create_summarization_middleware，强制注入中文 summary_prompt
+# deepagents graph.py:608 的 create_deep_agent 会自动调用此函数注入自动压缩 middleware，
+# 但默认不传 summary_prompt，导致用英文 DEFAULT_SUMMARY_PROMPT（含 SESSION INTENT 等标题）。
+def _patched_create_summarization_middleware(model, backend):
+    defaults = _patched_compute_summarization_defaults(model)
+    return _summ_mod.SummarizationMiddleware(
+        model=model,
+        backend=backend,
+        trigger=defaults["trigger"],
+        keep=defaults["keep"],
+        trim_tokens_to_summarize=None,
+        truncate_args_settings=defaults["truncate_args_settings"],
+        summary_prompt=CUSTOM_SUMMARY_PROMPT,
+    )
+
+
+_summ_mod.create_summarization_middleware = _patched_create_summarization_middleware
+# graph.py 在模块加载时 from import 了旧引用，需要同步 patch
+try:
+    import deepagents.graph as _graph_mod
+    _graph_mod.create_summarization_middleware = _patched_create_summarization_middleware
+except ImportError:
+    pass
+
+# ==================== 防御性补丁 ====================
+# 以下补丁确保即使某些代码路径绕过了 _patched_create_summarization_middleware，
+# DEFAULT_SUMMARY_PROMPT 的英文标题（SESSION INTENT/SUMMARY/ARTIFACTS/NEXT STEPS）
+# 也不会出现在模型生成的摘要中。
+
+# 防御 1: 替换模块级 DEFAULT_SUMMARY_PROMPT 常量
+# 虽然不能改变 __init__ 的默认参数（Python 在定义时求值），
+# 但可以防止任何运行时读取 DEFAULT_SUMMARY_PROMPT 的代码拿到英文版。
+_summ_mod.DEFAULT_SUMMARY_PROMPT = CUSTOM_SUMMARY_PROMPT
+try:
+    import langchain.agents.middleware.summarization as _lc_summ_mod
+    _lc_summ_mod.DEFAULT_SUMMARY_PROMPT = CUSTOM_SUMMARY_PROMPT
+except ImportError:
+    pass
+
+# 防御 2: 包装 __init__，强制 summary_prompt 默认值为 CUSTOM_SUMMARY_PROMPT
+# 即使调用方不传 summary_prompt，也会使用中文版。
+_orig_da_init = _OrigDeepAgentsSumm.__init__
+
+
+def _patched_da_init(self, model, *, backend, trigger=None,
+                     keep=("messages", 20),
+                     token_counter=count_tokens_approximately,
+                     summary_prompt=CUSTOM_SUMMARY_PROMPT,  # ← 关键：改为中文默认值
+                     trim_tokens_to_summarize=4000,
+                     truncate_args_settings=None, **kwargs):
+    _orig_da_init(self, model, backend=backend, trigger=trigger, keep=keep,
+                  token_counter=token_counter, summary_prompt=summary_prompt,
+                  trim_tokens_to_summarize=trim_tokens_to_summarize,
+                  truncate_args_settings=truncate_args_settings, **kwargs)
+
+
+_OrigDeepAgentsSumm.__init__ = _patched_da_init
+
+# 防御 3: patch create_summarization_tool_middleware（deepagents 同模块本地调用绕过）
+# deepagents summarization.py 中 create_summarization_tool_middleware 内部调用
+# create_summarization_middleware 用的是同模块本地名称绑定，
+# 不会走 _summ_mod.create_summarization_middleware 的模块属性替换。
+if hasattr(_summ_mod, 'create_summarization_tool_middleware'):
+    _orig_create_tool_mw = _summ_mod.create_summarization_tool_middleware
+
+    def _patched_create_summarization_tool_middleware(model, backend, *, system_prompt=None):
+        """强制使用 CUSTOM_SUMMARY_PROMPT 创建 SummarizationToolMiddleware。"""
+        defaults = _patched_compute_summarization_defaults(model)
+        summ = _summ_mod.SummarizationMiddleware(
+            model=model,
+            backend=backend,
+            trigger=defaults["trigger"],
+            keep=defaults["keep"],
+            summary_prompt=CUSTOM_SUMMARY_PROMPT,
+            trim_tokens_to_summarize=None,
+            truncate_args_settings=defaults["truncate_args_settings"],
+        )
+        return _summ_mod.SummarizationToolMiddleware(summ, system_prompt=system_prompt)
+
+    _summ_mod.create_summarization_tool_middleware = _patched_create_summarization_tool_middleware
+
+logger.info("[SummarizationUtils] 防御性补丁已应用: DEFAULT_SUMMARY_PROMPT 替换 + __init__ 默认值覆盖 + create_summarization_tool_middleware 覆盖")
+
 
 def build_summarization_middleware(
     model: BaseChatModel,

{sycommon_python_lib-0.2.5a34 → sycommon_python_lib-0.2.5a36}/src/sycommon/middleware/tool_result_truncation.py

@@ -40,6 +40,21 @@ DEFAULT_PASSTHROUGH_TOOLS: FrozenSet[str] = frozenset({
     "web_search",  # web_search 已在工具内部自行截断
 })
 
+# 认证错误关键词（用于检测工具结果中的 SYT_TOKEN 相关错误）
+_AUTH_ERROR_KEYWORDS = [
+    "401", "unauthorized", "token expired", "authentication failed",
+    "440", "login timeout", "403", "forbidden",
+    "认证失败", "登录过期", "token无效", "token过期",
+    "syt_token", "SYT_TOKEN",
+]
+
+# 认证错误追加提示
+_AUTH_ERROR_HINT = (
+    "\n\n⚠️ **检测到认证错误**：这可能是 SYT_TOKEN 过期或未设置导致的。"
+    "请立即调用 `authorize` 工具（传入失败原因和待重试的命令），"
+    "让用户重新授权后再自动重试。不要只是告知用户有问题。"
+)
+
 # head+tail 预览截断模板（对齐 deepagents 0.6.3 TOO_LARGE_TOOL_MSG 风格）
 HEAD_TAIL_TRUNCATION_TEMPLATE = (
     "[输出已截断，原始长度 {original} 字符 / {original_lines} 行。]"
@@ -216,6 +231,28 @@ class ToolResultTruncationMiddleware(AgentMiddleware):
         )
         return truncated
 
+    def _inject_auth_hint(self, content: str, tool_name: str) -> str:
+        """检测工具结果中的认证错误，追加 authorize 工具调用提示。
+
+        仅对 execute 工具和 MCP 工具生效（这些是可能触发认证问题的工具），
+        跳过 authorize 工具本身避免循环。
+        """
+        if tool_name == "authorize":
+            return content
+        # 仅对可能触发认证错误的工具检测（execute、mcp__、read_file 等）
+        is_relevant_tool = (
+            tool_name == "execute"
+            or tool_name.startswith("mcp__")
+            or tool_name in ("read_file", "write_file", "edit_file")
+        )
+        if not is_relevant_tool:
+            return content
+
+        content_lower = content.lower()
+        if any(kw.lower() in content_lower for kw in _AUTH_ERROR_KEYWORDS):
+            return content + _AUTH_ERROR_HINT
+        return content
+
     def _process_result(
         self,
         result: Any,
@@ -254,6 +291,9 @@ class ToolResultTruncationMiddleware(AgentMiddleware):
         if not isinstance(content, str):
             return result
 
+        # 注入认证错误提示（在截断之前检测，避免被截断丢失）
+        content = self._inject_auth_hint(content, tool_name)
+
         new_content = self._truncate(content, tool_name)
         if new_content is content:
             return result

{sycommon_python_lib-0.2.5a34 → 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.5a34 → 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.5a34 → 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