sycommon-python-lib 0.2.7a15__tar.gz → 0.2.7a17__tar.gz

{sycommon_python_lib-0.2.7a15 → sycommon_python_lib-0.2.7a17}/PKG-INFO

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

{sycommon_python_lib-0.2.7a15 → sycommon_python_lib-0.2.7a17}/pyproject.toml

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

{sycommon_python_lib-0.2.7a15 → sycommon_python_lib-0.2.7a17}/src/sycli/simple_chat_agent.py

@@ -29,7 +29,7 @@ def _init_llm_config_from_env() -> None:
     base = os.getenv("ACP_CHAT_BASE")
     if not base:
         return  # 无 env，走默认 Nacos 配置
-    model = os.getenv("ACP_CHAT_MODEL", "digital-worker-llm")
+    model = os.getenv("ACP_CHAT_MODEL", "digital-worker-external")
     key = os.getenv("ACP_CHAT_KEY", "-")
     try:
         import sycommon.config.Config as cfgmod
@@ -64,14 +64,14 @@ def _init_llm_config_from_env() -> None:
 async def chat_once(message: str, on_chunk=None) -> str:
     """调一次 LLM 完成对话，可选流式回调。返回完整回复文本。
 
-    用 sycommon 的 get_llm，模型名从环境 ACP_CHAT_MODEL 读（默认 digital-worker-llm）。
+    用 sycommon 的 get_llm，模型名从环境 ACP_CHAT_MODEL 读（默认 digital-worker-external）。
     若设置了 ACP_CHAT_BASE，则用环境变量配置（不依赖 Nacos）。
     """
     _init_llm_config_from_env()
     from sycommon.llm.get_llm import get_llm
     from langchain_core.messages import HumanMessage, SystemMessage
 
