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

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

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

{sycommon_python_lib-0.2.5a35 → sycommon_python_lib-0.2.5a37}/pyproject.toml

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

{sycommon_python_lib-0.2.5a35 → sycommon_python_lib-0.2.5a37}/src/sycommon/agent/deep_agent.py

@@ -104,27 +104,35 @@ def _patch_agent_streaming(agent):
         from langchain_core.messages import AIMessageChunk as _AIC, AIMessage as _AIM
         from langchain_core.runnables.config import var_child_runnable_config
 
-        print(f"[StreamingPatch] agent.nodes: {list(agent.nodes.keys())}", flush=True)
+        print(
+            f"[StreamingPatch] agent.nodes: {list(agent.nodes.keys())}", flush=True)
         node = agent.nodes.get("model")
         if node is None:
             print("[StreamingPatch] model node not found, skip", flush=True)
-            SYLogger.warning("[DeepAgent] model node not found, skip streaming patch")
+            SYLogger.warning(
+                "[DeepAgent] model node not found, skip streaming patch")
             return
 
         inner = node.node  # RunnableSeq
-        print(f"[StreamingPatch] inner type: {type(inner).__name__}", flush=True)
+        print(
+            f"[StreamingPatch] inner type: {type(inner).__name__}", flush=True)
         if not hasattr(inner, 'steps') or not inner.steps:
             print(f"[StreamingPatch] no steps, inner={inner}", flush=True)
-            SYLogger.warning("[DeepAgent] model node has no steps, skip streaming patch")
+            SYLogger.warning(
+                "[DeepAgent] model node has no steps, skip streaming patch")
             return
 
-        step0 = inner.steps[0]  # RunnableCallable(trace=False, afunc=amodel_node)
-        print(f"[StreamingPatch] step0 type: {type(step0).__name__}, trace={getattr(step0, 'trace', 'N/A')}", flush=True)
+        # RunnableCallable(trace=False, afunc=amodel_node)
+        step0 = inner.steps[0]
+        print(
+            f"[StreamingPatch] step0 type: {type(step0).__name__}, trace={getattr(step0, 'trace', 'N/A')}", flush=True)
         afunc = getattr(step0, "afunc", None)  # amodel_node
         if afunc is None or afunc.__closure__ is None:
-            SYLogger.warning("[DeepAgent] amodel_node afunc/closure 缺失, skip streaming patch")
+            SYLogger.warning(
+                "[DeepAgent] amodel_node afunc/closure 缺失, skip streaming patch")
             return
-        print(f"[StreamingPatch] afunc: {afunc.__name__}, freevars={afunc.__code__.co_freevars}", flush=True)
+        print(
+            f"[StreamingPatch] afunc: {afunc.__name__}, freevars={afunc.__code__.co_freevars}", flush=True)
 
         # ---- 按自由变量名定位 cell（不依赖固定索引）----
         def _cell_by_name(fn, name):
@@ -192,7 +200,8 @@ def _patch_agent_streaming(agent):
                     f"[StreamingPatch] clamp max_tokens: "
                     f"context={max_tokens_limit}, max_output={max_output} → {dynamic_max}")
             except Exception as e:
-                SYLogger.warning(f"[StreamingPatch] clamp max_tokens failed: {e}")
+                SYLogger.warning(
+                    f"[StreamingPatch] clamp max_tokens failed: {e}")
 
         async def _patched_execute_model_async(request):
             """替代 factory._execute_model_async: 用 astream + config 实现流式回调。"""
@@ -201,26 +210,43 @@ def _patch_agent_streaming(agent):
             model_, effective_response_format = _get_bound_model(request)
             messages = request.messages
 
-            # 🔑 根治摘要泄漏：将 lc_source="summarization" 的 HumanMessage 从模型输入中移除
+            # 🔑 根治摘要泄漏：将 lc_source="summarization" 的 HumanMessage 内容
+            # 注入到 system_message 而非直接丢弃，保持记忆连续性。
             # 根因分析（2026-06-06 端到端测试确认）：
