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

sycommon/agent/deep_agent.py

@@ -201,34 +201,27 @@ 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 从模型输入中移除
+            # 根因分析（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 状态中，供后续压缩轮次使用
             _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 转换")
+                    SYLogger.debug("[DeepAgent] 摘要 HumanMessage 已从模型输入中移除（防止回显泄漏）")
                 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 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:
+            if request.system_message:
                 messages = [request.system_message, *messages]
 
             # 动态调整 max_tokens，防止 input + max_output 超过上下文窗口

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/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/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/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,109 @@ _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"
+    )
     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/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/tests/test_summary_leak_e2e.py

@@ -0,0 +1,872 @@
+"""摘要泄漏 E2E 真实测试 — 必须触发压缩才能验证修复。
+
+核心策略：用极小 maxTokens (3000) 确保压缩触发，然后：
+1. 直接对比：绕过 agent graph，构造压缩后的消息发给真实模型
+2. 完整 E2E：通过 DeepAgent 多轮对话，触发压缩后收集回复
+3. 转换验证：hook 模型层确认 HumanMessage→SystemMessage 生效
+
+运行方式：
+    cd sycommon-python-lib
+    python src/sycommon/tests/test_summary_leak_e2e.py
+"""
+import asyncio
+import functools
+import os
+import sys
+import tempfile
+import time
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+from unittest.mock import AsyncMock, MagicMock, patch
+from pathlib import Path
+
+# ---------- 配置 ----------
+MODEL = "glm-5.1"
+BASE_URL = "http://10.10.6.132:3000/v1"
+API_KEY = "sk-3hXhO7uCG5CRi7t3THE2cWTKVJqesXJ38cKstHZhDVXHQOIn"
+
+# 泄漏标记词 — 绝不应出现在用户可见回复中
+LEAK_MARKERS = [
+    # 英文 DEFAULT_SUMMARY_PROMPT 的标题
+    "SESSION INTENT",
+    "ARTIFACTS",
+    "NEXT STEPS",
+    "Context Extraction",
+    # langchain _build_new_messages 原始英文模板
+    "You are in the middle of a conversation",
+    "condensed summary follows",
+    "Here is a summary of the conversation",
+    # 新版 internal_context_data 标签（如果模型复述了就说明泄漏）
+    "<internal_context_data>",
+    "</internal_context_data>",
+    "<compressed_history>",
+    "</compressed_history>",
+    "INTERNAL SYSTEM DATA",
+    "DO NOT OUTPUT",
+    "DO NOT OUTPUT, PARAPHRASE, OR REFERENCE",
+]
+
+# 摘要原文片段 — 这些是压缩后模型回复中绝不应原样出现的上下文内容
+# （注意：这些是从实际压缩输出中提取的典型片段）
+LEAK_CONTENT_PATTERNS = [
+    # 英文提示词残留
+    r"SESSION\s+INTENT",
+    r"ARTIFACTS",
+    r"NEXT\s+STEPS",
+    r"condensed\s+summary",
+    r"conversation\s+history\s+has\s+been\s+saved",
+    r"summarization",
+    # XML 标签泄漏
+    r"<internal_context_data>",
+    r"</internal_context_data>",
+    r"<compressed_history>",
+    r"</compressed_history>",
+    # 防护指令泄漏
+    r"INTERNAL\s+SYSTEM\s+DATA",
+    r"DO\s+NOT\s+OUTPUT",
+    r"PARAPHRASE",
+]
+
+
+def _make_model(streaming=False):
+    from langchain.chat_models import init_chat_model
+    return init_chat_model(
+        model=MODEL, model_provider="openai", streaming=streaming,
+        base_url=BASE_URL, api_key=API_KEY,
+        temperature=0.7, max_retries=2, timeout=180,
+    )
+
+
+import re
+
+def _check_leak(text: str) -> list[str]:
+    """检查回复是否包含泄漏标记词（精确匹配）。"""
+    return [m for m in LEAK_MARKERS if m in text]
+
+def _check_leak_patterns(text: str) -> list[str]:
+    """检查回复是否匹配泄漏正则模式（更灵活的匹配）。"""
+    results = []
+    for pat in LEAK_CONTENT_PATTERNS:
+        if re.search(pat, text, re.IGNORECASE):
+            results.append(pat)
+    return results
+
+def _check_english_leak(text: str) -> list[str]:
+    """检查回复中是否出现大段英文（可能是泄漏了摘要模板的英文内容）。
+
+    策略：提取连续英文片段（>=40字符），如果出现则可能是泄漏。
+    """
+    leaks = []
+    # 找连续英文片段（含空格和标点）
+    english_chunks = re.findall(r'[A-Za-z][A-Za-z ,.;:!?\'"\-]{39,}', text)
+    for chunk in english_chunks:
+        # 排除常见的合法英文片段（代码、变量名等）
+        # 如果包含典型的摘要模板词汇，判定为泄漏
+        leak_words = ["summary", "summarization", "context", "history",
+                       "conversation", "SESSION", "ARTIFACTS", "STEPS",
+                       "INTERNAL", "compressed", "archived"]
+        if any(w.lower() in chunk.lower() for w in leak_words):
+            leaks.append(chunk[:80])
+    return leaks
+
+
+# ============================================================
+# 测试 1: 直接构造压缩后的消息场景 — 最可靠的复现方式
+# 模拟 SummarizationMiddleware 刚执行完压缩后的消息列表
+# ============================================================
+
+async def test_1_direct_injected_summary_no_leak():
+    """核心测试：构造压缩后的消息发给真实模型，检查回复是否泄漏。
+
+    这直接模拟了压缩触发后的场景：
+    - 摘要作为 HumanMessage(lc_source="summarization")
+    - 然后有正常用户提问
+    模型回复不应包含任何摘要标记。
+    """
+    print("\n" + "=" * 60)
+    print("测试 1: 直接注入压缩摘要 — 检查回复泄漏")
+    print("=" * 60)
+
+    from langchain_core.messages import HumanMessage, SystemMessage
+
+    model = _make_model(streaming=False)
+
+    # 模拟 CUSTOM_SUMMARY_PROMPT 生成的中文摘要（纯自然段落格式）
+    summary_text = (
+        "用户的主要目标是测试上下文压缩功能。"
+        "之前讨论了Python asyncio异步编程的事件循环、协程概念，"
+        "以及Docker容器化技术的镜像和网络配置。"
+        "涉及的重要文件包括 test_summary_leak_e2e.py。"
+        "仍需完成对压缩后回复的泄漏检查。"
+    )
+
+    # 用当前 _patched_build_new_messages 生成的包装格式
+    summary_human = HumanMessage(
+        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"
+            "<compressed_history>\n"
+            + summary_text +
+            "\n</compressed_history>\n"
+            "</internal_context_data>"
+        ),
+        additional_kwargs={"lc_source": "summarization"},
+    )
+
+    user_question = HumanMessage(content="你好，请帮我写一个简单的 Python Hello World 程序。")
+
+    # --- 路径 A: 摘要作为 HumanMessage（压缩后原始状态，经过 Layer 2 之前）---
+    print("\n  路径 A: 摘要作为 HumanMessage（未转换）...")
+    try:
+        resp_a = await model.ainvoke([summary_human, user_question])
+        text_a = resp_a.content
+    except Exception as e:
+        text_a = f"[错误: {e}]"
+
+    leaks_a = _check_leak(text_a)
+    english_a = _check_english_leak(text_a)
+    print(f"  A 回复 ({len(text_a)} 字): {text_a[:150]}...")
+    print(f"  A 标记泄漏: {leaks_a if leaks_a else '无'}")
+    print(f"  A 英文片段: {english_a if english_a else '无'}")
+
+    # --- 路径 B: 摘要转换为 SystemMessage（Layer 2 修复后）---
+    print("\n  路径 B: 摘要转换为 SystemMessage（Layer 2 修复）...")
+    summary_system = SystemMessage(
+        content="[系统注入的对话上下文摘要，仅供你理解历史，不要复述或提及给用户]\n\n"
+        + summary_human.content
+    )
+    try:
+        resp_b = await model.ainvoke([summary_system, user_question])
+        text_b = resp_b.content
+    except Exception as e:
+        text_b = f"[错误: {e}]"
+
+    leaks_b = _check_leak(text_b)
+    english_b = _check_english_leak(text_b)
+    print(f"  B 回复 ({len(text_b)} 字): {text_b[:150]}...")
+    print(f"  B 标记泄漏: {leaks_b if leaks_b else '无'}")
+    print(f"  B 英文片段: {english_b if english_b else '无'}")
+
+    # --- 结论 ---
+    print("\n  结论:")
+    any_leak_a = leaks_a or english_a
+    any_leak_b = leaks_b or english_b
+    if any_leak_a and not any_leak_b:
+        print("  ✓ 证实: HumanMessage 路径泄漏，SystemMessage 修复有效!")
+        return True
+    elif not any_leak_a and not any_leak_b:
+        print("  ✓ 两种路径均无泄漏（标记+英文片段检查通过）")
+        print("  注: Layer 2 转换仍作为结构性保障")
+        return True
+    else:
+        print(f"  ✗ 存在泄漏!")
+        if any_leak_a:
+            print(f"    HumanMessage 路径: 标记={leaks_a}, 英文={english_a}")
+        if any_leak_b:
+            print(f"    SystemMessage 路径: 标记={leaks_b}, 英文={english_b}")
+        return False
+
+
+# ============================================================
+# 测试 2: 完整 DeepAgent E2E — 压缩必须触发
+# ============================================================
+
+async def test_2_deepagent_compress_must_trigger():
+    """极小 maxTokens (3000) DeepAgent，多轮长对话，压缩必须触发。
+
+    收集触发压缩后的模型回复，验证无泄漏。
+    """
+    print("\n" + "=" * 60)
+    print("测试 2: DeepAgent 完整 E2E（maxTokens=3000）— 压缩必须触发")
+    print("=" * 60)
+
+    from sycommon.agent.deep_agent import AgentConfig, create_deep_agent
+    from deepagents.middleware.summarization import ExtendedModelResponse
+    from langgraph.checkpoint.memory import MemorySaver
+    import deepagents.middleware.summarization as summ_mod
+
+    model = _make_model(streaming=True)
+    sandbox = AsyncMock()
+    sandbox.async_sync = AsyncMock(return_value={})
+    sandbox.akill_all_processes = AsyncMock()
+    sandbox.atree = AsyncMock(return_value=None)
+    sandbox.async_sync_dirs = AsyncMock()
+
+    nacos_max_tokens = 3000
+    mock_llm_cfg = {
+        "model": MODEL, "provider": "openai",
+        "baseUrl": BASE_URL, "maxTokens": nacos_max_tokens,
+        "vision": False, "callFunction": True, "default": True,
+        "apiKey": API_KEY,
+    }
+
+    _orig_awrap = summ_mod._DeepAgentsSummarizationMiddleware.awrap_model_call
+    compress_events = []
+
+    async def _tracking_awrap(self, request, handler):
+        result = await _orig_awrap(self, request, handler)
+        if isinstance(result, ExtendedModelResponse):
+            event = result.command.update.get("_summarization_event")
+            compress_events.append(event)
+            summary_preview = event["summary_message"].content[:100] if event else "?"
+            print(f"  >>> 压缩触发 #{len(compress_events)}! cutoff={event['cutoff_index']}")
+            print(f"      summary 预览: {summary_preview}...")
+        return result
+
+    summ_mod._DeepAgentsSummarizationMiddleware.awrap_model_call = _tracking_awrap
+
+    try:
+        with patch("sycommon.config.Config.Config") as mock_config_cls, \
+             patch("sycommon.agent.deep_agent.get_llm", return_value=model):
+            config_instance = MagicMock()
+            config_instance.get_llm_config = MagicMock(return_value=mock_llm_cfg)
+            config_instance.get_default_llm_model_name = MagicMock(return_value=MODEL)
+            mock_config_cls.return_value = config_instance
+
+            deep_agent = await create_deep_agent(
+                user_id=f"e2e_test_{int(time.time())}",
+                config=AgentConfig(
+                    model_name=MODEL,
+                    system_prompt="你是测试助手。用中文回答，每次写300字以上。",
+                    tools=[],
+                    debug=False,
+                ),
+                sandbox_backend=sandbox,
+                checkpointer=MemorySaver(),
+                project_root=Path(tempfile.mkdtemp()),
+            )
+    finally:
+        summ_mod._DeepAgentsSummarizationMiddleware.awrap_model_call = _orig_awrap
+
+    questions = [
+        "请详细介绍Python的asyncio异步编程，包括事件循环、协程、Task和Future的概念。",
+        "请详细介绍中国古代四大发明，每个发明至少写200字。",
+        "请详细介绍Docker容器化技术，包括镜像、容器、网络和卷。",
+    ]
+
+    all_responses = []
+    for i, q in enumerate(questions):
+        print(f"\n  --- 第 {i+1} 轮 ---")
+        print(f"  Q: {q[:50]}...")
+        full_response = ""
+        try:
+            async for event in deep_agent.chat(q):
+                if event.type == "ai_chunk":
+                    content = event.data.get("content", "")
+                    full_response += content
+        except Exception as e:
+            print(f"  chat 出错: {e}")
+            import traceback
+            traceback.print_exc()
+
+        all_responses.append(full_response)
+        print(f"  A ({len(full_response)} 字): {full_response[:120]}...")
+
+    # 压缩必须触发
+    print(f"\n  压缩触发次数: {len(compress_events)}")
+    if not compress_events:
+        print("  ✗ 压缩未触发! 测试无效。")
+        return False
+    print(f"  ✓ 压缩已触发 {len(compress_events)} 次")
+
+    # 检查压缩后的回复（第2轮及之后）
+    post_compress_responses = all_responses[1:]  # 第2轮开始
+    all_leaks = []
+    all_pattern_leaks = []
+    all_english_leaks = []
+    for i, resp in enumerate(post_compress_responses):
+        if not resp:
+            print(f"  ⚠ 第 {i+2} 轮回复为空!")
+            continue
+        # 1) 精确标记检查
+        leaks = _check_leak(resp)
+        if leaks:
+            all_leaks.append((i + 2, leaks))
+        # 2) 正则模式检查
+        pattern_leaks = _check_leak_patterns(resp)
+        if pattern_leaks:
+            all_pattern_leaks.append((i + 2, pattern_leaks))
+        # 3) 英文长片段泄漏检查
+        english_leaks = _check_english_leak(resp)
+        if english_leaks:
+            all_english_leaks.append((i + 2, english_leaks))
+
+    passed = True
+    if all_leaks:
+        print(f"  ✗ 压缩后回复存在标记泄漏:")
+        for round_num, markers in all_leaks:
+            print(f"    第 {round_num} 轮: {markers}")
+        passed = False
+    if all_pattern_leaks:
+        print(f"  ✗ 压缩后回复存在模式泄漏:")
+        for round_num, patterns in all_pattern_leaks:
+            print(f"    第 {round_num} 轮: {patterns}")
+        passed = False
+    if all_english_leaks:
+        print(f"  ✗ 压缩后回复存在英文片段泄漏（可能是摘要模板泄漏）:")
+        for round_num, chunks in all_english_leaks:
+            for chunk in chunks:
+                print(f"    第 {round_num} 轮: {chunk}...")
+        passed = False
+
+    if passed:
+        print("  ✓ 压缩后所有回复无泄漏（标记/模式/英文片段均通过）")
+    return passed
+
+
+# ============================================================
+# 测试 3: Hook 验证 HumanMessage→SystemMessage 转换
+# ============================================================
+
+async def test_3_conversion_hook():
+    """Hook 模型底层，验证压缩触发时摘要消息确实从 HumanMessage 变为 SystemMessage。"""
+    print("\n" + "=" * 60)
+    print("测试 3: HumanMessage→SystemMessage 转换 Hook 验证")
+    print("=" * 60)
+
+    from sycommon.agent.deep_agent import AgentConfig, create_deep_agent
+    from langgraph.checkpoint.memory import MemorySaver
+    from langchain_core.messages import SystemMessage, HumanMessage
+
+    model = _make_model(streaming=True)
+    sandbox = AsyncMock()
+    sandbox.async_sync = AsyncMock(return_value={})
+    sandbox.akill_all_processes = AsyncMock()
+    sandbox.atree = AsyncMock(return_value=None)
+    sandbox.async_sync_dirs = AsyncMock()
+
+    nacos_max_tokens = 3000
+    mock_llm_cfg = {
+        "model": MODEL, "provider": "openai",
+        "baseUrl": BASE_URL, "maxTokens": nacos_max_tokens,
+        "vision": False, "callFunction": True, "default": True,
+        "apiKey": API_KEY,
+    }
+
+    # 先创建 agent
+    with patch("sycommon.config.Config.Config") as mock_config_cls, \
+         patch("sycommon.agent.deep_agent.get_llm", return_value=model):
+        config_instance = MagicMock()
+        config_instance.get_llm_config = MagicMock(return_value=mock_llm_cfg)
+        config_instance.get_default_llm_model_name = MagicMock(return_value=MODEL)
+        mock_config_cls.return_value = config_instance
+
+        deep_agent = await create_deep_agent(
+            user_id=f"hook_test_{int(time.time())}",
+            config=AgentConfig(
+                model_name=MODEL,
+                system_prompt="你是测试助手。用中文回答，写300字以上。",
+                tools=[],
+                debug=False,
+            ),
+            sandbox_backend=sandbox,
+            checkpointer=MemorySaver(),
+            project_root=Path(tempfile.mkdtemp()),
+        )
+
+    # Hook raw model 底层 _astream
+    conversion_log = []
+    raw_model = getattr(model, 'llm', model)
+    _has_method = hasattr(raw_model, '_astream')
+    _orig_method = None
+    if _has_method:
+        _orig_method = raw_model._astream
+
+        async def _tracking(messages, *args, **kwargs):
+            msg_types = [type(m).__name__ for m in messages]
+            has_summary_human = any(
+                isinstance(m, HumanMessage)
+                and getattr(m, "additional_kwargs", {}).get("lc_source") == "summarization"
+                for m in messages
+            )
+            has_summary_system = any(
+                isinstance(m, SystemMessage)
+                and "不要复述" in (m.content or "")
+                for m in messages
+            )
+            conversion_log.append({
+                "types": msg_types,
+                "human_leak": has_summary_human,
+                "system_ok": has_summary_system,
+            })
+            async for chunk in _orig_method(messages, *args, **kwargs):
+                yield chunk
+
+        raw_model._astream = _tracking
+
+    questions = [
+        "请详细介绍Python的asyncio异步编程。",
+        "请详细介绍中国古代四大发明。",
+        "请详细介绍Docker容器化技术。",
+    ]
+
+    for i, q in enumerate(questions):
+        print(f"\n  --- 第 {i+1} 轮 ---")
+        try:
+            async for event in deep_agent.chat(q):
+                pass
+        except Exception as e:
+            print(f"  chat 出错: {e}")
+
+    if _has_method and _orig_method:
+        raw_model._astream = _orig_method
+
+    # 分析结果
+    print(f"\n  模型调用次数: {len(conversion_log)}")
+    for i, log in enumerate(conversion_log):
+        flag = "⚠ HUMAN_LEAK" if log["human_leak"] else ("✓ SYSTEM" if log["system_ok"] else "")
+        print(f"  调用 {i+1}: types={log['types']} {flag}")
+
+    human_leaked = any(log["human_leak"] for log in conversion_log)
+    system_ok = any(log["system_ok"] for log in conversion_log)
+
+    if human_leaked:
+        print("  ✗ 存在摘要 HumanMessage 未转换!")
+        return False
+
+    if system_ok:
+        print("  ✓ 摘要已从 HumanMessage 转换为 SystemMessage")
+    else:
+        print("  ⚠ 压缩可能未触发")
+
+    print("  ✓ 转换验证通过")
+    return True
+
+
+# ============================================================
+# 测试 4: 用英文原始 DEFAULT_SUMMARY_PROMPT 触发压缩 — 复现 bug
+# 证明如果不 monkey-patch，SESSION INTENT 等确实会泄漏
+# ============================================================
+
+async def test_4_original_english_prompt_reproduces_bug():
+    """使用 langchain 原始英文 DEFAULT_SUMMARY_PROMPT 触发压缩，
+    证明 bug 确实可以复现。"""
+    print("\n" + "=" * 60)
+    print("测试 4: 用原始英文 prompt 复现 bug（对照组）")
+    print("=" * 60)
+
+    from langchain_core.messages import HumanMessage, AIMessage
+
+    model = _make_model(streaming=False)
+
+    # 原始英文 DEFAULT_SUMMARY_PROMPT 会生成这种格式的摘要
+    english_summary = """## SESSION INTENT
+The user wants to test summarization leak.
+
+## SUMMARY
+Discussed Python asyncio, Docker containers, and Chinese inventions.
+
+## ARTIFACTS
+- test_summary_leak_e2e.py was created.
+
+## NEXT STEPS
+Verify the summary doesn't leak into model response."""
+
+    # 用 langchain _build_new_messages 原始格式
+    original_format_msg = HumanMessage(
+        content=f"You are in the middle of a conversation that has been summarized.\n\n"
+                f"The full conversation history has been saved to /conversation_history/test.md "
+                f"should you need to refer back to it for details.\n\n"
+                f"A condensed summary follows:\n\n"
+                f"<summary>\n{english_summary}\n</summary>",
+        additional_kwargs={"lc_source": "summarization"},
+    )
+
+    user_msg = HumanMessage(content="请帮我写一个Python Hello World程序。")
+
+    print("  发送原始英文摘要格式给模型...")
+    try:
+        resp = await model.ainvoke([original_format_msg, user_msg])
+        text = resp.content
+    except Exception as e:
+        text = f"[错误: {e}]"
+
+    print(f"  回复 ({len(text)} 字): {text[:200]}...")
+
+    # 检查英文标记
+    en_markers = ["SESSION INTENT", "ARTIFACTS", "NEXT STEPS", "condensed summary"]
+    leaks = [m for m in en_markers if m in text]
+    # 同时检查英文长片段
+    english_leaks = _check_english_leak(text)
+    if leaks:
+        print(f"  ✓ Bug 可复现! 回复包含英文标记: {leaks}")
+    else:
+        print(f"  当前模型未泄漏英文标记（模型自身抑制了）")
+    if english_leaks:
+        print(f"  ✓ 英文片段泄漏: {english_leaks[:3]}")
+
+    return True  # 观察性测试
+
+
+# ============================================================
+# 测试 6: 防御性补丁验证 — 不传 summary_prompt 时应使用中文版
+# ============================================================
+
+async def test_6_defense_in_depth_no_default_prompt_leak():
+    """验证防御性补丁: 直接实例化 SummarizationMiddleware 不传 summary_prompt 时
+    应使用 CUSTOM_SUMMARY_PROMPT（中文），而非 DEFAULT_SUMMARY_PROMPT（英文）。
+
+    这测试了 workflow 发现的根因:
+    - __init__ 的 summary_prompt 默认值在类定义时烘焙了 DEFAULT_SUMMARY_PROMPT
+    - 防御补丁覆盖了 __init__ 默认值为 CUSTOM_SUMMARY_PROMPT
+    """
+    print("\n" + "=" * 60)
+    print("测试 6: 防御性补丁 — 不传 summary_prompt 时用中文版")
+    print("=" * 60)
+
+    import deepagents.middleware.summarization as summ_mod
+    from deepagents.backends import StateBackend
+    from langchain.chat_models import init_chat_model
+
+    model = init_chat_model(
+        model=MODEL, model_provider="openai", streaming=False,
+        base_url=BASE_URL, api_key=API_KEY,
+        temperature=0.7, max_retries=2, timeout=180,
+    )
+
+    # 路径 A: 不传 summary_prompt — 应使用中文版
+    print("\n  路径 A: SummarizationMiddleware(model, backend) — 不传 summary_prompt")
+    mw_a = summ_mod.SummarizationMiddleware(model=model, backend=StateBackend())
+    prompt_a = mw_a._lc_helper.summary_prompt
+    has_english_headers = "SESSION INTENT" in prompt_a
+    has_chinese = "上下文提取助手" in prompt_a
+    print(f"    SESSION INTENT 在 prompt 中: {has_english_headers}")
+    print(f"    上下文提取助手 在 prompt 中: {has_chinese}")
+
+    if has_english_headers:
+        print("  ✗ 路径 A 仍有英文标题! 防御补丁未生效!")
+        return False
+
+    # 路径 B: 通过 create_summarization_middleware
+    print("\n  路径 B: create_summarization_middleware(model, backend)")
+    mw_b = summ_mod.create_summarization_middleware(model, StateBackend())
+    prompt_b = mw_b._lc_helper.summary_prompt
+    has_english_headers_b = "SESSION INTENT" in prompt_b
+    has_chinese_b = "上下文提取助手" in prompt_b
+    print(f"    SESSION INTENT 在 prompt 中: {has_english_headers_b}")
+    print(f"    上下文提取助手 在 prompt 中: {has_chinese_b}")
+
+    if has_english_headers_b:
+        print("  ✗ 路径 B 仍有英文标题!")
+        return False
+
+    # 路径 C: DEFAULT_SUMMARY_PROMPT 模块常量
+    print("\n  路径 C: DEFAULT_SUMMARY_PROMPT 模块常量")
+    has_en_const = "SESSION INTENT" in summ_mod.DEFAULT_SUMMARY_PROMPT
+    print(f"    SESSION INTENT 在模块常量中: {has_en_const}")
+    if has_en_const:
+        print("  ⚠ 模块常量仍有英文标题（不影响运行时但需注意）")
+
+    # 路径 D: create_summarization_tool_middleware
+    print("\n  路径 D: create_summarization_tool_middleware(model, backend)")
+    if hasattr(summ_mod, 'create_summarization_tool_middleware'):
+        tool_mw = summ_mod.create_summarization_tool_middleware(model, StateBackend())
+        prompt_d = tool_mw._summmary_middleware._lc_helper.summary_prompt if hasattr(tool_mw, '_summmary_middleware') else "?"
+        # 尝试从内部获取
+        inner = getattr(tool_mw, '_middleware', None) or getattr(tool_mw, '_summmary_middleware', None)
+        if inner:
+            prompt_d = inner._lc_helper.summary_prompt
+        else:
+            # 遍历属性找 _lc_helper
+            for attr_name in dir(tool_mw):
+                attr = getattr(tool_mw, attr_name, None)
+                if hasattr(attr, '_lc_helper'):
+                    prompt_d = attr._lc_helper.summary_prompt
+                    break
+        has_en_d = "SESSION INTENT" in prompt_d
+        print(f"    SESSION INTENT 在 prompt 中: {has_en_d}")
+        if has_en_d:
+            print("  ⚠ 路径 D 有英文标题（create_summarization_tool_middleware 可能需单独检查）")
+    else:
+        print("    (create_summarization_tool_middleware 不存在，跳过)")
+
+    print("\n  ✓ 防御补丁验证通过: 所有路径使用中文摘要提示词")
+    return True
+
+
+# ============================================================
+# 测试 7: 压缩摘要内容检查 — 确认摘要不包含英文标题
+# ============================================================
+
+async def test_7_summary_content_no_english_headers():
+    """触发压缩，获取实际生成的摘要文本，检查是否包含英文标题。
+
+    之前的测试只检查模型回复是否泄漏，这个测试直接检查摘要内容本身。
+    """
+    print("\n" + "=" * 60)
+    print("测试 7: 压缩摘要内容检查 — 确认无英文标题")
+    print("=" * 60)
+
+    from sycommon.agent.deep_agent import AgentConfig, create_deep_agent
+    from deepagents.middleware.summarization import ExtendedModelResponse
+    from langgraph.checkpoint.memory import MemorySaver
+    import deepagents.middleware.summarization as summ_mod
+
+    model = _make_model(streaming=True)
+    sandbox = AsyncMock()
+    sandbox.async_sync = AsyncMock(return_value={})
+    sandbox.akill_all_processes = AsyncMock()
+    sandbox.atree = AsyncMock(return_value=None)
+    sandbox.async_sync_dirs = AsyncMock()
+
+    nacos_max_tokens = 3000
+    mock_llm_cfg = {
+        "model": MODEL, "provider": "openai",
+        "baseUrl": BASE_URL, "maxTokens": nacos_max_tokens,
+        "vision": False, "callFunction": True, "default": True,
+        "apiKey": API_KEY,
+    }
+
+    _orig_awrap = summ_mod._DeepAgentsSummarizationMiddleware.awrap_model_call
+    summary_texts = []
+
+    async def _capturing_awrap(self, request, handler):
+        result = await _orig_awrap(self, request, handler)
+        if isinstance(result, ExtendedModelResponse):
+            event = result.command.update.get("_summarization_event")
+            if event and "summary_message" in event:
+                summary_content = event["summary_message"].content
+                summary_texts.append(summary_content)
+                print(f"  >>> 捕获摘要 #{len(summary_texts)} ({len(summary_content)} 字)")
+        return result
+
+    summ_mod._DeepAgentsSummarizationMiddleware.awrap_model_call = _capturing_awrap
+
+    try:
+        with patch("sycommon.config.Config.Config") as mock_config_cls, \
+             patch("sycommon.agent.deep_agent.get_llm", return_value=model):
+            config_instance = MagicMock()
+            config_instance.get_llm_config = MagicMock(return_value=mock_llm_cfg)
+            config_instance.get_default_llm_model_name = MagicMock(return_value=MODEL)
+            mock_config_cls.return_value = config_instance
+
+            deep_agent = await create_deep_agent(
+                user_id=f"summary_test_{int(time.time())}",
+                config=AgentConfig(
+                    model_name=MODEL,
+                    system_prompt="你是测试助手。用中文回答，每次写300字以上。",
+                    tools=[],
+                    debug=False,
+                ),
+                sandbox_backend=sandbox,
+                checkpointer=MemorySaver(),
+                project_root=Path(tempfile.mkdtemp()),
+            )
+    finally:
+        summ_mod._DeepAgentsSummarizationMiddleware.awrap_model_call = _orig_awrap
+
+    questions = [
+        "请详细介绍Python的asyncio异步编程，包括事件循环、协程、Task和Future的概念。",
+        "请详细介绍中国古代四大发明，每个发明至少写200字。",
+        "请详细介绍Docker容器化技术，包括镜像、容器、网络和卷。",
+    ]
+
+    for i, q in enumerate(questions):
+        print(f"\n  --- 第 {i+1} 轮 ---")
+        try:
+            async for event in deep_agent.chat(q):
+                pass
+        except Exception as e:
+            print(f"  chat 出错: {e}")
+
+    # 检查摘要内容
+    if not summary_texts:
+        print("  ✗ 未捕获到任何摘要! 压缩未触发。")
+        return False
+
+    print(f"\n  捕获到 {len(summary_texts)} 个摘要")
+    all_passed = True
+    for i, summary in enumerate(summary_texts):
+        print(f"\n  --- 摘要 {i+1} ({len(summary)} 字) ---")
+        print(f"  前 200 字: {summary[:200]}...")
+
+        # 检查英文标题
+        en_headers = ["SESSION INTENT", "ARTIFACTS", "NEXT STEPS",
+                       "## SUMMARY", "## ARTIFACTS", "## NEXT STEPS",
+                       "## SESSION INTENT"]
+        found_headers = [h for h in en_headers if h in summary]
+        if found_headers:
+            print(f"  ✗ 摘要包含英文标题: {found_headers}")
+            all_passed = False
+        else:
+            print(f"  ✓ 摘要无英文标题")
+
+        # 检查英文模板特征词
+        en_features = ["Context Extraction", "condensed summary",
+                        "You are in the middle of a conversation"]
+        found_features = [f for f in en_features if f in summary]
+        if found_features:
+            print(f"  ✗ 摘要包含英文模板特征: {found_features}")
+            all_passed = False
+
+    if all_passed:
+        print("\n  ✓ 所有摘要均无英文标题和模板特征")
+    return all_passed
+
+
+# ============================================================
+# 测试 5: 200k/128k 默认配置 — 确保不误触发
+# ============================================================
+
+async def test_5_normal_config_no_false_trigger():
+    """200k maxTokens + 128k maxOutputTokens，单轮短对话不应触发压缩。"""
+    print("\n" + "=" * 60)
+    print("测试 5: 200k/128k 默认配置 — 不误触发压缩")
+    print("=" * 60)
+
+    from sycommon.agent.deep_agent import AgentConfig, create_deep_agent
+    from deepagents.middleware.summarization import ExtendedModelResponse
+    from langgraph.checkpoint.memory import MemorySaver
+    import deepagents.middleware.summarization as summ_mod
+
+    model = _make_model(streaming=True)
+    sandbox = AsyncMock()
+    sandbox.async_sync = AsyncMock(return_value={})
+    sandbox.akill_all_processes = AsyncMock()
+    sandbox.atree = AsyncMock(return_value=None)
+    sandbox.async_sync_dirs = AsyncMock()
+
+    mock_llm_cfg = {
+        "model": MODEL, "provider": "openai",
+        "baseUrl": BASE_URL, "maxTokens": 200000,
+        "maxOutputTokens": 128000,
+        "vision": False, "callFunction": True, "default": True,
+        "apiKey": API_KEY,
+    }
+
+    _orig_awrap = summ_mod._DeepAgentsSummarizationMiddleware.awrap_model_call
+    compress_count = [0]
+
+    async def _tracking(self, request, handler):
+        result = await _orig_awrap(self, request, handler)
+        if isinstance(result, ExtendedModelResponse):
+            compress_count[0] += 1
+        return result
+
+    summ_mod._DeepAgentsSummarizationMiddleware.awrap_model_call = _tracking
+
+    try:
+        with patch("sycommon.config.Config.Config") as mock_config_cls, \
+             patch("sycommon.agent.deep_agent.get_llm", return_value=model):
+            config_instance = MagicMock()
+            config_instance.get_llm_config = MagicMock(return_value=mock_llm_cfg)
+            config_instance.get_default_llm_model_name = MagicMock(return_value=MODEL)
+            mock_config_cls.return_value = config_instance
+
+            deep_agent = await create_deep_agent(
+                user_id=f"normal_{int(time.time())}",
+                config=AgentConfig(
+                    model_name=MODEL,
+                    system_prompt="你是测试助手。简短回答。",
+                    tools=[],
+                    debug=False,
+                ),
+                sandbox_backend=sandbox,
+                checkpointer=MemorySaver(),
+                project_root=Path(tempfile.mkdtemp()),
+            )
+    finally:
+        summ_mod._DeepAgentsSummarizationMiddleware.awrap_model_call = _orig_awrap
+
+    full_response = ""
+    async for event in deep_agent.chat("你好，请用一句话介绍你自己。"):
+        if event.type == "ai_chunk":
+            content = event.data.get("content", "")
+            full_response += content
+
+    print(f"  A: {full_response[:150]}")
+    print(f"  压缩触发: {compress_count[0]} 次")
+
+    if compress_count[0] > 0:
+        print("  ✗ 不应触发压缩!")
+        return False
+    print("  ✓ 200k/128k 配置正常，无误触发")
+    return True
+
+
+# ============================================================
+# 主入口
+# ============================================================
+
+async def main():
+    print(f"摘要泄漏 E2E 真实测试 - {time.strftime('%H:%M:%S')}")
+    print(f"模型: {MODEL} @ {BASE_URL}")
+    print()
+
+    results = {}
+
+    tests = [
+        ("1. 直接注入摘要-无泄漏", test_1_direct_injected_summary_no_leak),
+        ("2. DeepAgent压缩必须触发", test_2_deepagent_compress_must_trigger),
+        ("3. HumanMsg→SystemMsg转换", test_3_conversion_hook),
+        ("4. 原始英文prompt复现bug", test_4_original_english_prompt_reproduces_bug),
+        ("5. 200k默认不误触", test_5_normal_config_no_false_trigger),
+        ("6. 防御补丁-默认值覆盖", test_6_defense_in_depth_no_default_prompt_leak),
+        ("7. 压缩摘要无英文标题", test_7_summary_content_no_english_headers),
+    ]
+
+    for name, fn in tests:
+        try:
+            passed = await fn()
+            results[name] = passed
+        except Exception as e:
+            import traceback
+            print(f"  FAILED: {e}")
+            traceback.print_exc()
+            results[name] = False
+
+    print(f"\n{'='*60}")
+    print(f"  测试结果汇总:")
+    for name, passed in results.items():
+        print(f"    {name}: {'✓ PASSED' if passed else '✗ FAILED'}")
+    total = len(results)
+    passed = sum(1 for v in results.values() if v)
+    print(f"  总计: {passed}/{total} 通过")
+    print(f"{'='*60}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.2.5a34
+Version: 0.2.5a35
 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.dist-info → sycommon_python_lib-0.2.5a35.dist-info}/RECORD