-    model_name = os.getenv("ACP_CHAT_MODEL", "digital-worker-llm")
+    model_name = os.getenv("ACP_CHAT_MODEL", "digital-worker-external")
     llm = get_llm(model=model_name, streaming=True)
     messages = [
         SystemMessage(content="你是一个简洁的对话助手，用一两句话回答。"),

{sycommon_python_lib-0.2.7a15 → sycommon_python_lib-0.2.7a17}/src/sycommon/agent/deep_agent.py

@@ -58,6 +58,7 @@ from sycommon.agent.chat_events import ChatEvent, ChatEventBuilder, DEFAULT_AGEN
 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 sycommon.agent.middleware.sandbox_path_guard import SandboxPathGuardMiddleware
 from sycommon.agent.middleware.sensitive_guard import SensitiveGuardMiddleware
 from deepagents.middleware.summarization import create_summarization_tool_middleware  # noqa: F401 保留 re-export
 from sycommon.agent.summarization_utils import build_summarization_middleware
@@ -374,8 +375,8 @@ class AgentConfig(BaseModel):
     internal_model_name: Optional[str] = None
     # 敏感检测提示词（应用层可覆盖）；未传(None)用基础库 DEFAULT_DETECT_PROMPT
     sensitive_detect_prompt: Optional[str] = None
-    # 命中敏感后的动作："downgrade"=降级内部模型继续；"block"=直接阻断不执行
-    sensitive_action: str = "downgrade"
+    # 命中敏感后的动作："allow"=不检测放行；"downgrade"=降级内部模型继续；"block"=直接阻断不执行
+    sensitive_action: str = "allow"
 
     # 系统提示词
     system_prompt: str = DEFAULT_SYSTEM_PROMPT
@@ -1254,6 +1255,7 @@ async def create_deep_agent(
         TokenTrackingMiddleware(model_name=config.model_name, user_id=user_id),
         summarization_mw,
         SkillWriteGuardMiddleware(),          # 系统 /skills/system 只读守卫(先于白名单)
+        SandboxPathGuardMiddleware(user_id),  # 宿主绝对路径规范化/拦截(防越权读他人沙箱文件)
     ]
 
     # RubricMiddleware：复用 FilesystemMiddleware 的工具（底层走 HTTPSandboxBackend HTTP 远程调用）

sycommon_python_lib-0.2.7a17/src/sycommon/agent/middleware/sandbox_path_guard.py

@@ -0,0 +1,143 @@
+"""沙箱路径守卫中间件。
+
+拦所有吃路径的沙箱工具调用,在发到沙箱服务端之前规范化/拦截宿主绝对路径:
+
+- **虚拟路径**(/skills/...、./x、output/...) → 放行
+- **自己的工作目录绝对路径**(/data/.../sycommon_sandbox/<本人>/...) → 改写为虚拟路径放行
+  (零往返,体验最好;也兼容 agent 偶尔把工作目录当绝对路径写的写法)
+- **越界/跨用户绝对路径**(别人的工作目录、/etc/passwd 等无关宿主路径) → 拦截返回 error
+  (防越权读他人数据;也避免把别的用户名/路径结构泄回 LLM 上下文)
+- **execute 命令串里出现宿主绝对路径前缀** → 拦截(shell 里不能安全改写子串,只能挡)
+
+与 SkillWriteGuardMiddleware(管 /skills/system 只读)互不冲突,均为 fail-closed 短路。
+这是「事前拦截」层;沙箱服务端 resolve_sandbox_path 的越权拒绝 + /read 的 outside-sandbox
+提示作为 defense-in-depth 兜底(漏过此层仍会被服务端挡)。
+"""
+import dataclasses
+import os
+import re
+
+from langchain.agents.middleware.types import AgentMiddleware
+from langchain_core.messages import ToolMessage
+from langgraph.prebuilt.tool_node import ToolCallRequest
+
+# 宿主工作目录根(Linux: /data/sycommon_sandbox;本地 macOS 测试: <tempdir>/sycommon_sandbox)。
+# 从 sandbox 服务端模块取,保证「middleware 算的前缀」与「服务端实际隔离边界」一致,不漂移。
+try:
+    from sycommon.middleware.sandbox import WORKSPACE_BASE, _sanitize_user_id
+except Exception:  # 测试/独立引入环境兜底,行为与 sandbox.py 保持一致
+    import tempfile
+    import platform
+    if platform.system() == "Linux":
+        WORKSPACE_BASE = os.environ.get("SANDBOX_WORKSPACE", "/data/sycommon_sandbox")
+    else:
+        WORKSPACE_BASE = os.environ.get(
+            "SANDBOX_WORKSPACE",
+            os.path.join(tempfile.gettempdir(), "sycommon_sandbox"))
+
+    def _sanitize_user_id(user_id: str) -> str:
+        import re as _re
+        return _re.sub(r'[^a-zA-Z0-9._\-]', '_', user_id.lower().replace(" ", ""))
+
+
+# 宿主工作目录根的规范化形式(realpath,去尾斜杠)。所有绝对路径判定以此为锚。
+_WORKSPACE_ROOT = os.path.realpath(WORKSPACE_BASE).rstrip(os.sep)
+
+
+# 工具 → 路径字段名映射(结构化参数,可安全改写/拦截)
+# get_share_url 是 app(base_tools)自定义工具,同样吃 file_path,纳入统一约束。
+_PATH_TOOLS = {
+    "read_file": "file_path",
+    "write_file": "file_path",
+    "edit_file": "file_path",
+    "ls": "path",
+    "glob": "path",
+    "grep": "path",
+    "get_share_url": "file_path",
+}
+
+# 宿主沙箱根前缀(用于 execute 命令串扫描;shell 里无法安全改写,只能拦)。
+# 命中即视为「引用了宿主沙箱真实路径」,一律拦。
+_HOST_SANDBOX_RE = re.compile(re.escape(_WORKSPACE_ROOT) + r'(?:/|\\)')
+
+_DENIED_MSG = (
+    "Error: 不允许使用宿主机绝对路径访问沙箱文件。"
+    "请改用沙箱相对路径(如 /skills/system/...、./output/report.pdf、result.xlsx)。"
+)
+
+
+def _is_host_absolute(path: str) -> bool:
+    """是否为「沙箱根之内」的宿主机绝对路径(才需规范化/拦截判断)。
+
+    沙箱根之外的宿主绝对路径(/etc/passwd 等)在沙箱里本来就读不到,
+    会自然落到服务端 'not found',无需此层干预——故这里只认沙箱根内的。
+    """
+    if not path or not os.path.isabs(path):
+        return False
+    rp = os.path.realpath(path)
+    return rp == _WORKSPACE_ROOT or rp.startswith(_WORKSPACE_ROOT + os.sep)
+
+
+def _within_self_workspace(path: str, self_ws: str) -> bool:
+    """宿主绝对路径是否落在当前用户自己的工作目录内。"""
+    rp = os.path.realpath(path)
+    self_rp = os.path.realpath(self_ws).rstrip(os.sep)
+    return rp == self_rp or rp.startswith(self_rp + os.sep)
+
+
+def _to_virtual(path: str, self_ws: str) -> str:
+    """把「自己工作目录内的宿主绝对路径」改写为沙箱虚拟路径(/ 开头 POSIX)。"""
+    rp = os.path.realpath(path)
+    self_rp = os.path.realpath(self_ws)
+    if rp == self_rp:
+        return "/"
+    rel = os.path.relpath(rp, self_rp)
+    return "/" + rel.replace("\\", "/")
+
+
+class SandboxPathGuardMiddleware(AgentMiddleware):
+    """规范化/拦截沙箱工具调用里的宿主绝对路径。
+
+    仅实现 awrap_tool_call(异步链路),与 SkillWriteGuardMiddleware 对齐。
+    构造时传入 user_id,据此算出「本人工作目录」前缀,区分改写 vs 拦截。
+    """
+
+    def __init__(self, user_id: str):
+        self._user_id = user_id or ""
+        self._self_ws = os.path.join(WORKSPACE_BASE, _sanitize_user_id(self._user_id)) \
+            if self._user_id else ""
+
+    async def awrap_tool_call(self, request: ToolCallRequest, handler):
+        tc = request.tool_call
+        name = tc.get("name")
+        args = tc.get("args", {})
+        if not isinstance(args, dict):
+            return await handler(request)
+
+        # 1) 结构化路径工具:read/write/edit/ls/grep/glob/get_share_url
+        field = _PATH_TOOLS.get(name)
+        if field:
+            raw = args.get(field)
+            if isinstance(raw, str) and _is_host_absolute(raw):
+                if self._self_ws and _within_self_workspace(raw, self._self_ws):
+                    # 自己工作目录内的绝对路径 → 改写为虚拟路径放行(零往返)
+                    new_tc = dict(tc)
+                    new_args = dict(args)
+                    new_args[field] = _to_virtual(raw, self._self_ws)
+                    new_tc["args"] = new_args
+                    new_request = dataclasses.replace(request, tool_call=new_tc)
+                    return await handler(new_request)
+                # 越界/跨用户宿主绝对路径 → 拦截
+                return ToolMessage(content=_DENIED_MSG, name=name,
+                                   tool_call_id=tc.get("id", ""), status="error")
+            return await handler(request)
+
+        # 2) execute(裸 shell):命令串里的宿主绝对路径无法安全改写,只能拦
+        if name == "execute":
+            command = args.get("command", "")
+            if isinstance(command, str) and _HOST_SANDBOX_RE.search(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_python_lib-0.2.7a15 → sycommon_python_lib-0.2.7a17}/src/sycommon/agent/middleware/sensitive_guard.py

@@ -228,8 +228,8 @@ class SensitiveGuardMiddleware(AgentMiddleware):
         state: Optional[DowngradeState] = None,
         # 应用层可覆盖检测提示词；未传(None)用 DEFAULT_DETECT_PROMPT
         detect_prompt: Optional[str] = None,
-        # 命中敏感后的动作："downgrade"=降级内部模型继续；"block"=直接阻断(不调任何模型)
-        action: str = "downgrade",
+        # 命中敏感后的动作："allow"=不检测放行；"downgrade"=降级内部模型继续；"block"=直接阻断(不调任何模型)
+        action: str = "allow",
         # 阻断模式下的异步提示回调（与 on_downgrade 区分文案）；downgrade 模式不用
         on_block: Optional[Callable[[], Awaitable[None]]] = None,
         # 测试注入：绕过懒加载的真实 get_llm
@@ -241,7 +241,8 @@ class SensitiveGuardMiddleware(AgentMiddleware):
         self._internal_name = internal_model_name
         self._on_downgrade = on_downgrade
         self._on_block = on_block
-        self._action = action if action in ("downgrade", "block") else "downgrade"
+        # 默认 allow（不检测）：应用层未显式指定时按"放行"处理，避免误伤。
+        self._action = action if action in ("downgrade", "block", "allow") else "allow"
         self._enabled = enabled
         self._state = state or DowngradeState()
         self._detect_prompt = detect_prompt or DEFAULT_DETECT_PROMPT
@@ -349,8 +350,9 @@ class SensitiveGuardMiddleware(AgentMiddleware):
         request: ModelRequest[ContextT],
         handler: Callable[[ModelRequest[ContextT]], Awaitable[ModelResponse[ResponseT]]],
     ) -> ModelResponse[ResponseT]:
-        # (a) 关闭 / 内部 tier：纯放行，不检测（避免内部模型检内部模型 + 省 token）
-        if not self._enabled or self._model_tier == "internal":
+        # (a) 关闭 / 内部 tier / allow 模式：纯放行，不检测。
+        #     allow = 应用层完全关闭敏感检测（不调用 detector、不阻断、不降级），零开销。
+        if not self._enabled or self._model_tier == "internal" or self._action == "allow":
             return await handler(request)
 
         # (b) 本会话已命中敏感

{sycommon_python_lib-0.2.7a15 → sycommon_python_lib-0.2.7a17}/src/sycommon/agent/multi_agent_team.py

@@ -133,7 +133,7 @@ class TeamConfig(BaseModel):
     sensitive_guard: bool = True        # 是否启用敏感信息检测守卫
     internal_model_name: Optional[str] = None   # 敏感降级目标内部模型名（应用层透传）
     sensitive_detect_prompt: Optional[str] = None  # 敏感检测提示词（应用层覆盖）
-    sensitive_action: str = "downgrade"  # "downgrade"=降级继续；"block"=阻断
+    sensitive_action: str = "allow"  # "allow"=不检测放行；"downgrade"=降级继续；"block"=阻断
 
     coordinator_prompt: str = ""
     coordinator_name: str = "项目经理"