-            # 1. SummarizationMiddleware 将摘要(可达 40K+ 字符)注入为 HumanMessage
-            # 2. 即使转为 SystemMessage + <system_directive> 指令，模型仍会将其作为
-            #    AIMessageChunk 直接回显（Round 20 泄漏了 40K 字符摘要原文）
-            # 3. LangGraph StreamMessagesHandler._find_and_emit_messages 会递归遍历
-            #    Command.update 中的 _summarization_event，将 summary_message HumanMessage
-            #    发射到 stream_mode="messages" 流中（deep_agent.py:624 的 lc_source 过滤
-            #    能捕获 HumanMessage，但模型自己输出的 AIMessageChunk 无法过滤）
-            # 修复策略：从模型输入中完全移除摘要 HumanMessage，不注入任何形式的摘要内容
-            # 摘要仍保留在 LangGraph _summarization_event 状态中，供后续压缩轮次使用
+            # 1. SummarizationMiddleware 将摘要注入为 HumanMessage
+            # 2. 模型看到 HumanMessage 后容易将其作为对话内容回显/复述
+            # 3. 之前完全移除摘要导致压缩后模型丢失所有记忆
+            # 修复策略：提取摘要内容 → 注入 SystemMessage（模型视其为指令/背景知识，
+            # 回显概率远低于 HumanMessage）→ 从 messages 中移除原始 HumanMessage
+            _summary_text = None
             _filtered_messages = []
             for _msg in messages:
                 if (isinstance(_msg, HumanMessage)
                         and getattr(_msg, "additional_kwargs", {}).get("lc_source") == "summarization"):
-                    SYLogger.debug("[DeepAgent] 摘要 HumanMessage 已从模型输入中移除（防止回显泄漏）")
+                    _raw = _msg.content or ""
+                    # 去掉 <internal_context_data> 包装标签，提取纯摘要
+                    _summary_text = re.sub(
+                        r'</?internal_context_data>', '', _raw, flags=re.DOTALL
+                    ).strip()
+                    SYLogger.debug(
+                        "[DeepAgent] 摘要已从 HumanMessage 提取，将注入 system_message")
                 else:
                     _filtered_messages.append(_msg)
             messages = _filtered_messages
 
+            if _summary_text and request.system_message:
+                from deepagents.middleware._utils import append_to_system_message
+                _summary_directive = (
+                    "\n\n<system_context>\n"
+                    "以下是之前对话历史的压缩摘要，作为你的内部记忆使用。"
+                    "把它当作你自己的回忆，绝对不要在回复中重复、复述或引用此内容的任何部分。\n"
+                    f"{_summary_text}\n"
+                    "</system_context>"
+                )
+                _new_sys = append_to_system_message(
+                    request.system_message, _summary_directive)
+                request = request.override(system_message=_new_sys)
+
             if request.system_message:
                 messages = [request.system_message, *messages]
 
@@ -239,7 +265,8 @@ def _patch_agent_streaming(agent):
 
             if not chunks:
                 # astream 无产出时降级到原始 ainvoke（不走流式）
-                SYLogger.warning("[StreamingPatch] astream returned empty, fallback to ainvoke")
+                SYLogger.warning(
+                    "[StreamingPatch] astream returned empty, fallback to ainvoke")
                 output = await model_.ainvoke(messages, config=config)
             else:
                 generation = chunks[0]
@@ -253,8 +280,10 @@ def _patch_agent_streaming(agent):
                         content=ai_message.content,
                         additional_kwargs=ai_message.additional_kwargs,
                         tool_calls=ai_message.tool_calls,
-                        usage_metadata=getattr(ai_message, "usage_metadata", None),
-                        response_metadata=getattr(ai_message, "response_metadata", {}),
+                        usage_metadata=getattr(
+                            ai_message, "usage_metadata", None),
+                        response_metadata=getattr(
+                            ai_message, "response_metadata", {}),
                         id=ai_message.id,
                     )
                 output = ai_message
