sycommon-python-lib 0.2.7a4__py3-none-any.whl → 0.2.7a5__py3-none-any.whl

sycommon/agent/deep_agent.py

@@ -50,6 +50,7 @@ from langchain_core.tools import BaseTool, tool
 
 from sycommon.logging.kafka_log import SYLogger
 from sycommon.tools.snowflake import Snowflake
+from sycommon.tools.env import check_env_flag
 from sycommon.llm.get_llm import get_llm
 from sycommon.agent.sandbox.http_sandbox_backend import HTTPSandboxBackend
 from sycommon.agent.sandbox.sandbox_recovery import SandboxRecoveryManager
@@ -59,6 +60,11 @@ from sycommon.middleware.tool_result_truncation import ToolResultTruncationMiddl
 from deepagents.middleware.summarization import create_summarization_tool_middleware  # noqa: F401 保留 re-export
 from sycommon.agent.summarization_utils import build_summarization_middleware
 
+# 流式逐 token 诊断日志开关（默认关）。开启后每个 chunk 都打印
+# chunk_type/content 等（仅供排障）。LLM 最终结果已由 LLMLogger.on_llm_end
+# 统一记录，正常无需打开此开关，避免流式日志刷屏。
+_STREAM_DEBUG = check_env_flag(['DEEP_AGENT_STREAM_DEBUG'], default='false')
+
 if TYPE_CHECKING:
     from deepagents.graph import CompiledStateGraph
     from langchain.agents.middleware.types import AgentState, ContextT, ModelRequest, ModelResponse, ResponseT
@@ -465,38 +471,27 @@ 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)
+            if _STREAM_DEBUG:
+                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,
                 base_delay=1.0,
             ):
-                # 🔑 详细打印 chunk 内容
-                _chunk_len = len(chunk) if isinstance(chunk, tuple) else '?'
-                if isinstance(chunk, tuple) and _chunk_len == 2:
-                    # 2-tuple: either (namespace, (msg, meta)) or (msg, meta)
-                    if isinstance(chunk[1], tuple) and len(chunk[1]) == 2:
-                        _ns = repr(chunk[0])[:30]
-                        _msg = chunk[1][0]
-                        _meta = chunk[1][1]
-                    else:
-                        _ns = '()'
-                        _msg = chunk[0]
-                        _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)
-                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:
-                        _msg = payload_p[0]
-                        _meta = payload_p[1]
+                # 🔑 逐 token 诊断日志：仅在 DEEP_AGENT_STREAM_DEBUG=true 时打印
+                if _STREAM_DEBUG:
+                    _chunk_len = len(chunk) if isinstance(chunk, tuple) else '?'
+                    if isinstance(chunk, tuple) and _chunk_len == 2:
+                        # 2-tuple: either (namespace, (msg, meta)) or (msg, meta)
+                        if isinstance(chunk[1], tuple) and len(chunk[1]) == 2:
+                            _ns = repr(chunk[0])[:30]
+                            _msg = chunk[1][0]
+                            _meta = chunk[1][1]
+                        else:
+                            _ns = '()'
+                            _msg = chunk[0]
+                            _meta = chunk[1]
                         _msg_type = type(_msg).__name__
                         _content = repr(str(getattr(_msg, 'content', ''))[:80])
                         _node = _meta.get('langgraph_node', '?') if isinstance(
@@ -504,13 +499,26 @@ class DeepAgent:
                         _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)
+                            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:
+                            _msg = payload_p[0]
+                            _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)
+                        else:
+                            print(
+                                f"[DeepAgent] 3tuple: payload_type={type(payload_p).__name__}", flush=True)
                     else:
                         print(
-                            f"[DeepAgent] 3tuple: payload_type={type(payload_p).__name__}", flush=True)
-                else:
-                    print(
-                        f"[DeepAgent] chunk: type={type(chunk).__name__}", flush=True)
+                            f"[DeepAgent] chunk: type={type(chunk).__name__}", flush=True)
                 # 检查取消
                 if cancel_event and cancel_event.is_set():
                     event = ChatEventBuilder.cancelled("任务已取消")
@@ -541,22 +549,23 @@ class DeepAgent:
 
                 stream_step += 1
 
-                # ===== 🔑 诊断日志：详细记录每个 chunk =====
-                _chunk_type = type(chunk).__name__
-                _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 "?"
-                _content_preview = ""
-                if isinstance(msg, BaseMessage):
-                    _c = msg.content or ""
-                    _content_preview = repr(_c[:80]) if _c else "(empty)"
-                SYLogger.info(
-                    f"[DeepAgent #{stream_step}] chunk_type={_chunk_type} msg_type={_msg_type} "
-                    f"ns={_ns} node={_node} step={_step} content={_content_preview}")
+                # ===== 逐 chunk 诊断日志：默认关闭，DEEP_AGENT_STREAM_DEBUG=true 时开启 =====
+                if _STREAM_DEBUG:
+                    _chunk_type = type(chunk).__name__
+                    _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 "?"
+                    _content_preview = ""
+                    if isinstance(msg, BaseMessage):
+                        _c = msg.content or ""
+                        _content_preview = repr(_c[:80]) if _c else "(empty)"
+                    SYLogger.info(
+                        f"[DeepAgent #{stream_step}] chunk_type={_chunk_type} msg_type={_msg_type} "
+                        f"ns={_ns} node={_node} step={_step} content={_content_preview}")
 
                 # ===== 日志（仅关键节点） =====
                 if isinstance(msg, BaseMessage):
@@ -653,12 +662,14 @@ 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)
+                if _STREAM_DEBUG:
+                    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)
+                    if _STREAM_DEBUG:
+                        print(
+                            f"[DeepAgent] SKIPPING non-BaseMessage: {type(msg).__name__}", flush=True)
                     continue
 
                 msg_type = msg.__class__.__name__
@@ -899,8 +910,9 @@ 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)
+            if _STREAM_DEBUG:
+                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:
@@ -1000,8 +1012,9 @@ class DeepAgent:
             while True:
                 for attempt in range(max_retries):
                     try:
-                        print(
-                            f"[DeepAgent] _astream_with_retry: attempt={attempt}, starting astream...", flush=True)
+                        if _STREAM_DEBUG:
+                            print(
+                                f"[DeepAgent] _astream_with_retry: attempt={attempt}, starting astream...", flush=True)
                         chunk_count = 0
                         async for chunk in self.agent.astream(
                             input_data,
@@ -1010,13 +1023,16 @@ class DeepAgent:
                             subgraphs=True
                         ):
                             chunk_count += 1
