sycommon-python-lib 0.2.7a12__tar.gz → 0.2.7a14__tar.gz

{sycommon_python_lib-0.2.7a12 → sycommon_python_lib-0.2.7a14}/PKG-INFO

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

{sycommon_python_lib-0.2.7a12 → sycommon_python_lib-0.2.7a14}/pyproject.toml

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

{sycommon_python_lib-0.2.7a12 → sycommon_python_lib-0.2.7a14}/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.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
 
@@ -367,6 +368,14 @@ class AgentConfig(BaseModel):
     model_name: Optional[str] = None
     model_temperature: float = 0.7
     model_thinking: bool = False
+    model_tier: str = "external"        # "external"|"internal"；internal 时跳过敏感检测
+    sensitive_guard: bool = True        # 是否启用敏感信息检测守卫
+    # 敏感降级目标内部模型名（由应用层透传，避免基础库硬编码应用常量）
+    internal_model_name: Optional[str] = None
+    # 敏感检测提示词（应用层可覆盖）；未传(None)用基础库 DEFAULT_DETECT_PROMPT
+    sensitive_detect_prompt: Optional[str] = None
+    # 命中敏感后的动作："downgrade"=降级内部模型继续；"block"=直接阻断不执行
+    sensitive_action: str = "downgrade"
 
     # 系统提示词
     system_prompt: str = DEFAULT_SYSTEM_PROMPT
@@ -446,6 +455,7 @@ class DeepAgent:
         sandbox_backend: HTTPSandboxBackend,
         recovery_manager: Optional[SandboxRecoveryManager] = None,
         rubric_eval_collector: Optional[_RubricEvalCollector] = None,
+        sensitive_guard: Optional[SensitiveGuardMiddleware] = None,
     ):
         self.user_id = user_id
         self.agent = agent
@@ -453,6 +463,7 @@ class DeepAgent:
         self.sandbox_backend = sandbox_backend
         self.recovery_manager = recovery_manager
         self.rubric_eval_collector = rubric_eval_collector
+        self.sensitive_guard = sensitive_guard
 
     async def cleanup(self):
         """清理资源"""
@@ -508,7 +519,8 @@ class DeepAgent:
             ):
                 # 🔑 逐 token 诊断日志：仅在 DEEP_AGENT_STREAM_DEBUG=true 时打印
                 if _STREAM_DEBUG:
-                    _chunk_len = len(chunk) if isinstance(chunk, tuple) else '?'
+                    _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:
@@ -533,7 +545,8 @@ class DeepAgent:
                             _msg = payload_p[0]
                             _meta = payload_p[1]
                             _msg_type = type(_msg).__name__
