sycommon-python-lib 0.2.7a6__py3-none-any.whl → 0.2.7a8__py3-none-any.whl

sycommon/agent/deep_agent.py

@@ -44,7 +44,7 @@ from typing import Any, AsyncGenerator, Dict, List, Optional, Tuple, TYPE_CHECKI
 
 import yaml
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, model_validator
 from langchain_core.messages import HumanMessage, BaseMessage, AIMessageChunk, AIMessage, SystemMessage
 from langchain_core.tools import BaseTool, tool
 
@@ -57,6 +57,7 @@ from sycommon.agent.sandbox.sandbox_recovery import SandboxRecoveryManager
 from sycommon.agent.chat_events import ChatEvent, ChatEventBuilder, DEFAULT_AGENT_NAME
 from sycommon.middleware.token_tracking import TokenTrackingMiddleware
 from sycommon.middleware.tool_result_truncation import ToolResultTruncationMiddleware
+from sycommon.agent.middleware.skill_write_guard import SkillWriteGuardMiddleware
 from deepagents.middleware.summarization import create_summarization_tool_middleware  # noqa: F401 保留 re-export
 from sycommon.agent.summarization_utils import build_summarization_middleware
 
@@ -373,13 +374,42 @@ class AgentConfig(BaseModel):
     # 沙箱配置
     sandbox_service_name: str = "shengye-platform-sandbox"
     sandbox_timeout: int = 300
-    skills_dir: Optional[str] = None
-    # 技能是否已同步到沙箱：True 时跳过 _sync_skills_to_sandbox 的 atree 检查，
-    # 但仍会基于 skills_dir 注入 /skills（即 SkillsMiddleware 照常挂载）。
-    # 注意：不要用「把 skills_dir 置 None」来跳过同步——那会连带关闭技能注入。
+    # system 技能:本地仓库目录路径 → 同步到沙箱 /skills/system(只读)
+    system_skills_dir: Optional[str] = None
+    # user 技能:标记启用沙箱 /skills/user(可写,内容由 MinIO 按 user 灌入);
+    # 本地兜底路径仅当目录存在时用于开发期同步,生产期为 None。
+    user_skills_dir: Optional[str] = None
+    # 技能是否已同步到沙箱:True 时跳过 _sync_skills_to_sandbox 的 atree 检查,
+    # 但 skills 注入(SkillsMiddleware)不受影响。
     skills_already_synced: bool = False
     memory_dir: Optional[str] = None
 