-                            print(
-                                f"[DeepAgent] _astream yielding chunk #{chunk_count}", flush=True)
+                            if _STREAM_DEBUG:
+                                print(
+                                    f"[DeepAgent] _astream yielding chunk #{chunk_count}", flush=True)
                             yield chunk
+                            if _STREAM_DEBUG:
+                                print(
+                                    f"[DeepAgent] _astream yield returned, consumer processed chunk #{chunk_count}", flush=True)
+                        if _STREAM_DEBUG:
                             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)
+                                f"[DeepAgent] _astream_with_retry: stream ended normally, total_chunks={chunk_count}", flush=True)
                         return
                     except BadRequestError as e:
                         # BadRequestError（含 ContextOverflowError）不重试：
@@ -1191,6 +1207,16 @@ async def create_deep_agent(
             on_evaluation=rubric_eval_collector.on_evaluation,
         ))
 
+    # SkillApiWhitelistMiddleware：按子技能注入接口白名单（拦 execute 工具，
+    # export SKILL_API_WHITELIST + 推送 sitecustomize 到沙箱做 path 级校验）
+    if sandbox_backend:
+        try:
+            from sycommon.agent.middleware.skill_api_whitelist import (
+                SkillApiWhitelistMiddleware)
+            middleware_list.append(SkillApiWhitelistMiddleware(sandbox_backend))
+        except Exception as _wl_err:
+            SYLogger.warning(f"[DeepAgent] 技能接口白名单中间件加载失败(忽略): {_wl_err}")
+
     agent_kwargs = {
         "model": raw_model,
         "tools": config.tools or [get_current_date],

sycommon/agent/middleware/sitecustomize.py

@@ -0,0 +1,146 @@
+"""技能接口白名单客户端注入脚本（部署到沙箱 site-packages）。
+
+Python 解释器启动时（未传 -S）自动 import 本模块。它负责 Python HTTP 库的
+请求拦截：
+
+  1. 读环境变量 SKILL_API_WHITELIST（JSON）。无此 env → 不管控（全放行，fail-open）。
+  2. monkeypatch urllib / httpx / requests / aiohttp，发请求前做 path 级前缀匹配，
+     未命中抛 PermissionError（LLM 能看到清晰错误）。
+
+  ⚠️ shell 命令（curl/wget 等）的拦截【不】在本文件处理——sitecustomize 只在
+     `python` 启动时执行，纯 shell 命令不会触发它。shell 拦截由主进程中间件把
+     curl/wget 包装函数【内联】到每条 execute 命令前缀实现（见 skill_api_whitelist.py）。
+
+URL 匹配核心逻辑复用同目录 skill_wl_check.py。
+
+注意：本模块在沙箱子进程里运行，不依赖主进程内存。白名单数据全部来自环境变量。
+"""
+
+import json
+import os
+import sys
+
+# SKILL_API_WHITELIST 存在即「启用管控」；allowlist 为空时「全拦截」。
+_ENABLED = "SKILL_API_WHITELIST" in os.environ
+
+# 把沙箱 site-packages 里存放本模块的目录加入 sys.path，以便 import skill_wl_check。
+_HERE = os.path.dirname(os.path.abspath(__file__))
+if _HERE not in sys.path:
+    sys.path.insert(0, _HERE)
+
+
+def _load_check():
+    """加载同目录 skill_wl_check，返回其 match 函数；失败返回 None。"""
+    try:
+        import skill_wl_check  # type: ignore
+        return skill_wl_check
+    except Exception as e:  # pragma: no cover
+        sys.stderr.write("[sitecustomize] 加载 skill_wl_check 失败，白名单禁用: %s\n" % e)
+        return None
+
+
+def _patch_urllib(match):
+    import urllib.request
+
+    _orig = urllib.request.urlopen
+
+    def _urlopen(url, *args, **kwargs):
+        actual = url.full_url if isinstance(url, urllib.request.Request) else url
+        if actual and not match(str(actual)):
+            raise PermissionError(
+                "[SkillApiWhitelist] 拦截: URL 不在白名单内 (urlopen, %s)" % actual)
+        return _orig(url, *args, **kwargs)
+
+    urllib.request.urlopen = _urlopen
+
+
+def _patch_httpx(match):
+    try:
+        import httpx
+    except ImportError:
+        return
+
+    _orig_sync = httpx.Client.send
+
+    def _send(self, request, **kwargs):
+        if not match(str(request.url)):
+            raise PermissionError(
+                "[SkillApiWhitelist] 拦截: URL 不在白名单内 (httpx, %s)" % request.url)
+        return _orig_sync(self, request, **kwargs)
+
+    httpx.Client.send = _send
+
+    if hasattr(httpx, "AsyncClient"):
+        _orig_async = httpx.AsyncClient.send
+
+        async def _asend(self, request, **kwargs):
+            if not match(str(request.url)):
+                raise PermissionError(
+                    "[SkillApiWhitelist] 拦截: URL 不在白名单内 (httpx.async, %s)" % request.url)
+            return await _orig_async(self, request, **kwargs)
+
+        httpx.AsyncClient.send = _asend
+
+
+def _patch_requests(match):
+    try:
+        import requests
+    except ImportError:
+        return
+
+    _orig = requests.Session.request
+
+    def _request(self, method, url, *args, **kwargs):
+        if not match(str(url)):
+            raise PermissionError(
+                "[SkillApiWhitelist] 拦截: URL 不在白名单内 (requests %s, %s)"
+                % (method.upper(), url))
+        return _orig(self, method, url, *args, **kwargs)
+
+    requests.Session.request = _request
+
+
+def _patch_aiohttp(match):
+    try:
+        import aiohttp
+    except ImportError:
+        return
+    if not hasattr(aiohttp.ClientSession, "_request"):
+        return
+
+    _orig = aiohttp.ClientSession._request
+
+    async def _request(self, method, str_or_url, **kwargs):
+        if not match(str(str_or_url)):
+            raise PermissionError(
+                "[SkillApiWhitelist] 拦截: URL 不在白名单内 (aiohttp %s, %s)"
+                % (method, str_or_url))
+        return await _orig(self, method, str_or_url, **kwargs)
+
+    aiohttp.ClientSession._request = _request
+
+
+def _install():
+    if not _ENABLED:
+        return
+    check = _load_check()
+    if check is None:
+        return
+    # allowlist 为空（明确禁止）时也走校验——match 必然 False，从而全拦截。
+    match = check.match
+    _patch_urllib(match)
+    _patch_httpx(match)
+    _patch_requests(match)
+    _patch_aiohttp(match)
+
+
+# 保留解析结果（供排查）
+try:
+    _WHITELIST_RAW = json.loads(os.environ.get("SKILL_API_WHITELIST", "{}"))
+except Exception:
+    _WHITELIST_RAW = {}
+
+try:
+    _install()
+except Exception as _e:  # 任何 patch 失败都不能阻断进程启动
+    sys.stderr.write("[sitecustomize] 白名单安装失败（fail-open）: %s\n" % _e)

sycommon/agent/middleware/skill_api_whitelist.py

@@ -0,0 +1,253 @@
+"""技能接口白名单中间件。
+
+拦截 `execute` 工具（FilesystemMiddleware 注册的 shell 执行工具），做两件事：
+
+1. 从命令路径推断子技能名（skills/<域>/<子技能>/scripts/ → <子技能>），
+   查 SkillApiWhitelist 配置得到该子技能的白名单，把占位符 ${VAR} 在主进程
+   解析成完整 URL，序列化成 JSON 后以 `export SKILL_API_WHITELIST='<json>'`
+   前缀注入命令——供沙箱内 sitecustomize.py 读取并 monkeypatch urllib/
+   httpx/requests/aiohttp。
+
+2. 命令前缀内联 curl/wget 的 shell 函数包装：纯 shell 命令（不走 Python）
+   不会触发 sitecustomize，故用 shell 函数在执行 curl/wget 前调
+   `python -m skill_wl_check <url>` 做校验，未命中则 return 1 拦截。
+
+3. 首次惰性把 sitecustomize.py + skill_wl_check.py 推进沙箱 site-packages，
+   使 Python 启动时自动 import sitecustomize。
+
+语义：子技能未配置 / enabled:false → 不注入（全放行，向后兼容）；
+allowlist:[] 空数组 → 注入空白名单（全拦截）。
+"""
+
+import json
+import os
+import re
+import shlex
+from typing import Optional
+
+from langchain.agents.middleware.types import AgentMiddleware
+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/<域>/<子技能>/」的第二段作子技能名，不限 scripts/，覆盖文档目录型子技能。
+# 用 (?:/|$) 锚定第二段结尾，避免误吞后续路径段。
+_SKILL_NESTED_RE = re.compile(r'skills/[A-Za-z0-9_\-]+/([A-Za-z0-9_\-]+)(?:/|$)')
+_SKILL_FLAT_RE = re.compile(r'/skills/([A-Za-z0-9_\-]+)(?:/|$)')
+
+# BASE_URL 占位符 ${VAR}
+_PLACEHOLDER_RE = re.compile(r'\$\{([A-Z_][A-Z0-9_]*)\}')
+
+# 推送到沙箱 workspace 内的 .wl 目录（沙箱强制路径隔离，绝对路径会被映射进 workspace，
+# 故用相对 POSIX 路径，落地为 {workspace}/.wl/，再 export PYTHONPATH 让 Python 自动 import）
+_PUSH_FILES = [
+    ("sitecustomize.py", ".wl/sitecustomize.py"),
+    ("skill_wl_check.py", ".wl/skill_wl_check.py"),
+]
+# workspace 内白名单目录的 shell 形式（init_script 已 export $_SANDBOX_WORKSPACE，运行期展开）
+_WL_DIR = "$_SANDBOX_WORKSPACE/.wl"
+
+
+def _resolve_placeholders(pattern: str, env_lookup) -> Optional[str]:
+    """把 ${VAR} 替换为解析后的值。任一 VAR 不存在返回 None（配置错误）。
+
+    env_lookup: callable(var_name) -> str|None。中间件传入「先查主进程 os.environ，
+    再查 sandbox env 字典（含 SYT_BASE_URL 等运行时算出/从 Nacos 读出的值）」的查找器。
+    """
+    missing = []
+
+    def _sub(m):
+        val = env_lookup(m.group(1))
+        if val is None:
+            missing.append(m.group(1))
+            return ""
+        return str(val).rstrip("/")
+
+    expanded = _PLACEHOLDER_RE.sub(_sub, pattern)
+    if missing:
+        SYLogger.warning(
+            "[Whitelist] 占位符未定义 %s，丢弃规则 %s", missing, pattern)
+        return None
+    return expanded
+
+
+def _load_resource_bytes(filename: str) -> bytes:
+    """从本包读取注入脚本源码（package_data）。"""
+    try:
+        from importlib.resources import files
+        return (files("sycommon.agent.middleware").joinpath(filename).read_bytes())
+    except Exception as e:
+        raise RuntimeError(
+            f"读取注入脚本 {filename} 失败，请确认已随包安装(package_data): {e}") from e
+
+
+def _build_shell_guard() -> str:
+    """生成内联到命令前缀的 curl/wget 包装函数（shell）。
+
+    在 SKILL_API_WHITELIST 已 export 的命令里生效：调用 curl/wget 前先抽取
+    参数里首个 http(s) URL，用沙箱 python3 调 skill_wl_check.match 校验，
+    未命中则 return 1 拦截。skill_wl_check 与 sitecustomize 同处 site-packages，
+    python3 启动时 sitecustomize 会 import 它并把该目录加入 sys.path。
+
+    覆盖 curl / wget；其它 shell 出网方式(nc/裸 /dev/tcp 等)不覆盖。
+    """
+    check_cmd = (
+        'python3 -c \'import skill_wl_check,sys; '
+        'sys.exit(0 if skill_wl_check.match(sys.argv[1]) else 1)\' "$_u"'
+    )
+    # 单个命令的函数体模板：抽取 URL → 校验 → 通过则 command <CMD> "$@"
+    body = (
+        '() { local _u; for _a in "$@"; do '
+        'case "$_a" in http://*|https://*) _u="$_a";; esac; done; '
+        f'if [ -n "$_u" ] && ! {check_cmd}; then '
+        'echo "[SkillApiWhitelist] 拦截 shell 请求: $_u" 1>&2; return 1; fi; '
+        'command {CMD} "$@"; };'
+    )
+    guard = "curl" + body.replace("{CMD}", "curl") + " wget" + body.replace("{CMD}", "wget")
+    return guard.rstrip(";")  # 末尾不带分号：由调用方按需拼接分隔符
+
+
+class SkillApiWhitelistMiddleware(AgentMiddleware):
+    """按子技能动态注入接口白名单环境变量 + shell 包装。
+
+    AgentMiddleware 协议钩子：实现 `awrap_tool_call`（异步版本），在 execute
+    工具真正执行前注入白名单。框架对工具调用走 astream/ainvoke 异步链路，故
+    只需实现异步钩子（与现有 TokenTrackingMiddleware/ToolResultTruncationMiddleware 一致）。
+    """
+
+    def __init__(self, sandbox_backend):
+        self._backend = sandbox_backend
+        self._pushed: bool = False  # 注入脚本是否已推送（每 backend 实例一次）
+
+    def _env_lookup(self):
+        """构造占位符查找器：先查主进程 os.environ，再查 sandbox env 字典。
+
+        SYT_BASE_URL / XINGHAN_BASE_URL / YEALINK_BASE_URL 等不在主进程 os.environ 里，
+        而是放在传给 sandbox backend 的 env 字典中（tools/config.py.build_sandbox_env 构造）。
+        MultiSandboxRouter/HTTPSandboxBackend 都暴露 `_env`，这里统一兜底取值。
+        """
+        sandbox_env = {}
+        b = self._backend
+        for attr in ("_env",):
+            v = getattr(b, attr, None)
+            if isinstance(v, dict):
+                sandbox_env.update(v)
+            else:
+                # RoutingBackend 等代理对象：尝试 default/local/remote 子 backend
+                pass
+        # 再尝试 default backend（MultiSandboxRouter._default._env）
+        default = getattr(b, "_default", None)
+        if default is not None:
+            v = getattr(default, "_env", None)
+            if isinstance(v, dict):
+                sandbox_env.update(v)
+
+        def lookup(var):
+            val = os.environ.get(var)
+            if val is None:
+                val = sandbox_env.get(var)
+            return val
+
+        return lookup
+
+    # ---- 懒加载:把注入脚本推进沙箱 workspace/.wl ----
+    async def _ensure_sitecustomize(self) -> bool:
+        """把 sitecustomize.py + skill_wl_check.py 推到沙箱 workspace 内的 .wl 目录。
+
+        沙箱强制路径隔离：任何绝对路径都会被 resolve_sandbox_path 映射进用户 workspace，
+        真实 site-packages 无法写入。故改用「推到 workspace/.wl/ + export PYTHONPATH」
+        的方案：Python 启动时若 .wl 在 PYTHONPATH 上，会自动 import sitecustomize。
+
+        幂等：每个 backend 实例只推一次（_pushed 标记）。失败 fail-open（不阻塞业务）。
+        """
+        if self._pushed:
+            return True
+        backend = self._backend
+        if backend is None:
+            return False
+        try:
+            files = []
+            for src, dst in _PUSH_FILES:
+                content = _load_resource_bytes(src)
+                files.append((dst, content))
+            await backend.aupload_files(files)
+            self._pushed = True
+            SYLogger.info("[Whitelist] 注入脚本已推送至沙箱 %s", _WL_DIR)
+            return True
+        except Exception as e:
+            SYLogger.error("[Whitelist] 推送 sitecustomize 失败(fail-open): %s", e)
+            return False
+
+    # ---- 子技能名提取 ----
+    def _extract_skill_name(self, command: str) -> Optional[str]:
+        m = _SKILL_NESTED_RE.search(command)
+        if m:
+            return m.group(1)
+        m = _SKILL_FLAT_RE.search(command)
+        if m:
+            return m.group(1)
+        return None
+
+    # ---- 主入口（AgentMiddleware 异步钩子）----
+    async def awrap_tool_call(
+        self,
+        request: ToolCallRequest,
+        handler,
+    ):
+        tc = request.tool_call
+        if tc.get("name") != "execute":
+            return await handler(request)
+
+        args = tc.get("args", {}) or {}
+        command = args.get("command", "") if isinstance(args, dict) else ""
+        if not command:
+            return await handler(request)
+
+        skill_name = self._extract_skill_name(command)
+        if skill_name is None:
+            # 非技能命令（无 skills/.../scripts/）→ 不管控
+            return await handler(request)
+
+        # 延迟导入避免模块加载期循环依赖
+        from sycommon.config.SkillApiWhitelistConfig import SkillApiWhitelistConfig
+        cfg = SkillApiWhitelistConfig.from_config(skill_name)
+        if cfg is None or not cfg.enabled:
+            # 未配置 / 禁用 → 全放行（向后兼容）
+            return await handler(request)
+
+        # 主进程解析占位符 ${VAR}（数据源：os.environ + sandbox env 字典）
+        env_lookup = self._env_lookup()
+        resolved = []
+        for pat in cfg.allowlist:
+            if "${" in pat:
+                expanded = _resolve_placeholders(pat, env_lookup)
+                if expanded:
+                    resolved.append(expanded)
+            else:
+                resolved.append(pat)
+
+        # 推送注入脚本（惰性，每后端实例一次）
+        await self._ensure_sitecustomize()
+
+        # 序列化白名单 + PYTHONPATH(shell 启动 python 时自动 import sitecustomize)
+        # + shell guard(curl/wget 拦截) + export SKILL_API_WHITELIST
+        payload = json.dumps({"skill": skill_name, "allowlist": resolved},
+                             ensure_ascii=False)
+        guard = _build_shell_guard()
+        prefix_parts = [
+            f"export SKILL_API_WHITELIST={shlex.quote(payload)}",
+            f'export PYTHONPATH="{_WL_DIR}:$PYTHONPATH"',
+            guard,
+        ]
+        # 每个 part 之间用 '; ' 分隔（而非空格）—— export 语句之间、函数定义与后续命令
+        # 之间都需要语句分隔符；末尾留一个 ';' 与原命令隔开。
+        prefix = "; ".join(prefix_parts) + "; "
+
+        new_command = prefix + command
+        new_args = {**args, "command": new_command} if isinstance(args, dict) else args
+        new_tc = {**tc, "args": new_args}
+        SYLogger.info("[Whitelist] 注入子技能 %s 白名单(%d 条)", skill_name, len(resolved))
+        return await handler(request.override(tool_call=new_tc))

sycommon/agent/middleware/skill_wl_check.py

@@ -0,0 +1,123 @@
+"""技能接口白名单：URL 匹配核心逻辑（被 sitecustomize 与 shell 包装层共用）。
+
+沙箱内运行。从环境变量 `SKILL_API_WHITELIST` 读取白名单 JSON：
+
+    {"skill": "<子技能名>", "allowlist": ["<完整URL或path前缀>", ...]}
+
+提供：
+  - match(url) -> bool        供 sitecustomize（Python 库 monkeypatch）内存调用
+  - main()                    CLI：`python3 -m skill_wl_check <url>`，exit 0=放行 / 1=拦截
+
+匹配规则（path 级前缀，带斜杠边界）：
+  - 完整 URL 条目：scheme/host 小写比较，port 规则未写则任意，path 前缀匹配
+  - 纯 path 前缀条目（无 host）：只比 path（匹配任意 host，谨慎用）
+  - /wf 匹配 /wf 与 /wf/...，不匹配 /wfcount（斜杠边界）
+  - query string 不参与匹配
+"""
+
+import json
+import os
+import sys
+from urllib.parse import urlparse
+
+_ENV = "SKILL_API_WHITELIST"
+
+
+def _load_allowlist() -> list[str]:
+    """从环境变量读白名单。无 env / 解析失败 → 空列表（sitecustomize 据此决定是否启用）。"""
+    raw = os.environ.get(_ENV, "")
+    if not raw:
+        return []
+    try:
+        data = json.loads(raw)
+        if isinstance(data, dict):
+            return [str(x) for x in data.get("allowlist", [])]
+        if isinstance(data, list):
+            return [str(x) for x in data]
+    except Exception:
+        pass
+    return []
+
+
+def _normalize(entry: str) -> tuple:
+    """把白名单条目规范化成 (scheme, host, port, path_prefix)。
+
+    - 'https://oa.syholdings.com/services/WorkflowService'
+        → ('https', 'oa.syholdings.com', None, '/services/WorkflowService')
+    - 'http://10.100.8.72:8888'
+        → ('http', '10.100.8.72', 8888, '')
+    - '/wf'  (纯 path 前缀，无 host)
+        → (None, None, None, '/wf')
+    """
+    entry = entry.strip().rstrip("/")
+    if entry.startswith(("http://", "https://")):
+        p = urlparse(entry)
+        path = (p.path or "").rstrip("/")
+        return (
+            (p.scheme or "").lower(),
+            (p.hostname or "").lower(),
+            p.port,
+            path,
+        )
+    # 纯 path 前缀（无 host）
+    if not entry.startswith("/"):
+        entry = "/" + entry
+    return (None, None, None, entry)
+
+
+def _compiled():
+    return [_normalize(e) for e in _load_allowlist()]
+
+
+def _is_allowed(url: str, rules=None) -> bool:
+    if rules is None:
+        rules = _compiled()
+    try:
+        p = urlparse(url if "://" in url else "http://" + str(url))
+    except Exception:
+        return False
+    req_scheme = (p.scheme or "").lower()
+    req_host = (p.hostname or "").lower()
+    req_port = p.port
+    req_path = (p.path or "").rstrip("/")
+    for (sch, host, port, pfx) in rules:
+        if pfx == "":
+            pfx_match = True  # 规则没带 path → 该 host 下任意 path 放行
+        elif req_path == pfx or req_path.startswith(pfx + "/"):
+            pfx_match = True
+        else:
+            pfx_match = False
+        if not pfx_match:
+            continue
+        if sch is None:
+            # 纯 path 前缀规则：只比 path（host 任意）
+            return True
+        if req_scheme != sch or req_host != host:
+            continue
+        if port is not None and req_port not in (None, port):
+            continue
+        return True
+    return False
+
+
+def match(url: str) -> bool:
+    """供 Python 库内存调用：URL 是否在白名单内。"""
+    return _is_allowed(url)
+
+
+def main(argv=None) -> int:
+    argv = list(sys.argv[1:] if argv is None else argv)
+    if not argv:
+        sys.stderr.write("[skill_wl_check] 用法: python3 -m skill_wl_check <url>\n")
+        return 2
+    url = argv[0]
+    if match(url):
+        return 0
+    sys.stderr.write(
+        "[SkillApiWhitelist] 拦截: URL 不在白名单内 (url=%s)。"
+        "请联系管理员修改 SkillApiWhitelist 配置。\n" % url)
+    return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

sycommon/agent/sandbox/http_sandbox_backend.py

@@ -47,6 +47,25 @@ def _shell_quote(value: str) -> str:
     return "'" + value.replace("'", "'\\''") + "'"
 
 
+def _is_response_error(exc: Exception) -> bool:
+    """判断异常是否属于「已收到 HTTP 响应」的错误（非瞬时网络抖动）。
+
+    含义：请求已成功抵达服务端并拿到了响应，只是状态码或响应体不符合预期。
+    这类错误（典型：服务端 500）通常对同一实例是确定性的，原地重试只会白等，
+    应直接跳到故障转移（切实例）一次，再不行就快速失败。
+    与之相对，「瞬时错误」（连接 reset / timeout / DNS / ClientConnectionError）
+    建议原地指数退避重试。
+
+    - 异步：aiohttp.ClientResponseError（raise_for_status 抛出）
+    - 同步：requests.exceptions.HTTPError（raise_for_status 抛出）
+    """
+    if isinstance(exc, aiohttp.ClientResponseError):
+        return True
+    if isinstance(exc, requests.exceptions.HTTPError):
+        return True
+    return False
+
+
 def filter_instances_by_owner(instances: list, user_id: str, timeout: float = 3.0) -> list:
     """过滤掉不属于当前用户的本地沙箱实例。
 
@@ -481,7 +500,12 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
         return headers
 
     def _post_sync_with_failover(self, endpoint: str, data: dict, timeout: int = None) -> dict:
-        """带故障转移的同步 POST 请求"""
+        """带故障转移的同步 POST 请求（策略对齐异步版本）
+
+        - 瞬时错误（连接 reset / timeout / ConnectionError）→ 原地指数退避重试，不切实例。
+        - 响应级错误（已拿到 HTTP 响应：HTTPError，典型为服务端 5xx）→ 跳过原地重试，
+          直接切一次实例（避免对确定性 500 白等 3 次）。
+        """
         actual_timeout = timeout if timeout is not None else self._timeout
         # 执行命令的 HTTP 超时需要更长，给沙箱足够时间执行
         # 只有在非 execute 端点时才加 30 秒缓冲
@@ -492,11 +516,13 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
         max_retries = 3
 
         headers = self._build_headers()
+        last_exc: Optional[Exception] = None
 
         url = f"{self._base_url}{endpoint}"
         SYLogger.info(
             f"[Sandbox] POST 请求开始: {url}, timeout={http_timeout}s, command_timeout={actual_timeout}s")
 
+        skip_in_place = False
         for attempt in range(max_retries):
             try:
                 SYLogger.info(
@@ -517,19 +543,46 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
                 return result
 
             except (requests.exceptions.RequestException, requests.exceptions.HTTPError) as e:
+                last_exc = e
+                if _is_response_error(e):
+                    # 已拿到服务端响应（如 500），重发同一实例是确定性的 → 跳过原地重试
+                    SYLogger.warning(
+                        f"[Sandbox] 服务端响应错误，跳过原地重试直接故障转移: "
+                        f"{self._base_url} - HTTP {getattr(e.response, 'status_code', None) or '?'}")
+                    skip_in_place = True
+                    break
                 SYLogger.warning(
-                    f"[Sandbox] 请求失败 (尝试 {attempt + 1}/{max_retries}): {self._base_url} - {e}")
-
+                    f"[Sandbox] 请求失败 (原地重试 {attempt + 1}/{max_retries}): {self._base_url} - {e}")
                 if attempt < max_retries - 1:
-                    backoff = 2 ** attempt
-                    switched = self._refresh_from_nacos_and_switch_sync()
-                    if not switched:
-                        import time
-                        time.sleep(backoff)
-                else:
-                    raise RuntimeError(f"沙箱服务不可用: {e}")
+                    import time
+                    time.sleep(2 ** attempt)  # 1s, 2s
+
+        # 原地重试耗尽 / 响应级错误 → 切一次实例
+        SYLogger.warning(
+            f"[Sandbox] 原地重试不可用{'(响应级错误)' if skip_in_place else ''}，尝试切换实例: {self._base_url}")
+        switched = self._refresh_from_nacos_and_switch_sync()
+        if switched:
+            try:
+                url = f"{self._base_url}{endpoint}"
+                SYLogger.info(f"[Sandbox] 切换后单次重试: {url}")
+                resp = requests.post(
+                    url,
+                    json=data,
+                    headers=headers if headers else None,
+                    timeout=http_timeout
+                )
+                if resp.status_code >= 400:
+                    SYLogger.error(
+                        f"[Sandbox] 切换后仍 HTTP 错误 {resp.status_code}: {resp.text}")
+                    resp.raise_for_status()
+                result = resp.json()
+                SYLogger.info(f"[Sandbox] 切换实例后成功: {url}")
+                return result
+            except (requests.exceptions.RequestException, requests.exceptions.HTTPError) as e:
+                last_exc = e
+                SYLogger.warning(f"[Sandbox] 切换实例后仍失败: {self._base_url} - {e}")
 
-        raise RuntimeError("沙箱服务不可用")
+        raise RuntimeError(f"沙箱服务不可用: {last_exc}")
 
     def _post_sync(self, endpoint: str, data: dict, timeout: int = None) -> dict:
         """发送同步 POST 请求（带故障转移）"""
@@ -572,30 +625,37 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
     async def _post_async_with_failover(self, endpoint: str, data: dict, timeout: int = None) -> dict:
         """带故障转移和指数退避的异步 POST 请求。
 
-        策略（修复「两实例无限横跳」）：
-        - 瞬时错误（连接 reset / timeout / ClientError）→ 原地指数退避重试，不切实例。
+        策略（修复「两实例无限横跳」+「服务端 500 白等 3 次」）：
+        - 瞬时错误（连接 reset / timeout / ClientConnectionError）→ 原地指数退避重试，不切实例。
           切实例会触发 MinIO 恢复（耗时且会污染新沙箱），瞬时抖动不该付出这个代价。
-        - 原地重试全部失败后 → 才切一次实例（带失败 URL 排除 + 冷却，避免切回刚失败的）。
+        - 响应级错误（已拿到 HTTP 响应：ClientResponseError，典型为服务端 5xx）→ 跳过原地重试。
+          服务端逻辑性错误对同一实例是确定性的，原地重发只会白等，直接切实例一次。
         - 切换后再试一次；仍失败才抛错。
         """
         max_retries = 3
         last_exc: Optional[Exception] = None
 
-        # 阶段 1：原地重试（不切实例），应对瞬时网络抖动
+        # 阶段 1：原地重试（不切实例），仅对瞬时网络抖动退避；响应级错误直接跳过
         for attempt in range(max_retries):
             try:
                 return await self._post_async(endpoint, data, timeout)
             except (aiohttp.ClientError, asyncio.TimeoutError) as e:
                 last_exc = e
+                if _is_response_error(e):
+                    # 已拿到服务端响应（如 500），重发同一实例是确定性的 → 跳过原地重试
+                    SYLogger.warning(
+                        f"[Sandbox] 服务端响应错误，跳过原地重试直接故障转移: "
+                        f"{self._base_url} - HTTP {getattr(e, 'status', None) or '?'}")
+                    break
                 SYLogger.warning(
                     f"[Sandbox] Async 请求失败 (原地重试 {attempt + 1}/{max_retries}): "
                     f"{self._base_url} - {e}")
                 if attempt < max_retries - 1:
                     await asyncio.sleep(2 ** attempt)  # 1s, 2s
 
-        # 阶段 2：原地重试耗尽 → 尝试切换实例一次
+        # 阶段 2：原地重试耗尽 / 响应级错误 → 尝试切换实例一次
         SYLogger.warning(
-            f"[Sandbox] 原地重试 {max_retries} 次仍失败，尝试切换实例: {self._base_url}")
+            f"[Sandbox] 原地重试不可用，尝试切换实例: {self._base_url}")
         switched = await asyncio.to_thread(self._refresh_from_nacos_and_switch_sync)
         if switched:
             try:

sycommon/config/Config.py

@@ -185,7 +185,8 @@ class Config(metaclass=SingletonMeta):
         # 这些 key 写在「与 app 同名的 dataId」里（如 shengye-platform-digital-work），
         # 但消费方按顶层 key 读取（LLMConfig 等）——提升到顶层，免得每个调用方都得知道嵌套路径。
         override_keys = ['LLMConfig', 'EmbeddingConfig', 'RerankerConfig',
-                         'ACPAgentConfig']
+                         'ACPAgentConfig',
+                         'SkillApiWhitelist']
         for k in override_keys:
             if k in project_cfg:
                 self.config[k] = project_cfg[k]

sycommon/config/SkillApiWhitelistConfig.py

@@ -0,0 +1,82 @@
+"""技能接口白名单配置模型。
+
+定义「单个子技能被允许访问的外部接口白名单」，配置来源是 Nacos 的
+`shengye-platform-digital-work` dataId 下的 `SkillApiWhitelist` 列表：
+
+    SkillApiWhitelist:
+      - skill: workflow-todo            # 子技能名（skills/<域>/<子技能>/scripts/ 里的 <子技能>）
+        enabled: true
+        allowlist:
+          - "${OA_WORKFLOW_URL}"                    # BASE_URL 占位符，主进程解析成完整 URL
+          - "${SYT_BASE_URL}/wf"                    # 占位符 + path 后缀
+          - "https://oa.syholdings.com"             # 完整 URL
+          - "/wf"                                   # 纯 path 前缀（匹配任意 host，谨慎用）
+
+语义约定（务必在 Nacos 配置注释里写明）：
+  - 子技能【未出现】在配置里 → 不管控，全放行（向后兼容）
+  - enabled: false            → 全放行
+  - allowlist: []（空数组）   → 明确禁止该子技能任何外网请求（全拦截）
+
+代码侧用 `SkillApiWhitelistConfig.from_config(skill)` 按 skill 取单条，
+或 `list_from_config()` 取全部。
+"""
+
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+
+class SkillApiWhitelistConfig(BaseModel):
+    """单个子技能的接口白名单配置。"""
+
+    skill: str = Field(
+        description="子技能名，对应命令路径 skills/<域>/<子技能>/scripts/x.py 里的 <子技能>，"
+                    "如 'workflow-todo'、'oa-workorder'、'wecomcli-wrapper'")
+    enabled: bool = Field(default=True, description="是否启用白名单管控；False 则全放行")
+    allowlist: list[str] = Field(
+        default_factory=list,
+        description=(
+            "白名单条目（字符串数组）。每条可以是：完整 URL（https://...）、"
+            "BASE_URL 占位符（${ENV_VAR} 或 ${ENV_VAR}/path）、纯 path 前缀（/wf）。"
+            "主进程加载时把 ${ENV_VAR} 解析成完整 URL，运行期做 path 级前缀匹配。"
+            "空数组 [] = 明确禁止该子技能任何外网请求。"
+        ))
+
+    @classmethod
+    def from_config(cls, skill: str) -> Optional["SkillApiWhitelistConfig"]:
+        """按 skill 名从 Nacos 配置取单个白名单配置。不存在返回 None。"""
+        for cfg in list_from_config():
+            if cfg.skill == skill:
+                return cfg
+        return None
+
+    @classmethod
+    def list_from_config(cls) -> list["SkillApiWhitelistConfig"]:
+        """从 Nacos 配置取全部已配置的子技能白名单。
+
+        配置读 `Config().config.get("SkillApiWhitelist", [])`——即
+        `shengye-platform-digital-work` dataId 下的 SkillApiWhitelist 列表
+        （需在 Config.set_attr 的 override_keys 里登记，否则读不到）。
+        """
+        from sycommon.config.Config import Config
+
+        raw_list = Config().config.get("SkillApiWhitelist", []) or []
+        result: list[SkillApiWhitelistConfig] = []
+        for item in raw_list:
+            try:
+                result.append(cls(**item))
+            except Exception as e:  # 单条配置错误不影响其它
+                import logging
+                logging.getLogger(__name__).warning(
+                    "Invalid SkillApiWhitelistConfig entry %s: %s", item, e)
+        return result
+
+    @classmethod
+    def list_enabled_from_config(cls) -> list["SkillApiWhitelistConfig"]:
+        """取全部 enabled=True 的配置。"""
+        return [c for c in cls.list_from_config() if c.enabled]
+
+
+def list_from_config() -> list[SkillApiWhitelistConfig]:
+    """模块级便捷函数，等价于 SkillApiWhitelistConfig.list_from_config()。"""
+    return SkillApiWhitelistConfig.list_from_config()

sycommon/middleware/sandbox.py

@@ -214,20 +214,38 @@ def _sanitize_user_id(user_id: str) -> str:
 
 
 def get_user_workspace(user_id: str) -> str:
-    """获取用户工作目录"""
+    """获取用户工作目录
+
+    创建失败（磁盘满/只读/权限不足）时不抛异常，记录后返回路径。
+    由后续具体文件操作（tree/read/write）返回各自的结构化错误，
+    避免被全局异常处理器吞成无信息 500；日志带真实原因便于排查。
+    """
     workspace = os.path.join(WORKSPACE_BASE, _sanitize_user_id(user_id))
     if not os.path.exists(workspace):
-        os.makedirs(workspace, exist_ok=True)
+        try:
+            os.makedirs(workspace, exist_ok=True)
+        except OSError as e:
+            SYLogger.error(
+                f"[Sandbox Server] 创建用户工作目录失败 (可能磁盘满/只读/权限不足): "
+                f"{workspace} - {type(e).__name__}: {e}")
     return workspace
 
 
 async def aget_user_workspace(user_id: str) -> str:
-    """获取用户工作目录（异步版本，避免阻塞事件循环）"""
+    """获取用户工作目录（异步版本，避免阻塞事件循环）
+
+    创建失败处理同 get_user_workspace：记录后返回路径，不抛异常。
+    """
     workspace = os.path.join(WORKSPACE_BASE, _sanitize_user_id(user_id))
 
     def _ensure():
         if not os.path.exists(workspace):
-            os.makedirs(workspace, exist_ok=True)
+            try:
+                os.makedirs(workspace, exist_ok=True)
+            except OSError as e:
+                SYLogger.error(
+                    f"[Sandbox Server] 创建用户工作目录失败 (可能磁盘满/只读/权限不足): "
+                    f"{workspace} - {type(e).__name__}: {e}")
 
     await asyncio.to_thread(_ensure)
     return workspace
@@ -394,7 +412,15 @@ def setup_sandbox_handler(app: FastAPI, config: dict = None):
         if not initialized:
             def _init():
                 if not os.path.exists(WORKSPACE_BASE):
-                    os.makedirs(WORKSPACE_BASE, exist_ok=True)
+                    try:
+                        os.makedirs(WORKSPACE_BASE, exist_ok=True)
+                    except OSError as e:
+                        # 不抛异常：建失败时具体文件操作会返回结构化错误，
+                        # 避免全局异常处理器吞成无信息 500；日志带真实原因。
+                        SYLogger.error(
+                            f"[Sandbox Server] 初始化工作根目录失败 "
+                            f"(可能磁盘满/只读/权限不足): {WORKSPACE_BASE} - "
+                            f"{type(e).__name__}: {e}")
             await asyncio.to_thread(_init)
             initialized = True
 

{sycommon_python_lib-0.2.7a4.dist-info → sycommon_python_lib-0.2.7a5.dist-info}/METADATA

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

{sycommon_python_lib-0.2.7a4.dist-info → sycommon_python_lib-0.2.7a5.dist-info}/RECORD

@@ -136,7 +136,7 @@ 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=MPGy7WR3SZ2Hs--g5VFqXE9DGNRNCsNHYY65SlEoTbU,65612
+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/acp/__init__.py,sha256=vQGMQYAA5-ZaejYmDZ4r4Fklqs17qH3cDXQ5pZlwj-0,1844
@@ -147,10 +147,13 @@ sycommon/agent/acp/tool.py,sha256=yt6ohKL2y7wIZMNiLv-m5oCg5u1p5GAbqgjzQVt285Y,10
 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=OQa-lE7RL2s3Lqh-kNOKaUrb130hvorB_HjyFBqZBZs,10960
+sycommon/agent/middleware/sitecustomize.py,sha256=Bt7XFnWV_LJo89l858AGp5VUkXwefpLGmjkCtLe-CMw,4800
+sycommon/agent/middleware/skill_api_whitelist.py,sha256=vAAUGIYYKVYAzJVYB0tTObLweQ1OBTnCfPPbc37yTfo,11029
+sycommon/agent/middleware/skill_wl_check.py,sha256=rCJ9F6aWPh8tVQBIPmcq2lKDsfwiJQduwSUku_8kXfs,3952
 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=EGRxHojLXGRrkjAqYmjbQnMvq1sr0CBKvCmVjUQUkKU,64774
+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/sandbox_pool.py,sha256=eMn8sLakCWf90l6ni2-333QM8oBdX1CflV-WzneFp_k,9133
 sycommon/agent/sandbox/sandbox_recovery.py,sha256=X-eDODx1tmGMh_iTngV6e1ppfDBHpTdkPreJusN5MHY,7358
@@ -162,7 +165,7 @@ sycommon/auth/oa_crypto.py,sha256=xpY1R1Bj3KLENXB0TuThB6Eku1E9PYjcoSpOdgDmCgc,18
 sycommon/auth/oa_service.py,sha256=kLepV9zgqpZoaB73DRPpMA5tJJQjoaDtQPdzBcGXeak,6235
 sycommon/auth/wecom_ldap_service.py,sha256=5DWXu-mR3ckZm2lkCJu7gLi_3GCiLNZNpK3bFCPcQAc,31122
 sycommon/config/ACPAgentConfig.py,sha256=paAa0c0gy1RnDDum-Q6m7QLTe7lhz2dsFt4r72QtmWE,3202
-sycommon/config/Config.py,sha256=KsXl6BrZ3piIcxu7IVQWnrT91xEhducnGwk2eh0Uav4,7839
+sycommon/config/Config.py,sha256=MP92XxB7hsQiOnyjMkZskbxuMn_OUAZ4RTbC74ZATl4,7885
 sycommon/config/DatabaseConfig.py,sha256=ILiUuYT9_xJZE2W-RYuC3JCt_YLKc1sbH13-MHIOPhg,804
 sycommon/config/ElasticsearchConfig.py,sha256=fO9ZPMgJxSg1-UyDJ90wO6UvYy-jscwPJsSkXgx9qTU,2308
 sycommon/config/EmbeddingConfig.py,sha256=gPKwiDYbeu1GpdIZXMmgqM7JqBIzCXi0yYuGRLZooMI,362
@@ -173,6 +176,7 @@ sycommon/config/PgConfig.py,sha256=Hs9LwgIxSBxcFP16oq18N6Gq9hU2qVl4-7bPfd-ON_s,2
 sycommon/config/RedisConfig.py,sha256=gIa4BS8L_HdmBg9Dkv3cuIK6CU9zt9RodZOJUuUlh5Y,5235
 sycommon/config/RerankerConfig.py,sha256=35sVwzus2IscvTHnCG63Orl2pC-pMsrVi6wAGDmOH3U,341
 sycommon/config/SentryConfig.py,sha256=OsLb3G9lTsCSZ7tWkcXWJHmvfILQopBxje5pjnkFJfo,320
+sycommon/config/SkillApiWhitelistConfig.py,sha256=ovxpBIY5rlafniydQ1UR4xYdaS3wfkk5ju_mVJAj4Y4,3764
 sycommon/config/XxlJobConfig.py,sha256=VSG6dn9ysfUVunOs7PqugyZUGJWmX_cEePz2ZCfqHtU,392
 sycommon/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sycommon/config/config_change_notifier.py,sha256=7qQe7vdBS1zohEfVq0d5IaDqYsLdgd2ckF4mKKgh0gE,6848
@@ -227,7 +231,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=me-gbt9T2-RC-UPlEmCd84W-BbEZpGvqbs-iHcdw5JI,48193
+sycommon/middleware/sandbox.py,sha256=_BjRqJgJDula_Vyg-ooifrqG9L3CaS7_KPLzvyW0JrY,49598
 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
@@ -301,8 +305,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.7a4.dist-info/METADATA,sha256=uZ0e_w_up1416YQu001gfJPQu6CJMVseAeBRddj8Yck,7960
-sycommon_python_lib-0.2.7a4.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-sycommon_python_lib-0.2.7a4.dist-info/entry_points.txt,sha256=gsR4SssKxDWjRU8ggidzNcdMXDPRSKRS7UaGyNP84Qg,92
-sycommon_python_lib-0.2.7a4.dist-info/top_level.txt,sha256=RgphKrg7nJyZ7irJqbxFr-5H2LUYTvI7ivoWZH2hcD0,29
-sycommon_python_lib-0.2.7a4.dist-info/RECORD,,
+sycommon_python_lib-0.2.7a5.dist-info/METADATA,sha256=dC6l-dxbcElpxqKBFZVmPTNYxSDYWmoAJFaVFCS2m74,7960
+sycommon_python_lib-0.2.7a5.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+sycommon_python_lib-0.2.7a5.dist-info/entry_points.txt,sha256=gsR4SssKxDWjRU8ggidzNcdMXDPRSKRS7UaGyNP84Qg,92
+sycommon_python_lib-0.2.7a5.dist-info/top_level.txt,sha256=RgphKrg7nJyZ7irJqbxFr-5H2LUYTvI7ivoWZH2hcD0,29
+sycommon_python_lib-0.2.7a5.dist-info/RECORD,,