@@ -129,14 +129,14 @@ 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=ZAsfyfaa_ZpDQceNYZgmyaqk4LrsLSJvJwo73NBq-FE,59459
-sycommon/agent/multi_agent_team.py,sha256=W5gP6sWIYhhXf6iBLHfyTIs9eAhUdkWrn_PF6W2cESs,26059
-sycommon/agent/summarization_utils.py,sha256=5eiLtxRZKTzO0tnr8sVaL-H3a0eUtvXpCa28Jw_j2eE,10889
+sycommon/agent/deep_agent.py,sha256=IcBM507zQY2L5lR23ysMUslL1uzr99oJggcQ8HcW4s4,59283
+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/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=iJkKSBClm348xeQ0CmK4lOUbLEQ-CRr-GvJdPmSHg9o,9916
+sycommon/agent/mcp/tool_loader.py,sha256=OQa-lE7RL2s3Lqh-kNOKaUrb130hvorB_HjyFBqZBZs,10960
 sycommon/agent/sandbox/__init__.py,sha256=jR7LlkD4J4Y6QYyRXQClkwmqDBCCPmycV_hQV9p9YHw,4621
-sycommon/agent/sandbox/file_ops.py,sha256=C1_gfarr2aHstaB9VzV_APJYgQtRfUVvkc3b7QIgmc0,24690
+sycommon/agent/sandbox/file_ops.py,sha256=JwxGwZzcjUEZ8bvomVe-pjVqneODG4_zl5142g71Qdc,24720
 sycommon/agent/sandbox/http_sandbox_backend.py,sha256=_l7guM-sv4XduE9NTNVLPyRTjZZIGR4qefJUTc8e5q4,59199
 sycommon/agent/sandbox/minio_sync.py,sha256=d1kuWllvyAvAMsFZCP0OdHEQtXN9BEIgHbupC31BjSk,20000
 sycommon/agent/sandbox/sandbox_pool.py,sha256=eMn8sLakCWf90l6ni2-333QM8oBdX1CflV-WzneFp_k,9133