+    @property
+    def skills_dir(self) -> Optional[str]:
+        """兼容旧字段:取 system_skills_dir(迁移期防外部调用崩)。"""
+        return self.system_skills_dir
+
+    @model_validator(mode="before")
+    @classmethod
+    def _map_legacy_skills_dir(cls, data: Any) -> Any:
+        """旧 skills_dir=... 映射到 system_skills_dir 并告警(修 I3)。
+
+        pydantic v2 默认 ignore 未知字段,而 skills_dir 现在是只读 property
+        (非字段)——直接传 skills_dir=... 会被静默丢弃,导致 agent 无技能却无报错。
+        这里在解析前拦截:若仍用旧 kwarg,映射到 system_skills_dir + DeprecationWarning。
+        """
+        if isinstance(data, dict) and "skills_dir" in data \
+                and "system_skills_dir" not in data:
+            import warnings
+            warnings.warn(
+                "AgentConfig(skills_dir=...) 已弃用,请改用 system_skills_dir="
+                "(system 只读)+ user_skills_dir=(user 可写)。本次按 system 处理。",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            data = {**data, "system_skills_dir": data.pop("skills_dir")}
+        return data
+
     # 工具
     tools: List[BaseTool] = Field(default_factory=list)
 
@@ -599,8 +629,10 @@ class DeepAgent:
                                 args_str = str(tc_args_l)[:100]
                                 SYLogger.debug(
                                     f"[DeepAgent #{stream_step}] tool_call | {tc_l.get('name','?')} | args={args_str}")
-                        elif not (msg.content or ""):
-                            # 检查是否有 reasoning_content（思考模式下内容在 reasoning_content 而非 content）
+                        elif _STREAM_DEBUG and not (msg.content or ""):
+                            # 仅在 DEEP_AGENT_STREAM_DEBUG=true 时打印逐 chunk 诊断日志。
+                            # 生产环境默认关闭：思考模式下每 token 都会触发此分支，
+                            # "(empty)"/"reasoning_content" 行数会随回答长度线性增长，刷爆日志量。
                             _rc = (
                                 getattr(msg, "reasoning_content", None)
                                 or getattr(msg, "additional_kwargs", {}).get("reasoning_content", None)
@@ -1163,17 +1195,16 @@ async def create_deep_agent(
     tid = thread_id or user_id
     agent_config = {"configurable": {"thread_id": tid}}
 
-    # 确定沙箱路径
-    # skills_dir: 本地目录路径 → 注入沙箱 /skills（SkillsMiddleware 据此挂载）
-    # memory_dir: 非路径字符串 → 标记启用沙箱 /memory/AGENTS.md
-    skills_path = "/skills" if config.skills_dir else None
+    # 沙箱 skills 双层结构:/skills/system(只读,仓库源)+ /skills/user(可写,MinIO 按 user 灌入)
+    system_path = "/skills/system" if config.system_skills_dir else None
+    user_path = "/skills/user" if config.user_skills_dir else None
     memory_path = "/memory/AGENTS.md" if config.memory_dir else None
 
-    # 同步 skills 到沙箱（按目录名检查，已存在则跳过）
-    # 仅在未同步过时执行 atree 检查 + 上传；skills_already_synced=True 时跳过同步，
-    # 但 skills_path 注入不受影响，确保 SkillsMiddleware 始终能挂载。
-    if config.skills_dir and sandbox_backend and not config.skills_already_synced:
-        await _sync_skills_to_sandbox(config.skills_dir, sandbox_backend)
+    # 同步 system 技能到沙箱(按版本检查,已同步则跳过)+ chmod 只读保护
+    # skills_already_synced=True 时跳过同步,但 system_path/user_path 注入不受影响。
+    if config.system_skills_dir and sandbox_backend and not config.skills_already_synced:
+        await _sync_skills_to_sandbox(config.system_skills_dir, sandbox_backend,
+                                      sandbox_dest="/skills/system", chmod_readonly=True)
 
     # 创建 agent
     from deepagents import create_deep_agent as _create_deep_agent
@@ -1194,6 +1225,7 @@ async def create_deep_agent(
         ToolResultTruncationMiddleware(),
         TokenTrackingMiddleware(model_name=config.model_name, user_id=user_id),
         summarization_mw,
+        SkillWriteGuardMiddleware(),          # 系统 /skills/system 只读守卫(先于白名单)
     ]
 
     # RubricMiddleware：复用 FilesystemMiddleware 的工具（底层走 HTTPSandboxBackend HTTP 远程调用）
@@ -1226,8 +1258,15 @@ async def create_deep_agent(
         "debug": config.debug,
         "middleware": middleware_list,
     }
-    if skills_path:
-        agent_kwargs["skills"] = [skills_path]
+    # deepagents SkillsMiddleware 支持多 source (path, label),后 source 覆盖先 source
+    # → user 在后,user 同名技能优先于 system
+    _sources = []
+    if system_path:
+        _sources.append((system_path, "系统"))
+    if user_path:
+        _sources.append((user_path, "用户"))
+    if _sources:
+        agent_kwargs["skills"] = _sources
     if memory_path:
         agent_kwargs["memory"] = [memory_path]
 
@@ -1297,21 +1336,24 @@ def _parse_skill_version(content: str) -> str:
 async def _sync_skills_to_sandbox(
     skills_dir: str,
     backend: HTTPSandboxBackend,
+    *,
+    sandbox_dest: str = "/skills",
+    chmod_readonly: bool = False,
 ) -> None:
-    """同步技能目录到沙箱（按版本检查，版本不一致则全量覆盖）
+    """同步技能目录到沙箱(按版本检查,版本不一致则全量覆盖)
 
-    技能来源是仓库内的 skills/ 目录（随部署持久，不随 Pod 重启丢失），
-    版本比较只看沙箱 /skills/{name}/SKILL.md，无需 MinIO 锚点：
+    技能来源是仓库内的 skills/ 目录(随部署持久,不随 Pod 重启丢失),
+    版本比较只看沙箱 sandbox_dest/{name}/SKILL.md,无需 MinIO 锚点:
     - 沙箱有该技能且 version 一致 → 跳过
-    - 沙箱没有 / version 不一致 → 从本地 skills/ 全量上传到沙箱
+    - 沙箱没有 / 版本不一致 → 从本地 skills/ 全量上传到沙箱
     """
     if not os.path.isdir(skills_dir):
         return
 
     try:
-        # 获取沙箱 /skills 下已有的目录列表
+        # 获取沙箱 sandbox_dest 下已有的目录列表
         existing_dirs = set()
-        tree_result = await backend.atree("/skills", max_depth=1)
+        tree_result = await backend.atree(sandbox_dest, max_depth=1)
         if tree_result and tree_result.tree and tree_result.tree.children:
             for child in tree_result.tree.children:
                 if child.is_dir:
@@ -1334,12 +1376,12 @@ async def _sync_skills_to_sandbox(
                 except Exception:
                     pass
 
-            # 比较版本：只从沙箱 /skills/{name}/SKILL.md 读取
+            # 比较版本:只从沙箱 sandbox_dest/{name}/SKILL.md 读取
             remote_version = ""
             if skill_name in existing_dirs:
                 try:
                     remote_content = await backend.aread(
-                        f"/skills/{skill_name}/SKILL.md")
+                        f"{sandbox_dest}/{skill_name}/SKILL.md")
                     if remote_content:
                         remote_version = _parse_skill_version(remote_content)
                 except Exception:
@@ -1347,29 +1389,39 @@ async def _sync_skills_to_sandbox(
 
             if remote_version and remote_version == local_version:
                 SYLogger.debug(
-                    f"[DeepAgent] 技能版本一致，跳过: {skill_name} v{local_version}")
+                    f"[DeepAgent] 技能版本一致,跳过: {skill_name} v{local_version}")
                 backend._synced_skills.add(skill_name)
                 skip_count += 1
                 continue
 
-            # 版本不一致或无版本，删除旧目录后全量覆盖
+            # 版本不一致或无版本,删除旧目录后全量覆盖
             if skill_name in existing_dirs:
                 try:
-                    await backend.aexecute(f"rm -rf /skills/{skill_name}")
+                    await backend.aexecute(f"rm -rf {sandbox_dest}/{skill_name}")
                     SYLogger.info(
-                        f"[DeepAgent] 技能版本不一致，覆盖: {skill_name} "
+                        f"[DeepAgent] 技能版本不一致,覆盖: {skill_name} "
                         f"({remote_version or '无版本'} → {local_version})")
                 except Exception as e:
                     SYLogger.warning(
                         f"[DeepAgent] 删除旧版技能失败: {skill_name}, {e}")
 
             # 全量上传整个技能目录到沙箱
-            await backend.async_sync_dirs([(src, f"/skills/{skill_name}")])
+            await backend.async_sync_dirs([(src, f"{sandbox_dest}/{skill_name}")])
             backend._synced_skills.add(skill_name)
             skill_count += 1
             SYLogger.info(
                 f"[DeepAgent] 全量同步技能到沙箱: {skill_name} v{local_version}")
 
+        if chmod_readonly:
+            try:
+                # sandbox_dest 是虚拟绝对路径(/skills/system),沙箱 shell 不重映射裸绝对路径,
+                # 须拼 $_SANDBOX_WORKSPACE 指向真实 workspace 才能命中。否则 chmod 静默失败。
+                await backend.aexecute(
+                    f'chmod -R 555 "$_SANDBOX_WORKSPACE{sandbox_dest}"')
+                SYLogger.info(f"[DeepAgent] 已设只读: chmod -R 555 {sandbox_dest}")
+            except Exception as e:
+                SYLogger.warning(f"[DeepAgent] chmod 只读失败(忽略): {e}")
+
         SYLogger.info(
             f"[DeepAgent] 技能同步完成: 同步 {skill_count} 个, 跳过 {skip_count} 个")
     except Exception as e:
@@ -1396,9 +1448,11 @@ async def _create_sandbox_backend(
     memory_dir.mkdir(parents=True, exist_ok=True)
     sync_dirs.append((str(memory_dir), "/memory"))
 
-    # 确定 skills_dir，传递给沙箱后端用于懒同步
-    if config.skills_dir:
-        skills_dir_for_backend = str(Path(config.skills_dir))
+    # 确定 skills_dir，传递给沙箱后端用于懒同步。
+    # 懒同步按 os.path.join(_skills_dir, scope, skill_name) 解析本地源(system/user/<域>),
+    # 故 _skills_dir 须是 system/ 与 user/ 的【父目录】(<repo>/skills),而非 system_skills_dir 本身。
+    if config.system_skills_dir:
+        skills_dir_for_backend = str(Path(config.system_skills_dir).parent)
     else:
         skills_dir_for_backend = str(project_root / "skills")
 

sycommon/agent/middleware/skill_api_whitelist.py

@@ -30,15 +30,13 @@ from langgraph.prebuilt.tool_node import ToolCallRequest
 
 from sycommon.logging.kafka_log import SYLogger
 
-# 命令路径形如  skills/sy-oa-skill/workflow-todo/scripts/x.py
-#               skills/sy-syt-skill/shengye-platform-zhongdeng/SKILL.md
-#               skills/sy-syt-skill/generate-plan/...     （有/无 scripts/ 都识别）
-# 取「skills/<顶级技能>/」的【第一段】作顶级技能名（如 sy-oa-skill），
-# 配合 SkillApiWhitelist 按顶级技能（5 个域）配置——每个域的 allowlist 是其下
-# 所有子技能出网地址的并集。用 (?:/|$) 锚定段尾，避免误吞后续路径段。
-# (?<![\w]) 否定左查找：要求 skills 前不是单词字符，避免误匹配 myskills/、
-# theskills/ 等含 skills 子串的路径（行首、空格、引号、/ 后均成立）。
-_SKILL_TOP_RE = re.compile(r'(?<![\w])skills/([A-Za-z0-9_\-]+)(?:/|$)')
+# 命令路径形如  skills/system/sy-oa-skill/workflow-todo/scripts/x.py
+#               skills/user/sy-oa-skill/SKILL.md
+# 拆为 system/user 双层后,顶层段是 system|user,需跳过它取【第二段】作域级技能名
+# (如 sy-oa-skill),配合 SkillApiWhitelist 按顶级域配置。
+# (?<![\w]) 否定左查找:要求 skills 前不是单词字符,避免误匹配 myskills/。
+_SKILL_TOP_RE = re.compile(
+    r'(?<![\w])skills/(?:system|user)/([A-Za-z0-9_\-]+)(?:/|$)')
 
 # BASE_URL 占位符 ${VAR}
 _PLACEHOLDER_RE = re.compile(r'\$\{([A-Z_][A-Z0-9_]*)\}')

sycommon/agent/middleware/skill_write_guard.py

@@ -0,0 +1,61 @@
+"""系统技能只读守卫中间件。
+
+拦 write_file / edit_file / execute 三类写操作对 /skills/system 的命中,
+返回 error ToolMessage(不调 handler,短路)。/skills/user 不拦。
+
+双层防护之一(另一层是沙箱 chmod -R 555 /skills/system):
+本中间件负责给 agent 清晰错误反馈并 fail-closed,chmod 负责兜底防 shell 绕过。
+"""
+import re
+from langchain.agents.middleware.types import AgentMiddleware
+from langchain_core.messages import ToolMessage
+from langgraph.prebuilt.tool_node import ToolCallRequest
+
+# /skills/system 或 /skills/system/... (行尾/引号/空白/斜杠均可作边界,防匹配 /skills/systembackup)
+_PROTECTED_PATH_RE = re.compile(r'/skills/system(?:/|\s|"|\'|$)')
+
+# 写动作动词(命令首或分号/管道/空格后)
+_WRITE_VERB_RE = re.compile(
+    r'(^|[\s;&|])(rm|rmdir|mv|cp|chmod|chown|tee|truncate|install|rsync|scp|dd)\b')
+# 输出重定向 > 或 >>
+_REDIRECT_RE = re.compile(r'>>?')
+
+_WRITE_TOOLS = {"write_file", "edit_file"}
+_DENIED_MSG = ("Error: 系统技能 /skills/system 为只读,禁止修改/删除。"
+               "如需定制,请复制到用户技能 /skills/user/ 后编辑。")
+
+
+def _is_protected_path(p: str) -> bool:
+    s = (p or "").strip().replace("\\", "/")
+    return s == "/skills/system" or s.startswith("/skills/system/")
+
+
+def _command_writes_system(cmd: str) -> bool:
+    if not _PROTECTED_PATH_RE.search(cmd or ""):
+        return False
+    return bool(_WRITE_VERB_RE.search(cmd) or _REDIRECT_RE.search(cmd))
+
+
+class SkillWriteGuardMiddleware(AgentMiddleware):
+    """拦对 /skills/system 的写。仅实现 awrap_tool_call(异步链路)。"""
+
+    async def awrap_tool_call(self, request: ToolCallRequest, handler):
+        tc = request.tool_call
+        name = tc.get("name")
+        args = tc.get("args", {}) or {}
+
+        if name in _WRITE_TOOLS:
+            fp = args.get("file_path") if isinstance(args, dict) else ""
+            if _is_protected_path(fp):
+                return ToolMessage(content=_DENIED_MSG, name=name,
+                                   tool_call_id=tc.get("id", ""), status="error")
+            return await handler(request)
+
+        if name == "execute":
+            command = args.get("command", "") if isinstance(args, dict) else ""
+            if _command_writes_system(command):
+                return ToolMessage(content=_DENIED_MSG, name="execute",
+                                   tool_call_id=tc.get("id", ""), status="error")
+            return await handler(request)
+
+        return await handler(request)

sycommon/agent/multi_agent_team.py

@@ -45,6 +45,7 @@ from sycommon.agent.sandbox.sandbox_recovery import SandboxRecoveryManager
 from sycommon.agent.chat_events import ChatEvent, ChatEventBuilder, DEFAULT_AGENT_NAME
 from sycommon.middleware.token_tracking import TokenTrackingMiddleware
 from sycommon.middleware.tool_result_truncation import ToolResultTruncationMiddleware
+from sycommon.agent.middleware.skill_write_guard import SkillWriteGuardMiddleware
 from deepagents.middleware.summarization import create_summarization_tool_middleware  # noqa: F401 保留 re-export
 from sycommon.agent.summarization_utils import build_summarization_middleware
 
@@ -131,9 +132,19 @@ class TeamConfig(BaseModel):
 
     sandbox_service_name: str = "shengye-platform-sandbox"
     sandbox_timeout: int = 300
-    skills_dir: Optional[str] = None
+    # system 技能:本地仓库目录 → 同步到沙箱 /skills/system(只读)
+    system_skills_dir: Optional[str] = None
+    # user 技能:标记启用沙箱 /skills/user(可写,内容由 MinIO 灌入)
+    user_skills_dir: Optional[str] = None
+    # 技能是否已同步到沙箱:True 时跳过 _sync_skills_to_sandbox
+    skills_already_synced: bool = False
     memory_dir: Optional[str] = None
 
+    @property
+    def skills_dir(self) -> Optional[str]:
+        """兼容旧字段:取 system_skills_dir。"""
+        return self.system_skills_dir
+
     shared_tools: List[BaseTool] = Field(default_factory=list)
 
     debug: bool = False
@@ -578,6 +589,21 @@ async def create_multi_agent_team(
     tid = thread_id or user_id
     agent_config = {"configurable": {"thread_id": tid}}
 
+    # 同步 system 技能到沙箱(按版本检查)+ chmod 只读保护(与单 Agent 路径对齐)
+    if config.system_skills_dir and sandbox_backend and not config.skills_already_synced:
+        from sycommon.agent.deep_agent import _sync_skills_to_sandbox
+        await _sync_skills_to_sandbox(config.system_skills_dir, sandbox_backend,
+                                      sandbox_dest="/skills/system", chmod_readonly=True)
+
+    # 沙箱 skills 双层路径(用于 SkillsMiddleware 双 source)
+    system_path = "/skills/system" if config.system_skills_dir else None
+    user_path = "/skills/user" if config.user_skills_dir else None
+    skill_sources = []
+    if system_path:
+        skill_sources.append((system_path, "系统"))
+    if user_path:
+        skill_sources.append((user_path, "用户"))   # user 在后 → 同名优先
+
     # 创建子 agents（递归支持嵌套团队）
     from deepagents import create_deep_agent
     from deepagents.middleware.subagents import CompiledSubAgent
@@ -587,6 +613,7 @@ async def create_multi_agent_team(
         ToolResultTruncationMiddleware(),
         TokenTrackingMiddleware(model_name=config.model_name, user_id=user_id),
         summarization_mw,
+        SkillWriteGuardMiddleware(),
     ]
     shared = config.shared_tools or [get_current_date]
 
@@ -632,7 +659,7 @@ async def create_multi_agent_team(
         model=model,
         tools=config.shared_tools or [get_current_date],
         backend=sandbox_backend,
-        skills=["/skills"],
+        skills=skill_sources or None,
         memory=["/memory/AGENTS.md"],
         checkpointer=checkpointer,
         system_prompt=config.coordinator_prompt,
@@ -643,6 +670,7 @@ async def create_multi_agent_team(
             ToolResultTruncationMiddleware(),
             TokenTrackingMiddleware(model_name=config.model_name, user_id=user_id),
             coord_summarization_mw,
+            SkillWriteGuardMiddleware(),
         ],
     )
 
@@ -679,9 +707,10 @@ async def _create_sandbox_backend_for_team(
     memory_dir.mkdir(parents=True, exist_ok=True)
     sync_dirs.append((str(memory_dir), "/memory"))
 
-    # 确定 skills_dir，传递给沙箱后端用于懒同步
-    if config.skills_dir:
-        skills_dir_for_backend = str(Path(config.skills_dir))
+    # 懒同步按 os.path.join(_skills_dir, scope, skill_name) 解析本地源(system/<域>),
+    # 故 _skills_dir 须是 system/ 与 user/ 的【父目录】。
+    if config.system_skills_dir:
+        skills_dir_for_backend = str(Path(config.system_skills_dir).parent)
     else:
         skills_dir_for_backend = str(project_root / "skills")
 

sycommon/agent/sandbox/http_sandbox_backend.py

@@ -9,6 +9,7 @@ HTTP 客户端沙箱后端
 import asyncio
 import base64
 import os
+import re
 import ssl
 import sys
 import tempfile
@@ -36,6 +37,12 @@ try:
 except ImportError:
     _SSL_CONTEXT = ssl.create_default_context()
 
+# 技能访问路径解析:/skills/(system|user)/<域>/...
+# 前导斜杠可选(命令里可能是 cd skills/system/x),(?<![\w]) 防误匹配 myskills/
+_SKILL_PATH_RE = re.compile(
+    r'(?:^|[\s/\'"])skills/(system|user)/([a-zA-Z0-9_\-]+)/'
+)
+
 
 def _read_file_safe(path: str) -> bytes:
     with open(path, "rb") as f:
@@ -851,33 +858,29 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
         if not self._skills_dir:
             return
 
-        import re
-        # 匹配 /skills/<skill_name>/ 或 skills/<skill_name>/
-        match = re.search(r'/skills/([a-zA-Z0-9_\-]+)/', path)
-        if not match:
-            match = re.search(r'(?:^|\s|")skills/([a-zA-Z0-9_\-]+)/', path)
+        match = _SKILL_PATH_RE.search(path)
         if not match:
             return
-
-        skill_name = match.group(1)
-        if skill_name in self._synced_skills:
+        scope, skill_name = match.group(1), match.group(2)
+        cache_key = f"{scope}/{skill_name}"
+        if cache_key in self._synced_skills:
             return
 
-        skill_dir = os.path.join(self._skills_dir, skill_name)
+        skill_dir = os.path.join(self._skills_dir, scope, skill_name)
         if not os.path.isdir(skill_dir):
-            self._synced_skills.add(skill_name)
+            self._synced_skills.add(cache_key)
             return
 
         try:
             await self.async_sync_dirs([
-                (skill_dir, f"/skills/{skill_name}")
+                (skill_dir, f"/skills/{scope}/{skill_name}")
             ])
-            self._synced_skills.add(skill_name)
+            self._synced_skills.add(cache_key)
             SYLogger.info(
-                f"[Sandbox] 懒同步技能目录: {skill_name}/")
+                f"[Sandbox] 懒同步技能目录: {cache_key}/")
         except Exception as e:
             SYLogger.warning(
-                f"[Sandbox] 懒同步技能目录失败: {skill_name}, {e}")
+                f"[Sandbox] 懒同步技能目录失败: {cache_key}, {e}")
 
     def _lazy_sync_skill_from_path_sync(self, path: str) -> None:
         """同步版本的懒同步（在同步文件操作中调用）
@@ -887,32 +890,29 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
         if not self._skills_dir:
             return
 
-        import re
-        match = re.search(r'/skills/([a-zA-Z0-9_\-]+)/', path)
-        if not match:
-            match = re.search(r'(?:^|\s|")skills/([a-zA-Z0-9_\-]+)/', path)
+        match = _SKILL_PATH_RE.search(path)
         if not match:
             return
-
-        skill_name = match.group(1)
-        if skill_name in self._synced_skills:
+        scope, skill_name = match.group(1), match.group(2)
+        cache_key = f"{scope}/{skill_name}"
+        if cache_key in self._synced_skills:
             return
 
-        skill_dir = os.path.join(self._skills_dir, skill_name)
+        skill_dir = os.path.join(self._skills_dir, scope, skill_name)
         if not os.path.isdir(skill_dir):
-            self._synced_skills.add(skill_name)
+            self._synced_skills.add(cache_key)
             return
 
         try:
             # 同步版本直接调用同步上传方法
             self._upload_directory_sync(
-                skill_dir, f"/skills/{skill_name}", mode="full")
-            self._synced_skills.add(skill_name)
+                skill_dir, f"/skills/{scope}/{skill_name}", mode="full")
+            self._synced_skills.add(cache_key)
             SYLogger.info(
-                f"[Sandbox] 懒同步技能目录(sync): {skill_name}/")
+                f"[Sandbox] 懒同步技能目录(sync): {cache_key}/")
         except Exception as e:
             SYLogger.warning(
-                f"[Sandbox] 懒同步技能目录失败(sync): {skill_name}, {e}")
+                f"[Sandbox] 懒同步技能目录失败(sync): {cache_key}, {e}")
 
     async def _sync_async(self, *, timeout: int = None) -> dict:
         """同步目录（异步版本）

sycommon/agent/sandbox/minio_sync.py

@@ -326,6 +326,20 @@ class MinioSyncService(metaclass=SingletonMeta):
         else:
             files.append(path)
 
+    def _exclude_system_skills(self, files: list[str]) -> list[str]:
+        """过滤掉 /skills/system/ 前缀文件——system 是只读仓库产物,不进 MinIO。
+
+        路径形如 skills/system/sy-oa-skill/...(collect_sandbox_files 已 strip 根 user_id
+        前缀,根盘符 / 由调用方拼接)。兼容带不带前导斜杠。
+        """
+        out = []
+        for fp in files:
+            norm = fp.replace("\\", "/").lstrip("/")
+            if norm == "skills/system" or norm.startswith("skills/system/"):
+                continue
+            out.append(fp)
+        return out
+
     async def sync_sandbox_to_minio(self, sandbox_backend, user_id: str) -> int:
         """扫描沙箱目录，增量同步文件到 MinIO
 