{sycommon_python_lib-0.2.7a15 → sycommon_python_lib-0.2.7a17}/src/sycommon/agent/sandbox/file_ops.py

@@ -361,7 +361,10 @@ class FileOperationsMixin:
                 return ReadResult(error=f"File '{file_path}': unexpected server response: {detail}")
             if result.get("error"):
                 err_msg = result['error']
-                if 'not found' in err_msg:
+                if 'not found' in err_msg or 'outside the sandbox' in err_msg:
+                    # not found 是 agent 正常试探；outside the sandbox 是安全守卫拦截
+                    # agent 用了宿主绝对路径，属正常 tool-error（会自愈改用虚拟路径）。
+                    # 降级为 warning，避免把正常工具错误刷成 ERROR 级。
                     SYLogger.warning(f"[Sandbox] 异步读取文件未找到: {err_msg}")
                 else:
                     SYLogger.error(f"[Sandbox] 异步读取文件失败: {err_msg}")

{sycommon_python_lib-0.2.7a15 → sycommon_python_lib-0.2.7a17}/src/sycommon/llm/llm_logger.py

@@ -53,9 +53,19 @@ class LLMLogger(AsyncCallbackHandler):
                         self._log_result(result, i+1)
 
     async def on_llm_error(self, error: Exception, **kwargs: Any) -> None:
+        import asyncio
+        # GeneratorExit: 消费方提前关闭生成器（如 SSE 客户端断开）
         if isinstance(error, GeneratorExit):
             SYLogger.info("LLM生成器正常关闭")
             return
+        # CancelledError: LangGraph 的 AsyncBackgroundExecutor 在图执行结束/取消时，
+        # 用 task.cancel(sentinel) 取消正在运行的模型任务，sentinel 是裸 object()，
+        # str() 即 "<object object at 0x...>"。这不是真正的 LLM 调用失败，
+        # 降级为 INFO，避免污染 ERROR 日志（CancelledError 属 BaseException）。
+        if isinstance(error, asyncio.CancelledError):
+            SYLogger.info(
+                f"LLM调用被取消（流式任务取消）: {str(error) or '(无消息)'}")
+            return
         SYLogger.error(f"LLM调用出错: {str(error)}")
 
     # ------------------------------

sycommon_python_lib-0.2.7a17/src/sycommon/llm/token_utils.py