@@ -213,7 +213,7 @@ sycommon/middleware/mq.py,sha256=9X6KKtadFjBXKS5L3kEKujYio9wwGfWgXwWOAHO-HDg,254
 sycommon/middleware/sandbox.py,sha256=er0zeHLQtHJqSr27fGcKbAtRo1ZOQ-Lqif8ALWNFSak,47858
 sycommon/middleware/timeout.py,sha256=KlxOPa8xl2dg6yuRi_EzkVJG8bX4stb5ueYxctzzGM8,1433
 sycommon/middleware/token_tracking.py,sha256=rEbgV1bgWMdzAERx4aq5XAvOIT6jTY_tK1P0xHJnL3o,6609
-sycommon/middleware/tool_result_truncation.py,sha256=307qUekFbhrh5x8rLYgoOOSH1Ph7doTicrpTiyiZo_A,10715
+sycommon/middleware/tool_result_truncation.py,sha256=SREo6tb_RDHxqiQdO0N82pio-Cpo0YSrHNa1sASUafM,12429
 sycommon/middleware/traceid.py,sha256=MrcHj-2hzwl5sOMbf6-34tezYv4COnh3R8vaCN9zRuA,14025
 sycommon/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sycommon/models/base_http.py,sha256=EICAAibx3xhjBsLqm35Mi3DCqxp0FME4rD_3iQVjT_E,3051