@@ -357,6 +371,7 @@ class MinioSyncService(metaclass=SingletonMeta):
             return 0
 
         sandbox_files = self.collect_sandbox_files(tree_result)
+        sandbox_files = self._exclude_system_skills(sandbox_files)
         if not sandbox_files:
             # 沙箱为空，清理 MinIO 中该用户的所有文件
             try:
@@ -523,6 +538,11 @@ class MinioSyncService(metaclass=SingletonMeta):
             if rel_path and rel_path not in existing_files:
                 to_restore.append(rel_path)
 
+        # 排除 /skills/system —— system 是只读仓库产物,由本地仓库注入,
+        # 绝不从 MinIO 恢复(否则旧的/遗留 system 副本会落回用户沙箱,污染只读区)。
+        # 与 sync_sandbox_to_minio 的排除对称,守住「system 不进 MinIO」不变式。
+        to_restore = self._exclude_system_skills(to_restore)
+
         if not to_restore:
             SYLogger.info(f"[MinIO] 沙箱文件完整，无需恢复: user={user_id}")
             return 0

sycommon/agent/summarization_utils.py

@@ -206,10 +206,9 @@ async def _patched_awrap_model_call(self, request, handler):
     real_tokens = _extract_last_usage_total_tokens(effective_messages)
 
     # 估算值（用于日志对比）