@@ -0,0 +1,169 @@
+# -*- coding: utf-8 -*-
+"""
+Token 计数与 max_tokens 动态调整工具函数
+
+统一供 LLMWithTokenTracking、LLMWithAutoTokenUsage、DeepAgent 等模块使用，
+避免同一逻辑分散在多处。
+"""
+
+from __future__ import annotations
+
+from typing import List, Optional
+
+from langchain_core.messages import BaseMessage, AIMessage
+
+# cl100k_base 对国产/第三方模型 tokenizer 存在系统性低估（尤其中文），
+# 用作纯估算时乘以此系数修正，使估算值偏向保守（宁可高估 input，不可低估）。
+_TIKTOKEN_SAFETY_FACTOR = 1.15
+_FORMAT_OVERHEAD_PER_MSG = 4  # 每条消息的 <im_start>role/...<im_end>\n 等格式开销
+
+
+def _count_text_tokens(content) -> int:
+    """对单条消息 content 估算 token 数（cl100k_base × 1.15 安全系数）。
+
+    content 可能是 str（纯文本）或 list（多模态 content block）。
+    """
+    if isinstance(content, str):
+        text = content
+    elif isinstance(content, list):
+        text = ""
+        for part in content:
+            if isinstance(part, str):
+                text += part
+            elif isinstance(part, dict):
+                text += str(part)
+    else:
+        text = str(content) if content is not None else ""
+
+    # 优先 tiktoken cl100k_base
+    try:
+        import tiktoken
+        enc = tiktoken.get_encoding("cl100k_base")
+        n = len(enc.encode(text))
+        return int(n * _TIKTOKEN_SAFETY_FACTOR)
+    except Exception:
+        pass
+
+    # 回退：字符估算（中文 1.5 chars/token，英文 3.5 chars/token）
+    non_ascii = sum(1 for c in text if ord(c) > 127)
+    ratio = non_ascii / max(len(text), 1)
+    chars_per_token = 1.5 if ratio > 0.3 else 3.5
+    return int(len(text) / chars_per_token)
+
+
+def _usage_input_tokens(msg: BaseMessage) -> Optional[int]:
+    """从消息的 usage_metadata 提取 input_tokens（API 真实返回值）。
+
+    仅 AIMessage 会携带 usage_metadata。返回 None 表示无锚点。
+    """
+    um = getattr(msg, "usage_metadata", None)
+    if not isinstance(um, dict):
+        return None
+    n = um.get("input_tokens")
+    return int(n) if isinstance(n, (int, float)) else None
+
+
+def count_messages_tokens_accurate(messages: List[BaseMessage]) -> int:
+    """精确估算 messages 的 input token 数（hybrid 策略）。
+
+    背景：原 ``count_messages_tokens`` 用 cl100k_base 对整段历史重新估算，
+    对国产模型 tokenizer 系统性低估 ~22%（如 68609 真实 tokens 被估成 ~53K），
+    导致 clamp 误判可用空间，max_tokens 放过大 → 400 报错。
+
+    策略（真实锚点 + 增量估算）：
+      1. 倒序找最近一条带 ``usage_metadata.input_tokens`` 的 AIMessage，
+         该值是模型上轮回复时 API 返回的真实 input token 数（精确，非估算）。
+      2. 真实基数 = 该锚点 input_tokens；其后新增的消息用 cl100k×1.15 估算增量。
+      3. 无锚点（首回合 / 历史被压缩）时，回退到整段 cl100k×1.15 估算。
+
+    这样误差从「整段 22%」缩到「新增几十~几百 token 的几个百分点」，
+    配合 clamp 的 0.90 安全系数 + buffer，几乎不会漏判超限。
+
+    Args:
+        messages: LangChain 消息列表。
+
+    Returns:
+        估算的 input token 总数。
+    """
+    if not messages:
+        return 0
+
+    # 1) 找最近一个 usage 锚点
+    anchor_idx = -1
+    anchor_input = None
+    for i in range(len(messages) - 1, -1, -1):
+        msg = messages[i]
+        if isinstance(msg, AIMessage):
+            n = _usage_input_tokens(msg)
+            if n is not None:
+                anchor_idx = i
+                anchor_input = n
+                break
+
+    if anchor_idx >= 0:
+        # 2) 真实基数 + 其后新增消息的增量估算
+        delta_tokens = 0
+        for msg in messages[anchor_idx + 1:]:
+            delta_tokens += _count_text_tokens(getattr(msg, "content", "")) + _FORMAT_OVERHEAD_PER_MSG
+        return anchor_input + delta_tokens
+
+    # 3) 无锚点：整段 cl100k×1.15 估算
+    total = 0
+    for msg in messages:
+        total += _count_text_tokens(getattr(msg, "content", "")) + _FORMAT_OVERHEAD_PER_MSG
+    return total
+
+
+def count_messages_tokens(messages: List[BaseMessage]) -> int:
+    """估算 messages 的 token 数（向后兼容入口）。
+
+    .. deprecated::
+        内部已委托给 :func:`count_messages_tokens_accurate`（hybrid 精确估算）。
+        新代码请直接使用 ``count_messages_tokens_accurate``。
+    """
+    return count_messages_tokens_accurate(messages)
+
+
+def clamp_max_tokens(
+    model,
+    messages: List[BaseMessage],
+    *,
+    context_window: int,
+    max_output_tokens: int,
+    buffer: int = 8192,
+    min_output: int = 1024,
+    safety_factor: float = 0.90,
+) -> int:
+    """动态调整模型的 max_tokens，确保 input + max_output 不超过上下文窗口。
+
+    每次调用前精确估算当前 input tokens，计算可用空间，
+    将 model.max_tokens = min(max_output_tokens, effective_context - input - buffer)，
+    最低保底 min_output。
+
+    三道防线（任一即可挡住超限，叠加更稳）：
+      1. **精确估算**：用 :func:`count_messages_tokens_accurate` 的 hybrid 策略
+         （真实 usage 锚点 + 增量 cl100k×1.15），把整段 22% 的低估误差降到 ~几个百分点。
+      2. **安全系数**：context_window × 0.90 作为有效上限，吸收「配置值虚高 /
+         tokenizer 偏差 / 锚点缺失回退估算」等残余误差（默认 0.90）。
+      3. **buffer**：再扣除 buffer（默认 8192）token 余量。
+
+    Args:
+        model: 拥有 ``max_tokens`` 属性的 ChatModel 实例。
+        messages: 即将发送给模型的消息列表。
+        context_window: 模型上下文窗口大小（来自 LLMConfig.maxTokens）。
+        max_output_tokens: 配置的最大输出 token 数（来自 LLMConfig.maxOutputTokens）。
+        buffer: 保留的余量 token 数，默认 8192。
+        min_output: 最小输出 token 数保底值，默认 1024。
+        safety_factor: 上下文窗口的有效系数，默认 0.90
+            （防止配置 maxTokens 大于模型真实窗口，如配 200000 实际 196608）。
+
+    Returns:
+        调整后的 max_tokens 值。
+    """
+    # 有效上下文窗口 = 配置值 × safety_factor
+    effective_context = int(context_window * safety_factor)
+    input_est = count_messages_tokens_accurate(messages)
+    available = effective_context - input_est - buffer
+    dynamic_max = min(max_output_tokens, max(available, min_output))
+    model.max_tokens = dynamic_max
+    return dynamic_max