@@ -269,6 +269,7 @@ sycommon/tests/test_oa_login.py,sha256=5psNnmUst20x-LdjPa_liunhMLGky2uTDVpQzefBn
 sycommon/tests/test_real_summarization.py,sha256=7B89es7-UwULk-kq9xUiWH1ylXUO3QDJm4oZWzJNPk0,6193
 sycommon/tests/test_summarization_config.py,sha256=Ztb-eJXt2NrpBXNp7xST4Cwq4x8DK9pFuC7-bXUUOaE,16860
 sycommon/tests/test_summarization_real.py,sha256=iTwwA_xQd5Zgkn849lu2M0zIHPnMp-3szsIGrg6G9J4,12406
+sycommon/tests/test_summary_leak_e2e.py,sha256=vE5r9QCcZRmUy3YQASwdwCBsVrRcl8vU95sLUyB6u9s,34739
 sycommon/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sycommon/tools/async_utils.py,sha256=e2Bp8v0LDrnViBIZ3zcCWtm_01w67vG34VhnAyGu9ZM,1015
 sycommon/tools/docs.py,sha256=OPj2ETheuWjXLyaXtaZPbwmJKfJaYXV5s4XMVAUNrms,1607
@@ -279,8 +280,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.5a34.dist-info/METADATA,sha256=nawJm7F20hnsLGU7iflCjrngeeSYIERqA2scgDTxxyA,7914
-sycommon_python_lib-0.2.5a34.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-sycommon_python_lib-0.2.5a34.dist-info/entry_points.txt,sha256=gsR4SssKxDWjRU8ggidzNcdMXDPRSKRS7UaGyNP84Qg,92
-sycommon_python_lib-0.2.5a34.dist-info/top_level.txt,sha256=RgphKrg7nJyZ7irJqbxFr-5H2LUYTvI7ivoWZH2hcD0,29
-sycommon_python_lib-0.2.5a34.dist-info/RECORD,,
+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,,