-    try:
-        estimated = _approx_counter(counted_messages, tools=request.tools)
-    except TypeError:
-        estimated = _approx_counter(counted_messages)
+    # langchain-core>=1.4.8 的 count_tokens_approximately 原生支持 tools=，
+    # 不再需要 try/except TypeError 兜底。
+    estimated = _approx_counter(counted_messages, tools=request.tools)
 
     # 如果有真实 token，临时替换 token_counter 使 _orig 内部判断也用真实值
     # 这样 _should_summarize 和 _determine_cutoff_index 都能拿到正确的 token 数
@@ -301,6 +300,11 @@ except ImportError:
 # 虽然不能改变 __init__ 的默认参数（Python 在定义时求值），
 # 但可以防止任何运行时读取 DEFAULT_SUMMARY_PROMPT 的代码拿到英文版。
 _summ_mod.DEFAULT_SUMMARY_PROMPT = CUSTOM_SUMMARY_PROMPT
+# deepagents 0.6.12 起 SummarizationMiddleware 的默认 prompt 改读
+# DEEPAGENTS_DEFAULT_SUMMARY_PROMPT（在模块加载时由 DEFAULT_SUMMARY_PROMPT 派生），
+# 因此只替换 DEFAULT_SUMMARY_PROMPT 已无法阻断新链路，需同步覆盖派生常量。
+if hasattr(_summ_mod, "DEEPAGENTS_DEFAULT_SUMMARY_PROMPT"):
+    _summ_mod.DEEPAGENTS_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

