sycommon-python-lib 0.2.8a1__py3-none-any.whl → 0.2.8a3__py3-none-any.whl

sycommon/agent/deep_agent.py

@@ -76,16 +76,67 @@ _STREAM_DEBUG = check_env_flag(['DEEP_AGENT_STREAM_DEBUG'], default='false')
 # 无上限可涨到几十 MB。超限停止追加（只影响前端 tool_call 进度展示，工具实际执行不受影响）。
 MAX_ARGS_BUFFER_BYTES = int(os.environ.get("DEEP_AGENT_MAX_ARGS_BUFFER", 1024 * 1024))
 
+# Defense 4 流式缓冲的判定阈值（字符）：累积到该长度做一次备忘复述前缀判定。
+# 需 >= _match_summary_prefix_overlap 的 min_overlap(20) 且覆盖典型复述开头。
+_DEFENSE4_PROBE_CHARS = int(os.environ.get("DEEP_AGENT_DEFENSE4_PROBE", 120))
+
 if TYPE_CHECKING:
     from deepagents.graph import CompiledStateGraph
     from langchain.agents.middleware.types import AgentState, ContextT, ModelRequest, ModelResponse, ResponseT
     from langgraph.runtime import Runtime
 
+
+def _match_summary_prefix_overlap(text: str, summary: str,
+                                  min_overlap: int = 20) -> int:
+    """检测回答开头对备忘原文的逐字复述，返回需剥除的字符数（0=无复述）。
+
+    Defense 4 的核心判定：模型复述备忘时几乎总是从备忘某行的开头逐字照抄
+    （实测样本：「用户的整体目标是深入学习...」= 备忘第一句原文）。这里对
+    备忘的每一条目（按行取正文）做前缀匹配：text 开头是某条目的开头片段
+    （且 >= min_overlap 字符）即命中，返回重叠长度。
+
+    只查开头（前缀），不做全文搜索 —— 备忘要素"融入回答"是期望行为，
+    只有开头照抄才是复述泄漏。正常回答恰好以备忘某条目前 20 字开头且
+    语义独立的概率可忽略；误剥时也只影响首个 chunk 的前缀。
+
+    Args:
+        text: AI 回答的首个非空文本 chunk。
+        summary: 注入 system 的备忘原文（电报式条目，逐行比对）。
+        min_overlap: 判定为复述的最小连续重叠字符数。
+
+    Returns:
+        text 开头与备忘条目重叠的字符数；无重叠返回 0。
+    """
+    if not text or not summary:
+        return 0
+    probe = text[:120]  # 复述只发生在开头，截断降低比对开销
+    for line in summary.splitlines():
+        line = line.strip()
+        if len(line) < min_overlap:
+            continue
+        # 条目锚点：行首（条目化后「目标:」等标签开头）+ 去掉标签后的正文开头
+        for anchor in (line, line.split(":", 1)[-1].lstrip()):
+            anchor = anchor.strip()
+            if len(anchor) < min_overlap:
+                continue
+            # 前缀重叠：probe 与 anchor 的最长公共前缀
+            n = min(len(probe), len(anchor))
+            common = 0
+            for i in range(n):
+                if probe[i] == anchor[i]:
+                    common += 1
+                else:
+                    break
+            if common >= min_overlap:
+                return common
+    return 0
+
+
 @tool
 def get_current_date() -> str:
-    """获取当前日期时间"""
-    from datetime import datetime
-    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    """获取当前日期时间（北京时间）"""
+    from sycommon.tools.time_utils import now_bj
+    return now_bj().strftime("%Y-%m-%d %H:%M:%S")
 
 
 # 默认系统提示词
@@ -232,6 +283,8 @@ class DeepAgent:
         rubric_eval_collector: Optional[_RubricEvalCollector] = None,
         sensitive_guard: Optional[SensitiveGuardMiddleware] = None,
         raw_model: Any = None,