{sycommon_python_lib-0.2.7a15 → sycommon_python_lib-0.2.7a17}/src/sycommon/middleware/sandbox.py

@@ -608,9 +608,18 @@ def setup_sandbox_handler(app: FastAPI, config: dict = None):
         def _read():
             if not os.path.isfile(file_path):
                 if os.path.isabs(original_path) and os.path.isfile(original_path):
+                    # 原始路径是宿主绝对路径且真实存在，但解析后落在用户工作目录外
+                    # （典型成因：上下文里混入了别的用户的绝对路径，或 agent 自行拼接了
+                    #   /data/sycommon_sandbox/... 形式的宿主路径）。
+                    # 提示用沙箱虚拟相对路径读，且**只透出 basename**——不回显完整
+                    # 宿主绝对路径，避免把路径结构（含其他用户名）泄回 LLM/上下文。
+                    SYLogger.info(
+                        f"[Sandbox Server] 读取命中沙箱外路径: {original_path} "
+                        f"(user={req.user_id})")
                     return ReadResponse(
-                        error=f"File '{original_path}' exists but is outside sandbox. "
-                              f"Try reading from sandbox path: {os.path.basename(original_path)}",
+                        error=f"File exists on host but is outside the sandbox workspace. "
+                              f"Use a sandbox-relative path (e.g. /skills/...) instead of a "
+                              f"host-absolute path; try reading: {os.path.basename(original_path)}",
                         content=None
                     )
                 return ReadResponse(error=f"File '{file_path}' not found", content=None)