sycommon/logging/kafka_log.py

@@ -3,6 +3,7 @@ import sys
 import json
 import logging
 import socket
+import time
 import threading
 import traceback
 import asyncio
@@ -75,6 +76,25 @@ class KafkaSink:
         self._producer_obj = self._build_producer() if self._enabled else None
         self._producer = self._producer_obj
 
+        # ===== 自愈计数器（健康探测 + 重建）=====
+        # 背景：网络长时间中断时，kafka-python 的投递 future 会持续失败（RequestTimedOut /
+        # KafkaTimeoutError 批次过期），即使网络恢复，旧 producer 内部累积的脏批次 / 已关闭的
+        # sender 线程 / 满载的 RecordAccumulator 也可能让它在恢复后继续报错（日志里曾出现
+        # `Task is already done!`、`Uncaught error in kafka producer I/O thread` + `KeyError
+        # muted.remove`，sender 线程一旦抛到这里就不再正常处理）。
+        # 做法：累计投递失败数；达到阈值就关闭旧 producer 并重建一个全新的。重建带冷却，避免
+        # 网络持续断时疯狂重建。
+        # 并发：send() 在 loguru 后台线程调用，future 的 errback 回调在 kafka-python 内部
+        # 线程触发，两者都会动这些计数器，必须加锁。
+        self._rebuild_lock = threading.Lock()
+        self._consecutive_failures = 0   # 连续投递失败计数（成功一次即清零）
+        self._last_rebuild_ts = 0.0      # 最近一次重建的时间戳（time.monotonic()），用于冷却
+        self._rebuild_in_progress = False  # 重建进行中标志：期间 write() 跳过惰性建 producer，避免与重建线程互踩
+        # 阈值：连续失败到这个数就触发重建。结合 linger/retries，意味着投递已经持续失败而非偶发抖动。
+        self._rebuild_failure_threshold = 50
+        # 冷却：两次重建之间至少间隔这么多秒，避免长断网下每条日志都尝试重建（每次重建要建 TCP + bootstrap）
+        self._rebuild_cooldown_sec = 60.0
+
         # 缓存主机信息，避免每次日志写入都做 DNS 解析
         try:
             self._ip = socket.gethostbyname(socket.gethostname())