+        request_prep: Optional[ModelRequestPrepMiddleware] = None,
+        summarization_mw: Any = None,
     ):
         self.user_id = user_id
         self.agent = agent
@@ -240,6 +293,12 @@ class DeepAgent:
         self.recovery_manager = recovery_manager
         self.rubric_eval_collector = rubric_eval_collector
         self.sensitive_guard = sensitive_guard
+        # 🔑 ModelRequestPrepMiddleware 实例引用：chat() 时读取其
+        # last_summary_text 做备忘复述兜底（Defense 4）。
+        self.request_prep = request_prep
+        # 🔑 SummarizationToolMiddleware 内部 middleware 引用：resume_compactor
+        # 恢复前分段压缩复用其 _acreate_summary/_partition_messages 等压缩链。
+        self.summarization_mw = summarization_mw
         # 🔑 存 raw_model 引用，供 cleanup 关 LLM client（root_async_client）。
         # model 被埋进 graph 内部节点闭包，表层拿不到，必须 create 时显式传入。
         self._raw_model = raw_model
@@ -290,6 +349,13 @@ class DeepAgent:
         ai_text_content = ""
         seen_tool_call_ids = set()
         stream_step = 0
+        # Defense 4（备忘复述兜底）状态：对每「版」备忘各判定一次。
+        # 比对文本取 ModelRequestPrepMiddleware.last_summary_text —— 压缩可发生
+        # 在本轮任意一次模型调用（不只在首轮）。流式下逐 token chunk 太小，
+        # 用缓冲累积到 ~120 字符再做一次判定（见流循环内 Defense 4 注释）。
+        _defense4_seen_summary = None
+        _defense4_buffer = ""
+        _defense4_done = True  # 无备忘时默认已完成（跳过判定）
         # 兜底：累积流式 chunk 中的 usage_metadata（middleware 在流式场景可能拿不到）
         total_input_tokens = 0
         total_output_tokens = 0
@@ -405,6 +471,14 @@ class DeepAgent:
 
                 stream_step += 1
 
+                # 🔑 跳过 middleware 内部模型调用的输出（lc_internal_call）。
+                # langchain 1.3.15 起 SummarizationMiddleware 的摘要生成调用带
+                # internal_call_metadata() 标记（进程内随机 token 防伪造），
+                # langgraph 会把它透传到流事件 metadata。压缩轮的「摘要本体」
+                # （目标:/事实: 等条目）曾因此被当回答发给用户 —— 根治点。
+                if isinstance(metadata, dict) and "lc_internal_call" in metadata:
+                    continue
+
                 # ===== 逐 chunk 诊断日志：默认关闭，DEEP_AGENT_STREAM_DEBUG=true 时开启 =====
                 if _STREAM_DEBUG:
                     _chunk_type = type(chunk).__name__
@@ -569,6 +643,46 @@ class DeepAgent:
                     if _cleaned:
                         content = content.strip()
 