@@ -262,7 +291,8 @@ def _patch_agent_streaming(agent):
             if _name:
                 output.name = _name
 
-            handled_output = _handle_model_output(output, effective_response_format)
+            handled_output = _handle_model_output(
+                output, effective_response_format)
             return ModelResponse(
                 result=handled_output["messages"],
                 structured_response=handled_output.get("structured_response"),
@@ -274,7 +304,6 @@ def _patch_agent_streaming(agent):
             f"[DeepAgent] _execute_model_async patched (astream + config) "
             f"| langchain={_cur.get('langchain')} core={_cur.get('langchain_core')}")
 
-
     except Exception as e:
         SYLogger.warning(f"[DeepAgent] streaming patch failed: {e}")
 
@@ -422,7 +451,8 @@ class DeepAgent:
             input_state = {"messages": [HumanMessage(content=message)]}
             if rubric:
                 input_state["rubric"] = rubric
-            print(f"[DeepAgent] chat() starting stream, message={repr(message[:80])}", flush=True)
+            print(
+                f"[DeepAgent] chat() starting stream, message={repr(message[:80])}", flush=True)
             async for chunk in self._astream_with_retry(
                 input_state,
                 max_retries=3,
@@ -442,9 +472,12 @@ class DeepAgent:
                         _meta = chunk[1]
                     _msg_type = type(_msg).__name__
                     _content = repr(str(getattr(_msg, 'content', ''))[:80])
-                    _node = _meta.get('langgraph_node', '?') if isinstance(_meta, dict) else '?'
-                    _step = _meta.get('langgraph_step', '?') if isinstance(_meta, dict) else '?'
-                    print(f"[DeepAgent] 2tuple: ns={_ns} msg={_msg_type} node={_node} step={_step} content={_content}", flush=True)
+                    _node = _meta.get('langgraph_node', '?') if isinstance(
+                        _meta, dict) else '?'
+                    _step = _meta.get('langgraph_step', '?') if isinstance(
+                        _meta, dict) else '?'
+                    print(
+                        f"[DeepAgent] 2tuple: ns={_ns} msg={_msg_type} node={_node} step={_step} content={_content}", flush=True)
                 elif isinstance(chunk, tuple) and _chunk_len == 3:
                     namespace_p, _tag_p, payload_p = chunk
                     if isinstance(payload_p, tuple) and len(payload_p) == 2:
@@ -452,13 +485,18 @@ class DeepAgent:
                         _meta = payload_p[1]
                         _msg_type = type(_msg).__name__
                         _content = repr(str(getattr(_msg, 'content', ''))[:80])
-                        _node = _meta.get('langgraph_node', '?') if isinstance(_meta, dict) else '?'
-                        _step = _meta.get('langgraph_step', '?') if isinstance(_meta, dict) else '?'
-                        print(f"[DeepAgent] 3tuple: ns={repr(namespace_p)[:30]} msg={_msg_type} node={_node} step={_step} content={_content}", flush=True)
+                        _node = _meta.get('langgraph_node', '?') if isinstance(
+                            _meta, dict) else '?'
+                        _step = _meta.get('langgraph_step', '?') if isinstance(
+                            _meta, dict) else '?'
+                        print(
+                            f"[DeepAgent] 3tuple: ns={repr(namespace_p)[:30]} msg={_msg_type} node={_node} step={_step} content={_content}", flush=True)
                     else:
-                        print(f"[DeepAgent] 3tuple: payload_type={type(payload_p).__name__}", flush=True)
+                        print(
+                            f"[DeepAgent] 3tuple: payload_type={type(payload_p).__name__}", flush=True)
                 else:
-                    print(f"[DeepAgent] chunk: type={type(chunk).__name__}", flush=True)
+                    print(
+                        f"[DeepAgent] chunk: type={type(chunk).__name__}", flush=True)
                 # 检查取消
                 if cancel_event and cancel_event.is_set():
                     event = ChatEventBuilder.cancelled("任务已取消")
@@ -491,10 +529,13 @@ class DeepAgent:
 
                 # ===== 🔑 诊断日志：详细记录每个 chunk =====
                 _chunk_type = type(chunk).__name__
-                _msg_type = getattr(msg, '__class__.__name__', '?') if msg else 'None'
+                _msg_type = getattr(
+                    msg, '__class__.__name__', '?') if msg else 'None'
                 _ns = namespace if namespace else '()'
-                _node = metadata.get("langgraph_node", "?") if metadata else "?"
-                _step = metadata.get("langgraph_step", "?") if metadata else "?"
+                _node = metadata.get(
+                    "langgraph_node", "?") if metadata else "?"
+                _step = metadata.get(
+                    "langgraph_step", "?") if metadata else "?"
                 _content_preview = ""
                 if isinstance(msg, BaseMessage):
                     _c = msg.content or ""
@@ -516,8 +557,10 @@ class DeepAgent:
                     if msg_type in ("AIMessage", "AIMessageChunk"):
                         usage_meta = getattr(msg, "usage_metadata", None)
                         if usage_meta:
-                            total_input_tokens += usage_meta.get("input_tokens", 0)
-                            total_output_tokens += usage_meta.get("output_tokens", 0)
+                            total_input_tokens += usage_meta.get(
+                                "input_tokens", 0)
+                            total_output_tokens += usage_meta.get(
+                                "output_tokens", 0)
                             if usage_meta.get("input_tokens", 0) > 0:
                                 SYLogger.debug(
                                     f"[DeepAgent] usage_metadata | input={usage_meta.get('input_tokens', 0)} "
@@ -596,10 +639,12 @@ class DeepAgent:
                         await on_event(event)
                     yield event
 
-                print(f"[DeepAgent] post-yield: msg_type={type(msg).__name__}, is_BaseMessage={isinstance(msg, BaseMessage)}", flush=True)
+                print(
+                    f"[DeepAgent] post-yield: msg_type={type(msg).__name__}, is_BaseMessage={isinstance(msg, BaseMessage)}", flush=True)
 
                 if not isinstance(msg, BaseMessage):
-                    print(f"[DeepAgent] SKIPPING non-BaseMessage: {type(msg).__name__}", flush=True)
+                    print(
+                        f"[DeepAgent] SKIPPING non-BaseMessage: {type(msg).__name__}", flush=True)
                     continue
 
                 msg_type = msg.__class__.__name__
@@ -608,19 +653,39 @@ class DeepAgent:
                 # SummarizationMiddleware 会将摘要包装为 HumanMessage（lc_source="summarization"），
                 # 这仅用于模型内部理解上下文，不应展示给用户
                 if msg_type == "HumanMessage" and getattr(msg, "additional_kwargs", {}).get("lc_source") == "summarization":
-                    SYLogger.debug(f"[DeepAgent] 跳过摘要消息 (lc_source=summarization)")
+                    SYLogger.debug(
+                        f"[DeepAgent] 跳过摘要消息 (lc_source=summarization)")
                     continue
 
                 raw_content = msg.content
                 # 🔑 处理 content 为 list 的情况（多模态模型）
                 if isinstance(raw_content, list):
                     content = "".join(
-                        item.get("text", "") if isinstance(item, dict) else str(item)
+                        item.get("text", "") if isinstance(
+                            item, dict) else str(item)
                         for item in raw_content
                     )
                 else:
                     content = raw_content or ""
 
+                # 🔑 Defense 3: 清理 AI 输出中的摘要泄漏标签（安全网）
+                # 即使摘要已注入 SystemMessage，模型仍可能在极少数情况下回显标签
+                if msg_type in ("AIMessage", "AIMessageChunk") and content:
+                    _cleaned = False
+                    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)
+                            _cleaned = True
+                            SYLogger.warning("[DeepAgent] AI 输出包含摘要泄漏标签，已清理")
+                    # 仅在确实清理了泄漏标签时才 strip，避免吞掉正常的换行符
+                    if _cleaned:
+                        content = content.strip()
+
                 if msg_type in ("AIMessage", "AIMessageChunk"):
                     # 🔑 提取 reasoning_content（思考/推理内容）
                     # 模型在 thinking 模式下会将推理过程放在 reasoning_content 字段，
@@ -655,11 +720,13 @@ class DeepAgent:
                             # 用 (id 或 index) 匹配已记录的 tool_call
                             if tcc_id:
                                 existing_tc = next(
-                                    (tc for tc in current_tool_calls if tc.get("id") == tcc_id), None
+                                    (tc for tc in current_tool_calls if tc.get(
+                                        "id") == tcc_id), None
                                 )
                             elif tcc_index is not None:
                                 existing_tc = next(
-                                    (tc for tc in current_tool_calls if tc.get("_index") == tcc_index), None
+                                    (tc for tc in current_tool_calls if tc.get(
+                                        "_index") == tcc_index), None
                                 )
                             else:
                                 existing_tc = None
@@ -736,7 +803,8 @@ class DeepAgent:
                                     # 非空 args 覆盖（完整解析后的结果）
                                     if tc_args and tc_args != {}:
                                         existing_tc["args"] = tc_args
-                                        existing_tc["_args_buffer"] = json.dumps(tc_args, ensure_ascii=False)
+                                        existing_tc["_args_buffer"] = json.dumps(
+                                            tc_args, ensure_ascii=False)
                                 else:
                                     current_tool_calls.append({
                                         "id": tc_id, "name": tc_name, "args": tc_args,
@@ -816,7 +884,8 @@ class DeepAgent:
                 SYLogger.debug(
                     f"[DeepAgent] AI chunk done | {repr(ai_chunk_buffer[:100])}...")
 
-            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)
+            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)
 
             # 空响应检测：模型被调用但没有产出任何文本
             if not ai_text_content and not ai_chunk_buffer:
@@ -856,7 +925,8 @@ class DeepAgent:
             yield event
             raise
         except Exception as e:
-            print(f"[DeepAgent] chat() Exception: {type(e).__name__}: {e}", flush=True)
+            print(
+                f"[DeepAgent] chat() Exception: {type(e).__name__}: {e}", flush=True)
             import traceback
             traceback.print_exc()
             SYLogger.error(f"[DeepAgent] 聊天异常: {e}")
@@ -908,66 +978,76 @@ class DeepAgent:
         max_sandbox_retries = 3
 
         try:
-          while True:
-            for attempt in range(max_retries):
-                try:
-                    print(f"[DeepAgent] _astream_with_retry: attempt={attempt}, starting astream...", flush=True)
-                    chunk_count = 0
-                    async for chunk in self.agent.astream(
-                        input_data,
-                        config=self.config,
-                        stream_mode="messages",
-                        subgraphs=True
-                    ):
-                        chunk_count += 1
-                        print(f"[DeepAgent] _astream yielding chunk #{chunk_count}", flush=True)
-                        yield chunk
-                        print(f"[DeepAgent] _astream yield returned, consumer processed chunk #{chunk_count}", flush=True)
-                    print(f"[DeepAgent] _astream_with_retry: stream ended normally, total_chunks={chunk_count}", flush=True)
-                    return
-                except (APIConnectionError, APIError, APITimeoutError, ConnectionError, httpx.RemoteProtocolError) as e:
-                    last_error = e
-                    print(f"[DeepAgent] _astream_with_retry: API error: {type(e).__name__}: {e}", flush=True)
-                    if attempt < max_retries - 1:
-                        delay = base_delay * (2 ** attempt)
-                        SYLogger.warning(
-                            f"[DeepAgent] 连接错误: {e}, {delay}秒后重试...")
-                        await asyncio.sleep(delay)
-                    else:
-                        raise last_error
-                except RuntimeError as e:
-                    err_msg = str(e)
-                    is_sandbox_error = "沙箱服务不可用" in err_msg or "Failed to download" in err_msg
-                    if is_sandbox_error and self.recovery_manager and sandbox_retries < max_sandbox_retries:
-                        sandbox_retries += 1
-                        SYLogger.warning(f"[DeepAgent] 沙箱服务不可用，尝试恢复 ({sandbox_retries}/{max_sandbox_retries})...")
-                        recovered = await self.recovery_manager.recover()
-                        if recovered:
-                            SYLogger.info("[DeepAgent] 沙箱已恢复，继续执行")
-                            break
-                        raise
-                    raise
-                except ValueError as e:
-                    err_msg = str(e)
-                    if "Failed to download" in err_msg or "沙箱服务不可用" in err_msg:
-                        if self.recovery_manager and sandbox_retries < max_sandbox_retries:
+            while True:
+                for attempt in range(max_retries):
+                    try:
+                        print(
+                            f"[DeepAgent] _astream_with_retry: attempt={attempt}, starting astream...", flush=True)
+                        chunk_count = 0
+                        async for chunk in self.agent.astream(
+                            input_data,
+                            config=self.config,
+                            stream_mode="messages",
+                            subgraphs=True
+                        ):
+                            chunk_count += 1
+                            print(
+                                f"[DeepAgent] _astream yielding chunk #{chunk_count}", flush=True)
+                            yield chunk
+                            print(
+                                f"[DeepAgent] _astream yield returned, consumer processed chunk #{chunk_count}", flush=True)
+                        print(
+                            f"[DeepAgent] _astream_with_retry: stream ended normally, total_chunks={chunk_count}", flush=True)
+                        return
+                    except (APIConnectionError, APIError, APITimeoutError, ConnectionError, httpx.RemoteProtocolError) as e:
+                        last_error = e
+                        print(
+                            f"[DeepAgent] _astream_with_retry: API error: {type(e).__name__}: {e}", flush=True)
+                        if attempt < max_retries - 1:
+                            delay = base_delay * (2 ** attempt)
+                            SYLogger.warning(
+                                f"[DeepAgent] 连接错误: {e}, {delay}秒后重试...")
+                            await asyncio.sleep(delay)
+                        else:
+                            raise last_error
+                    except RuntimeError as e:
+                        err_msg = str(e)
+                        is_sandbox_error = "沙箱服务不可用" in err_msg or "Failed to download" in err_msg
+                        if is_sandbox_error and self.recovery_manager and sandbox_retries < max_sandbox_retries:
                             sandbox_retries += 1
-                            SYLogger.warning(f"[DeepAgent] Memory 下载失败（沙箱不可达），尝试恢复 ({sandbox_retries}/{max_sandbox_retries})...")
+                            SYLogger.warning(
+                                f"[DeepAgent] 沙箱服务不可用，尝试恢复 ({sandbox_retries}/{max_sandbox_retries})...")
                             recovered = await self.recovery_manager.recover()
                             if recovered:
                                 SYLogger.info("[DeepAgent] 沙箱已恢复，继续执行")
                                 break
-                        # 恢复失败也继续执行（降级：memory 不可用不阻塞聊天）
-                        SYLogger.warning(f"[DeepAgent] Memory 不可用，降级继续执行: {err_msg}")
-                        continue
-                    raise
-            else:
-                break
+                            raise
+                        raise
+                    except ValueError as e:
+                        err_msg = str(e)
+                        if "Failed to download" in err_msg or "沙箱服务不可用" in err_msg:
+                            if self.recovery_manager and sandbox_retries < max_sandbox_retries:
+                                sandbox_retries += 1
+                                SYLogger.warning(
+                                    f"[DeepAgent] Memory 下载失败（沙箱不可达），尝试恢复 ({sandbox_retries}/{max_sandbox_retries})...")
+                                recovered = await self.recovery_manager.recover()
+                                if recovered:
+                                    SYLogger.info("[DeepAgent] 沙箱已恢复，继续执行")
+                                    break
+                            # 恢复失败也继续执行（降级：memory 不可用不阻塞聊天）
+                            SYLogger.warning(
+                                f"[DeepAgent] Memory 不可用，降级继续执行: {err_msg}")
+                            continue
+                        raise
+                else:
+                    break
         except GeneratorExit:
-            print("[DeepAgent] _astream_with_retry: GeneratorExit! Consumer closed the generator!", flush=True)
+            print(
+                "[DeepAgent] _astream_with_retry: GeneratorExit! Consumer closed the generator!", flush=True)
             raise
         except Exception as e:
-            print(f"[DeepAgent] _astream_with_retry: Unexpected exception: {type(e).__name__}: {e}", flush=True)
+            print(
+                f"[DeepAgent] _astream_with_retry: Unexpected exception: {type(e).__name__}: {e}", flush=True)
             raise
 
 
@@ -1019,7 +1099,8 @@ async def create_deep_agent(
     # 等方法在原始 ChatOpenAI 上工作，而不是被 LLMWithTokenTracking 的包装拦截。
     raw_model = getattr(model, 'llm', model)
     if raw_model is not model:
-        print(f"[DeepAgent] 提取原始模型: {type(model).__name__} → {type(raw_model).__name__}", flush=True)
+        print(
+            f"[DeepAgent] 提取原始模型: {type(model).__name__} → {type(raw_model).__name__}", flush=True)
         if hasattr(raw_model, 'streaming'):
             raw_model.streaming = True
 
@@ -1108,10 +1189,12 @@ async def create_deep_agent(
 
         RunnableCallable.__init__ = _patched_rc_init
     except Exception as _patch_err:
-        SYLogger.warning(f"[DeepAgent] RunnableCallable monkey-patch FAILED: {_patch_err}")
+        SYLogger.warning(
+            f"[DeepAgent] RunnableCallable monkey-patch FAILED: {_patch_err}")
 
     agent = _create_deep_agent(**agent_kwargs)
-    print(f"[DeepAgent] Agent created, type={type(agent).__name__}", flush=True)
+    print(
+        f"[DeepAgent] Agent created, type={type(agent).__name__}", flush=True)
 
     # 恢复原始 __init__
     if _original_rc_init is not None:
@@ -1194,19 +1277,23 @@ async def _sync_skills_to_sandbox(
                     pass
 
                 if remote_version and remote_version == local_version:
-                    SYLogger.debug(f"[DeepAgent] 技能版本一致，跳过: {skill_name} v{local_version}")
+                    SYLogger.debug(
+                        f"[DeepAgent] 技能版本一致，跳过: {skill_name} v{local_version}")
                     continue
 
                 # 版本不一致或沙箱无版本，删除后重新上传
                 try:
                     await backend.aexecute(f"rm -rf /skills/{skill_name}")
-                    SYLogger.info(f"[DeepAgent] 技能版本不一致，覆盖: {skill_name} ({remote_version or '无版本'} → {local_version})")
+                    SYLogger.info(
+                        f"[DeepAgent] 技能版本不一致，覆盖: {skill_name} ({remote_version or '无版本'} → {local_version})")
                 except Exception as e:
-                    SYLogger.warning(f"[DeepAgent] 删除旧版技能失败: {skill_name}, {e}")
+                    SYLogger.warning(
+                        f"[DeepAgent] 删除旧版技能失败: {skill_name}, {e}")
                     continue
 
             await backend.async_sync_dirs([(src, f"/skills/{skill_name}")])
-            SYLogger.info(f"[DeepAgent] 同步技能到沙箱: {skill_name} v{local_version}")
+            SYLogger.info(
+                f"[DeepAgent] 同步技能到沙箱: {skill_name} v{local_version}")
     except Exception as e:
         SYLogger.warning(f"[DeepAgent] 技能同步失败: {e}")
 

{sycommon_python_lib-0.2.5a35 → sycommon_python_lib-0.2.5a37}/src/sycommon/agent/summarization_utils.py

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

{sycommon_python_lib-0.2.5a35 → sycommon_python_lib-0.2.5a37}/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()