@@ -88,15 +108,28 @@ class KafkaSink:
         注意：kafka-python 的 KafkaProducer 在构造时会尝试拉取元数据，
         broker 不可达时可能抛异常——此处不吞异常，由调用方决定
         （__init__ 保持原启动期失败即抛的行为；write() 的惰性路径 try 包裹）。
+
+        max_block_ms 收紧到 5000ms（原 60000ms）：
+            kafka-python 在缓冲区满 / 元数据不可用时，send() 会阻塞调用线程直到
+            max_block_ms。本 sink 在 loguru 后台线程里调用 send()，网络长时间中断时
+            缓冲区会持续积压，60s 的阻塞会让日志队列在后台线程里严重堆积、内存上涨。
+            日志是旁路、不可拖垮主进程——宁可丢日志也要尽快返回，因此收紧到 5s。
+            （request_timeout_ms=30000 保持不变：那是单次网络请求的超时，与 send() 阻塞
+            上限是两回事。）
+        bootstrap_timeout_ms=10000：
+            api_version 默认为 None，__init__ 会 eager bootstrap 拉取版本信息，
+            broker 不可达时默认 30s 才超时。重建/惰性补建路径下 30s 太长，收到 10s。
         """
         return KafkaProducer(
             bootstrap_servers=self._bootstrap_servers,
             value_serializer=lambda v: json.dumps(
                 v, ensure_ascii=False).encode('utf-8'),
-            # 保持原有的优化配置
-            max_block_ms=60000,
+            # 日志旁路不可拖垮主进程：网络断 + 缓冲满时，send() 最长阻塞 5s 后即放弃
+            max_block_ms=5000,
             retries=5,
             request_timeout_ms=30000,
+            # 重建/惰性补建时 eager bootstrap 最长 10s，避免长断网下补建卡 30s
+            bootstrap_timeout_ms=10000,
             compression_type='gzip',
             batch_size=16384,
             linger_ms=5,
@@ -114,6 +147,10 @@ class KafkaSink:
 
             # producer 已关闭则跳过
             if self._producer is None:
+                # 重建进行中（_rebuild_producer 正在关闭旧的/构造新的）：直接跳过本条，
+                # 避免和重建线程同时 _build_producer 造成两个 producer 泄漏。
+                if self._rebuild_in_progress:
+                    return
                 # 全局关闭（_enabled=False 时未建 producer）：仅放行 ERROR 与
                 # 单条强制日志（enabled=True），并为它们惰性补建一次 producer。
                 record = message.record
@@ -211,13 +248,89 @@ class KafkaSink:
                 "uid": int(Snowflake.id)
             }
 
-            # 8. 发送（添加回调监控发送失败）
+            # 8. 发送（添加回调监控发送失败 + 驱动自愈）
             future = self._producer.send("shengye-json-log", log_entry)
-            future.add_errback(lambda e: print(f"Kafka send failed: {e}"))
+            future.add_errback(self._on_send_failed)
+            # send() 本身成功入队，记一次“健康”以清零连续失败计数
+            self._on_send_succeeded()
+
+        except Exception:
+            pass
+
+    def _on_send_succeeded(self):
+        """send() 成功把消息放进缓冲区：清零连续失败计数（注意，这只是入队成功，
+        不代表 broker 已 ack；但用于判断 producer 是否还能接收新消息已足够）。"""
+        if self._consecutive_failures:
+            with self._rebuild_lock:
+                self._consecutive_failures = 0
+
+    def _on_send_failed(self, exc):
+        """future 投递失败回调（在 kafka-python 的 IO/sender 线程触发，与 loguru
+        后台线程不是同一个线程，故所有对计数器的读写都在 _rebuild_lock 内）。
 