+                # 🔑 Defense 4（输出兜底）：开头与注入备忘的复述检测。
+                # 前三层防线（备忘条目化 / 正向契约 / 标签清理）失效时，模型会把
+                # 备忘开头当回答开头逐字复述（实测"用户的整体目标是..."）。这里
+                # 对本条 agent 回答的开头做一次重叠判定：开头与备忘原文出现连续
+                # 长重叠（>= 20 字符）即剥掉重叠前缀。
+                # 🔑 流式适配：逐 token 流式下首 chunk 仅 1-2 字符，单个 chunk
+                # 永远达不到 20 字符判定阈值。因此用「先缓冲后放行」：本条回答的
+                # 前 _DEFENSE4_PROBE_CHARS 字符先累积到 _defense4_buffer（不
+                # yield），凑满后做一次判定——命中复述剥除前缀、未命中原样，
+                # 然后一次性 flush 发出；此后所有 chunk 直通。回答总长不足阈值
+                # 时由流末 flush（见 FOR 循环结束处）兜底。代价是回答开头延迟
+                # 若干 token 到达，换取首句复述的可靠拦截。
+                if (msg_type in ("AIMessage", "AIMessageChunk")
+                        and content.strip()):
+                    _summary_ref = getattr(
+                        getattr(self, 'request_prep', None),
+                        'last_summary_text', None)
+                    # 新一版备忘 → 重置缓冲与完成标记（压缩可发生在本轮任意一次模型调用后）
+                    if _summary_ref and _summary_ref is not _defense4_seen_summary:
+                        _defense4_seen_summary = _summary_ref
+                        _defense4_buffer = ""
+                        _defense4_done = False
+                    if _summary_ref and not _defense4_done:
+                        _defense4_buffer += content
+                        if len(_defense4_buffer) >= _DEFENSE4_PROBE_CHARS:
+                            _defense4_done = True
+                            _strip = _match_summary_prefix_overlap(
+                                _defense4_buffer, _summary_ref)
+                            if _strip:
+                                SYLogger.warning(
+                                    f"[DeepAgent] 回答开头复述备忘（重叠 {_strip} 字符），已剥除")
+                                _defense4_buffer = _defense4_buffer[_strip:].lstrip()
+                        # 缓冲未满或刚好判定完：本 chunk 已并入缓冲，不单独发出。
+                        # 判定完成时下方统一 flush；未满时置空等待后续。
+                        content = ""
+                    # 判定完成后：缓冲里剩余的内容一次性放到本 chunk 发出
+                    if _defense4_done and _defense4_buffer:
+                        content = _defense4_buffer + (content or "")
+                        _defense4_buffer = ""
+
                 if msg_type in ("AIMessage", "AIMessageChunk"):
                     # 🔑 提取 reasoning_content（思考/推理内容）
                     # 模型在 thinking 模式下会将推理过程放在 reasoning_content 字段，
@@ -781,6 +895,28 @@ class DeepAgent:
                 print(
                     f"[DeepAgent] FOR LOOP ENDED. stream_step={stream_step}, ai_text_content={repr(ai_text_content[:100])}, tool_calls={len(current_tool_calls)}", flush=True)
 