{sycommon_python_lib-0.2.7a15 → sycommon_python_lib-0.2.7a17}/src/sycommon/tests/test_dynamic_max_tokens.py

@@ -24,6 +24,73 @@ from langchain_core.outputs import ChatResult, ChatGeneration
 from sycommon.config.LLMConfig import LLMConfig
 from sycommon.llm.llm_with_token_tracking import LLMWithTokenTracking
 from sycommon.llm.usage_token import LLMWithAutoTokenUsage
+from sycommon.llm.token_utils import (
+    count_messages_tokens_accurate,
+    count_messages_tokens,
+    clamp_max_tokens,
+)
+
+
+# ============== hybrid 精确估算单测（token_utils）==============
+
+
+class TestHybridTokenEstimation:
+    """验证真实 usage 锚点 + 增量估算策略"""
+
+    def test_anchor_plus_delta(self):
+        """有 usage 锚点时：真实 input_tokens + 其后新增消息增量"""
+        # 锚点：上轮 AI 回复，API 返回真实 input_tokens=68609（报错场景复现）
+        messages = [
+            SystemMessage(content="你是数字员工"),
+            AIMessage(content="历史回复内容" * 100,
+                      usage_metadata={"input_tokens": 68609, "output_tokens": 3000, "total_tokens": 71609}),
+            HumanMessage(content="请基于上面的内容帮我做数据分析报告"),
+        ]
+        est = count_messages_tokens_accurate(messages)
+        # 真实基数 68609 + 新增 HumanMessage 增量(几十~百 token)
+        assert est >= 68609
+        assert est < 69000  # 增量不会太离谱
+
+    def test_no_anchor_fallback_with_safety_factor(self):
+        """无锚点（首回合）：整段 cl100k × 1.15 保守估算"""
+        messages = [HumanMessage(content="这是一段测试文本。" * 100)]
+        est = count_messages_tokens_accurate(messages)
+        # cl100k 算 "这是一段测试文本。"=8 tokens，×100=800，×1.15≈920 + 格式开销
+        assert est > 800  # 比 cl100k 裸值更保守
+
+    def test_legacy_alias_matches_accurate(self):
+        """count_messages_tokens（向后兼容）应等价于 accurate 版本"""
+        messages = [
+            AIMessage(content="x", usage_metadata={"input_tokens": 1000, "output_tokens": 0, "total_tokens": 1000}),
+            HumanMessage(content="y"),
+        ]
+        assert count_messages_tokens(messages) == count_messages_tokens_accurate(messages)
+
+    def test_empty_messages(self):
+        assert count_messages_tokens_accurate([]) == 0
+
+    def test_prevents_400_on_real_error_scenario(self):
+        """回归：复现线上 68609 真实 input 场景，clamp 后 input+output 不超真实窗口
+
+        线上 bug：cl100k 把 68609 估成 ~53K，clamp 放过 128000 output，
+        导致 128000+68609=196609 > 196608 → 400 报错。
+        """
+        class FakeModel:
+            model = "digital-worker-external"
+            max_tokens = 128000
+
+        messages = [
+            AIMessage(content="历史" * 5000,
+                      usage_metadata={"input_tokens": 68609, "output_tokens": 3000, "total_tokens": 71609}),
+            HumanMessage(content="继续分析"),
+        ]
+        m = FakeModel()
+        dyn = clamp_max_tokens(m, messages,
+                               context_window=200000,  # 配置值虚高，真实 196608
+                               max_output_tokens=128000)
+        # 真实 input 68609 + clamp 后的 output 必须 ≤ 真实窗口 196608
+        assert 68609 + dyn <= 196608, \
+            f"仍会 400: 68609(input) + {dyn}(output) = {68609 + dyn} > 196608"
 
 
 def _make_llm_config(max_tokens=196608, max_output=128000):
@@ -84,30 +151,32 @@ class TestLLMWithTokenTrackingClamp:
         assert llm.max_tokens == 128000
 
     def test_large_input_reduces_max_output(self):
-        """input 大时，max_tokens 自动缩小"""
+        """input 大时，max_tokens 自动缩小（仍高于 1024 保底）"""
         llm = MockChatModel(max_tokens=128000)
         config = _make_llm_config(max_tokens=196608, max_output=128000)
         wrapper = LLMWithTokenTracking(llm=llm, llmConfig=config)
 