+        累计连续失败；达到阈值且过了冷却期就重建 producer。重建本身可能阻塞
+        （_build_producer 的 bootstrap），放在 kafka-python 线程里执行会拖慢它的
+        网络收发，因此用一个 try 快速尝试并吞掉所有异常——日志旁路，绝不抛。"""
+        try:
+            rebuild = False
+            with self._rebuild_lock:
+                self._consecutive_failures += 1
+                if self._consecutive_failures >= self._rebuild_failure_threshold:
+                    now = time.monotonic()
+                    if now - self._last_rebuild_ts >= self._rebuild_cooldown_sec:
+                        rebuild = True
+                        self._last_rebuild_ts = now
+                        self._consecutive_failures = 0
+            if rebuild:
+                self._rebuild_producer()
+            # 失败仍打到 stdout，便于运维感知（与原行为一致）
+            print(f"Kafka send failed: {exc}")
         except Exception:
+            # 回调里绝不能抛，否则会污染 kafka-python 的 future 处理
             pass
 
+    def _rebuild_producer(self):
+        """关闭旧 producer 并重建一个全新的。
+
+        线程模型：本方法由 errback 在 kafka-python 的 sender/IO 线程触发调用，
+        而 write()（含惰性建 producer）在 loguru 后台线程。两者会同时碰 producer
+        引用，故全程用 _rebuild_lock 保护，并置 _rebuild_in_progress 让 write()
+        在此期间跳过惰性建 producer，避免重复构造。
+
+        关键：close() 内部会 join sender 线程（sender.join(timeout)），而本方法
+        正是从 sender 线程的 errback 链调进来的——若在锁内直接 close 旧 producer
+        会触发“在自己线程里 join 自己”的死锁。所以 flush/close 必须放在锁外，
+        且把 _rebuild_in_progress 始终维持到新 producer 就位，避免 join 期间又有
+        write() 介入。绝不在锁内做 close 这种长阻塞。"""
+        with self._rebuild_lock:
+            if self._rebuild_in_progress:
+                return  # 已有重建在进行，不重入
+            self._rebuild_in_progress = True
+            old = self._producer_obj
+            # 摘引用：write() 见到 _producer is None 且 _rebuild_in_progress 会跳过
+            self._producer = None
+            self._producer_obj = None
+        # flush/close 放锁外：close() 会 join sender 线程，绝不能在 sender 线程里持锁做
+        if old is not None:
+            try:
+                old.flush(timeout=5)
+                old.close(timeout=10)
+            except Exception:
+                pass
+        # 重建新 producer（bootstrap 不可达会抛，吞掉，下次失败计数还会再触发）
+        try:
+            new_prod = self._build_producer()
+            with self._rebuild_lock:
+                self._producer_obj = new_prod
+                self._producer = new_prod
+                self._rebuild_in_progress = False
+            print("[KafkaSink] producer 已自愈重建（连续投递失败达到阈值）")
+        except Exception as e:
+            # 重建失败也要清标志，否则后续永远重建不了
+            with self._rebuild_lock:
+                self._rebuild_in_progress = False
+            print(f"[KafkaSink] producer 重建失败: {e}")
+
     def flush(self):
         if self._producer:
             try:
@@ -242,6 +355,10 @@ class KafkaSink:
             pass
         finally:
             self._producer_obj = None
+            # 重置自愈计数器，避免 reload/重建后的 sink 复用了旧状态
+            with self._rebuild_lock:
+                self._consecutive_failures = 0
+                self._last_rebuild_ts = 0.0
 
 
 class _InterceptHandler(logging.Handler):

sycommon/middleware/sandbox.py

@@ -689,18 +689,21 @@ def setup_sandbox_handler(app: FastAPI, config: dict = None):
                 SYLogger.warning(f"[Sandbox Server] 文件已存在: {file_path}")
                 return WriteResponse(error=f"Error: File already exists at {req.file_path}. Use edit_file to modify existing files.", path=None)
 
-            content = base64.b64decode(req.content).decode('utf-8')
+            # 二进制安全写入：base64 解码后直接写 bytes，不再 decode('utf-8')。
+            # deepagents 0.6.12 的媒体 offload（图片/音频等）可能走 write 路径，
+            # 若用 utf-8 解码二进制内容会抛 UnicodeDecodeError。与 /upload 对齐。
+            content = base64.b64decode(req.content)
 
             parent = os.path.dirname(file_path)
             if parent:
                 os.makedirs(parent, exist_ok=True)
 
-            with open(file_path, 'w') as f:
+            with open(file_path, 'wb') as f:
                 f.write(content)
 
             action = "覆盖" if (os.path.exists(file_path) and overwrite) else "新建"
             SYLogger.info(
-                f"[Sandbox Server] 写入成功({action}): {file_path} ({len(content)} 字符)")
+                f"[Sandbox Server] 写入成功({action}): {file_path} ({len(content)} 字节)")
             virtual_path = _to_virtual_path(file_path, workspace)
             return WriteResponse(error=None, path=virtual_path)
 

{sycommon_python_lib-0.2.7a6.dist-info → sycommon_python_lib-0.2.7a8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.2.7a6
+Version: 0.2.7a8
 Summary: Add your description here
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -9,18 +9,18 @@ Requires-Dist: aiohttp==3.14.1
 Requires-Dist: aiomysql==0.3.2
 Requires-Dist: anyio==4.14.1
 Requires-Dist: decorator==5.3.1
-Requires-Dist: deepagents==0.6.11
+Requires-Dist: deepagents==0.6.12
 Requires-Dist: elasticsearch==9.4.1
-Requires-Dist: fastapi==0.138.0
+Requires-Dist: fastapi==0.138.1
 Requires-Dist: jinja2==3.1.6
-Requires-Dist: kafka-python==3.0.2
+Requires-Dist: kafka-python==3.0.6
 Requires-Dist: langchain==1.3.11
 Requires-Dist: langchain-core==1.4.8
 Requires-Dist: langchain-openai==1.3.3
-Requires-Dist: langfuse==4.9.1
+Requires-Dist: langfuse==4.12.0
 Requires-Dist: langgraph==1.2.6
 Requires-Dist: langgraph-checkpoint-postgres==3.1.0
-Requires-Dist: langgraph-checkpoint-redis==0.4.1
+Requires-Dist: langgraph-checkpoint-redis==0.5.0
 Requires-Dist: ldap3==2.9.1
 Requires-Dist: loguru==0.7.3
 Requires-Dist: mysql-connector-python==9.7.0

{sycommon_python_lib-0.2.7a6.dist-info → sycommon_python_lib-0.2.7a8.dist-info}/RECORD

@@ -136,9 +136,9 @@ sycommon/services.py,sha256=CwC_gESafo05Qn41KLQgtulx6PfX7s2FkxlBI-hXve4,24861
 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=ZcqQ8aVo6PYx3YWzV8aEV9HRtuXuoVUyXWGwXUJ_VTw,67278
-sycommon/agent/multi_agent_team.py,sha256=mskS-FJbAB_n5kghjHhiWxpA3L9cD1lObeW_wjrLI6s,27079
-sycommon/agent/summarization_utils.py,sha256=zAnNtqzZ6mKmLVpLQLgcnbdV0D5ohxpAjPkg9Uz2V7s,17934
+sycommon/agent/deep_agent.py,sha256=ztovDHzIXfqMFmznBgABy4xAA50xttEtFzeo3lR54wg,70290
+sycommon/agent/multi_agent_team.py,sha256=ariJvJKTLMy7BAxig_eMkXCrvELKmS3sUD978pMZDRs,28692
+sycommon/agent/summarization_utils.py,sha256=bqZRFqSekNGlv2mYQPaT_s2QNA5VDTKddi2Va_SkHWc,18376
 sycommon/agent/acp/__init__.py,sha256=vQGMQYAA5-ZaejYmDZ4r4Fklqs17qH3cDXQ5pZlwj-0,1844
 sycommon/agent/acp/client.py,sha256=s-K626b9ierwyEq61gejrW0xOysvrY2PIpYFsFqSHjc,27108
 sycommon/agent/acp/fetch.py,sha256=a6tL13eeGT1KgExgNbdYpzQ54xBqLeTGNTIQmxr3eQ4,6796
@@ -148,13 +148,14 @@ sycommon/agent/mcp/__init__.py,sha256=iKrdDhIrFsNIkqG_kgcwNe-nOiM6uVfolKv44LfQ-F
 sycommon/agent/mcp/models.py,sha256=zda4ho-UTYOJ5oPAZPZ-vxhfDRLghUCsMroHnA2A2QQ,1490
 sycommon/agent/mcp/tool_loader.py,sha256=OQa-lE7RL2s3Lqh-kNOKaUrb130hvorB_HjyFBqZBZs,10960
 sycommon/agent/middleware/sitecustomize.py,sha256=Bt7XFnWV_LJo89l858AGp5VUkXwefpLGmjkCtLe-CMw,4800
-sycommon/agent/middleware/skill_api_whitelist.py,sha256=V8QjPwtj0msCxlU10PaXyaWWFnFACjNZg_BFByo_kO4,11263
+sycommon/agent/middleware/skill_api_whitelist.py,sha256=e15aJekXegPp64owSCEdUE5y0SmwCQVQCF4jnhReZNU,10958
 sycommon/agent/middleware/skill_wl_check.py,sha256=rCJ9F6aWPh8tVQBIPmcq2lKDsfwiJQduwSUku_8kXfs,3952
+sycommon/agent/middleware/skill_write_guard.py,sha256=N7EsHMc87eo5QFLjTxbIcn0kurM1LD3vlfeHSR3jVg4,2557
 sycommon/agent/sandbox/__init__.py,sha256=jR7LlkD4J4Y6QYyRXQClkwmqDBCCPmycV_hQV9p9YHw,4621
 sycommon/agent/sandbox/consistent_hash.py,sha256=8Jgk-W4NAD2-u5_vKRVlPmql_e0Vy4aNORiXOuzvIrs,7277
 sycommon/agent/sandbox/file_ops.py,sha256=7A-T5dV2o5OzPT2kaNrlOTAqmyQ8HGiHV7ifqqMivZA,32988
-sycommon/agent/sandbox/http_sandbox_backend.py,sha256=0uQD4juPqUGJ_lQf0aTCgBn81GtansiuaCwGgsLZ7zc,68230
-sycommon/agent/sandbox/minio_sync.py,sha256=vGpc2rwfG86q8D_1eAxg_0X1n_6IfYxwQF3waQPgopY,22413
+sycommon/agent/sandbox/http_sandbox_backend.py,sha256=59FvNhU9WdevXx_X14uiN_REWnEtQk01OXT0UQlgoTk,68303
+sycommon/agent/sandbox/minio_sync.py,sha256=HRtw3SwOlgy0G-AsXhWr_1Ob7s-n4Z-9bjpFRfKecTA,23438
 sycommon/agent/sandbox/sandbox_pool.py,sha256=eMn8sLakCWf90l6ni2-333QM8oBdX1CflV-WzneFp_k,9133
 sycommon/agent/sandbox/sandbox_recovery.py,sha256=X-eDODx1tmGMh_iTngV6e1ppfDBHpTdkPreJusN5MHY,7358
 sycommon/agent/sandbox/session.py,sha256=TjzC3yFC-VaJ75UwCyL26QX4PRTGNNfQae1FKFuOsYI,2365
@@ -215,7 +216,7 @@ sycommon/llm/tiktoken_cache/9b5ad71b2ce5302211f9c61530b329a4922fc6a4,sha256=Ijkh
 sycommon/llm/tiktoken_cache/fb374d419588a4632f3f557e76b4b70aebbca790,sha256=RGqVOMtsNI41FhINfAiwn1fDZJXirP_-WaW_iwz7Gi0,3613922
 sycommon/logging/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sycommon/logging/async_sql_logger.py,sha256=TIUAqK8_F9H7Graw00hNjEI3DJ1ZRo5fRUcnqaMZlbU,2187
-sycommon/logging/kafka_log.py,sha256=H_nnSQtCXalxUyKzpjpa_6iTp1brGRRhyQhXH5qEjd0,20656
+sycommon/logging/kafka_log.py,sha256=0DM3OqaBhe1pERpKCWEgCWRJJGTVeYajz8dsSIYPGms,28096
 sycommon/logging/log_masker.py,sha256=o4yE1rZ8f8a3xwTLV7TZvAt9nPB2IjacKCxoJspbhBM,12797
 sycommon/logging/logger_levels.py,sha256=xJBzPV2H7GpEQggOIjyckEsA4yf6s4NpI9ckgO3xWKA,1154
 sycommon/logging/logger_wrapper.py,sha256=TtzmGw_K5NjBGBq9Gjqtnh834izAv8TQwsOeL2fIbAI,481
@@ -231,7 +232,7 @@ sycommon/middleware/exception.py,sha256=UAy0tKijI_2JoKjwT3h62aL-tybftP3IETvcr26N
 sycommon/middleware/middleware.py,sha256=1qA_0rT7pv1xTfuvA0kdYkxVOHYT6roSSNO7Cmf2wYg,1778
 sycommon/middleware/monitor_memory.py,sha256=pYRK-wRuDd6enSg9Pf8tQxPdYQS6S0AyjyXeKFRLKEs,628
 sycommon/middleware/mq.py,sha256=9X6KKtadFjBXKS5L3kEKujYio9wwGfWgXwWOAHO-HDg,254
-sycommon/middleware/sandbox.py,sha256=_BjRqJgJDula_Vyg-ooifrqG9L3CaS7_KPLzvyW0JrY,49598
+sycommon/middleware/sandbox.py,sha256=6nt62XLE0Ow-rs-0FZNLUgwgfgkCOGwiIKKDtTjU6D8,49876
 sycommon/middleware/timeout.py,sha256=KlxOPa8xl2dg6yuRi_EzkVJG8bX4stb5ueYxctzzGM8,1433
 sycommon/middleware/token_tracking.py,sha256=rEbgV1bgWMdzAERx4aq5XAvOIT6jTY_tK1P0xHJnL3o,6609
 sycommon/middleware/tool_result_truncation.py,sha256=SREo6tb_RDHxqiQdO0N82pio-Cpo0YSrHNa1sASUafM,12429
@@ -305,8 +306,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=1yifwIBNGsCIxLnQjHKiBlbsigc_zvPH-dMTZcNxe-Q,7649
-sycommon_python_lib-0.2.7a6.dist-info/METADATA,sha256=hU2LQjrN0I2oL5pC9AnipDDJG2khY7jdB1TW98tN3Es,7960
-sycommon_python_lib-0.2.7a6.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-sycommon_python_lib-0.2.7a6.dist-info/entry_points.txt,sha256=gsR4SssKxDWjRU8ggidzNcdMXDPRSKRS7UaGyNP84Qg,92
-sycommon_python_lib-0.2.7a6.dist-info/top_level.txt,sha256=RgphKrg7nJyZ7irJqbxFr-5H2LUYTvI7ivoWZH2hcD0,29
-sycommon_python_lib-0.2.7a6.dist-info/RECORD,,
+sycommon_python_lib-0.2.7a8.dist-info/METADATA,sha256=IIlGEa1pB6mxNZgON7ofCiMBvWXJGwIkGxrDpqTOgkw,7961
+sycommon_python_lib-0.2.7a8.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+sycommon_python_lib-0.2.7a8.dist-info/entry_points.txt,sha256=gsR4SssKxDWjRU8ggidzNcdMXDPRSKRS7UaGyNP84Qg,92
+sycommon_python_lib-0.2.7a8.dist-info/top_level.txt,sha256=RgphKrg7nJyZ7irJqbxFr-5H2LUYTvI7ivoWZH2hcD0,29
+sycommon_python_lib-0.2.7a8.dist-info/RECORD,,