+            # 🔑 Defense 4 流末 flush：回答总长不足判定阈值时缓冲里还压着内容
+            # （正常路径在缓冲满 _DEFENSE4_PROBE_CHARS 时已 flush）。这里做
+            # 最后一次判定并发出，避免短回答被缓冲吞掉。
+            if _defense4_buffer:
+                if not _defense4_done and _defense4_seen_summary:
+                    _strip = _match_summary_prefix_overlap(
+                        _defense4_buffer, _defense4_seen_summary)
+                    if _strip:
+                        SYLogger.warning(
+                            f"[DeepAgent] 回答开头复述备忘（流末判定，重叠 {_strip} 字符），已剥除")
+                        _defense4_buffer = _defense4_buffer[_strip:].lstrip()
+                if _defense4_buffer:
+                    flushed = _defense4_buffer
+                    _defense4_buffer = ""
+                    ai_text_content += flushed
+                    event = ChatEventBuilder.ai_chunk(
+                        flushed, id=None, agent=DEFAULT_AGENT_NAME)
+                    if on_event:
+                        await on_event(event)
+                    yield event
+                _defense4_done = True
+
             SYLogger.warning(
                 f"[STREAM-DEBUG] FOR LOOP ENDED | _astream_chunk_count={_astream_chunk_count} | "
                 f"stream_step={stream_step} | ai_text_len={len(ai_text_content)} | "
@@ -1115,7 +1251,8 @@ async def create_deep_agent(
 
     middleware_list = [
         guard,
-        ToolResultTruncationMiddleware(),
+        # 截断上限从 nacos maxTokens 推导(×0.04,下限2000);读不到配置兜底 8192
+        ToolResultTruncationMiddleware(model_name=config.model_name),
         TokenTrackingMiddleware(model_name=config.model_name, user_id=user_id),
         summarization_mw,
         ModelRequestPrepMiddleware(),     # 紧跟 summarization：摘要重定位 + 动态压 max_tokens
@@ -1211,6 +1348,15 @@ async def create_deep_agent(
         rubric_eval_collector=rubric_eval_collector,
         sensitive_guard=guard,
         raw_model=raw_model,
+        request_prep=next(
+            (m for m in middleware_list
+             if type(m).__name__ == "ModelRequestPrepMiddleware"), None),
+        # SummarizationToolMiddleware 实例引用:resume_compactor 分段压缩复用
+        # 其内部 _DeepAgentsSummarizationMiddleware(_acreate_summary 等)。
+        # graph 内部探测(deepagents 未暴露 middleware 列表)不可靠,创建时显式传入。
+        summarization_mw=next(
+            (getattr(m, "_summarization", None) for m in middleware_list
+             if type(m).__name__ == "SummarizationToolMiddleware"), None),
     )
 
 
@@ -1436,6 +1582,8 @@ async def _sync_skills_to_sandbox(
 
         skill_count = 0
         skip_count = 0
+        # 收集需要重传的技能（版本不一致 / 无版本 / 正文校验失败）
+        pending = []  # [(skill_name, local_version, src, remote_version)]
         for skill_name, local_version, src in local_skills:
             remote_version = remote_version_map.get(skill_name, "")
 
@@ -1444,19 +1592,27 @@ async def _sync_skills_to_sandbox(
                 # （历史上出现过沙箱 SKILL.md 版本号新、正文旧的脏数据，导致 agent
                 # 永远读不到新版指令）。校验失败则强制走删除+重传。
                 # fresh_map 在进入循环前已并发预取，这里只查表不再 await。
-                if not fresh_map.get(skill_name, False):
-                    SYLogger.warning(
-                        f"[DeepAgent] 技能版本一致但正文不一致，强制重传: {skill_name} "
-                        f"v{local_version}")
-                    # 落到下方的删除+重传分支
-                else:
+                if fresh_map.get(skill_name, False):
                     SYLogger.debug(
                         f"[DeepAgent] 技能版本一致,跳过: {skill_name} v{local_version}")
                     backend._synced_skills.add(skill_name)
                     skip_count += 1
                     continue
-
-            # 版本不一致或无版本（或正文校验失败），删除旧目录(走 /delete,跳过懒同步,毫秒级)
+                SYLogger.warning(
+                    f"[DeepAgent] 技能版本一致但正文不一致，强制重传: {skill_name} "
+                    f"v{local_version}")
+            pending.append((skill_name, local_version, src, remote_version))
+
+        # 并发删除 + 全量上传：信号量限流，把「N 次串行 HTTP 上传」压成「N/并发 批」。
+        # 单个技能上传失败仅记 warning、不拖垮其余（原串行版会让一个失败中断后续所有技能）。
+        # 内存安全：技能库总量 ~2.9MB / 最大单文件 ~608KB，base64 编码瞬时膨胀 ~3x，
+        # 6 路并发最坏额外内存峰值 ~10MB 量级，对服务进程可忽略；若未来技能塞入大资源文件，
+        # 可调低此值或改走 aupload_stream_from_disk 流式上传。
+        _SKILL_SYNC_CONCURRENCY = 6
+        _sync_sem = asyncio.Semaphore(_SKILL_SYNC_CONCURRENCY)
+
+        async def _sync_one(skill_name, local_version, src, remote_version):
+            # 删除旧目录(走 /delete,跳过懒同步,毫秒级)
             if skill_name in existing_dirs:
                 deleted_ok = False
                 for _attempt in range(2):  # 最多重试一次，确保旧内容真删掉
@@ -1480,11 +1636,21 @@ async def _sync_skills_to_sandbox(
                         f"[DeepAgent] 删除旧版技能彻底失败，本次跳过: {skill_name}")
 
             # 全量上传整个技能目录到沙箱(batch_upload 服务端无条件覆盖)
-            await backend.async_sync_dirs([(src, f"{sandbox_dest}/{skill_name}")])
+            try:
+                async with _sync_sem:
+                    await backend.async_sync_dirs([(src, f"{sandbox_dest}/{skill_name}")])
+            except Exception as e:
+                SYLogger.warning(
+                    f"[DeepAgent] 技能上传失败: {skill_name}, {e}")
+                return 0
             backend._synced_skills.add(skill_name)
-            skill_count += 1
             SYLogger.info(
                 f"[DeepAgent] 全量同步技能到沙箱: {skill_name} v{local_version}")
+            return 1
+
+        if pending:
+            results = await asyncio.gather(*[_sync_one(*p) for p in pending])
+            skill_count = sum(r for r in results if r)
 
         if chmod_readonly:
             try:

sycommon/agent/middleware/model_request_prep.py

@@ -45,8 +45,16 @@ class ModelRequestPrepMiddleware(AgentMiddleware):
     通过 ``awrap_model_call`` 在调用 handler 前改造 request。与
     ``TokenTrackingMiddleware`` / ``SensitiveGuardMiddleware`` 同一套写法，
     需排在 ``SummarizationMiddleware`` 之后（摘要 HumanMessage 由后者产生）。
+
+    另持有 ``last_summary_text``（最近一次注入 system 的备忘原文），
+    供 deep_agent 的输出兜底（首句与备忘重叠检测）使用。同一 agent 实例
+    串行会话下读取方在流式消费阶段访问，与写入（模型调用前）天然错开，
+    无并发竞争；多轮压缩时被新摘要覆盖，兜底始终比对最新一版。
     """
 
+    #: 最近一次注入 system_message 的备忘原文（无摘要时为 None）
+    last_summary_text: Optional[str] = None
+
     @property
     def name(self) -> str:
         return "ModelRequestPrepMiddleware"
@@ -77,13 +85,20 @@ class ModelRequestPrepMiddleware(AgentMiddleware):
             return request
 
         from deepagents.middleware._utils import append_to_system_message
+        # 🔑 注入形态 = 备忘在前、行为契约在后（recency：靠近对话末端的指令
+        # 遵循度最高），且用正向指令替代"不要复述"禁令 —— 负向禁令对
+        # glm/DeepSeek 系模型有反向唤起效果（提到"复述"反而引导复述）。
         _summary_directive = (
             "\n\n<system_context>\n"
-            "以下是之前对话历史的压缩摘要，作为你的内部记忆使用。"
-            "把它当作你自己的回忆，绝对不要在回复中重复、复述或引用此内容的任何部分。\n"
+            "以下是之前对话历史的压缩备忘（内部笔记，仅供你参考，不属于对话内容）。\n"
             f"{_summary_text}\n"
+            "\n回复规范：直接以对新问题的回答开头。"
+            "备忘中的相关要素直接融入回答本身；"
+            "不要先盘点、复述或引用备忘内容，也不要提及备忘的存在。\n"
             "</system_context>"
         )
+        # 记录备忘原文，供 deep_agent 输出兜底（首句重叠检测）比对
+        self.last_summary_text = _summary_text
         _new_sys = append_to_system_message(
             request.system_message, _summary_directive)
         return request.override(messages=_filtered, system_message=_new_sys)

sycommon/agent/middleware/sensitive_guard.py

@@ -14,6 +14,7 @@ agent 本就是内部模型（model_tier="internal"）时短路放行，不检
 """
 import asyncio
 import os
+import time
 from typing import Any, Awaitable, Callable, List, Optional
 
 from langchain.agents.middleware.types import (
@@ -458,10 +459,13 @@ class SensitiveGuardMiddleware(AgentMiddleware):
             # 恢复，让检测器在干净的上下文里跑（非流式、不进用户事件流）。
             from langchain_core.runnables.config import var_child_runnable_config
             _ctx_token = var_child_runnable_config.set({})
+            _t0 = time.perf_counter()
             try:
                 raw = await detector.ainvoke(prompt)
             finally:
                 var_child_runnable_config.reset(_ctx_token)
+            _dt = time.perf_counter() - _t0
+            SYLogger.info(f"[Perf] sensitive_detect: {_dt:.3f}s")
             text = raw.content if isinstance(raw, BaseMessage) else str(raw)
             check = _parse_detect_json(text)
             if check is None:

sycommon/agent/multi_agent_team.py

@@ -60,9 +60,9 @@ if TYPE_CHECKING:
 
 @tool
 def get_current_date() -> str:
-    """获取当前日期时间"""
-    from datetime import datetime
-    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    """获取当前日期时间（北京时间）"""
+    from sycommon.tools.time_utils import now_bj
+    return now_bj().strftime("%Y-%m-%d %H:%M:%S")
 
 
 # 默认记忆系统提示词（所有角色共享）
@@ -208,6 +208,7 @@ class MultiAgentTeam:
         downgrade_state: Optional[DowngradeState] = None,
         sensitive_guard: Optional["SensitiveGuardMiddleware"] = None,
         raw_model: Any = None,
+        summarization_mw: Any = None,
     ):
         self.user_id = user_id
         self.agent = agent
@@ -224,6 +225,9 @@ class MultiAgentTeam:
         self.sensitive_guard = sensitive_guard
         # 🔑 存协调者 raw_model 引用，供 cleanup 关 LLM client
         self._raw_model = raw_model
+        # 🔑 协调者 SummarizationToolMiddleware 内部 middleware 引用：
+        # resume_compactor 恢复前分段压缩复用其压缩链（与 DeepAgent 对齐）。
+        self.summarization_mw = summarization_mw
 
     @property
     def is_downgraded(self) -> bool:
@@ -304,6 +308,13 @@ class MultiAgentTeam:
                 if msg is None:
                     continue
 
+                # 🔑 跳过 middleware 内部模型调用的输出（lc_internal_call）。
+                # 与 deep_agent 对齐：协调者/子 agent 的 deepagents 内置
+                # SummarizationMiddleware 生成摘要时，其内部模型调用的输出
+                # 会混进 messages 流 —— 不过滤会把「摘要本体」当回答发给用户。
+                if isinstance(metadata, dict) and "lc_internal_call" in metadata:
+                    continue
+
                 # 检测 agent 切换
                 subagent_name = self._detect_agent_change(namespace, metadata, current_agent)
                 if subagent_name and subagent_name != current_agent:
@@ -680,7 +691,7 @@ async def create_multi_agent_team(
 
     middleware = [
         _make_guard(detect=False),
-        ToolResultTruncationMiddleware(),
+        ToolResultTruncationMiddleware(model_name=config.model_name),
         TokenTrackingMiddleware(model_name=config.model_name, user_id=user_id),
         summarization_mw,
         ModelRequestPrepMiddleware(),     # 紧跟 summarization：摘要重定位 + 动态压 max_tokens
@@ -746,7 +757,7 @@ async def create_multi_agent_team(
         name=coord_name,
         middleware=[
             coord_guard,
-            ToolResultTruncationMiddleware(),
+            ToolResultTruncationMiddleware(model_name=config.model_name),
             TokenTrackingMiddleware(model_name=config.model_name, user_id=user_id),
             coord_summarization_mw,
             SkillWriteGuardMiddleware(),
@@ -767,6 +778,7 @@ async def create_multi_agent_team(
         downgrade_state=shared_downgrade_state,
         sensitive_guard=coord_guard,
         raw_model=raw_model,
+        summarization_mw=getattr(coord_summarization_mw, "_summarization", None),
     )