-        # 模拟 ~100K 字符 ≈ ~50K tokens 的 input
+        # 100K 字符 ≈ cl100k 100K tokens × 1.15 ≈ 115K tokens 的 input
+        # （"这是一段测试文本。" 9字符=8tokens，近乎 1:1，并非 0.5:1）
         messages = _make_long_messages(100000)
         wrapper._clamp_max_tokens(messages)
 
-        # available = 196608 - ~50K - 4096 ≈ 142K, min(128000, 142K) = 128000
-        assert llm.max_tokens == 128000
+        # available = 176947 - ~115K - 8192 ≈ 53K → min(128000, 53K) ≈ 53K
+        assert llm.max_tokens < 128000
+        assert llm.max_tokens > 1024  # 至少保留 1024
 
     def test_near_limit_input_clamps_hard(self):
-        """input 接近上限时，max_tokens 被大幅压缩"""
+        """input 接近上限时，max_tokens 被大幅压缩（但仍高于保底）"""
         llm = MockChatModel(max_tokens=128000)
         config = _make_llm_config(max_tokens=196608, max_output=128000)
         wrapper = LLMWithTokenTracking(llm=llm, llmConfig=config)
 
-        # 模拟 ~160K 字符 ≈ ~80K tokens 的 input
-        messages = _make_long_messages(160000)
+        # ~130K 字符 ≈ 150K tokens 的 input
+        messages = _make_long_messages(130000)
         wrapper._clamp_max_tokens(messages)
 
-        # available = 196608 - ~80K - 4096 ≈ 112K, min(128000, 112K) = ~112K
-        assert llm.max_tokens < 128000
+        # available ≈ 176947 - ~150K - 8192 ≈ 18K
+        assert llm.max_tokens < 50000
         assert llm.max_tokens > 1024  # 至少保留 1024
 
     def test_extremely_large_input_floors_at_1024(self):
@@ -168,7 +237,8 @@ class TestLLMWithAutoTokenUsageClamp:
         config = _make_llm_config(max_tokens=196608, max_output=128000)
         wrapper = LLMWithAutoTokenUsage(llm=llm, langfuse=None, llmConfig=config, summary_prompt=None)
 
-        messages = _make_long_messages(160000)
+        # ~130K 字符 ≈ 150K tokens 的 input，会被压到 5 万档
+        messages = _make_long_messages(130000)
         wrapper._clamp_max_tokens(messages)
 
         assert llm.max_tokens < 128000

{sycommon_python_lib-0.2.7a15 → sycommon_python_lib-0.2.7a17}/src/sycommon_python_lib.egg-info/PKG-INFO

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

{sycommon_python_lib-0.2.7a15 → sycommon_python_lib-0.2.7a17}/src/sycommon_python_lib.egg-info/SOURCES.txt

@@ -149,6 +149,7 @@ src/sycommon/agent/acp/tool.py
 src/sycommon/agent/mcp/__init__.py
 src/sycommon/agent/mcp/models.py
 src/sycommon/agent/mcp/tool_loader.py
+src/sycommon/agent/middleware/sandbox_path_guard.py
 src/sycommon/agent/middleware/sensitive_guard.py
 src/sycommon/agent/middleware/sitecustomize.py
 src/sycommon/agent/middleware/skill_api_whitelist.py

{sycommon_python_lib-0.2.7a15 → sycommon_python_lib-0.2.7a17}/tests/test_sensitive_guard.py

@@ -35,8 +35,9 @@ class _FakeRequest:
 
 
 def _mk_mw(detector_response: SensitiveCheck, model_tier="external",
-           on_downgrade=None, state=None):
-    """构造 middleware，detector 直接返回原始文本（_detect 自行解析 {…}）。"""
+           on_downgrade=None, state=None, action="downgrade"):
+    """构造 middleware，detector 直接返回原始文本（_detect 自行解析 {…}）。
+    默认 action=downgrade（命中降级）以匹配多数测试断言。"""
     import json as _json
 
     def _to_text(resp):
@@ -55,6 +56,7 @@ def _mk_mw(detector_response: SensitiveCheck, model_tier="external",
         model_tier=model_tier,
         on_downgrade=on_downgrade,
         state=state,
+        action=action,
         _detector=_FakeDetector(),
         _internal_raw=_FakeModel(),
     )