-                            _content = repr(str(getattr(_msg, 'content', ''))[:80])
+                            _content = repr(
+                                str(getattr(_msg, 'content', ''))[:80])
                             _node = _meta.get('langgraph_node', '?') if isinstance(
                                 _meta, dict) else '?'
                             _step = _meta.get('langgraph_step', '?') if isinstance(
@@ -1221,7 +1234,22 @@ async def create_deep_agent(
     rubric_eval_collector = None
 
     # 构建 middleware 列表
+    # 🔒 敏感信息检测守卫：插在最外层（最先执行），命中则会话内降级内部模型。
+    #    enabled=False / model_tier="internal" 时内部短路，零开销。
+    #    internal_model_name 由应用层透传（避免基础库硬编码应用常量）；
+    #    未传(None)时 middleware 内部用 get_llm() 读 nacos default 模型兜底。
+    #    sensitive_detect_prompt 由应用层透传覆盖默认检测提示词。
+    #    sensitive_action 决定命中后降级还是阻断。
+    guard = SensitiveGuardMiddleware(
+        model_tier=config.model_tier,
+        enabled=config.sensitive_guard,
+        internal_model_name=config.internal_model_name,
+        detect_prompt=config.sensitive_detect_prompt,
+        action=config.sensitive_action,
+    )
+
     middleware_list = [
+        guard,
         ToolResultTruncationMiddleware(),
         TokenTrackingMiddleware(model_name=config.model_name, user_id=user_id),
         summarization_mw,
@@ -1245,7 +1273,8 @@ async def create_deep_agent(
         try:
             from sycommon.agent.middleware.skill_api_whitelist import (
                 SkillApiWhitelistMiddleware)
-            middleware_list.append(SkillApiWhitelistMiddleware(sandbox_backend))
+            middleware_list.append(
+                SkillApiWhitelistMiddleware(sandbox_backend))
         except Exception as _wl_err:
             SYLogger.warning(f"[DeepAgent] 技能接口白名单中间件加载失败(忽略): {_wl_err}")
 
@@ -1312,6 +1341,7 @@ async def create_deep_agent(
         sandbox_backend=sandbox_backend,
         recovery_manager=recovery_manager,
         rubric_eval_collector=rubric_eval_collector,
+        sensitive_guard=guard,
     )
 
 
@@ -1390,8 +1420,18 @@ async def _sync_skills_to_sandbox(
                     _skip_lazy_sync=True)
                 if remote_content and remote_content.file_data:
                     # FileData 是 TypedDict(dict), 用键访问而非属性
-                    return _parse_skill_version(
-                        remote_content.file_data.get("content", "") or "")
+                    content = remote_content.file_data.get("content", "") or ""
+                    # 沙箱 /read 对大文件(如 skill-creator 的 34KB SKILL.md)返回
+                    # encoding=base64，直接解析会因找不到 "version:" 行而误判为"无版本"
+                    # → 每次新建 Agent 都全量重传。base64 时先解码再解析。
+                    encoding = remote_content.file_data.get("encoding", "utf-8")
+                    if encoding == "base64" and content:
+                        try:
+                            import base64 as _b64
+                            content = _b64.b64decode(content).decode("utf-8", errors="replace")
+                        except Exception:
+                            pass
+                    return _parse_skill_version(content)
             except Exception:
                 pass
             return ""

sycommon_python_lib-0.2.7a14/src/sycommon/agent/middleware/sensitive_guard.py

@@ -0,0 +1,429 @@
+# -*- coding: utf-8 -*-
+"""敏感信息检测守卫中间件。
+
+每次模型调用前，用内部模型检测「即将发给外部模型的完整上下文」是否含
+数据外泄类敏感信息（个人信息组合 / 公司机密 / 凭证）。命中则：
+  - 会话内降级到内部模型（就地 request.override(model=内部模型raw层)，不重跑本轮）；
+  - 首个命中者通过 on_downgrade 回调发一次切换提示（CAS 保证）。
+
+降级状态由 DowngradeState 承载：单 agent 独立实例；multi-agent（协调者+子agent）
+共享同一实例，避免敏感数据通过委派链继续流向外部模型。
+
+agent 本就是内部模型（model_tier="internal"）时短路放行，不检测。
+检测失败 fail-close（视为敏感，降级内部模型）。
+"""
+import asyncio
+from typing import Any, Awaitable, Callable, List, Optional
+
+from langchain.agents.middleware.types import (
+    AgentMiddleware, ContextT, ModelRequest, ModelResponse, ResponseT,
+)
+from langchain_core.messages import BaseMessage, HumanMessage, AIMessage
+from pydantic import BaseModel
+
+from sycommon.logging.kafka_log import SYLogger
+
+
+# 敏感降级目标内部模型名：由应用层通过 AgentConfig.internal_model_name 显式传入。
+# 未传入(None)时，检测器和降级目标都直接用 get_llm() 读取 nacos 配置的 default 模型，
+# 基础库不写死任何模型名。
+
+# 降级提示文案（按敏感来源区分）
+NOTICE_FROM_INPUT = (
+    "您的任务经AI识别涉及到敏感信息，无法调用外部模型完成，"
+    "已自动切换至内部模型继续处理。"
+)
+NOTICE_FROM_HISTORY = (
+    "您的任务经AI识别记忆涉及到敏感信息，无法调用外部模型完成，"
+    "已自动切换至内部模型继续处理，您可输入'新建会话'消除记忆中的敏感信息。"
+)
+class SensitiveCheck(BaseModel):
+    """检测结果。"""
+    is_sensitive: bool
+    reason: str = ""
+    # 敏感信息来源：user_input(本次用户输入) / history(历史对话记忆) / tool_result(本轮工具执行结果)
+    source: str = "user_input"
+
+
+class DowngradeState:
+    """降级状态容器（会话级）。
+
+    - 单 agent：独占一个实例。
+    - multi-agent：协调者 + 所有子 agent 共享同一实例，任一命中 → 全员降级。
+
+    首个命中者通过 mark_downgraded 的 CAS 返回值决定是否发提示，避免重复。
+    """
+
+    def __init__(self):
+        self.downgraded = False
+        self.last_source = "user_input"   # 首次命中时的敏感来源，供应用层选提示文案
+        self._lock = asyncio.Lock()
+
+    @property
+    def is_downgraded(self) -> bool:
+        return self.downgraded
+
+    async def mark_downgraded(self, source: str = "user_input") -> bool:
+        """CAS：返回 True 表示本次调用是首个触发降级的（应发提示），并记下来源。"""
+        async with self._lock:
+            if self.downgraded:
+                return False
+            self.downgraded = True
+            self.last_source = source
+            return True
+
+
+DEFAULT_DETECT_PROMPT = """你是数据脱敏分类器。判断以下「即将发送给外部云模型」的对话上下文是否包含不宜外流的敏感数据，只回答结构化字段（is_sensitive + reason + source）。
+
+只有以下才算敏感（必须严格命中才算）：
+- 个人身份信息组合：姓名+手机号/身份证号/护照号/银行卡号 等能定位到具体个人的字段组合（单独一个姓名或一个邮箱不算）
+- 公司机密：未公开的经营/财务/合同/客户清单等核心商业数据
+- 真实明文凭证：实际的 token 值 / 明文密码 / 私钥 / access token 的具体值
+
+不算敏感（一律不要误判，即使出现也不选 is_sensitive）：
+- 内部系统接口地址、内部接口名、内部系统名（如 oa/eas/xxx-api）
+- 环境变量名或占位符（如 ${SYT_TOKEN}、SYT_BASE_URL）—— 是"变量名/占位符"，不是真实 token 值
+- 内部文件路径、项目代号、沙箱路径、对话历史存档路径
+- 单个员工姓名、域账号、工作邮箱（仅姓名+邮箱不构成隐私组合）
+- 单独的部门名、岗位名、普通工作内容、通用业务讨论
+- 公司内部知识库的通用知识、行业通识、业务规则概述
+
+判断原则：宁可放行也不要误判。只有当上下文出现「能定位到具体个人的完整身份/财务信息」或「真实的明文凭证值」时才判敏感。
+
+若判定 is_sensitive=true，还需指明 source（敏感信息最早出现的来源），三选一：
+- "user_input"：敏感信息出现在最后一条 HumanMessage（本次用户输入/本轮补充）中
+- "tool_result"：敏感信息出现在 ToolMessage（本轮工具执行后读取文档/查询产生的结果）中
+- "history"：敏感信息只出现在更早的历史对话（AI/人类历史消息、摘要）中，本次输入和本轮工具结果本身不含
+
+对话上下文：
+{content}"""
+
+
+def _messages_to_text(messages: List[BaseMessage]) -> str:
+    """把 messages 列表拼成检测用文本（[Role] content）。"""
+    parts = []
+    for m in messages:
+        role = type(m).__name__
+        content = m.content
+        if isinstance(content, list):
+            # 多模态 content（如 [{'type':'text','text':...}]）取文本拼接
+            content = " ".join(
+                str(c.get("text", "")) if isinstance(c, dict) else str(c)
+                for c in content
+            )
+        parts.append(f"[{role}] {content}")
+    return "\n".join(parts)
+
+
+def _parse_detect_json(text: str) -> Optional[SensitiveCheck]:
+    """从模型原始文本里稳健提取 SensitiveCheck。
+
+    容忍：前后多余文字、<think>…</think> 包裹、```json 代码块、
+    JSON 尾部跟自然语言（"Extra data"）等。无法解析返回 None（由调用方 fail-close）。
+    """
+    import json
+    import re
+
+    # 1) 先剥已闭合的 <think>…</think>（思维链不应参与解析，但模型常把 JSON 放在它后面）
+    text_no_think = re.sub(r"<think>.*?</think>", "", text, flags=re.DOTALL)
+    # 1b) 若 <think> 没闭合（模型把整个 JSON+回答都包在 think 里，常见漏闭合），
+    #     取 </think> 之后的部分（如果有）；否则剥掉开头的 <think> 标签
+    if "</think>" in text and "<think>" not in text_no_think:
+        # 已无完整 think 对，但仍有闭合标签 → 取闭合后的内容
+        text_no_think = text_no_think.split("</think>", 1)[-1]
+    elif "<think>" in text_no_think:
+        # 残留未闭合 <think>：把它当普通文字剥掉（取 <think> 之后的内容）
+        text_no_think = text_no_think.split("<think>", 1)[-1]
+    # 2) 去 ```json / ``` 代码块围栏
+    text_clean = re.sub(r"```(?:json)?", "", text_no_think)
+    # 3) 取第一个 { 到最后一个 } 之间的片段（贪婪，吸收多对象/尾随文字场景）
+    start = text_clean.find("{")
+    end = text_clean.rfind("}")
+    # 注意：无大括号（纯 yaml/散文式）时不在此 return None —— 还要走 4c 正则兜底。
+    candidate = text_clean[start:end + 1] if (start != -1 and end != -1 and end > start) else ""
+
+    # 4) 直接解析；失败则按「JSON 尾部跟自然语言 / 多个对象」逐个试
+    def _try(s: str) -> Optional[SensitiveCheck]:
+        try:
+            data = json.loads(s)
+            if isinstance(data, dict):
+                # 模型常在不敏感时回 "source": null；source 是 str 字段，
+                # None 会让 Pydantic 校验失败 → 整体解析失败 → fail-close 误判敏感。
+                # 这里把 None 值剔除，让字段走默认值。
+                data = {k: v for k, v in data.items() if v is not None}
+                return SensitiveCheck(**data)
+        except Exception:
+            return None
+        return None
+
+    # 4a) 整体
+    chk = _try(candidate)
+    if chk is not None:
+        return chk
+
+    # 4b) 多个顶层 {...} 对象：取第一个完整对象（栈匹配大括号）
+    depth = 0
+    in_str = False
+    esc = False
+    for i, ch in enumerate(candidate):
+        if esc:
+            esc = False
+            continue
+        if ch == "\\":
+            esc = True
+            continue
+        if ch == '"':
+            in_str = not in_str
+            continue
+        if in_str:
+            continue
+        if ch == "{":
+            depth += 1
+        elif ch == "}":
+            depth -= 1
+            if depth == 0:
+                chk = _try(candidate[:i + 1])
+                if chk is not None:
+                    return chk
+                # 第一个对象也解析失败，放弃
+                return None
+
+    # 4c) 兜底：模型把判定字段写成「- key: value」或「key: value」散文式
+    #     （常见于 think 内，如 "- is_sensitive: true\n- reason: ...\n- source: tool_result"，
+    #     或 "is_sensitive: true- reason: ..." 这种换行被吞的畸形文本）。
+    #     注意：在 4a/4b 走完仍未返回时才到这里，此时要么没大括号、
+    #     要么大括号是工具结果片段（不是判定 JSON），用正则从全文提判定字段更稳。
+    m_bool = re.search(r'is[_\s\-]*sensitive["\']?\s*[:：]\s*(true|false)', text, re.I)
+    if m_bool:
+        data = {"is_sensitive": m_bool.group(1).lower() == "true"}
+        # reason: 取到行尾（容忍换行被吞成空格，遇下一个字段名停止）
+        m_reason = re.search(
+            r'reason["\']?\s*[:：]\s*["\']?(.+?)(?=\s*(?:[\-]*\s*)?(?:reason|source|is[_\s\-]*sensitive)["\']?\s*[:：]|$)',
+            text, re.I | re.DOTALL)
+        if m_reason:
+            r = m_reason.group(1).strip()
+            # 截到第一个换行（reason 不跨行）
+            r = r.split("\n", 1)[0].strip().strip('"\'')
+            if r:
+                data["reason"] = r
+        m_source = re.search(r'source["\']?\s*[:：]\s*["\']?(user_input|tool_result|history)', text, re.I)
+        if m_source:
+            data["source"] = m_source.group(1).lower()
+        try:
+            return SensitiveCheck(**{k: v for k, v in data.items() if v is not None})
+        except Exception:
+            return None
+    return None
+
+
+class SensitiveGuardMiddleware(AgentMiddleware):
+    """敏感信息检测 + 会话内降级到内部模型。"""
+
+    def __init__(
+        self,
+        model_tier: str,
+        internal_model_name: Optional[str] = None,
+        on_downgrade: Optional[Callable[[], Awaitable[None]]] = None,
+        enabled: bool = True,
+        state: Optional[DowngradeState] = None,
+        # 应用层可覆盖检测提示词；未传(None)用 DEFAULT_DETECT_PROMPT
+        detect_prompt: Optional[str] = None,
+        # 命中敏感后的动作："downgrade"=降级内部模型继续；"block"=直接阻断(不调任何模型)
+        action: str = "downgrade",
+        # 阻断模式下的异步提示回调（与 on_downgrade 区分文案）；downgrade 模式不用
+        on_block: Optional[Callable[[], Awaitable[None]]] = None,
+        # 测试注入：绕过懒加载的真实 get_llm
+        _detector: Any = None,
+        _internal_raw: Any = None,
+    ):
+        self._model_tier = model_tier
+        # None 时检测器/降级目标都用 get_llm() 读 nacos default 模型，不写死模型名
+        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"
+        self._enabled = enabled
+        self._state = state or DowngradeState()
+        self._detect_prompt = detect_prompt or DEFAULT_DETECT_PROMPT
+        self._detector = _detector        # 懒加载（None 时首次检测用 get_llm 建）
+        self._internal_raw = _internal_raw
+        self._init_lock = asyncio.Lock()
+
+    @property
+    def is_downgraded(self) -> bool:
+        return self._state.is_downgraded
+
+    @property
+    def is_blocked(self) -> bool:
+        """本会话是否已阻断（命中过敏感且 action=block）。"""
+        return self._state.is_downgraded and self._action == "block"
+
+    @property
+    def action(self) -> str:
+        return self._action
+
+    @property
+    def last_notice_source(self) -> str:
+        """首次命中时的敏感来源(user_input/tool_result/history)，供应用层选文案。"""
+        return getattr(self._state, "last_source", "user_input")
+
+    @property
+    def state(self) -> DowngradeState:
+        return self._state
+
+    async def _get_detector(self):
+        if self._detector is None:
+            async with self._init_lock:
+                if self._detector is None:
+                    from sycommon.llm.get_llm import get_llm
+                    # wrap_structured=False：检测器直接拿原始文本，由 _detect 自行解析。
+                    # 避免 with_structured_output 在 JSON 不合规时触发修正重试（烧 token、拖慢）。
+                    # ⚠️ 必须用 ainvoke（非流式）+ 干净 config：本中间件在 awrap_model_call 里
+                    # 被调用，此时 agent 的 _patched_execute_model_async 把检测器也当成普通模型
+                    # 走 astream，导致 on_llm_new_token 把检测的 <think>/JSON token 推给
+                    # StreamMessagesHandler → agent.chat() 当作 AI chunk yield 给应用层 →
+                    # 用户看到脱敏分类器的思考过程。get_llm(wrap_structured=False) 返回的是
+                    # LLMWithTokenTracking（BaseChatModel），其 ainvoke 走 _agenerate，不触发
+                    # 流式回调；且这里用独立 config（不取 agent 的 StreamMessagesHandler），
+                    # 从源头断开检测器与用户事件流。
+                    self._detector = get_llm(
+                        self._internal_name, temperature=0.0, wrap_structured=False)
+        return self._detector
+
+    async def _get_internal_raw(self):
+        if self._internal_raw is None:
+            async with self._init_lock:
+                if self._internal_raw is None:
+                    from sycommon.llm.get_llm import get_llm
+                    llm = get_llm(self._internal_name, streaming=True, wrap_structured=False)
+                    # 取 raw 层（ChatOpenAI），与 agent 原模型 getattr(model,'llm',model) 对齐
+                    self._internal_raw = getattr(llm, "llm", llm)
+        return self._internal_raw
+
+    async def _detect(self, messages: List[BaseMessage]) -> SensitiveCheck:
+        """一次检测：命中即返回 SensitiveCheck。fail-close（异常→视为敏感）。
+
+        稳定性策略：
+        - 检测提示词只描述「判什么敏感」，不要求模型自己格式化输出；
+        - 直接用 detector.ainvoke 拿原始文本，本方法用正则提 {…} 再 Pydantic 解析；
+        - 单轮、零修正重试，避免 with_structured_output 的解析重试烧 token。
+        解析失败时 fail-close 视为敏感（宁可错杀不让敏感外泄）。
+        """
+        import json
+        import re
+        content = _messages_to_text(messages)
+        try:
+            detector = await self._get_detector()
+            # 🔑 提示词模板里含 {content} 占位符（应用层 SENSITIVE_DETECT_PROMPT）。
+            # 这里手工替换（不走 langchain 模板）：把完整上下文塞进去。
+            # 用字符串 split+join 避免提示词里其他 {xxx} 被 .format 误伤。
+            prompt = self._detect_prompt.replace("{content}", content) \
+                if "{content}" in self._detect_prompt \
+                else self._detect_prompt + content
+            # 🔑 隔离 agent 的流式回调上下文，防止检测器输出泄漏给用户。
+            # 本中间件在 agent 的模型节点内被调用，此刻 ContextVar
+            # var_child_runnable_config 持有 agent 的 config（含 StreamMessagesHandler
+            # 回调）。若直接 detector.ainvoke，langchain 会继承该回调，检测器的每个
+            # token 都触发 on_llm_new_token → 被当成 AI chunk yield 给用户，导致
+            # 脱敏分类器的 <think>/JSON 全部可见。这里临时清空该 ContextVar，调用完
+            # 恢复，让检测器在干净的上下文里跑（非流式、不进用户事件流）。
+            from langchain_core.runnables.config import var_child_runnable_config
+            _ctx_token = var_child_runnable_config.set({})
+            try:
+                raw = await detector.ainvoke(prompt)
+            finally:
+                var_child_runnable_config.reset(_ctx_token)
+            text = raw.content if isinstance(raw, BaseMessage) else str(raw)
+            check = _parse_detect_json(text)
+            if check is None:
+                SYLogger.warning(
+                    f"[SensitiveGuard] 检测无有效JSON(fail-close→内部模型): {text[:500]!r}")
+                return SensitiveCheck(is_sensitive=True, reason="no_json_in_detect_output")
+            return check
+        except Exception as e:
+            SYLogger.warning(f"[SensitiveGuard] 检测异常(fail-close→内部模型): {e}")
+            return SensitiveCheck(is_sensitive=True, reason=f"detect_error:{e}")
+
+    async def awrap_model_call(
+        self,
+        request: ModelRequest[ContextT],
+        handler: Callable[[ModelRequest[ContextT]], Awaitable[ModelResponse[ResponseT]]],
+    ) -> ModelResponse[ResponseT]:
+        # (a) 关闭 / 内部 tier：纯放行，不检测（避免内部模型检内部模型 + 省 token）
+        if not self._enabled or self._model_tier == "internal":
+            return await handler(request)
+
+        # (b) 本会话已命中敏感
+        if self._state.is_downgraded:
+            # 阻断模式：直接返回空响应，不再调任何模型；应用层发完提示后会 break stream。
+            # 这里构造一个 content 空的 AIMessage，让 langgraph 把本轮当作模型已回完，
+            # 不进工具循环（无 tool_calls），干净结束。
+            if self._action == "block":
+                return ModelResponse(result=[AIMessage(content="")])
+            # 降级模式：路由内部模型继续；本次输入若非敏感(来自历史记忆)刷新 source=history
+            await self._refresh_source_if_history(request.messages)
+            return await handler(request.override(model=await self._get_internal_raw()))
+
+        # (c) 检测
+        check = await self._detect(request.messages)
+        if not check.is_sensitive:
+            return await handler(request)
+
+        # (d) 命中 → CAS 抢占；按 action 分流
+        is_first = await self._state.mark_downgraded(check.source)
+        if self._action == "block":
+            SYLogger.info(
+                f"[SensitiveGuard] 命中敏感信息，阻断执行: {check.reason} (source={check.source})")
+            if is_first and self._on_block:
+                try:
+                    await self._on_block()
+                except Exception as e:
+                    SYLogger.warning(f"[SensitiveGuard] 阻断提示回调失败: {e}")
+            # 不调 handler，返回空响应结束本轮
+            return ModelResponse(result=[AIMessage(content="")])
+        # downgrade 模式：发提示 + 路由内部模型继续执行
+        SYLogger.info(
+            f"[SensitiveGuard] 命中敏感信息，降级内部模型: {check.reason} (source={check.source})")
+        if is_first and self._on_downgrade:
+            try:
+                await self._on_downgrade()
+            except Exception as e:
+                SYLogger.warning(f"[SensitiveGuard] 提示回调失败: {e}")
+        return await handler(request.override(model=await self._get_internal_raw()))
+
+    async def _refresh_source_if_history(self, messages: List[BaseMessage]) -> None:
+        """已降级后的短路路径上调用：判断本次输入本身是否含敏感。
+
+        场景：会话首次命中敏感（如查 LDAP 档案）后降级。用户紧接着发"今日金价"
+        等本身不含敏感的消息——此刻敏感的来源是「历史记忆」，应用层应提示
+        NOTICE_FROM_HISTORY（带"新建会话"引导）。本方法用 detector 轻判「仅本次
+        输入」是否敏感：不敏感 → 把 last_source 刷成 history；仍敏感 → 保持原值。
+
+        注意：只在 last_source 还不是 history 时才刷（一旦判过 history 就稳定），
+        避免反复抖动。轻判只看最后一条 HumanMessage，cost 低。
+        """
+        # 已是 history，无需再刷
+        if self._state.last_source == "history":
+            return
+        try:
+            # 取最后一条 HumanMessage 作为「本次输入」单独判
+            last_human = None
+            for m in reversed(messages):
+                if isinstance(m, HumanMessage):
+                    last_human = m
+                    break
+            if last_human is None:
+                return
+            check = await self._detect([last_human])
+            if not check.is_sensitive:
+                # 本次输入干净 → 敏感来自记忆
+                async with self._state._lock:
+                    self._state.last_source = "history"
+                SYLogger.info(
+                    "[SensitiveGuard] 已降级；本次输入非敏感，source 刷新为 history"
+                    "（后续提示走「记忆」文案）")
+        except Exception as e:
+            # 兜底失败不影响短路路径，保持原 source
+            SYLogger.warning(f"[SensitiveGuard] refresh_source_if_history 失败(忽略): {e}")
+
+

{sycommon_python_lib-0.2.7a12 → sycommon_python_lib-0.2.7a14}/src/sycommon/agent/multi_agent_team.py

@@ -46,6 +46,9 @@ 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.sensitive_guard import (
+    SensitiveGuardMiddleware, DowngradeState,
+)
 from deepagents.middleware.summarization import create_summarization_tool_middleware  # noqa: F401 保留 re-export
 from sycommon.agent.summarization_utils import build_summarization_middleware
 
@@ -126,6 +129,11 @@ class TeamConfig(BaseModel):
     model_name: Optional[str] = None
     model_temperature: float = 0.7
     model_thinking: bool = False
+    model_tier: str = "external"        # "external"|"internal"；internal 时跳过敏感检测
+    sensitive_guard: bool = True        # 是否启用敏感信息检测守卫
+    internal_model_name: Optional[str] = None   # 敏感降级目标内部模型名（应用层透传）
+    sensitive_detect_prompt: Optional[str] = None  # 敏感检测提示词（应用层覆盖）
+    sensitive_action: str = "downgrade"  # "downgrade"=降级继续；"block"=阻断
 
     coordinator_prompt: str = ""
     coordinator_name: str = "项目经理"
@@ -190,6 +198,7 @@ class MultiAgentTeam:
         sandbox_backend: HTTPSandboxBackend,
         coordinator_name: str = "项目经理",
         recovery_manager: Optional[SandboxRecoveryManager] = None,
+        downgrade_state: Optional[DowngradeState] = None,
     ):
         self.user_id = user_id
         self.agent = agent
@@ -199,6 +208,12 @@ class MultiAgentTeam:
         self.coordinator_name = coordinator_name
         self.sandbox_backend = sandbox_backend
         self.recovery_manager = recovery_manager
+        self.downgrade_state = downgrade_state
+
+    @property
+    def is_downgraded(self) -> bool:
+        """敏感降级状态（协调者+子agent 共享，任一命中→True）。"""
+        return bool(self.downgrade_state and self.downgrade_state.is_downgraded)
 
     async def cleanup(self):
         """清理资源"""
@@ -608,7 +623,22 @@ async def create_multi_agent_team(
     from deepagents.middleware.subagents import CompiledSubAgent
 
     summarization_mw = build_summarization_middleware(model, config.model_name, sandbox_backend)
+    # 🔒 敏感检测：协调者 + 所有子 agent 共享一个 DowngradeState，
+    # 任一命中 → 全员降级（敏感数据会经委派链流动，独立 state 会漏）。
+    shared_downgrade_state = DowngradeState()
+
+    def _make_guard():
+        return SensitiveGuardMiddleware(
+            model_tier=config.model_tier,
+            enabled=config.sensitive_guard,
+            state=shared_downgrade_state,
+            internal_model_name=config.internal_model_name,
+            detect_prompt=config.sensitive_detect_prompt,
+            action=config.sensitive_action,
+        )
+
     middleware = [
+        _make_guard(),
         ToolResultTruncationMiddleware(),
         TokenTrackingMiddleware(model_name=config.model_name, user_id=user_id),
         summarization_mw,
@@ -666,6 +696,7 @@ async def create_multi_agent_team(
         debug=config.debug,
         name=coord_name,
         middleware=[
+            _make_guard(),
             ToolResultTruncationMiddleware(),
             TokenTrackingMiddleware(model_name=config.model_name, user_id=user_id),
             coord_summarization_mw,
@@ -683,6 +714,7 @@ async def create_multi_agent_team(
         sandbox_backend=sandbox_backend,
         coordinator_name=coord_name,
         recovery_manager=recovery_manager,
+        downgrade_state=shared_downgrade_state,
     )
 
 

{sycommon_python_lib-0.2.7a12 → sycommon_python_lib-0.2.7a14}/src/sycommon/middleware/context.py

@@ -14,3 +14,8 @@ current_llm_api_key = contextvars.ContextVar("llm_api_key", default=None)
 #   None = 走 per-user 派生 key（默认，正常路径）
 # 沿 asyncio task 树传播，请求结束自动重置 → 每次新请求仍优先派生 key。
 llm_key_override = contextvars.ContextVar("llm_key_override", default=None)
+
+# 当前请求来源："web" | "wecom" | None。agent 创建入口（create_sy_deep_agent /
+# stream_chat=web，create_wecom_agent=wecom）set，沿 task 树传播。
+# authorize 等工具据此分流：web 走二维码弹窗、企微走 markdown 链接。
+current_chat_source = contextvars.ContextVar("chat_source", default=None)

{sycommon_python_lib-0.2.7a12 → sycommon_python_lib-0.2.7a14}/src/sycommon_python_lib.egg-info/PKG-INFO

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